- Plugins/startup: tolerate transient bundled-channel catalog/metadata drift while auto-enabling configured plugins, so CLI and gateway startup no longer crash when a channel id is known but its display metadata is unavailable.

- CLI/Claude: report CLI-backed reply runs as streaming while Claude/Codex CLI turns are still in flight, so WebChat keeps visible response state until the backend finishes. Fixes #70125.

- Codex harness: rotate the shared app-server websocket client when the configured bearer token changes, so auth-token refreshes reconnect with the new `Authorization` header instead of reusing a stale socket. (#70328) Thanks @Lucenx9.

- Telegram/sandbox: keep Telegram bot DMs on per-account sender session keys even when `session.dmScope=main`, so sandbox/tool policy can distinguish Telegram-originated direct chats from the agent main session.

- Channels/sandbox: derive runtime policy keys for external direct messages that share the main conversation, so sandbox/tool policy no longer treats channel-originated DMs as local main-session runs.

- Config/models: merge provider-scoped model allowlist updates and protect model/provider map writes from accidental full replacement, adding `config set --merge` for additive updates and `--replace` for intentional clobbers. Fixes #65920, #68392, and #68653.

- Agents/Pi auth: preserve AWS SDK-authenticated Bedrock runs for IMDS and task-role setups, clear stale refresh timers on sentinel fallback, and log unexpected runtime-auth prep failures instead of silently leaving the provider unauthenticated. Thanks @wirjo.

- Config/gateway: restore last-known-good config on critical clobber signatures such as missing metadata, missing `gateway.mode`, or sharp size drops, preventing gateway crash loops when a valid backup exists. Fixes #70336.

## Session key shapes (examples)

Most direct messages collapse to the agent’s **main** session:

Direct messages collapse to the agent’s **main** session by default:

- `agent:<agentId>:<mainKey>` (default: `agent:main:main`)

Telegram bot direct messages are isolated per bot account and sender even when

`session.dmScope` is `main`, so sandbox and tool policy decisions can distinguish

channel-originated DMs from the agent main session:

- `agent:<agentId>:telegram:<accountId>:direct:<senderId>`

Even when direct-message conversation history is shared with main, sandbox and

tool policy use a derived per-account direct-chat runtime key for external DMs

so channel-originated messages are not treated like local main-session runs.

Groups and channels remain isolated per channel:

Token resolution order is account-aware. In practice, config values win over env fallback, and `TELEGRAM_BOT_TOKEN` only applies to the default account.

</Note>

## Session isolation

Telegram bot DMs use per-account sender session keys, for example

`agent:main:telegram:default:direct:814912386`. This keeps Telegram-originated

tool and sandbox policy distinct from the agent main session even when the

global `session.dmScope` setting is `main`.

## Telegram side settings

<AccordionGroup>

expect(ctx).not.toBeNull();

expect(ctx?.ctxPayload?.MessageThreadId).toBe(42);

expect(ctx?.ctxPayload?.SessionKey).toBe(

"agent:main:telegram:default:direct:42:thread:1234:42",

);

expect(ctx?.ctxPayload?.SessionKey).toBe("agent:main:main:thread:1234:42");

});

it("uses the Telegram direct session key when no thread id", async () => {

it("uses the main session key when no thread id", async () => {

const ctx = await buildContext({

message_id: 2,

chat: { id: 1234, type: "private" },

expect(ctx).not.toBeNull();

expect(ctx?.ctxPayload?.MessageThreadId).toBeUndefined();

expect(ctx?.ctxPayload?.SessionKey).toBe("agent:main:telegram:default:direct:42");

expect(ctx?.ctxPayload?.SessionKey).toBe("agent:main:main");

});

});

expect(ctx).toBeNull();

});

it("uses a per-account session key for default-account DMs", async () => {

it("uses the main session key for default-account DMs", async () => {

setRuntimeConfigSnapshot(baseCfg);

const ctx = await buildTelegramMessageContextForTest({

},

});

expect(ctx?.ctxPayload?.SessionKey).toBe("agent:main:telegram:default:direct:42");

expect(getLastUpdateLastRoute()?.sessionKey).toBe("agent:main:telegram:default:direct:42");

expect(ctx?.ctxPayload?.SessionKey).toBe("agent:main:main");

expect(getLastUpdateLastRoute()?.sessionKey).toBe("agent:main:main");

});

});

import { logInboundDrop } from "openclaw/plugin-sdk/channel-inbound";

import type { TelegramDirectConfig, TelegramGroupConfig } from "openclaw/plugin-sdk/config-runtime";

import { deriveLastRoutePolicy } from "openclaw/plugin-sdk/routing";

import { DEFAULT_ACCOUNT_ID, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";

import { normalizeAccountId, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";

import { logVerbose } from "openclaw/plugin-sdk/runtime-env";

import { resolveDefaultTelegramAccountId } from "./accounts.js";

import { withTelegramApiErrorLogging } from "./api-logging.js";

import { firstDefined, normalizeAllowFrom, normalizeDmAllowFromWithStore } from "./bot-access.js";

import { resolveTelegramInboundBody } from "./bot-message-context.body.js";

});

const requiresExplicitAccountBinding = (

candidate: ReturnType<typeof resolveTelegramConversationRoute>["route"],

): boolean => candidate.accountId !== DEFAULT_ACCOUNT_ID && candidate.matchedBy === "default";

): boolean =>

normalizeAccountId(candidate.accountId) !==

normalizeAccountId(resolveDefaultTelegramAccountId(freshCfg)) &&

candidate.matchedBy === "default";

const isNamedAccountFallback = requiresExplicitAccountBinding(route);

// Named-account groups still require an explicit binding; DMs get a

// per-account fallback session key below to preserve isolation.

expect(replySpy).toHaveBeenCalledTimes(1);

const payload = replySpy.mock.calls[0][0];

expect(payload.AccountId).toBe("opie");

expect(payload.SessionKey).toBe("agent:opie:telegram:opie:direct:999");

expect(payload.SessionKey).toBe("agent:opie:main");

});

it("reloads DM routing bindings between messages without recreating the bot", async () => {

let boundAgentId = "agent-a";

const configForAgent = (agentId: string) => ({

channels: {

telegram: {

defaultAccount: "work",

accounts: {

work: {

botToken: "tok-work",

dmPolicy: "open",

},

opie: {

botToken: "tok-opie",

dmPolicy: "open",

loadConfig.mockReturnValue({

channels: {

telegram: {

defaultAccount: "work",

accounts: {

work: {

botToken: "tok-work",

dmPolicy: "open",

},

opie: {

botToken: "tok-opie",

dmPolicy: "open",

expect(replySpy).toHaveBeenCalledTimes(1);

const payload = replySpy.mock.calls[0][0];

expect(payload.CommandTargetSessionKey).toBe(

"agent:main:telegram:default:direct:12345:thread:12345:99",

);

expect(payload.CommandTargetSessionKey).toBe("agent:main:main:thread:12345:99");

});

it("allows native DM commands for paired users", async () => {

describe("resolveTelegramConversationBaseSessionKey", () => {

const cfg: OpenClawConfig = {};

it("uses a per-account key for default-account DMs", () => {

it("keeps default-account DMs on the route session key", () => {

expect(

resolveTelegramConversationBaseSessionKey({

cfg,

isGroup: false,

senderId: 12345,

}),

).toBe("agent:main:telegram:default:direct:12345");

).toBe("agent:main:main");

});

it("keeps configured default-account DMs on the route session key", () => {

expect(

resolveTelegramConversationBaseSessionKey({

cfg: {

channels: {

telegram: {

defaultAccount: "work",

accounts: {

work: {},

personal: {},

},

},

},

},

route: {

agentId: "main",

accountId: "work",

matchedBy: "default",

sessionKey: "agent:main:main",

},

chatId: 12345,

isGroup: false,

senderId: 12345,

}),

).toBe("agent:main:main");

});

it("uses the per-account fallback key for named-account DMs without an explicit binding", () => {

import {

buildAgentSessionKey,

deriveLastRoutePolicy,

normalizeAccountId,

resolveAgentRoute,

} from "openclaw/plugin-sdk/routing";

import { buildAgentMainSessionKey, sanitizeAgentId } from "openclaw/plugin-sdk/routing";

import { logVerbose } from "openclaw/plugin-sdk/runtime-env";

import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";

import { resolveDefaultTelegramAccountId } from "./accounts.js";

import {

buildTelegramGroupPeerId,

buildTelegramParentPeer,

isGroup: boolean;

senderId?: string | number | null;

}): string {

if (params.isGroup || params.route.matchedBy === "binding.channel") {

const routeAccountId = normalizeAccountId(params.route.accountId);

const defaultAccountId = normalizeAccountId(resolveDefaultTelegramAccountId(params.cfg));

const isNamedAccountFallback =

routeAccountId !== defaultAccountId && params.route.matchedBy === "default";

if (!isNamedAccountFallback || params.isGroup) {

return params.route.sessionKey;

}

const configuredDmScope = params.cfg.session?.dmScope;

return normalizeLowercaseStringOrEmpty(

buildAgentSessionKey({

agentId: params.route.agentId,

senderId: params.senderId,

}),

},

dmScope:

configuredDmScope && configuredDmScope !== "main"

? configuredDmScope

: "per-account-channel-peer",

dmScope: "per-account-channel-peer",

identityLinks: params.cfg.session?.identityLinks,

}),

);