### Changes

- Models/commands: add `/models add <provider> <modelId>` so you can register a model from chat and use it without restarting the gateway; keep `/models` as a simple provider browser while adding clearer add guidance and copy-friendly command examples. (#70211) Thanks @Takhoffman.

- Pi/models: update the bundled pi packages to `0.68.1` and let the OpenCode Go catalog come from pi instead of plugin-maintained model aliases, adding the refreshed `opencode-go/kimi-k2.6`, Qwen, GLM, MiMo, and MiniMax entries.

- CLI/doctor plugins: lazy-load doctor plugin paths and prefer installed plugin `dist/*` runtime entries over source-adjacent JavaScript fallbacks, reducing the measured `doctor --non-interactive` runtime by about 74% while keeping cold doctor startup on built plugin artifacts. (#69840) Thanks @gumadeiras.

- WhatsApp/groups+direct: forward per-group and per-direct `systemPrompt` config into inbound context `GroupSystemPrompt` so configured per-chat behavioral instructions are injected on every turn. Supports `"*"` wildcard fallback and account-scoped overrides under `channels.whatsapp.accounts.<id>.{groups,direct}`; account maps fully replace root maps (no deep merge), matching the existing `requireMention` pattern. Closes #7011. (#59553) Thanks @Bluetegu.

To restrict who can click a button, set `allowedUsers` on that button (Discord user IDs, tags, or `*`). When configured, unmatched users receive an ephemeral denial.

The `/model` and `/models` slash commands open an interactive model picker with provider and model dropdowns plus a Submit step. The picker reply is ephemeral and only the invoking user can use it.

The `/model` and `/models` slash commands open an interactive model picker with provider and model dropdowns plus a Submit step. `/models add` also supports adding a new provider/model entry from chat, and newly added models show up without restarting the gateway. The picker reply is ephemeral and only the invoking user can use it.

File attachments:

},

{

"command": "/models",

"description": "List providers or models for a provider",

"usage_hint": "[provider] [page] [limit=<n>|size=<n>|all]"

"description": "List providers/models or add a model",

"usage_hint": "[provider] [page] [limit=<n>|size=<n>|all] | add <provider> <modelId>"

},

{

"command": "/help",

- `/model` (and `/model list`) is a compact, numbered picker (model family + available providers).

- On Discord, `/model` and `/models` open an interactive picker with provider and model dropdowns plus a Submit step.

- `/models add` lets you add a provider/model entry from chat without editing config manually.

- `/models add <provider> <modelId>` is the fastest path; bare `/models add` starts a provider-first guided flow where supported.

- After `/models add`, the new model becomes available in `/models` and `/model` without restarting the gateway.

- `/model <#>` selects from that picker.

- `/model` persists the new session selection immediately.

- If the agent is idle, the next run uses the new model right away.

Full command behavior/config: [Slash commands](/tools/slash-commands).

Examples:

```text

/models add

/models add ollama glm-5.1:cloud

/models add lmstudio qwen/qwen3.5-9b

```

## CLI commands

```bash

withResolvedTelegramForumFlag,

} from "./bot/helpers.js";

import type { TelegramContext, TelegramGetChat } from "./bot/types.js";

import { buildCommandsPaginationKeyboard } from "./command-ui.js";

import { buildCommandsPaginationKeyboard, buildTelegramModelsMenuButtons } from "./command-ui.js";

import {

resolveTelegramConversationBaseSessionKey,

resolveTelegramConversationRoute,

id: p,

count: byProvider.get(p)?.size ?? 0,

}));

const buttons = buildProviderKeyboard(providerInfos);

const buttons = buildTelegramModelsMenuButtons({ providers: providerInfos });

try {

await editMessageWithButtons("Select a provider:", buttons);

} catch (err) {

id: p,

count: byProvider.get(p)?.size ?? 0,

}));

const buttons = buildProviderKeyboard(providerInfos);

const buttons = buildTelegramModelsMenuButtons({ providers: providerInfos });

try {

await editMessageWithButtons(

`Unknown provider: ${provider}\n\nSelect a provider:`,

id: p,

count: byProvider.get(p)?.size ?? 0,

}));

const buttons = buildProviderKeyboard(providerInfos);

const buttons = buildTelegramModelsMenuButtons({ providers: providerInfos });

try {

await editMessageWithButtons(

`Could not resolve model "${selection.model}".\n\nSelect a provider:`,

expect(buildModelsProviderDataMock).toHaveBeenCalledTimes(2);

expect(editMessageTextSpy).toHaveBeenCalledTimes(1);

expect(editMessageTextSpy.mock.calls[0]?.[2]).toContain("Select a provider:");

expect(

(

editMessageTextSpy.mock.calls[0]?.[3] as {

reply_markup?: { inline_keyboard?: unknown[][] };

}

)?.reply_markup?.inline_keyboard?.[0]?.[0],

).toEqual({

text: "Add model",

callback_data: "/models add",

});

});

it("retries command pagination callbacks after a bubbled edit failure", async () => {

expect(editMessageTextSpy).toHaveBeenCalledTimes(2);

expect(editMessageTextSpy.mock.calls.at(-1)?.[2]).toContain("Select a provider:");

expect(

(

editMessageTextSpy.mock.calls.at(-1)?.[3] as {

reply_markup?: { inline_keyboard?: unknown[][] };

}

)?.reply_markup?.inline_keyboard?.[0]?.[0],

).toEqual({

text: "Add model",

callback_data: "/models add",

});

});

it("retries model selection callbacks after a bubbled session-store failure", async () => {

toPluginMessageContext,

toPluginMessageSentEvent,

} from "openclaw/plugin-sdk/hook-runtime";

import type { ReplyPayloadDelivery } from "openclaw/plugin-sdk/interactive-runtime";

import { buildOutboundMediaLoadOptions } from "openclaw/plugin-sdk/media-runtime";

import { isGifMedia, kindFromMime } from "openclaw/plugin-sdk/media-runtime";

import {

}

async function maybePinFirstDeliveredMessage(params: {

pin: NonNullable<ReplyPayload["delivery"]>["pin"] | undefined;

pin: ReplyPayloadDelivery["pin"];

bot: Bot;

chatId: string;

runtime: RuntimeEnv;

export { buildCommandsPaginationKeyboard };

export function buildTelegramModelsMenuButtons(params: { providers: ProviderInfo[] }) {

return [

[{ text: "Add model", callback_data: "/models add" }],

...buildProviderKeyboard(params.providers),

];

}

export function buildTelegramModelsMenuChannelData(params: {

providers: ProviderInfo[];

}): ReplyPayload["channelData"] | null {

if (params.providers.length === 0) {

return null;

}

return {

telegram: {

buttons: buildTelegramModelsMenuButtons(params),

},

};

}

export function buildTelegramCommandsListChannelData(params: {

currentPage: number;

totalPages: number;

};

}

export function buildTelegramModelsAddProviderChannelData(params: {

providers: Array<{ id: string }>;

}): ReplyPayload["channelData"] | null {

if (params.providers.length === 0) {

return null;

}

const buttons = params.providers.map((provider) => [

{

text: provider.id,

callback_data: `/models add ${provider.id}`,

},

]);

return {

telegram: {

buttons,

},

};

}

export function buildTelegramModelsListChannelData(params: {

provider: string;

models: readonly string[];

}

describe("createTelegramPluginBase config duplicate token guard", () => {

it("wires the top-level models menu adapter into the production plugin", () => {

const channelData = telegramPluginBase.commands?.buildModelsMenuChannelData?.({

providers: [

{ id: "anthropic", count: 2 },

{ id: "openai", count: 3 },

],

});

expect(channelData).toEqual({

telegram: {

buttons: [

[{ text: "Add model", callback_data: "/models add" }],

[

{ text: "anthropic (2)", callback_data: "mdl_list_anthropic_1" },

{ text: "openai (3)", callback_data: "mdl_list_openai_1" },

],

],

},

});

});

it("wires the guided add-provider adapter into the production plugin", () => {

const channelData = telegramPluginBase.commands?.buildModelsAddProviderChannelData?.({

providers: [{ id: "ollama" }, { id: "lmstudio" }],

});

expect(channelData).toEqual({

telegram: {

buttons: [

[{ text: "ollama", callback_data: "/models add ollama" }],

[{ text: "lmstudio", callback_data: "/models add lmstudio" }],

],

},

});

});

it("marks secondary account as not configured when token is shared", async () => {

const cfg = createCfg();

const alertsAccount = resolveAccount(cfg, "alerts");

import {

buildTelegramCommandsListChannelData,

buildTelegramModelBrowseChannelData,

buildTelegramModelsAddProviderChannelData,

buildTelegramModelsListChannelData,

buildTelegramModelsMenuChannelData,

buildTelegramModelsProviderChannelData,

} from "./command-ui.js";

import { TelegramChannelConfigSchema } from "./config-schema.js";

nativeCommandsAutoEnabled: true,

nativeSkillsAutoEnabled: true,

buildCommandsListChannelData: buildTelegramCommandsListChannelData,

buildModelsMenuChannelData: buildTelegramModelsMenuChannelData,

buildModelsProviderChannelData: buildTelegramModelsProviderChannelData,

buildModelsAddProviderChannelData: buildTelegramModelsAddProviderChannelData,

buildModelsListChannelData: buildTelegramModelsListChannelData,

buildModelBrowseChannelData: buildTelegramModelBrowseChannelData,

},