@inline-openclaw/inline 0.0.28 → 0.0.30

package/dist/index.js

@@ -5837,7 +5837,8 @@ class ConnectionInit$Type extends import_runtime4.MessageType {
       { no: 1, name: "token", kind: "scalar", T: 9 },
       { no: 2, name: "build_number", kind: "scalar", opt: true, T: 5 },
       { no: 3, name: "layer", kind: "scalar", opt: true, T: 13 },
-      { no: 4, name: "client_version", kind: "scalar", opt: true, T: 9 }
+      { no: 4, name: "client_version", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "os_version", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
@@ -5864,6 +5865,9 @@ class ConnectionInit$Type extends import_runtime4.MessageType {
         case 4:
           message.clientVersion = reader.string();
           break;
+        case 5:
+          message.osVersion = reader.string();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -5884,6 +5888,8 @@ class ConnectionInit$Type extends import_runtime4.MessageType {
       writer.tag(3, import_runtime.WireType.Varint).uint32(message.layer);
     if (message.clientVersion !== undefined)
       writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.clientVersion);
+    if (message.osVersion !== undefined)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.osVersion);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -18289,6 +18295,9 @@ class PingPongService {
   sleepTimer = null;
   sleepResolver = null;
   pings = new Map;
+  lastPingAt = null;
+  lastPongAt = null;
+  lastTimeoutAt = null;
   constructor(options) {
     this.log = options?.logger ?? {};
     const cryptoAny = globalThis.crypto;
@@ -18317,13 +18326,16 @@ class PingPongService {
       return;
     const nonce = this.randomNonce();
     await client.sendPing(nonce);
-    this.pings.set(nonce, Date.now());
+    const now = Date.now();
+    this.lastPingAt = now;
+    this.pings.set(nonce, now);
   }
   pong(nonce) {
     const pingDate = this.pings.get(nonce);
     if (!pingDate)
       return;
     this.pings.delete(nonce);
+    this.lastPongAt = Date.now();
   }
   async loop() {
     while (this.running) {
@@ -18344,11 +18356,16 @@ class PingPongService {
     if (client.state !== "open")
       return;
     const now = Date.now();
-    const hasTimedOutPing = [...this.pings.values()].some((timestamp) => now - timestamp > 30000);
-    if (!hasTimedOutPing)
+    const oldestPendingPingAt = [...this.pings.values()].reduce((oldest, timestamp) => oldest == null || timestamp < oldest ? timestamp : oldest, null);
+    if (oldestPendingPingAt == null)
       return;
-    this.log.warn?.("Ping timeout, reconnecting");
-    await client.reconnect();
+    const oldestPendingAgeMs = now - oldestPendingPingAt;
+    if (oldestPendingAgeMs <= 30000)
+      return;
+    this.lastTimeoutAt = now;
+    this.log.warn?.(`Ping timeout, reconnecting (pending=${this.pings.size}, oldestPendingAgeMs=${oldestPendingAgeMs}${this.lastPongAt != null ? `, lastPongAgeMs=${now - this.lastPongAt}` : ""})`);
+    this.reset();
+    await client.reconnect({ cause: "ping-timeout" });
   }
   async sleep(ms) {
     if (ms <= 0)
@@ -18382,6 +18399,19 @@ class PingPongService {
     }
     return BigInt(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER));
   }
+  getDiagnostics() {
+    const now = Date.now();
+    const oldestPendingPingAt = [...this.pings.values()].reduce((oldest, timestamp) => oldest == null || timestamp < oldest ? timestamp : oldest, null);
+    return {
+      running: this.running,
+      pendingCount: this.pings.size,
+      lastPingAt: this.lastPingAt,
+      lastPongAt: this.lastPongAt,
+      lastTimeoutAt: this.lastTimeoutAt,
+      oldestPendingPingAt,
+      oldestPendingPingAgeMs: oldestPendingPingAt != null ? now - oldestPendingPingAt : null
+    };
+  }
 }
 var isCrypto = (value) => typeof value === "object" && value !== null && ("getRandomValues" in value) && typeof value.getRandomValues === "function";
 
@@ -18411,6 +18441,11 @@ class ProtocolClient {
   reconnectionTimer = null;
   authenticationTimeout = null;
   listenersStarted = false;
+  lastConnectingAt = null;
+  lastOpenAt = null;
+  lastTransportMessageAt = null;
+  lastFailureAt = null;
+  lastFailureReason = null;
   constructor(options) {
     this.transport = options.transport;
     this.log = options.logger ?? {};
@@ -18438,7 +18473,10 @@ class ProtocolClient {
     }
   }
   async reconnect(options) {
-    await this.transport.reconnect({ skipDelay: options?.skipDelay });
+    await this.transport.reconnect({
+      skipDelay: options?.skipDelay,
+      cause: options?.cause ?? this.lastFailureReason ?? "protocol-reconnect"
+    });
   }
   async sendRpc(method, input = emptyRpcInput) {
     this.ensureOpenForRpc();
@@ -18499,6 +18537,7 @@ class ProtocolClient {
     });
   }
   async handleTransportMessage(message) {
+    this.lastTransportMessageAt = Date.now();
     switch (message.body.oneofKind) {
       case "connectionOpen":
         await this.connectionOpen();
@@ -18531,7 +18570,7 @@ class ProtocolClient {
         this.pingPong.pong(message.body.pong.nonce);
         break;
       case "connectionError":
-        this.handleClientFailure();
+        this.handleClientFailure(describeConnectionError(message.body.connectionError));
         break;
       default:
         break;
@@ -18553,11 +18592,12 @@ class ProtocolClient {
       this.startAuthenticationTimeout();
     } catch (error) {
       this.log.error?.("Failed to authenticate", error);
-      this.handleClientFailure();
+      this.handleClientFailure(`authenticate failed: ${summarizeError(error)}`);
     }
   }
   async connectionOpen() {
     this.state = "open";
+    this.lastOpenAt = Date.now();
     await this.events.send({ type: "open" });
     this.stopAuthenticationTimeout();
     if (this.reconnectionTimer) {
@@ -18569,7 +18609,9 @@ class ProtocolClient {
     this.resendPendingRpcRequests();
   }
   async connecting() {
+    this.pingPong.stop();
     this.state = "connecting";
+    this.lastConnectingAt = Date.now();
     await this.events.send({ type: "connecting" });
   }
   async reset() {
@@ -18583,7 +18625,7 @@ class ProtocolClient {
     this.authenticationTimeout = setTimeout(() => {
       if (this.state === "open")
         return;
-      this.handleClientFailure();
+      this.handleClientFailure("authentication timeout after 10000ms");
     }, 1e4);
   }
   stopAuthenticationTimeout() {
@@ -18592,19 +18634,23 @@ class ProtocolClient {
     clearTimeout(this.authenticationTimeout);
     this.authenticationTimeout = null;
   }
-  handleClientFailure() {
+  handleClientFailure(reason = "connection failure") {
     this.pingPong.stop();
     this.stopAuthenticationTimeout();
     this.state = "connecting";
+    this.lastFailureAt = Date.now();
+    this.lastFailureReason = reason;
     if (this.reconnectionTimer) {
       clearTimeout(this.reconnectionTimer);
     }
     this.connectionAttemptNo = this.connectionAttemptNo + 1 >>> 0;
+    const delayMs = Math.round(this.getReconnectionDelay() * 1000);
+    this.log.warn?.(`Protocol reconnect scheduled (attempt=${this.connectionAttemptNo}, delayMs=${delayMs}, reason=${reason})`);
     this.reconnectionTimer = setTimeout(() => {
       if (this.state === "open")
         return;
       this.reconnect({ skipDelay: true });
-    }, this.getReconnectionDelay() * 1000);
+    }, delayMs);
   }
   getReconnectionDelay() {
     const attemptNo = this.connectionAttemptNo;
@@ -18690,11 +18736,25 @@ class ProtocolClient {
     pending.sending = true;
     this.transport.send(pending.message).catch((error) => {
       this.log.warn?.("Failed to send RPC request; waiting for reconnect", error);
-      this.handleClientFailure();
+      this.handleClientFailure(`rpc send failed: ${summarizeError(error)}`);
     }).finally(() => {
       pending.sending = false;
     });
   }
+  getDiagnostics() {
+    return {
+      state: this.state,
+      connectionAttemptNo: this.connectionAttemptNo,
+      pendingRpcCount: this.pendingRpcRequests.size,
+      lastConnectingAt: this.lastConnectingAt,
+      lastOpenAt: this.lastOpenAt,
+      lastTransportMessageAt: this.lastTransportMessageAt,
+      lastFailureAt: this.lastFailureAt,
+      lastFailureReason: this.lastFailureReason,
+      ping: this.pingPong.getDiagnostics(),
+      transport: typeof this.transport.getDiagnostics === "function" ? this.transport.getDiagnostics() : null
+    };
+  }
 }
 var normalizeRpcTimeoutMs = (timeoutMs, fallback) => {
   const resolved = timeoutMs === undefined ? fallback : timeoutMs;
@@ -18715,6 +18775,18 @@ class ProtocolClientError extends Error {
     this.name = `ProtocolClientError:${code}`;
   }
 }
+function summarizeError(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+function describeConnectionError(error) {
+  const value = typeof error === "object" && error !== null ? error : null;
+  const code = typeof value?.code === "number" ? value.code : null;
+  const message = typeof value?.message === "string" && value.message.trim() ? value.message.trim() : "unknown";
+  return `server connection error${code != null ? ` (code=${code})` : ""}: ${message}`;
+}
 
 // ../../node_modules/.bun/ws@8.20.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -18746,6 +18818,18 @@ class WebSocketTransport {
   connectionAttemptNo = 0;
   socket = null;
   reconnectionTimer = null;
+  lastConnectStartedAt = null;
+  lastConnectedAt = null;
+  lastDisconnectedAt = null;
+  lastMessageAt = null;
+  lastCloseCode = null;
+  lastCloseReason = null;
+  lastErrorAt = null;
+  lastErrorMessage = null;
+  lastReconnectScheduledAt = null;
+  lastReconnectDelayMs = null;
+  lastReconnectCause = null;
+  reconnectCount = 0;
   constructor(options) {
     this.url = options.url;
     this.log = options.logger ?? {};
@@ -18777,7 +18861,13 @@ class WebSocketTransport {
     this.cleanUpPreviousConnection();
     this.connectionAttemptNo = this.connectionAttemptNo + 1 >>> 0;
     const delaySeconds = this.getReconnectionDelaySeconds(this.connectionAttemptNo);
-    this.log.debug?.("reconnect scheduled", { attempt: this.connectionAttemptNo, delaySeconds });
+    const delayMs = Math.round(delaySeconds * 1000);
+    const cause = options?.cause?.trim() || "unspecified";
+    this.lastReconnectScheduledAt = Date.now();
+    this.lastReconnectDelayMs = delayMs;
+    this.lastReconnectCause = cause;
+    this.reconnectCount += 1;
+    this.log.warn?.(`WebSocket reconnect scheduled (attempt=${this.connectionAttemptNo}, delayMs=${delayMs}, cause=${cause})`);
     this.reconnectionTimer = setTimeout(() => {
       this.reconnectionTimer = null;
       if (this.state === "idle" || this.state === "connected")
@@ -18821,6 +18911,7 @@ class WebSocketTransport {
   async openConnection() {
     if (this.state === "idle")
       return;
+    this.lastConnectStartedAt = Date.now();
     const socket = new import_websocket.default(this.url);
     this.socket = socket;
     socket.on("open", () => {
@@ -18843,6 +18934,8 @@ class WebSocketTransport {
       return;
     this.connectionAttemptNo = 0;
     this.state = "connected";
+    this.lastConnectedAt = Date.now();
+    this.lastDisconnectedAt = null;
     await this.events.send({ type: "connected" });
   }
   async handleMessage(socket, data) {
@@ -18851,6 +18944,7 @@ class WebSocketTransport {
     try {
       const payload = this.coerceBinary(data);
       const message = ServerProtocolMessage.fromBinary(payload);
+      this.lastMessageAt = Date.now();
       await this.events.send({ type: "message", message });
     } catch (error) {
       this.log.error?.("Failed to decode message", error);
@@ -18870,16 +18964,24 @@ class WebSocketTransport {
       return;
     if (this.state === "idle")
       return;
-    this.log.warn?.("WebSocket closed", { code, reason: reason.toString("utf8") });
-    await this.reconnect();
+    const reasonText = stringifyCloseReason(reason);
+    this.lastDisconnectedAt = Date.now();
+    this.lastCloseCode = code;
+    this.lastCloseReason = reasonText;
+    const connectedForMs = this.lastConnectedAt != null ? Math.max(0, this.lastDisconnectedAt - this.lastConnectedAt) : null;
+    this.log.warn?.(`WebSocket closed (code=${code}, reason=${reasonText || "none"}${connectedForMs != null ? `, connectedForMs=${connectedForMs}` : ""})`);
+    await this.reconnect({ cause: `socket-close:${code}${reasonText ? `:${reasonText}` : ""}` });
   }
   async handleError(socket, error) {
     if (this.socket !== socket)
       return;
     if (this.state === "idle")
       return;
-    this.log.error?.("WebSocket error", error);
-    await this.reconnect();
+    const summary = summarizeError2(error);
+    this.lastErrorAt = Date.now();
+    this.lastErrorMessage = summary;
+    this.log.error?.(`WebSocket error: ${summary}`);
+    await this.reconnect({ cause: `socket-error:${summary}` });
   }
   async setIdle() {
     if (this.state === "idle")
@@ -18893,6 +18995,46 @@ class WebSocketTransport {
     this.state = "connecting";
     await this.events.send({ type: "connecting" });
   }
+  getDiagnostics() {
+    return {
+      kind: "websocket",
+      url: redactUrlForDiagnostics(this.url),
+      state: this.state,
+      connectionAttemptNo: this.connectionAttemptNo,
+      reconnectCount: this.reconnectCount,
+      lastConnectStartedAt: this.lastConnectStartedAt,
+      lastConnectedAt: this.lastConnectedAt,
+      lastDisconnectedAt: this.lastDisconnectedAt,
+      lastMessageAt: this.lastMessageAt,
+      lastCloseCode: this.lastCloseCode,
+      lastCloseReason: this.lastCloseReason,
+      lastErrorAt: this.lastErrorAt,
+      lastErrorMessage: this.lastErrorMessage,
+      lastReconnectScheduledAt: this.lastReconnectScheduledAt,
+      lastReconnectDelayMs: this.lastReconnectDelayMs,
+      lastReconnectCause: this.lastReconnectCause,
+      socketReadyState: this.socket?.readyState ?? null
+    };
+  }
+}
+function stringifyCloseReason(reason) {
+  const text = reason.toString("utf8").trim();
+  return text;
+}
+function summarizeError2(error) {
+  if (error instanceof Error) {
+    const code = typeof error.code === "string" ? error.code : null;
+    return code ? `${error.name}: ${error.message} (code=${code})` : `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+function redactUrlForDiagnostics(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.protocol}//${url.host}${url.pathname}`;
+  } catch {
+    return raw;
+  }
 }
 
 // ../sdk/dist/sdk/types.js
@@ -19047,6 +19189,7 @@ class InlineSdkClient {
   saveInFlight = null;
   catchUpInFlightByChatId = new Map;
   catchUpRequestedByChatId = new Map;
+  userCatchUpInFlight = null;
   constructor(options) {
     this.options = options;
     this.log = options.logger ?? noopLogger;
@@ -19114,6 +19257,13 @@ class InlineSdkClient {
     await this.flushStateSave();
     await this.protocol.stopTransport();
   }
+  getDiagnostics() {
+    return {
+      started: this.started,
+      baseUrl: this.httpBaseUrl,
+      protocol: this.protocol.getDiagnostics()
+    };
+  }
   rejectOpen(error) {
     this.openRejecter?.(error);
     this.openResolver = null;
@@ -19126,7 +19276,8 @@ class InlineSdkClient {
     return {
       version: 1,
       ...this.state.dateCursor != null ? { dateCursor: this.state.dateCursor } : {},
-      ...this.state.lastSeqByChatId != null ? { lastSeqByChatId: { ...this.state.lastSeqByChatId } } : {}
+      ...this.state.lastSeqByChatId != null ? { lastSeqByChatId: { ...this.state.lastSeqByChatId } } : {},
+      ...this.state.lastUserSeq != null ? { lastUserSeq: this.state.lastUserSeq } : {}
     };
   }
   async getMe() {
@@ -19392,6 +19543,7 @@ class InlineSdkClient {
     this.openResolver = null;
     this.openRejecter = null;
     this.initializeDateCursor();
+    this.requestCatchUpUser();
   }
   async initializeDateCursor() {
     const date = this.state.dateCursor ?? nowSeconds();
@@ -19490,6 +19642,10 @@ class InlineSdkClient {
       }
       case "messageActionInvoked": {
         const payload = update.update.messageActionInvoked;
+        if (this.shouldSkipUserSeq(seq)) {
+          return;
+        }
+        this.bumpUserSeq(seq);
         await this.eventStream.send({
           kind: "message.action.invoke",
           interactionId: payload.interactionId,
@@ -19505,6 +19661,10 @@ class InlineSdkClient {
       }
       case "messageActionAnswered": {
         const payload = update.update.messageActionAnswered;
+        if (this.shouldSkipUserSeq(seq)) {
+          return;
+        }
+        this.bumpUserSeq(seq);
         await this.eventStream.send({
           kind: "message.action.answered",
           interactionId: payload.interactionId,
@@ -19551,6 +19711,86 @@ class InlineSdkClient {
       this.scheduleStateSave();
     }
   }
+  shouldSkipUserSeq(seq) {
+    if (!Number.isFinite(seq))
+      return false;
+    const lastUserSeq = this.state.lastUserSeq ?? 0;
+    return seq > 0 && seq <= lastUserSeq;
+  }
+  bumpUserSeq(seq) {
+    if (!Number.isFinite(seq) || seq <= 0)
+      return;
+    const prev = this.state.lastUserSeq ?? 0;
+    if (seq > prev) {
+      this.state.lastUserSeq = seq;
+      this.scheduleStateSave();
+    }
+  }
+  requestCatchUpUser() {
+    const lastUserSeq = this.state.lastUserSeq ?? 0;
+    if (lastUserSeq <= 0) {
+      return;
+    }
+    if (this.userCatchUpInFlight) {
+      return;
+    }
+    this.userCatchUpInFlight = this.doCatchUpUser(lastUserSeq).catch((error) => {
+      this.log.warn?.("GET_UPDATES user catch-up failed; continuing live delivery", {
+        error: extractErrorMessage(error)
+      });
+    }).finally(() => {
+      this.userCatchUpInFlight = null;
+    });
+  }
+  async doCatchUpUser(startSeq) {
+    let cursor = startSeq;
+    while (true) {
+      const result = await this.invoke(Method.GET_UPDATES, {
+        oneofKind: "getUpdates",
+        getUpdates: GetUpdatesInput.create({
+          bucket: UpdateBucket.create({
+            type: {
+              oneofKind: "user",
+              user: {}
+            }
+          }),
+          startSeq: BigInt(cursor),
+          totalLimit: defaultCatchUpTotalLimit
+        })
+      });
+      const payload = result.getUpdates;
+      const deliveredSeq = Number(payload.seq ?? 0n);
+      if (!Number.isSafeInteger(deliveredSeq)) {
+        this.log.warn?.("GET_UPDATES user catch-up returned non-integer seq; aborting", { deliveredSeq });
+        return;
+      }
+      if (payload.resultType === GetUpdatesResult_ResultType.TOO_LONG) {
+        this.log.warn?.("GET_UPDATES user catch-up too long; fast-forwarding cursor", { seq: deliveredSeq });
+        this.bumpUserSeq(deliveredSeq);
+        if (payload.date !== 0n) {
+          this.state.dateCursor = payload.date;
+        }
+        this.scheduleStateSave();
+        return;
+      }
+      for (const update of payload.updates) {
+        await this.handleUpdate(update);
+      }
+      this.bumpUserSeq(deliveredSeq);
+      if (payload.date !== 0n) {
+        this.state.dateCursor = payload.date;
+      }
+      this.scheduleStateSave();
+      if (payload.final) {
+        return;
+      }
+      if (deliveredSeq <= cursor) {
+        this.log.warn?.("GET_UPDATES user catch-up made no progress; aborting", { cursor, deliveredSeq });
+        return;
+      }
+      cursor = deliveredSeq;
+    }
+  }
   requestCatchUpChat(params) {
     const previous = this.catchUpRequestedByChatId.get(params.chatId);
     this.catchUpRequestedByChatId.set(params.chatId, {
@@ -19715,7 +19955,8 @@ class InlineSdkClient {
     const snapshot = {
       version: 1,
       ...this.state.dateCursor != null ? { dateCursor: this.state.dateCursor } : {},
-      ...this.state.lastSeqByChatId != null ? { lastSeqByChatId: { ...this.state.lastSeqByChatId } } : {}
+      ...this.state.lastSeqByChatId != null ? { lastSeqByChatId: { ...this.state.lastSeqByChatId } } : {},
+      ...this.state.lastUserSeq != null ? { lastUserSeq: this.state.lastUserSeq } : {}
     };
     this.saveInFlight = store.save(snapshot).catch((error) => {
       this.log.warn?.("Failed to persist SDK state", error);
@@ -34029,9 +34270,21 @@ function looksLikeInlineTargetId(raw, normalizedInput) {
 // src/inline/monitor.ts
 import { mkdir } from "node:fs/promises";
 import path2 from "node:path";
+import {
+  buildCommandTextFromArgs,
+  findCommandByNativeName,
+  parseCommandArgs,
+  resolveCommandArgMenu
+} from "openclaw/plugin-sdk/native-command-registry";
+import {
+  createChannelInboundDebouncer,
+  shouldDebounceTextInbound
+} from "openclaw/plugin-sdk/channel-inbound";
+import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
+import { applyModelOverrideToSessionEntry, updateSessionStore } from "openclaw/plugin-sdk/config-runtime";
+import { buildModelsProviderData } from "openclaw/plugin-sdk/models-provider-runtime";
 
 // src/sdk-runtime-compat.ts
-import { createMessageToolButtonsSchema } from "openclaw/plugin-sdk/channel-actions";
 var HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
 var CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
 var MAX_HISTORY_KEYS = 1000;
@@ -34122,14 +34375,6 @@ function recordPendingHistoryEntryIfEnabled(params) {
     limit: params.limit
   });
 }
-var TYPEBOX_OPTIONAL_SYMBOL = Symbol.for("TypeBox.Optional");
-function markTypeBoxOptional(schema) {
-  schema[TYPEBOX_OPTIONAL_SYMBOL] = "Optional";
-  return schema;
-}
-function createMessageToolButtonsSchemaCompat() {
-  return markTypeBoxOptional(createMessageToolButtonsSchema());
-}
 function extensionForMimeCompat(mime) {
   const normalized = mime?.trim().toLowerCase();
   if (!normalized)
@@ -34230,44 +34475,6 @@ async function createChannelReplyPipelineCompat(params) {
     };
   }
 }
-async function loadNativeCommandHelpersCompat() {
-  try {
-    const sdk = await import("openclaw/plugin-sdk/command-auth");
-    const listNativeCommandSpecsForConfig = typeof sdk.listNativeCommandSpecsForConfig === "function" ? sdk.listNativeCommandSpecsForConfig : null;
-    const listSkillCommandsForAgents = typeof sdk.listSkillCommandsForAgents === "function" ? sdk.listSkillCommandsForAgents : null;
-    if (!listNativeCommandSpecsForConfig || !listSkillCommandsForAgents) {
-      throw new Error("command-auth helpers unavailable");
-    }
-    return {
-      available: true,
-      listNativeCommandSpecsForConfig,
-      listSkillCommandsForAgents
-    };
-  } catch {
-    return {
-      available: false,
-      listNativeCommandSpecsForConfig: () => [],
-      listSkillCommandsForAgents: () => []
-    };
-  }
-}
-async function loadPluginCommandSpecsCompat(provider) {
-  try {
-    const sdk = await import("openclaw/plugin-sdk/plugin-runtime");
-    if (typeof sdk.getPluginCommandSpecs !== "function") {
-      throw new Error("plugin runtime command helper unavailable");
-    }
-    return {
-      available: true,
-      specs: sdk.getPluginCommandSpecs(provider)
-    };
-  } catch {
-    return {
-      available: false,
-      specs: []
-    };
-  }
-}
 
 // src/inline/message-formatting.ts
 var INLINE_FORMATTING_NOTE = "Inline formatting note: prefer bullet lists over markdown tables. If a table is necessary, render it inside a fenced code block. Do not wrap bare URLs in inline code or backticks. Use plain URLs or markdown links. Use inline code only for actual code, commands, file paths, env vars, or identifiers.";
@@ -34926,246 +35133,28 @@ function summarizeInlineMessageContent(message) {
   };
 }
 
-// src/inline/command-menu-compat.ts
-var THINKING_LEVEL_CHOICES = ["off", "minimal", "low", "medium", "high", "xhigh"];
-var COMPAT_COMMANDS = [
-  {
-    key: "tts",
-    nativeName: "tts",
-    args: [
-      {
-        name: "action",
-        description: "TTS action",
-        choices: [
-          { value: "on", label: "On" },
-          { value: "off", label: "Off" },
-          { value: "status", label: "Status" },
-          { value: "provider", label: "Provider" },
-          { value: "limit", label: "Limit" },
-          { value: "summary", label: "Summary" },
-          { value: "audio", label: "Audio" },
-          { value: "help", label: "Help" }
-        ]
-      },
-      { name: "value", description: "Provider, limit, or text" }
-    ],
-    argsMenu: {
-      arg: "action",
-      title: "Choose TTS action:"
-    }
-  },
-  {
-    key: "session",
-    nativeName: "session",
-    args: [
-      { name: "action", description: "idle | max-age", choices: ["idle", "max-age"] },
-      { name: "value", description: "Duration or off" }
-    ],
-    argsMenu: "auto"
-  },
-  {
-    key: "subagents",
-    nativeName: "subagents",
-    args: [
-      {
-        name: "action",
-        description: "list | kill | log | info | send | steer | spawn",
-        choices: ["list", "kill", "log", "info", "send", "steer", "spawn"]
-      },
-      { name: "target", description: "Run id, index, or session key" },
-      { name: "value", description: "Additional input" }
-    ],
-    argsMenu: "auto"
-  },
-  {
-    key: "acp",
-    nativeName: "acp",
-    args: [
-      {
-        name: "action",
-        description: "Action to run",
-        choices: [
-          "spawn",
-          "cancel",
-          "steer",
-          "close",
-          "sessions",
-          "status",
-          "set-mode",
-          "set",
-          "cwd",
-          "permissions",
-          "timeout",
-          "model",
-          "reset-options",
-          "doctor",
-          "install",
-          "help"
-        ]
-      },
-      { name: "value", description: "Action arguments" }
-    ],
-    argsMenu: "auto"
-  },
-  {
-    key: "usage",
-    nativeName: "usage",
-    args: [{ name: "mode", description: "off, tokens, full, or cost", choices: ["off", "tokens", "full", "cost"] }],
-    argsMenu: "auto"
-  },
-  {
-    key: "activation",
-    nativeName: "activation",
-    args: [{ name: "mode", description: "mention or always", choices: ["mention", "always"] }],
-    argsMenu: "auto"
-  },
-  {
-    key: "send",
-    nativeName: "send",
-    args: [{ name: "mode", description: "on, off, or inherit", choices: ["on", "off", "inherit"] }],
-    argsMenu: "auto"
-  },
-  {
-    key: "think",
-    nativeName: "think",
-    args: [{ name: "level", description: "thinking level", choices: [...THINKING_LEVEL_CHOICES] }],
-    argsMenu: "auto"
-  },
-  {
-    key: "verbose",
-    nativeName: "verbose",
-    args: [{ name: "mode", description: "on or off", choices: ["on", "off"] }],
-    argsMenu: "auto"
-  },
-  {
-    key: "fast",
-    nativeName: "fast",
-    args: [{ name: "mode", description: "status, on, or off", choices: ["status", "on", "off"] }],
-    argsMenu: "auto"
-  },
-  {
-    key: "reasoning",
-    nativeName: "reasoning",
-    args: [{ name: "mode", description: "on, off, or stream", choices: ["on", "off", "stream"] }],
-    argsMenu: "auto"
-  },
-  {
-    key: "elevated",
-    nativeName: "elevated",
-    args: [{ name: "mode", description: "on, off, ask, or full", choices: ["on", "off", "ask", "full"] }],
-    argsMenu: "auto"
-  }
-];
-function parsePositionalArgs(definitions, raw) {
-  const values = {};
-  const trimmed = raw.trim();
-  if (!trimmed)
-    return values;
-  const tokens = trimmed.split(/\s+/).filter(Boolean);
-  let index = 0;
-  for (const definition of definitions) {
-    if (index >= tokens.length)
-      break;
-    const token = tokens[index];
-    if (!token)
-      break;
-    values[definition.name] = token;
-    index += 1;
-  }
-  return values;
-}
-function parseCommandArgs(command, raw) {
-  const trimmed = raw?.trim();
-  if (!trimmed)
-    return;
-  if (!command.args || command.argsParsing === "none") {
-    return { raw: trimmed };
-  }
-  return {
-    raw: trimmed,
-    values: parsePositionalArgs(command.args, trimmed)
-  };
-}
-function findCommandByNativeName(name) {
-  const normalized = name.trim().toLowerCase();
-  return COMPAT_COMMANDS.find((command) => command.nativeName.toLowerCase() === normalized);
-}
-function resolveCommandArgChoices(arg) {
-  const raw = arg.choices ?? [];
-  return raw.map((choice) => typeof choice === "string" ? { value: choice, label: choice } : choice);
-}
-function resolveCommandArgMenu(params) {
-  const { command, args } = params;
-  if (!command.args || !command.argsMenu)
-    return null;
-  if (command.argsParsing === "none")
-    return null;
-  const argName = command.argsMenu === "auto" ? command.args.find((arg2) => resolveCommandArgChoices(arg2).length > 0)?.name : command.argsMenu.arg;
-  if (!argName)
-    return null;
-  if (args?.values && args.values[argName] != null)
-    return null;
-  if (args?.raw && !args.values)
-    return null;
-  const arg = command.args.find((entry) => entry.name === argName);
-  if (!arg)
-    return null;
-  const choices = resolveCommandArgChoices(arg);
-  if (choices.length === 0)
-    return null;
-  const title = command.argsMenu !== "auto" ? command.argsMenu.title : undefined;
-  return {
-    arg,
-    choices,
-    ...title ? { title } : {}
-  };
-}
-function buildCommandTextFromArgs(command, args) {
-  const values = args?.values ?? {};
-  const argDefs = command.args ?? [];
-  const renderedArgs = [];
-  for (const argDef of argDefs) {
-    const value = values[argDef.name];
-    if (value == null)
-      continue;
-    const normalized = typeof value === "string" ? value.trim() : String(value);
-    if (!normalized)
-      continue;
-    renderedArgs.push(normalized);
+// src/inline/monitor.ts
+var CHANNEL_ID = "inline";
+function summarizeSdkMeta(meta3) {
+  if (meta3 == null)
+    return "";
+  if (meta3 instanceof Error)
+    return `${meta3.name}: ${meta3.message}`;
+  if (typeof meta3 === "string")
+    return meta3;
+  try {
+    const json2 = JSON.stringify(meta3);
+    return json2 === undefined ? String(meta3) : json2;
+  } catch {
+    return String(meta3);
   }
-  return renderedArgs.length > 0 ? `/${command.nativeName} ${renderedArgs.join(" ")}` : `/${command.nativeName}`;
 }
-function resolveInlineCompatNativeCommandMenu(commandBody) {
-  const normalized = commandBody.trim();
-  const match = normalized.match(/^\/([^\s]+)(?:\s+([\s\S]+))?$/);
-  if (!match?.[1])
-    return null;
-  const command = findCommandByNativeName(match[1]);
-  if (!command)
-    return null;
-  const args = parseCommandArgs(command, match[2]);
-  const menu = resolveCommandArgMenu({
-    command,
-    ...args ? { args } : {}
-  });
-  if (!menu)
-    return null;
-  const title = menu.title ?? `Choose ${menu.arg.description || menu.arg.name} for /${command.nativeName}.`;
-  const rows = [];
-  for (let index = 0;index < menu.choices.length; index += 2) {
-    const slice = menu.choices.slice(index, index + 2);
-    rows.push(slice.map((choice) => ({
-      text: choice.label,
-      callback_data: buildCommandTextFromArgs(command, {
-        values: { [menu.arg.name]: choice.value }
-      })
-    })));
-  }
-  return { title, buttons: rows };
+function formatSdkLogLine(message, meta3) {
+  const detail = summarizeSdkMeta(meta3);
+  if (!detail)
+    return message;
+  return `${message} ${detail}`;
 }
-
-// src/inline/monitor.ts
-var CHANNEL_ID = "inline";
 var DEFAULT_DM_HISTORY_LIMIT = 6;
 var HISTORY_LINE_MAX_CHARS = 280;
 var URL_LIKE_PATTERN = /https?:\/\/\S+/i;
@@ -35228,35 +35217,137 @@ function callbackDataToUtf8(data) {
     return;
   }
 }
+function buildInlineInboundMessageSid(params) {
+  if (params.callbackActionEvent) {
+    return `callback:${String(params.callbackActionEvent.targetMessageId)}:${String(params.callbackActionEvent.interactionId)}`;
+  }
+  return String(params.msgId);
+}
+function buildInlineDebounceKey(params) {
+  if (params.senderId == null)
+    return null;
+  return `inline:${params.accountId}:${String(params.chatId)}:${String(params.senderId)}`;
+}
+function buildSyntheticInlineTextMessage(params) {
+  return {
+    ...params.base,
+    message: params.text,
+    ...params.mentioned !== undefined ? { mentioned: params.mentioned } : {}
+  };
+}
 var INLINE_ACTION_MAX_ROWS = 8;
 var INLINE_ACTION_MAX_PER_ROW = 8;
 function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
+function resolveInlineNativeCommandMenu(params) {
+  const normalized = params.commandBody.trim();
+  const match = normalized.match(/^\/([^\s]+)(?:\s+([\s\S]+))?$/);
+  if (!match?.[1])
+    return null;
+  const command = findCommandByNativeName(match[1], "telegram");
+  if (!command)
+    return null;
+  const args = parseCommandArgs(command, match[2]);
+  const menu = resolveCommandArgMenu({
+    command,
+    ...args ? { args } : {},
+    cfg: params.cfg
+  });
+  if (!menu)
+    return null;
+  const title = menu.title ?? `Choose ${menu.arg.description || menu.arg.name} for /${command.nativeName}.`;
+  const rows = [];
+  for (let index = 0;index < menu.choices.length; index += 2) {
+    const slice = menu.choices.slice(index, index + 2);
+    rows.push(slice.map((choice) => ({
+      text: choice.label,
+      callback_data: buildCommandTextFromArgs(command, {
+        values: { [menu.arg.name]: choice.value }
+      })
+    })));
+  }
+  return { title, buttons: rows };
+}
 function mapInlineModelPickerCallbackToCommand(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed)
+  const callback = parseInlineModelPickerCallback(raw);
+  if (!callback)
     return;
-  if (trimmed === "mdl_prov" || trimmed === "mdl_back") {
-    return "/models";
+  switch (callback.type) {
+    case "providers":
+    case "back":
+      return "/models";
+    case "list":
+      return `/models ${callback.provider} ${String(callback.page)}`;
+    case "select":
+      return callback.provider ? `/model ${callback.provider}/${callback.model}` : `/model ${callback.model}`;
   }
+}
+function parseInlineModelPickerCallback(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "mdl_prov")
+    return { type: "providers" };
+  if (trimmed === "mdl_back")
+    return { type: "back" };
   const listMatch = trimmed.match(/^mdl_list_([a-z0-9_-]+)_(\d+)$/i);
   if (listMatch?.[1] && listMatch[2]) {
     const provider = listMatch[1].trim();
     const page = Number.parseInt(listMatch[2], 10);
     if (provider && Number.isFinite(page) && page > 0) {
-      return `/models ${provider} ${String(page)}`;
+      return { type: "list", provider, page };
     }
   }
   const standardSelectionMatch = trimmed.match(/^mdl_sel_(.+)$/);
   if (standardSelectionMatch?.[1]?.trim()) {
-    return `/model ${standardSelectionMatch[1].trim()}`;
+    const modelRef = standardSelectionMatch[1].trim();
+    const slashIndex = modelRef.indexOf("/");
+    if (slashIndex > 0 && slashIndex < modelRef.length - 1) {
+      return {
+        type: "select",
+        provider: modelRef.slice(0, slashIndex),
+        model: modelRef.slice(slashIndex + 1)
+      };
+    }
   }
   const compactSelectionMatch = trimmed.match(/^mdl_sel\/(.+)$/);
   if (compactSelectionMatch?.[1]?.trim()) {
-    return `/model ${compactSelectionMatch[1].trim()}`;
+    return { type: "select", model: compactSelectionMatch[1].trim() };
   }
-  return;
+  return null;
+}
+function resolveInlineModelPickerSelection(params) {
+  if (params.callback.provider) {
+    return {
+      kind: "resolved",
+      provider: params.callback.provider,
+      model: params.callback.model
+    };
+  }
+  const matchingProviders = params.providers.filter((id) => params.byProvider.get(id)?.has(params.callback.model));
+  if (matchingProviders.length === 1 && matchingProviders[0]) {
+    return {
+      kind: "resolved",
+      provider: matchingProviders[0],
+      model: params.callback.model
+    };
+  }
+  return {
+    kind: "ambiguous",
+    model: params.callback.model
+  };
+}
+function buildInlineModelProviderButtons(providers) {
+  const rows = [];
+  for (let index = 0;index < providers.length; index += 2) {
+    const slice = providers.slice(index, index + 2);
+    rows.push(slice.map((provider) => ({
+      text: `${provider.id} (${provider.count})`,
+      callback_data: `mdl_list_${provider.id}_1`
+    })));
+  }
+  return rows;
 }
 function normalizeInlineActionCallbackData(raw) {
   const trimmed = raw.trim();
@@ -35264,6 +35355,14 @@ function normalizeInlineActionCallbackData(raw) {
     return "";
   return mapInlineModelPickerCallbackToCommand(trimmed) ?? trimmed;
 }
+function normalizeInlineTelegramButtonCallbackData(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return "";
+  if (parseInlineModelPickerCallback(trimmed))
+    return trimmed;
+  return normalizeInlineActionCallbackData(trimmed);
+}
 function normalizeReplyMarkupButtonsWith(raw, options) {
   if (!Array.isArray(raw))
     return [];
@@ -35305,7 +35404,7 @@ function resolveInlineReplyActions(payload) {
   } else if (telegramData && Object.prototype.hasOwnProperty.call(telegramData, "buttons")) {
     rawButtons = telegramData.buttons;
     hasExplicitButtons = true;
-    mapCallbackData = normalizeInlineActionCallbackData;
+    mapCallbackData = normalizeInlineTelegramButtonCallbackData;
   } else if (Object.prototype.hasOwnProperty.call(payload, "buttons")) {
     rawButtons = payload.buttons;
     hasExplicitButtons = true;
@@ -35870,19 +35969,35 @@ async function monitorInlineProvider(params) {
   const stateDir = core3.state.resolveStateDir();
   const statePath = path2.join(stateDir, "channels", "inline", `${account.accountId}.json`);
   await mkdir(path2.dirname(statePath), { recursive: true });
+  let client = null;
+  const pushDiagnostics = (patch) => {
+    statusSink?.({
+      ...patch ?? {},
+      ...client ? { diagnostics: client.getDiagnostics() } : {}
+    });
+  };
   const sdkLog = {
-    debug: (msg) => log?.debug?.(msg),
-    info: (msg) => log?.info(msg),
-    warn: (msg) => log?.warn(msg),
-    error: (msg) => log?.error(msg)
+    debug: (msg, meta3) => log?.debug?.(formatSdkLogLine(msg, meta3)),
+    info: (msg, meta3) => log?.info(formatSdkLogLine(msg, meta3)),
+    warn: (msg, meta3) => {
+      const line = formatSdkLogLine(msg, meta3);
+      log?.warn(line);
+      pushDiagnostics({ lastError: line });
+    },
+    error: (msg, meta3) => {
+      const line = formatSdkLogLine(msg, meta3);
+      log?.error(line);
+      pushDiagnostics({ lastError: line });
+    }
   };
-  const client = new InlineSdkClient({
+  client = new InlineSdkClient({
     baseUrl: account.baseUrl,
     token,
     logger: sdkLog,
     state: new JsonFileStateStore(statePath)
   });
   await client.connect(abortSignal);
+  pushDiagnostics();
   const meResult = await client.invokeRaw(Method.GET_ME, {
     oneofKind: "getMe",
     getMe: {}
@@ -35893,6 +36008,7 @@ async function monitorInlineProvider(params) {
   const meId = meResult.getMe.user.id;
   const botUsername = normalizeInlineUsername(meResult.getMe.user.username)?.toLowerCase();
   log?.info(`[${account.accountId}] inline connected (me=${String(meId)})`);
+  pushDiagnostics();
   const chatCache = new Map;
   const senderProfilesById = new Map;
   const botMessageIdsByChat = new Map;
@@ -35937,852 +36053,1078 @@ async function monitorInlineProvider(params) {
     participantFetches.set(chatKey, run);
     await run;
   };
-  const loop = (async () => {
+  const handleInboundNow = async (input) => {
+    const chatId = input.chatId;
+    const msg = input.msg;
+    const rawBodyOverride = input.rawBodyOverride ?? null;
+    const reactionEvent = input.reactionEvent ?? null;
+    const callbackActionEvent = input.callbackActionEvent ?? null;
+    let rawBody = "";
+    let currentContent = null;
+    let currentAttachmentText = null;
+    let currentEntityText = null;
+    if (!reactionEvent && !callbackActionEvent) {
+      if (rawBodyOverride != null) {
+        rawBody = rawBodyOverride.trim();
+      } else {
+        currentContent = summarizeInlineMessageContent(msg);
+        rawBody = buildInlineInboundBodyText(currentContent);
+        currentAttachmentText = currentContent.attachmentText || null;
+        currentEntityText = currentContent.entityText || null;
+      }
+      if (!rawBody)
+        return;
+    }
+    statusSink?.({ lastInboundAt: Date.now() });
+    let chatInfo;
     try {
-      for await (const event of client.events()) {
-        if (abortSignal.aborted)
-          break;
-        const rawEvent = event;
-        let msg;
-        let rawBody = "";
-        let currentContent = null;
-        let currentAttachmentText = null;
-        let currentEntityText = null;
-        let reactionEvent = null;
-        let inboundChatId = null;
-        let callbackActionEvent = null;
-        if (event.kind === "message.new") {
-          inboundChatId = event.chatId;
-          msg = {
-            ...event.message,
-            chatId: event.chatId
-          };
-          currentContent = summarizeInlineMessageContent(msg);
-          rawBody = buildInlineInboundBodyText(currentContent);
-          currentAttachmentText = currentContent.attachmentText || null;
-          currentEntityText = currentContent.entityText || null;
-          if (!rawBody)
-            continue;
-          if (msg.out || msg.fromId === meId)
-            continue;
-        } else if (event.kind === "reaction.add") {
-          inboundChatId = event.chatId;
-          if (event.reaction.userId === meId)
-            continue;
-          const onBotMessage = await isReactionTargetBotMessage({
-            client,
-            chatId: event.chatId,
-            messageId: event.reaction.messageId,
-            meId,
-            botMessageIdsByChat
-          }).catch((err) => {
-            statusSink?.({ lastError: `getChatHistory (reaction target) failed: ${String(err)}` });
-            return false;
-          });
-          if (!onBotMessage)
-            continue;
-          reactionEvent = {
-            action: "added",
-            emoji: event.reaction.emoji,
-            targetMessageId: event.reaction.messageId
-          };
-          msg = {
-            id: event.reaction.messageId,
-            chatId: event.chatId,
-            date: event.date,
-            fromId: event.reaction.userId,
-            message: "",
-            out: false,
-            mentioned: false,
-            replyToMsgId: event.reaction.messageId
-          };
-        } else if (event.kind === "reaction.delete") {
-          inboundChatId = event.chatId;
-          if (event.userId === meId)
-            continue;
-          const onBotMessage = await isReactionTargetBotMessage({
-            client,
-            chatId: event.chatId,
-            messageId: event.messageId,
-            meId,
-            botMessageIdsByChat
-          }).catch((err) => {
-            statusSink?.({ lastError: `getChatHistory (reaction target) failed: ${String(err)}` });
-            return false;
-          });
-          if (!onBotMessage)
-            continue;
-          reactionEvent = {
-            action: "removed",
-            emoji: event.emoji,
-            targetMessageId: event.messageId
-          };
-          msg = {
-            id: event.messageId,
-            chatId: event.chatId,
-            date: event.date,
-            fromId: event.userId,
-            message: "",
-            out: false,
-            mentioned: false,
-            replyToMsgId: event.messageId
-          };
-        } else if (rawEvent["kind"] === "message.action.invoke") {
-          const actorUserId = rawEvent["actorUserId"];
-          const interactionId = rawEvent["interactionId"];
-          const actionId = rawEvent["actionId"];
-          const targetMessageId = rawEvent["messageId"];
-          const data = rawEvent["data"];
-          const eventChatId = rawEvent["chatId"];
-          const eventDate = rawEvent["date"];
-          if (!actorUserId || !interactionId || !actionId || !targetMessageId || !eventChatId || !eventDate || !data) {
-            continue;
-          }
-          inboundChatId = eventChatId;
-          if (actorUserId === meId)
-            continue;
-          callbackActionEvent = {
-            interactionId,
-            actionId,
-            targetMessageId,
-            data
-          };
-          msg = {
-            id: targetMessageId,
-            chatId: eventChatId,
-            date: eventDate,
-            fromId: actorUserId,
-            message: "",
-            out: false,
-            mentioned: false,
-            replyToMsgId: targetMessageId
-          };
-        } else {
-          continue;
-        }
-        if (!inboundChatId)
-          continue;
-        const chatId = inboundChatId;
-        statusSink?.({ lastInboundAt: Date.now() });
-        let chatInfo;
-        try {
-          chatInfo = await resolveChatInfo(client, chatCache, chatId);
-        } catch (err) {
-          chatInfo = { kind: "group", title: null };
-          statusSink?.({ lastError: `getChat failed: ${String(err)}` });
-        }
-        const isGroup = chatInfo.kind !== "direct";
-        const replyThreadsEnabled = account.config.capabilities?.replyThreads === true || isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
-        const replyThreadContext = await resolveInlineInboundReplyThreadContext({
-          replyThreadsEnabled,
-          client,
-          chatId,
-          chatInfo,
-          chatCache
-        }).catch((err) => {
-          statusSink?.({ lastError: `getChat (reply thread) failed: ${String(err)}` });
-          return null;
-        });
-        const effectiveChatId = replyThreadContext?.parentChatId ?? chatId;
-        const effectiveGroupTitle = replyThreadContext?.parentChatTitle ?? chatInfo.title ?? null;
-        const senderId = String(msg.fromId);
-        await hydrateChatParticipants(chatId);
-        const senderProfile = senderProfilesById.get(senderId);
-        const senderUsername = senderProfile?.username;
-        const senderName = senderProfile?.name ?? (!isGroup ? chatInfo.title ?? undefined : undefined);
-        if (reactionEvent) {
-          const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
-          const emoji3 = reactionEvent.emoji.trim() || "a reaction";
-          const messageId = String(reactionEvent.targetMessageId);
-          if (reactionEvent.action === "added") {
-            rawBody = `${actor} reacted with ${emoji3} to your message #${messageId}`;
-          } else {
-            rawBody = `${actor} removed ${emoji3} from your message #${messageId}`;
-          }
-        } else if (callbackActionEvent) {
-          const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
-          const payload = {
-            type: "inline_message_action_callback",
-            interaction_id: String(callbackActionEvent.interactionId),
-            actor_user_id: senderId,
-            chat_id: String(chatId),
-            message_id: String(callbackActionEvent.targetMessageId),
-            action_id: callbackActionEvent.actionId,
-            data_base64: callbackDataToBase64(callbackActionEvent.data),
-            data_utf8: callbackDataToUtf8(callbackActionEvent.data) ?? null
-          };
-          rawBody = `${actor} pressed a button on message #${String(callbackActionEvent.targetMessageId)}
+      chatInfo = await resolveChatInfo(client, chatCache, chatId);
+    } catch (err) {
+      chatInfo = { kind: "group", title: null };
+      statusSink?.({ lastError: `getChat failed: ${String(err)}` });
+    }
+    const isGroup = chatInfo.kind !== "direct";
+    const replyThreadsEnabled = account.config.capabilities?.replyThreads === true || isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
+    const replyThreadContext = await resolveInlineInboundReplyThreadContext({
+      replyThreadsEnabled,
+      client,
+      chatId,
+      chatInfo,
+      chatCache
+    }).catch((err) => {
+      statusSink?.({ lastError: `getChat (reply thread) failed: ${String(err)}` });
+      return null;
+    });
+    const effectiveChatId = replyThreadContext?.parentChatId ?? chatId;
+    const effectiveGroupTitle = replyThreadContext?.parentChatTitle ?? chatInfo.title ?? null;
+    const senderId = String(msg.fromId);
+    await hydrateChatParticipants(chatId);
+    const senderProfile = senderProfilesById.get(senderId);
+    const senderUsername = senderProfile?.username;
+    const senderName = senderProfile?.name ?? (!isGroup ? chatInfo.title ?? undefined : undefined);
+    if (reactionEvent) {
+      const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
+      const emoji3 = reactionEvent.emoji.trim() || "a reaction";
+      const messageId = String(reactionEvent.targetMessageId);
+      if (reactionEvent.action === "added") {
+        rawBody = `${actor} reacted with ${emoji3} to your message #${messageId}`;
+      } else {
+        rawBody = `${actor} removed ${emoji3} from your message #${messageId}`;
+      }
+    } else if (callbackActionEvent) {
+      const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
+      const payload = {
+        type: "inline_message_action_callback",
+        interaction_id: String(callbackActionEvent.interactionId),
+        actor_user_id: senderId,
+        chat_id: String(chatId),
+        message_id: String(callbackActionEvent.targetMessageId),
+        action_id: callbackActionEvent.actionId,
+        data_base64: callbackDataToBase64(callbackActionEvent.data),
+        data_utf8: callbackDataToUtf8(callbackActionEvent.data) ?? null
+      };
+      rawBody = `${actor} pressed a button on message #${String(callbackActionEvent.targetMessageId)}
 ${JSON.stringify(payload)}`;
-        }
-        const dmPolicy = account.config.dmPolicy ?? "pairing";
-        const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-        const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
-        const configAllowFrom = normalizeAllowlist(account.config.allowFrom);
-        const configGroupAllowFrom = normalizeAllowlist(account.config.groupAllowFrom);
-        const storeAllowFrom = await core3.channel.pairing.readAllowFromStore({
-          channel: CHANNEL_ID,
-          accountId: account.accountId
-        }).catch(() => []);
-        const storeAllowList = normalizeAllowlist(storeAllowFrom);
-        const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
-        const effectiveGroupAllowFrom = [
-          ...configGroupAllowFrom.length > 0 ? configGroupAllowFrom : configAllowFrom,
-          ...storeAllowList
-        ].filter(Boolean);
-        const callbackCommandBody = callbackActionEvent ? resolveCallbackCommandBodyFromActionData({
-          data: callbackActionEvent.data,
-          ...botUsername ? { botUsername } : {}
-        }) : undefined;
-        let callbackActionAnswered = false;
-        const answerCallbackIfNeeded = async () => {
-          if (!callbackActionEvent || callbackActionAnswered)
-            return;
-          await answerInlineMessageAction(client, callbackActionEvent.interactionId);
-          callbackActionAnswered = true;
-        };
-        const shouldEditCallbackTargetInPlace = false;
-        const normalizedCommandBody = callbackCommandBody ?? normalizeInlineCommandBody(rawBody, botUsername);
-        const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
-          cfg,
-          surface: CHANNEL_ID
+    }
+    const dmPolicy = account.config.dmPolicy ?? "pairing";
+    const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const configAllowFrom = normalizeAllowlist(account.config.allowFrom);
+    const configGroupAllowFrom = normalizeAllowlist(account.config.groupAllowFrom);
+    const storeAllowFrom = await core3.channel.pairing.readAllowFromStore({
+      channel: CHANNEL_ID,
+      accountId: account.accountId
+    }).catch(() => []);
+    const storeAllowList = normalizeAllowlist(storeAllowFrom);
+    const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
+    const effectiveGroupAllowFrom = [
+      ...configGroupAllowFrom.length > 0 ? configGroupAllowFrom : configAllowFrom,
+      ...storeAllowList
+    ].filter(Boolean);
+    const callbackCommandBody = callbackActionEvent ? resolveCallbackCommandBodyFromActionData({
+      data: callbackActionEvent.data,
+      ...botUsername ? { botUsername } : {}
+    }) : undefined;
+    let callbackActionAnswered = false;
+    const answerCallbackIfNeeded = async () => {
+      if (!callbackActionEvent || callbackActionAnswered)
+        return;
+      await answerInlineMessageAction(client, callbackActionEvent.interactionId);
+      callbackActionAnswered = true;
+    };
+    if (callbackActionEvent) {
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+    }
+    const shouldEditCallbackTargetInPlace = callbackActionEvent != null;
+    const normalizedCommandBody = callbackCommandBody ?? normalizeInlineCommandBody(rawBody, botUsername);
+    const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
+      cfg,
+      surface: CHANNEL_ID
+    });
+    const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+    const allowForCommands = isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom;
+    const senderAllowedForCommands = allowlistMatch({ allowFrom: allowForCommands, senderId });
+    const hasControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
+    const commandGate = resolveControlCommandGate({
+      useAccessGroups,
+      authorizers: [{ configured: allowForCommands.length > 0, allowed: senderAllowedForCommands }],
+      allowTextCommands,
+      hasControlCommand
+    });
+    const commandAuthorized = commandGate.commandAuthorized;
+    if (isGroup) {
+      if (groupPolicy === "disabled") {
+        log?.info(`[${account.accountId}] inline: drop group chat=${String(chatId)} (groupPolicy=disabled)`);
+        await answerCallbackIfNeeded().catch((error48) => {
+          runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
         });
-        const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-        const allowForCommands = isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom;
-        const senderAllowedForCommands = allowlistMatch({ allowFrom: allowForCommands, senderId });
-        const hasControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
-        const commandGate = resolveControlCommandGate({
-          useAccessGroups,
-          authorizers: [{ configured: allowForCommands.length > 0, allowed: senderAllowedForCommands }],
-          allowTextCommands,
-          hasControlCommand
+        return;
+      }
+      if (groupPolicy === "allowlist") {
+        const allowed = allowlistMatch({ allowFrom: effectiveGroupAllowFrom, senderId });
+        if (!allowed) {
+          log?.info(`[${account.accountId}] inline: drop group sender=${senderId} (groupPolicy=allowlist)`);
+          await answerCallbackIfNeeded().catch((error48) => {
+            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+          });
+          return;
+        }
+      }
+    } else {
+      if (dmPolicy === "disabled") {
+        log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=disabled)`);
+        await answerCallbackIfNeeded().catch((error48) => {
+          runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
         });
-        const commandAuthorized = commandGate.commandAuthorized;
-        if (isGroup) {
-          if (groupPolicy === "disabled") {
-            log?.info(`[${account.accountId}] inline: drop group chat=${String(chatId)} (groupPolicy=disabled)`);
-            await answerCallbackIfNeeded().catch((error48) => {
-              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-            });
-            continue;
-          }
-          if (groupPolicy === "allowlist") {
-            const allowed = allowlistMatch({ allowFrom: effectiveGroupAllowFrom, senderId });
-            if (!allowed) {
-              log?.info(`[${account.accountId}] inline: drop group sender=${senderId} (groupPolicy=allowlist)`);
-              await answerCallbackIfNeeded().catch((error48) => {
-                runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-              });
-              continue;
-            }
-          }
-        } else {
-          if (dmPolicy === "disabled") {
-            log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=disabled)`);
-            await answerCallbackIfNeeded().catch((error48) => {
-              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+        return;
+      }
+      if (dmPolicy !== "open") {
+        const allowed = allowlistMatch({ allowFrom: effectiveAllowFrom, senderId });
+        if (!allowed) {
+          if (dmPolicy === "pairing") {
+            const { code, created } = await core3.channel.pairing.upsertPairingRequest({
+              channel: CHANNEL_ID,
+              id: senderId,
+              accountId: account.accountId,
+              meta: {},
+              pairingAdapter: { idLabel: "inlineUserId", normalizeAllowEntry }
             });
-            continue;
-          }
-          if (dmPolicy !== "open") {
-            const allowed = allowlistMatch({ allowFrom: effectiveAllowFrom, senderId });
-            if (!allowed) {
-              if (dmPolicy === "pairing") {
-                const { code, created } = await core3.channel.pairing.upsertPairingRequest({
-                  channel: CHANNEL_ID,
-                  id: senderId,
-                  accountId: account.accountId,
-                  meta: {},
-                  pairingAdapter: { idLabel: "inlineUserId", normalizeAllowEntry }
+            if (created) {
+              try {
+                await client.sendMessage({
+                  chatId,
+                  text: core3.channel.pairing.buildPairingReply({
+                    channel: CHANNEL_ID,
+                    idLine: `Your Inline user id: ${senderId}`,
+                    code
+                  })
                 });
-                if (created) {
-                  try {
-                    await client.sendMessage({
-                      chatId,
-                      text: core3.channel.pairing.buildPairingReply({
-                        channel: CHANNEL_ID,
-                        idLine: `Your Inline user id: ${senderId}`,
-                        code
-                      })
-                    });
-                    statusSink?.({ lastOutboundAt: Date.now() });
-                  } catch (err) {
-                    runtime2.error?.(`inline: pairing reply failed for ${senderId}: ${String(err)}`);
-                  }
-                }
+                statusSink?.({ lastOutboundAt: Date.now() });
+              } catch (err) {
+                runtime2.error?.(`inline: pairing reply failed for ${senderId}: ${String(err)}`);
               }
-              log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=${dmPolicy})`);
-              await answerCallbackIfNeeded().catch((error48) => {
-                runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-              });
-              continue;
             }
           }
-        }
-        if (isGroup && commandGate.shouldBlock) {
-          logInboundDrop({
-            log: (m) => runtime2.log?.(m),
-            channel: CHANNEL_ID,
-            reason: "control command (unauthorized)",
-            target: senderId
-          });
+          log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=${dmPolicy})`);
           await answerCallbackIfNeeded().catch((error48) => {
             runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
           });
-          continue;
+          return;
         }
-        const route = core3.channel.routing.resolveAgentRoute({
-          cfg,
-          channel: CHANNEL_ID,
-          accountId: account.accountId,
-          peer: {
-            kind: isGroup ? "group" : "direct",
-            id: isGroup ? String(effectiveChatId) : senderId
+      }
+    }
+    if (isGroup && commandGate.shouldBlock) {
+      logInboundDrop({
+        log: (m) => runtime2.log?.(m),
+        channel: CHANNEL_ID,
+        reason: "control command (unauthorized)",
+        target: senderId
+      });
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+      return;
+    }
+    const route = core3.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      peer: {
+        kind: isGroup ? "group" : "direct",
+        id: isGroup ? String(effectiveChatId) : senderId
+      }
+    });
+    const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
+    const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
+    const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
+    const wasMentioned = nativeMentioned || patternMentioned;
+    const messageTimestamp = Number(msg.date) * 1000;
+    const groupHistoryKey = isGroup ? replyThreadContext ? `${route.sessionKey}:thread:${String(replyThreadContext.childChatId)}` : route.sessionKey : null;
+    const pendingHistorySender = senderUsername ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
+    const historyLimit = resolveHistoryLimit({
+      cfg,
+      isGroup,
+      historyLimit: account.config.historyLimit,
+      dmHistoryLimit: account.config.dmHistoryLimit
+    });
+    const historyContext = await buildHistoryContext2({
+      client,
+      chatId,
+      currentMessageId: msg.id,
+      replyToMsgId: msg.replyToMsgId,
+      senderProfilesById,
+      meId,
+      historyLimit,
+      botMessageIdsByChat
+    }).catch((err) => {
+      statusSink?.({ lastError: `getChatHistory failed: ${String(err)}` });
+      return {
+        historyText: null,
+        attachmentText: null,
+        entityText: null,
+        inboundHistory: [],
+        repliedToBot: false,
+        replyToSenderId: null
+      };
+    });
+    const effectiveHistoryContext = replyThreadContext?.anchorMessage != null ? prependInlineReplyThreadAnchor({
+      historyContext,
+      anchorMessage: replyThreadContext.anchorMessage,
+      parentChatId: replyThreadContext.parentChatId,
+      senderProfilesById,
+      meId
+    }) : historyContext;
+    const implicitMention = (reactionEvent != null || callbackActionEvent != null) && isGroup || isGroup && (account.config.replyToBotWithoutMention ?? false) && msg.replyToMsgId != null && effectiveHistoryContext.repliedToBot;
+    const requireMention = isGroup ? resolveInlineGroupRequireMention({
+      cfg,
+      groupId: String(effectiveChatId),
+      accountId: account.accountId,
+      requireMentionDefault: account.config.requireMention ?? false
+    }) : false;
+    const mentionGate = resolveMentionGatingWithBypass({
+      isGroup,
+      requireMention,
+      canDetectMention: typeof msg.mentioned === "boolean" || mentionRegexes.length > 0,
+      wasMentioned,
+      implicitMention,
+      allowTextCommands,
+      hasControlCommand,
+      commandAuthorized
+    });
+    if (isGroup && mentionGate.shouldSkip) {
+      runtime2.log?.(`inline: drop group chat ${String(chatId)} (no mention)`);
+      const pendingBody = normalizeHistoryText(currentContent?.text) ?? normalizeHistoryText(rawBody);
+      recordPendingHistoryEntryIfEnabled({
+        historyMap: groupPendingHistories,
+        historyKey: groupHistoryKey ?? "",
+        limit: historyLimit,
+        entry: groupHistoryKey && pendingBody ? {
+          sender: pendingHistorySender,
+          body: pendingBody,
+          timestamp: messageTimestamp || Date.now(),
+          messageId: String(msg.id)
+        } : null
+      });
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+      return;
+    }
+    const parseMarkdown = account.config.parseMarkdown ?? true;
+    const nativeCommandMenu = resolveInlineNativeCommandMenu({
+      commandBody: normalizedCommandBody,
+      cfg
+    });
+    if (nativeCommandMenu) {
+      const menuActions = resolveInlineReplyActions({
+        channelData: {
+          inline: {
+            buttons: nativeCommandMenu.buttons
           }
-        });
-        const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
-        const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
-        const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
-        const wasMentioned = nativeMentioned || patternMentioned;
-        const messageTimestamp = Number(msg.date) * 1000;
-        const groupHistoryKey = isGroup ? replyThreadContext ? `${route.sessionKey}:thread:${String(replyThreadContext.childChatId)}` : route.sessionKey : null;
-        const pendingHistorySender = senderUsername ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
-        const historyLimit = resolveHistoryLimit({
-          cfg,
-          isGroup,
-          historyLimit: account.config.historyLimit,
-          dmHistoryLimit: account.config.dmHistoryLimit
-        });
-        const historyContext = await buildHistoryContext2({
-          client,
+        }
+      });
+      let deliveredNativeMenu = false;
+      if (shouldEditCallbackTargetInPlace && callbackActionEvent) {
+        try {
+          const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
+            oneofKind: "editMessage",
+            editMessage: {
+              messageId: callbackActionEvent.targetMessageId,
+              peerId: buildChatPeer2(chatId),
+              text: nativeCommandMenu.title,
+              ...menuActions ? { actions: menuActions } : {},
+              parseMarkdown
+            }
+          });
+          if (result.oneofKind !== "editMessage") {
+            throw new Error(`inline native command menu: expected editMessage result, got ${String(result.oneofKind)}`);
+          }
+          deliveredNativeMenu = true;
+        } catch (error48) {
+          runtime2.error?.(`inline native command menu edit failed; falling back to send (${String(error48)})`);
+        }
+      }
+      if (!deliveredNativeMenu) {
+        const sent = await client.sendMessage({
           chatId,
-          currentMessageId: msg.id,
-          replyToMsgId: msg.replyToMsgId,
-          senderProfilesById,
-          meId,
-          historyLimit,
-          botMessageIdsByChat
-        }).catch((err) => {
-          statusSink?.({ lastError: `getChatHistory failed: ${String(err)}` });
-          return {
-            historyText: null,
-            attachmentText: null,
-            entityText: null,
-            inboundHistory: [],
-            repliedToBot: false,
-            replyToSenderId: null
-          };
+          text: nativeCommandMenu.title,
+          ...menuActions ? { actions: menuActions } : {}
         });
-        const effectiveHistoryContext = replyThreadContext?.anchorMessage != null ? prependInlineReplyThreadAnchor({
-          historyContext,
-          anchorMessage: replyThreadContext.anchorMessage,
-          parentChatId: replyThreadContext.parentChatId,
-          senderProfilesById,
-          meId
-        }) : historyContext;
-        const implicitMention = (reactionEvent != null || callbackActionEvent != null) && isGroup || isGroup && (account.config.replyToBotWithoutMention ?? false) && msg.replyToMsgId != null && effectiveHistoryContext.repliedToBot;
-        const requireMention = isGroup ? resolveInlineGroupRequireMention({
-          cfg,
-          groupId: String(effectiveChatId),
-          accountId: account.accountId,
-          requireMentionDefault: account.config.requireMention ?? false
-        }) : false;
-        const mentionGate = resolveMentionGatingWithBypass({
-          isGroup,
-          requireMention,
-          canDetectMention: typeof msg.mentioned === "boolean" || mentionRegexes.length > 0,
-          wasMentioned,
-          implicitMention,
-          allowTextCommands,
-          hasControlCommand,
-          commandAuthorized
-        });
-        if (isGroup && mentionGate.shouldSkip) {
-          runtime2.log?.(`inline: drop group chat ${String(chatId)} (no mention)`);
-          const pendingBody = normalizeHistoryText(currentContent?.text) ?? normalizeHistoryText(rawBody);
-          recordPendingHistoryEntryIfEnabled({
-            historyMap: groupPendingHistories,
-            historyKey: groupHistoryKey ?? "",
-            limit: historyLimit,
-            entry: groupHistoryKey && pendingBody ? {
-              sender: pendingHistorySender,
-              body: pendingBody,
-              timestamp: messageTimestamp || Date.now(),
-              messageId: String(msg.id)
-            } : null
-          });
-          await answerCallbackIfNeeded().catch((error48) => {
-            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-          });
-          continue;
+        if (sent.messageId != null) {
+          rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
         }
-        const parseMarkdown = account.config.parseMarkdown ?? true;
-        const nativeCommandMenu = resolveInlineCompatNativeCommandMenu(normalizedCommandBody);
-        if (nativeCommandMenu) {
-          const menuActions = resolveInlineReplyActions({
-            channelData: {
-              inline: {
-                buttons: nativeCommandMenu.buttons
-              }
+      }
+      statusSink?.({ lastOutboundAt: Date.now() });
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+      return;
+    }
+    const modelPickerCallbackData = callbackActionEvent ? callbackDataToUtf8(callbackActionEvent.data) : undefined;
+    const modelPickerCallback = modelPickerCallbackData ? parseInlineModelPickerCallback(modelPickerCallbackData) : null;
+    if (shouldEditCallbackTargetInPlace && callbackActionEvent && modelPickerCallback?.type === "select") {
+      const deliverModelPickerEdit = async (text, buttons) => {
+        const actions = resolveInlineReplyActions({
+          channelData: {
+            inline: {
+              buttons
+            }
+          }
+        }) ?? { rows: [] };
+        try {
+          const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
+            oneofKind: "editMessage",
+            editMessage: {
+              messageId: callbackActionEvent.targetMessageId,
+              peerId: buildChatPeer2(chatId),
+              text,
+              actions,
+              parseMarkdown
             }
           });
+          if (result.oneofKind !== "editMessage") {
+            throw new Error(`inline model picker edit: expected editMessage result, got ${String(result.oneofKind)}`);
+          }
+        } catch (error48) {
+          runtime2.error?.(`inline model picker edit failed; falling back to send (${String(error48)})`);
           const sent = await client.sendMessage({
             chatId,
-            text: nativeCommandMenu.title,
-            ...menuActions ? { actions: menuActions } : {}
+            text,
+            actions,
+            parseMarkdown
           });
           if (sent.messageId != null) {
             rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
           }
-          statusSink?.({ lastOutboundAt: Date.now() });
-          await answerCallbackIfNeeded().catch((error48) => {
-            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
-          });
-          continue;
         }
-        const inboundMedia = reactionEvent ? [] : await resolveInlineInboundMedia({
-          core: core3,
-          message: msg,
-          maxBytes: inboundMediaMaxBytes,
-          ...log ? { log } : {}
-        });
-        const timestamp = messageTimestamp;
-        const fromLabel = isGroup ? `chat:${effectiveGroupTitle ?? String(effectiveChatId)}` : `user:${senderId}`;
-        const storePath = core3.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
-        const envelopeOptions = core3.channel.reply.resolveEnvelopeFormatOptions(cfg);
-        const previousTimestamp = core3.channel.session.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey });
-        const combinedBody = [
-          effectiveHistoryContext.historyText,
-          effectiveHistoryContext.attachmentText,
-          effectiveHistoryContext.entityText,
-          INLINE_FORMATTING_NOTE,
-          `Current message:
+      };
+      const { byProvider, providers } = await buildModelsProviderData(cfg, route.agentId);
+      const providerButtons = buildInlineModelProviderButtons(providers.map((provider) => ({
+        id: provider,
+        count: byProvider.get(provider)?.size ?? 0
+      })));
+      const selection = resolveInlineModelPickerSelection({
+        callback: modelPickerCallback,
+        providers,
+        byProvider
+      });
+      if (selection.kind !== "resolved") {
+        await deliverModelPickerEdit(`Could not resolve model "${selection.model}".
+
+Select a provider:`, providerButtons);
+      } else {
+        const modelSet = byProvider.get(selection.provider);
+        if (!modelSet?.has(selection.model)) {
+          await deliverModelPickerEdit(`❌ Model "${selection.provider}/${selection.model}" is not allowed.`, []);
+        } else {
+          try {
+            const storePath2 = core3.channel.session.resolveStorePath(cfg.session?.store, {
+              agentId: route.agentId
+            });
+            const resolvedDefault = resolveDefaultModelForAgent({
+              cfg,
+              agentId: route.agentId
+            });
+            const isDefaultSelection = selection.provider === resolvedDefault.provider && selection.model === resolvedDefault.model;
+            await updateSessionStore(storePath2, (store) => {
+              const entry = store[route.sessionKey] ?? {
+                sessionId: route.sessionKey,
+                updatedAt: Date.now()
+              };
+              store[route.sessionKey] = entry;
+              applyModelOverrideToSessionEntry({
+                entry,
+                selection: {
+                  provider: selection.provider,
+                  model: selection.model,
+                  isDefault: isDefaultSelection
+                }
+              });
+            });
+            const actionText = isDefaultSelection ? "reset to default" : `changed to **${selection.provider}/${selection.model}**`;
+            await deliverModelPickerEdit(`✅ Model ${actionText}
+
+This model will be used for your next message.`, []);
+          } catch (error48) {
+            await deliverModelPickerEdit(`❌ Failed to change model: ${String(error48)}`, []);
+          }
+        }
+      }
+      statusSink?.({ lastOutboundAt: Date.now() });
+      await answerCallbackIfNeeded().catch((error48) => {
+        runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+      });
+      return;
+    }
+    const inboundMedia = reactionEvent ? [] : await resolveInlineInboundMedia({
+      core: core3,
+      message: msg,
+      maxBytes: inboundMediaMaxBytes,
+      ...log ? { log } : {}
+    });
+    const timestamp = messageTimestamp;
+    const fromLabel = isGroup ? `chat:${effectiveGroupTitle ?? String(effectiveChatId)}` : `user:${senderId}`;
+    const storePath = core3.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+    const envelopeOptions = core3.channel.reply.resolveEnvelopeFormatOptions(cfg);
+    const previousTimestamp = core3.channel.session.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey });
+    const combinedBody = [
+      effectiveHistoryContext.historyText,
+      effectiveHistoryContext.attachmentText,
+      effectiveHistoryContext.entityText,
+      INLINE_FORMATTING_NOTE,
+      `Current message:
 ${rawBody}`,
-          currentAttachmentText && currentAttachmentText !== rawBody ? `Current media/attachments:
+      currentAttachmentText && currentAttachmentText !== rawBody ? `Current media/attachments:
 ${currentAttachmentText}` : null,
-          currentEntityText ? `Current message entities:
+      currentEntityText ? `Current message entities:
 ${currentEntityText}` : null
-        ].filter(Boolean).join(`
+    ].filter(Boolean).join(`
 
 `);
-        let body = core3.channel.reply.formatAgentEnvelope({
+    let body = core3.channel.reply.formatAgentEnvelope({
+      channel: "Inline",
+      from: fromLabel,
+      timestamp,
+      ...previousTimestamp != null ? { previousTimestamp } : {},
+      envelope: envelopeOptions,
+      body: combinedBody || rawBody
+    });
+    if (isGroup && groupHistoryKey) {
+      body = buildPendingHistoryContextFromMap({
+        historyMap: groupPendingHistories,
+        historyKey: groupHistoryKey,
+        limit: historyLimit,
+        currentMessage: body,
+        formatEntry: (entry) => core3.channel.reply.formatAgentEnvelope({
           channel: "Inline",
           from: fromLabel,
-          timestamp,
-          ...previousTimestamp != null ? { previousTimestamp } : {},
+          ...entry.timestamp != null ? { timestamp: entry.timestamp } : {},
           envelope: envelopeOptions,
-          body: combinedBody || rawBody
-        });
-        if (isGroup && groupHistoryKey) {
-          body = buildPendingHistoryContextFromMap({
-            historyMap: groupPendingHistories,
-            historyKey: groupHistoryKey,
-            limit: historyLimit,
-            currentMessage: body,
-            formatEntry: (entry) => core3.channel.reply.formatAgentEnvelope({
-              channel: "Inline",
-              from: fromLabel,
-              ...entry.timestamp != null ? { timestamp: entry.timestamp } : {},
-              envelope: envelopeOptions,
-              body: `${entry.body}${entry.messageId ? ` [id:${entry.messageId} chat:${String(chatId)}]` : ""}`
-            })
-          });
+          body: `${entry.body}${entry.messageId ? ` [id:${entry.messageId} chat:${String(chatId)}]` : ""}`
+        })
+      });
+    }
+    const inboundHistory = isGroup && groupHistoryKey ? mergeInboundHistoryEntries({
+      historyContextEntries: effectiveHistoryContext.inboundHistory,
+      pendingEntries: groupPendingHistories.get(groupHistoryKey) ?? [],
+      limit: historyLimit
+    }) : [];
+    const bodyForAgent = buildInlineBodyForAgent({
+      rawBody,
+      currentAttachmentText,
+      currentEntityText
+    });
+    const effectiveSurface = shouldUseTelegramSurfaceForModelCommands(normalizedCommandBody) ? "telegram" : CHANNEL_ID;
+    const systemPrompt = resolveInlineSystemPrompt({
+      account,
+      ...isGroup ? { groupId: String(effectiveChatId) } : {}
+    });
+    const ctxPayload = core3.channel.reply.finalizeInboundContext({
+      Body: body,
+      BodyForAgent: bodyForAgent,
+      ...isGroup ? { InboundHistory: inboundHistory } : {},
+      RawBody: rawBody,
+      CommandBody: normalizedCommandBody,
+      From: isGroup ? `inline:chat:${String(effectiveChatId)}` : `inline:${senderId}`,
+      To: `inline:${String(effectiveChatId)}`,
+      SessionKey: route.sessionKey,
+      ...replyThreadContext ? { ParentSessionKey: route.sessionKey } : {},
+      AccountId: route.accountId,
+      ChatType: isGroup ? "group" : "direct",
+      ConversationLabel: fromLabel,
+      ...isGroup ? { GroupSubject: effectiveGroupTitle ?? String(effectiveChatId) } : {},
+      SenderId: senderId,
+      ...senderName ? { SenderName: senderName } : {},
+      ...senderUsername ? { SenderUsername: senderUsername } : {},
+      Provider: CHANNEL_ID,
+      Surface: effectiveSurface,
+      MessageSid: buildInlineInboundMessageSid({
+        msgId: msg.id,
+        ...callbackActionEvent ? { callbackActionEvent } : {}
+      }),
+      ...replyThreadContext ? { MessageThreadId: String(replyThreadContext.childChatId) } : {},
+      ...replyThreadContext?.threadLabel ? { ThreadLabel: replyThreadContext.threadLabel } : {},
+      ...msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {},
+      ...effectiveHistoryContext.replyToSenderId != null ? { ReplyToSenderId: effectiveHistoryContext.replyToSenderId } : {},
+      ...msg.replyToMsgId != null ? { ReplyToWasBot: effectiveHistoryContext.repliedToBot } : {},
+      ...callbackActionEvent ? {
+        MessageActionInteractionId: String(callbackActionEvent.interactionId),
+        MessageActionId: callbackActionEvent.actionId,
+        MessageActionDataBase64: callbackDataToBase64(callbackActionEvent.data),
+        ...callbackDataToUtf8(callbackActionEvent.data) ? { MessageActionDataUtf8: callbackDataToUtf8(callbackActionEvent.data) } : {}
+      } : {},
+      ...buildInlineInboundMediaPayload(inboundMedia),
+      Timestamp: timestamp || Date.now(),
+      WasMentioned: mentionGate.effectiveWasMentioned,
+      CommandAuthorized: commandAuthorized,
+      GroupSystemPrompt: systemPrompt,
+      OriginatingChannel: CHANNEL_ID,
+      OriginatingTo: `inline:${String(effectiveChatId)}`
+    });
+    await core3.channel.session.recordInboundSession({
+      storePath,
+      sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+      ctx: ctxPayload,
+      ...!isGroup ? {
+        updateLastRoute: {
+          sessionKey: route.mainSessionKey,
+          channel: CHANNEL_ID,
+          to: `inline:${String(effectiveChatId)}`,
+          accountId: route.accountId
         }
-        const inboundHistory = isGroup && groupHistoryKey ? mergeInboundHistoryEntries({
-          historyContextEntries: effectiveHistoryContext.inboundHistory,
-          pendingEntries: groupPendingHistories.get(groupHistoryKey) ?? [],
-          limit: historyLimit
-        }) : [];
-        const bodyForAgent = buildInlineBodyForAgent({
-          rawBody,
-          currentAttachmentText,
-          currentEntityText
-        });
-        const effectiveSurface = shouldUseTelegramSurfaceForModelCommands(normalizedCommandBody) ? "telegram" : CHANNEL_ID;
-        const systemPrompt = resolveInlineSystemPrompt({
-          account,
-          ...isGroup ? { groupId: String(effectiveChatId) } : {}
-        });
-        const ctxPayload = core3.channel.reply.finalizeInboundContext({
-          Body: body,
-          BodyForAgent: bodyForAgent,
-          ...isGroup ? { InboundHistory: inboundHistory } : {},
-          RawBody: rawBody,
-          CommandBody: normalizedCommandBody,
-          From: isGroup ? `inline:chat:${String(effectiveChatId)}` : `inline:${senderId}`,
-          To: `inline:${String(effectiveChatId)}`,
-          SessionKey: route.sessionKey,
-          ...replyThreadContext ? { ParentSessionKey: route.sessionKey } : {},
-          AccountId: route.accountId,
-          ChatType: isGroup ? "group" : "direct",
-          ConversationLabel: fromLabel,
-          ...isGroup ? { GroupSubject: effectiveGroupTitle ?? String(effectiveChatId) } : {},
-          SenderId: senderId,
-          ...senderName ? { SenderName: senderName } : {},
-          ...senderUsername ? { SenderUsername: senderUsername } : {},
-          Provider: CHANNEL_ID,
-          Surface: effectiveSurface,
-          MessageSid: String(msg.id),
-          ...replyThreadContext ? { MessageThreadId: String(replyThreadContext.childChatId) } : {},
-          ...replyThreadContext?.threadLabel ? { ThreadLabel: replyThreadContext.threadLabel } : {},
-          ...msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {},
-          ...effectiveHistoryContext.replyToSenderId != null ? { ReplyToSenderId: effectiveHistoryContext.replyToSenderId } : {},
-          ...msg.replyToMsgId != null ? { ReplyToWasBot: effectiveHistoryContext.repliedToBot } : {},
-          ...callbackActionEvent ? {
-            MessageActionInteractionId: String(callbackActionEvent.interactionId),
-            MessageActionId: callbackActionEvent.actionId,
-            MessageActionDataBase64: callbackDataToBase64(callbackActionEvent.data),
-            ...callbackDataToUtf8(callbackActionEvent.data) ? { MessageActionDataUtf8: callbackDataToUtf8(callbackActionEvent.data) } : {}
-          } : {},
-          ...buildInlineInboundMediaPayload(inboundMedia),
-          Timestamp: timestamp || Date.now(),
-          WasMentioned: mentionGate.effectiveWasMentioned,
-          CommandAuthorized: commandAuthorized,
-          GroupSystemPrompt: systemPrompt,
-          OriginatingChannel: CHANNEL_ID,
-          OriginatingTo: `inline:${String(effectiveChatId)}`
-        });
-        await core3.channel.session.recordInboundSession({
-          storePath,
-          sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-          ctx: ctxPayload,
-          ...!isGroup ? {
-            updateLastRoute: {
-              sessionKey: route.mainSessionKey,
-              channel: CHANNEL_ID,
-              to: `inline:${String(effectiveChatId)}`,
-              accountId: route.accountId
+      } : {},
+      onRecordError: (err) => runtime2.error?.(`inline: failed updating session meta: ${String(err)}`)
+    });
+    const replyPipeline = await createChannelReplyPipelineCompat({
+      cfg,
+      agentId: route.agentId,
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      typing: {
+        start: () => client.sendTyping({ chatId, typing: true }),
+        stop: () => client.sendTyping({ chatId, typing: false }),
+        onStartError: (err) => runtime2.error?.(`inline typing start failed: ${String(err)}`),
+        onStopError: (err) => runtime2.error?.(`inline typing stop failed: ${String(err)}`)
+      }
+    });
+    const onModelSelected = replyPipeline.onModelSelected;
+    const typingCallbacks = replyPipeline.typingCallbacks;
+    const prefixOptions = {
+      ...replyPipeline.responsePrefix !== undefined ? { responsePrefix: replyPipeline.responsePrefix } : {},
+      ...replyPipeline.enableSlackInteractiveReplies !== undefined ? { enableSlackInteractiveReplies: replyPipeline.enableSlackInteractiveReplies } : {},
+      ...replyPipeline.responsePrefixContextProvider ? {
+        responsePrefixContextProvider: replyPipeline.responsePrefixContextProvider
+      } : {}
+    };
+    const callbackTargetMessage = shouldEditCallbackTargetInPlace && callbackActionEvent ? await findChatMessageById({
+      client,
+      chatId,
+      messageId: callbackActionEvent.targetMessageId,
+      limit: REPLY_TARGET_LOOKUP_LIMIT,
+      meId,
+      botMessageIdsByChat
+    }).catch(() => null) : null;
+    const streamViaEditMessage = account.config.streamViaEditMessage === true && !shouldEditCallbackTargetInPlace;
+    const defaultReplyToMsgId = isGroup && msg.replyToMsgId != null ? msg.id : undefined;
+    const disableBlockStreaming = streamViaEditMessage ? true : typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : undefined;
+    const editStreamState = {
+      messageId: shouldEditCallbackTargetInPlace ? callbackActionEvent?.targetMessageId ?? null : null,
+      accumulatedText: callbackTargetMessage?.message ?? "",
+      lastPartialText: "",
+      finalTextAccumulator: "",
+      failed: false,
+      opChain: Promise.resolve()
+    };
+    let finalDeliveredForCurrentAssistantMessage = false;
+    const resetEditStreamForAssistantMessage = async () => {
+      await editStreamState.opChain;
+      const hasActiveState = editStreamState.messageId != null || editStreamState.accumulatedText.length > 0 || editStreamState.lastPartialText.length > 0 || editStreamState.finalTextAccumulator.length > 0;
+      if (!hasActiveState)
+        return;
+      editStreamState.messageId = null;
+      editStreamState.accumulatedText = "";
+      editStreamState.lastPartialText = "";
+      editStreamState.finalTextAccumulator = "";
+      editStreamState.failed = false;
+      finalDeliveredForCurrentAssistantMessage = false;
+    };
+    const resetEditStreamOnBoundary = async () => {
+      if (!streamViaEditMessage)
+        return;
+      await resetEditStreamForAssistantMessage();
+    };
+    const handlePartialStreamPayload = async (payload) => {
+      if (editStreamState.failed)
+        return;
+      if ((payload.mediaUrls?.length ?? 0) > 0)
+        return;
+      const partialText = typeof payload.text === "string" ? payload.text : "";
+      if (!partialText || partialText === editStreamState.lastPartialText)
+        return;
+      editStreamState.lastPartialText = partialText;
+      const nextText = rewriteNumericMentionsToUsernames(extractCompleteParagraphText(partialText), senderProfilesById).trim();
+      if (!nextText || nextText === editStreamState.accumulatedText)
+        return;
+      editStreamState.opChain = editStreamState.opChain.then(async () => {
+        if (editStreamState.failed)
+          return;
+        if (!nextText || nextText === editStreamState.accumulatedText)
+          return;
+        try {
+          if (editStreamState.messageId == null) {
+            const sent = await client.sendMessage({
+              chatId,
+              text: nextText,
+              ...defaultReplyToMsgId != null ? { replyToMsgId: defaultReplyToMsgId } : {},
+              parseMarkdown
+            });
+            if (sent.messageId == null) {
+              throw new Error("inline edit stream: sendMessage returned no messageId");
+            }
+            editStreamState.messageId = sent.messageId;
+            rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+          } else {
+            const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
+              oneofKind: "editMessage",
+              editMessage: {
+                messageId: editStreamState.messageId,
+                peerId: buildChatPeer2(chatId),
+                text: nextText,
+                parseMarkdown
+              }
+            });
+            if (result.oneofKind !== "editMessage") {
+              throw new Error(`inline edit stream: expected editMessage result, got ${String(result.oneofKind)}`);
             }
-          } : {},
-          onRecordError: (err) => runtime2.error?.(`inline: failed updating session meta: ${String(err)}`)
-        });
-        const replyPipeline = await createChannelReplyPipelineCompat({
-          cfg,
-          agentId: route.agentId,
-          channel: CHANNEL_ID,
-          accountId: account.accountId,
-          typing: {
-            start: () => client.sendTyping({ chatId, typing: true }),
-            stop: () => client.sendTyping({ chatId, typing: false }),
-            onStartError: (err) => runtime2.error?.(`inline typing start failed: ${String(err)}`),
-            onStopError: (err) => runtime2.error?.(`inline typing stop failed: ${String(err)}`)
           }
-        });
-        const onModelSelected = replyPipeline.onModelSelected;
-        const typingCallbacks = replyPipeline.typingCallbacks;
-        const prefixOptions = {
-          ...replyPipeline.responsePrefix !== undefined ? { responsePrefix: replyPipeline.responsePrefix } : {},
-          ...replyPipeline.enableSlackInteractiveReplies !== undefined ? { enableSlackInteractiveReplies: replyPipeline.enableSlackInteractiveReplies } : {},
-          ...replyPipeline.responsePrefixContextProvider ? {
-            responsePrefixContextProvider: replyPipeline.responsePrefixContextProvider
-          } : {}
-        };
-        const streamViaEditMessage = account.config.streamViaEditMessage === true && !shouldEditCallbackTargetInPlace;
-        const defaultReplyToMsgId = isGroup && msg.replyToMsgId != null ? msg.id : undefined;
-        const disableBlockStreaming = streamViaEditMessage ? true : typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : undefined;
-        const editStreamState = {
-          messageId: null,
-          accumulatedText: "",
-          lastPartialText: "",
-          finalTextAccumulator: "",
-          failed: false,
-          opChain: Promise.resolve()
-        };
-        let finalDeliveredForCurrentAssistantMessage = false;
-        const resetEditStreamForAssistantMessage = async () => {
+          editStreamState.accumulatedText = nextText;
+          statusSink?.({ lastOutboundAt: Date.now() });
+        } catch (error48) {
+          editStreamState.failed = true;
+          runtime2.error?.(`inline edit stream failed: ${String(error48)}`);
+        }
+      });
+      await editStreamState.opChain;
+    };
+    const replyOptions = {
+      ...onModelSelected ? { onModelSelected } : {},
+      blockReplyTimeoutMs: 25000,
+      ...streamViaEditMessage ? {
+        onAssistantMessageStart: async () => {
+          await resetEditStreamOnBoundary();
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onPartialReply: async (payload) => {
+          await handlePartialStreamPayload(payload);
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onReasoningStream: async (payload) => {
+          await handlePartialStreamPayload(payload);
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onReasoningEnd: async () => {
           await editStreamState.opChain;
-          const hasActiveState = editStreamState.messageId != null || editStreamState.accumulatedText.length > 0 || editStreamState.lastPartialText.length > 0 || editStreamState.finalTextAccumulator.length > 0;
-          if (!hasActiveState)
-            return;
-          editStreamState.messageId = null;
-          editStreamState.accumulatedText = "";
-          editStreamState.lastPartialText = "";
-          editStreamState.finalTextAccumulator = "";
-          editStreamState.failed = false;
-          finalDeliveredForCurrentAssistantMessage = false;
-        };
-        const resetEditStreamOnBoundary = async () => {
-          if (!streamViaEditMessage)
-            return;
-          await resetEditStreamForAssistantMessage();
-        };
-        const handlePartialStreamPayload = async (payload) => {
-          if (editStreamState.failed)
-            return;
-          if ((payload.mediaUrls?.length ?? 0) > 0)
-            return;
-          const partialText = typeof payload.text === "string" ? payload.text : "";
-          if (!partialText || partialText === editStreamState.lastPartialText)
-            return;
-          editStreamState.lastPartialText = partialText;
-          const nextText = rewriteNumericMentionsToUsernames(extractCompleteParagraphText(partialText), senderProfilesById).trim();
-          if (!nextText || nextText === editStreamState.accumulatedText)
-            return;
-          editStreamState.opChain = editStreamState.opChain.then(async () => {
-            if (editStreamState.failed)
-              return;
-            if (!nextText || nextText === editStreamState.accumulatedText)
-              return;
-            try {
-              if (editStreamState.messageId == null) {
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onToolStart: async () => {
+          await resetEditStreamOnBoundary();
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onCompactionStart: async () => {
+          await resetEditStreamOnBoundary();
+        }
+      } : {},
+      ...streamViaEditMessage ? {
+        onCompactionEnd: async () => {
+          await resetEditStreamOnBoundary();
+        }
+      } : {},
+      ...typeof disableBlockStreaming === "boolean" ? { disableBlockStreaming } : {}
+    };
+    try {
+      let delivered = false;
+      let skippedNonSilent = false;
+      let failedNonSilent = false;
+      let dispatchError = null;
+      try {
+        await core3.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+          ctx: ctxPayload,
+          cfg,
+          dispatcherOptions: {
+            ...prefixOptions,
+            ...typingCallbacks ? { typingCallbacks } : {},
+            deliver: async (payload, info) => {
+              const rawText = payload.text ?? "";
+              const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
+              const outboundText = rewriteNumericMentionsToUsernames(rawText, senderProfilesById);
+              const outboundActions = resolveInlineReplyActions(payload);
+              const infoKind = typeof info?.kind === "string" ? info.kind : undefined;
+              let replyToMsgId;
+              if (payload.replyToId != null) {
+                try {
+                  replyToMsgId = BigInt(payload.replyToId);
+                } catch {}
+              }
+              if (replyToMsgId == null && isGroup && msg.replyToMsgId != null) {
+                replyToMsgId = msg.id;
+              }
+              const rememberSent = (messageId) => {
+                if (messageId != null) {
+                  rememberBotMessageId(botMessageIdsByChat, chatId, messageId);
+                }
+              };
+              const sendTextFallback = async (text, includeReplyTo, includeActions) => {
+                if (!text.trim())
+                  return;
                 const sent = await client.sendMessage({
                   chatId,
-                  text: nextText,
-                  ...defaultReplyToMsgId != null ? { replyToMsgId: defaultReplyToMsgId } : {},
+                  text,
+                  ...includeReplyTo && replyToMsgId != null ? { replyToMsgId } : {},
+                  ...includeActions && outboundActions !== undefined ? { actions: outboundActions } : {},
                   parseMarkdown
                 });
-                if (sent.messageId == null) {
-                  throw new Error("inline edit stream: sendMessage returned no messageId");
-                }
-                editStreamState.messageId = sent.messageId;
-                rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
-              } else {
+                rememberSent(sent.messageId);
+                delivered = true;
+              };
+              const updateStreamedMessage = async (text, actions) => {
+                await editStreamState.opChain;
+                if (editStreamState.messageId == null)
+                  return false;
+                const nextText = text.trim();
+                const textForEdit = nextText || editStreamState.accumulatedText;
+                if (!textForEdit && actions === undefined)
+                  return true;
+                const shouldSkipTextUpdate = !editStreamState.failed && textForEdit === editStreamState.accumulatedText;
+                if (shouldSkipTextUpdate && actions === undefined)
+                  return true;
                 const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
                   oneofKind: "editMessage",
                   editMessage: {
                     messageId: editStreamState.messageId,
                     peerId: buildChatPeer2(chatId),
-                    text: nextText,
-                    parseMarkdown
+                    text: textForEdit,
+                    parseMarkdown,
+                    ...actions !== undefined ? { actions } : {}
                   }
                 });
                 if (result.oneofKind !== "editMessage") {
                   throw new Error(`inline edit stream: expected editMessage result, got ${String(result.oneofKind)}`);
                 }
-              }
-              editStreamState.accumulatedText = nextText;
-              statusSink?.({ lastOutboundAt: Date.now() });
-            } catch (error48) {
-              editStreamState.failed = true;
-              runtime2.error?.(`inline edit stream failed: ${String(error48)}`);
-            }
-          });
-          await editStreamState.opChain;
-        };
-        const replyOptions = {
-          ...onModelSelected ? { onModelSelected } : {},
-          blockReplyTimeoutMs: 25000,
-          ...streamViaEditMessage ? {
-            onAssistantMessageStart: async () => {
-              await resetEditStreamOnBoundary();
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onPartialReply: async (payload) => {
-              await handlePartialStreamPayload(payload);
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onReasoningStream: async (payload) => {
-              await handlePartialStreamPayload(payload);
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onReasoningEnd: async () => {
-              await editStreamState.opChain;
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onToolStart: async () => {
-              await resetEditStreamOnBoundary();
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onCompactionStart: async () => {
-              await resetEditStreamOnBoundary();
-            }
-          } : {},
-          ...streamViaEditMessage ? {
-            onCompactionEnd: async () => {
-              await resetEditStreamOnBoundary();
-            }
-          } : {},
-          ...typeof disableBlockStreaming === "boolean" ? { disableBlockStreaming } : {}
-        };
-        try {
-          let delivered = false;
-          let skippedNonSilent = false;
-          let failedNonSilent = false;
-          let dispatchError = null;
-          try {
-            await core3.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-              ctx: ctxPayload,
-              cfg,
-              dispatcherOptions: {
-                ...prefixOptions,
-                ...typingCallbacks ? { typingCallbacks } : {},
-                deliver: async (payload, info) => {
-                  const rawText = payload.text ?? "";
-                  const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
-                  const outboundText = rewriteNumericMentionsToUsernames(rawText, senderProfilesById);
-                  const outboundActions = resolveInlineReplyActions(payload);
-                  const infoKind = typeof info?.kind === "string" ? info.kind : undefined;
-                  let replyToMsgId;
-                  if (payload.replyToId != null) {
-                    try {
-                      replyToMsgId = BigInt(payload.replyToId);
-                    } catch {}
+                if (!shouldSkipTextUpdate) {
+                  editStreamState.accumulatedText = textForEdit;
+                  editStreamState.lastPartialText = textForEdit;
+                }
+                editStreamState.failed = false;
+                return true;
+              };
+              if (mediaList.length === 0) {
+                if (shouldEditCallbackTargetInPlace && editStreamState.messageId != null) {
+                  const callbackEditActions = outboundActions ?? { rows: [] };
+                  if (!outboundText.trim() && outboundActions === undefined) {
+                    return;
                   }
-                  if (replyToMsgId == null && isGroup && msg.replyToMsgId != null) {
-                    replyToMsgId = msg.id;
+                  await updateStreamedMessage(outboundText, callbackEditActions);
+                  delivered = true;
+                  statusSink?.({ lastOutboundAt: Date.now() });
+                  return;
+                }
+                if (streamViaEditMessage && infoKind === "final" && finalDeliveredForCurrentAssistantMessage && editStreamState.messageId != null) {
+                  await resetEditStreamForAssistantMessage();
+                }
+                if (streamViaEditMessage && editStreamState.messageId != null) {
+                  if (outboundText.trim()) {
+                    editStreamState.finalTextAccumulator += outboundText;
                   }
-                  const rememberSent = (messageId) => {
-                    if (messageId != null) {
-                      rememberBotMessageId(botMessageIdsByChat, chatId, messageId);
-                    }
-                  };
-                  const sendTextFallback = async (text, includeReplyTo, includeActions) => {
-                    if (!text.trim())
-                      return;
-                    const sent = await client.sendMessage({
-                      chatId,
-                      text,
-                      ...includeReplyTo && replyToMsgId != null ? { replyToMsgId } : {},
-                      ...includeActions && outboundActions !== undefined ? { actions: outboundActions } : {},
-                      parseMarkdown
-                    });
-                    rememberSent(sent.messageId);
-                    delivered = true;
-                  };
-                  const updateStreamedMessage = async (text, actions) => {
-                    await editStreamState.opChain;
-                    if (editStreamState.messageId == null)
-                      return false;
-                    const nextText = text.trim();
-                    const textForEdit = nextText || editStreamState.accumulatedText;
-                    if (!textForEdit)
-                      return true;
-                    const shouldSkipTextUpdate = !editStreamState.failed && textForEdit === editStreamState.accumulatedText;
-                    if (shouldSkipTextUpdate && actions === undefined)
-                      return true;
-                    const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
-                      oneofKind: "editMessage",
-                      editMessage: {
-                        messageId: editStreamState.messageId,
-                        peerId: buildChatPeer2(chatId),
-                        text: textForEdit,
-                        parseMarkdown,
-                        ...actions !== undefined ? { actions } : {}
-                      }
-                    });
-                    if (result.oneofKind !== "editMessage") {
-                      throw new Error(`inline edit stream: expected editMessage result, got ${String(result.oneofKind)}`);
-                    }
-                    if (!shouldSkipTextUpdate) {
-                      editStreamState.accumulatedText = textForEdit;
-                      editStreamState.lastPartialText = textForEdit;
-                    }
-                    editStreamState.failed = false;
-                    return true;
-                  };
-                  if (mediaList.length === 0) {
-                    if (streamViaEditMessage && infoKind === "final" && finalDeliveredForCurrentAssistantMessage && editStreamState.messageId != null) {
-                      await resetEditStreamForAssistantMessage();
-                    }
-                    if (streamViaEditMessage && editStreamState.messageId != null) {
-                      if (outboundText.trim()) {
-                        editStreamState.finalTextAccumulator += outboundText;
-                      }
-                      if (!editStreamState.finalTextAccumulator.trim() && outboundActions === undefined) {
-                        return;
-                      }
-                      await updateStreamedMessage(editStreamState.finalTextAccumulator, outboundActions);
-                      delivered = true;
-                      if (infoKind === "final") {
-                        finalDeliveredForCurrentAssistantMessage = true;
-                      }
-                      statusSink?.({ lastOutboundAt: Date.now() });
-                      return;
-                    }
-                    if (!outboundText.trim())
-                      return;
-                    await sendTextFallback(outboundText, true, true);
-                    statusSink?.({ lastOutboundAt: Date.now() });
+                  if (!editStreamState.finalTextAccumulator.trim() && outboundActions === undefined) {
                     return;
                   }
-                  if (streamViaEditMessage && editStreamState.messageId != null && outboundText.trim()) {
-                    await updateStreamedMessage(outboundText, outboundActions);
+                  await updateStreamedMessage(editStreamState.finalTextAccumulator, outboundActions);
+                  delivered = true;
+                  if (infoKind === "final") {
+                    finalDeliveredForCurrentAssistantMessage = true;
                   }
-                  for (let index = 0;index < mediaList.length; index++) {
-                    const mediaUrl = mediaList[index];
-                    if (!mediaUrl?.trim())
-                      continue;
-                    const isFirst = index === 0;
-                    const shouldAttachActionsToMedia = isFirst && (!(streamViaEditMessage && editStreamState.messageId != null) || !outboundText.trim());
-                    const caption = isFirst && !(streamViaEditMessage && editStreamState.messageId != null) ? outboundText : "";
-                    try {
-                      const media = await uploadInlineMediaFromUrl({
-                        client,
-                        cfg,
-                        accountId: account.accountId,
-                        mediaUrl
-                      });
-                      const sent = await client.sendMessage({
-                        chatId,
-                        ...caption ? { text: caption } : {},
-                        media,
-                        ...isFirst && replyToMsgId != null ? { replyToMsgId } : {},
-                        ...shouldAttachActionsToMedia && outboundActions !== undefined ? { actions: outboundActions } : {},
-                        ...caption ? { parseMarkdown } : {}
-                      });
-                      rememberSent(sent.messageId);
-                      delivered = true;
-                    } catch (error48) {
-                      runtime2.error?.(`inline media upload failed; falling back to url text (${String(error48)})`);
-                      const fallbackText = caption ? `${caption}
+                  statusSink?.({ lastOutboundAt: Date.now() });
+                  return;
+                }
+                if (!outboundText.trim())
+                  return;
+                await sendTextFallback(outboundText, true, true);
+                statusSink?.({ lastOutboundAt: Date.now() });
+                return;
+              }
+              if (streamViaEditMessage && editStreamState.messageId != null && outboundText.trim()) {
+                await updateStreamedMessage(outboundText, outboundActions);
+              }
+              for (let index = 0;index < mediaList.length; index++) {
+                const mediaUrl = mediaList[index];
+                if (!mediaUrl?.trim())
+                  continue;
+                const isFirst = index === 0;
+                const shouldAttachActionsToMedia = isFirst && (!(streamViaEditMessage && editStreamState.messageId != null) || !outboundText.trim());
+                const caption = isFirst && !(streamViaEditMessage && editStreamState.messageId != null) ? outboundText : "";
+                try {
+                  const media = await uploadInlineMediaFromUrl({
+                    client,
+                    cfg,
+                    accountId: account.accountId,
+                    mediaUrl
+                  });
+                  const sent = await client.sendMessage({
+                    chatId,
+                    ...caption ? { text: caption } : {},
+                    media,
+                    ...isFirst && replyToMsgId != null ? { replyToMsgId } : {},
+                    ...shouldAttachActionsToMedia && outboundActions !== undefined ? { actions: outboundActions } : {},
+                    ...caption ? { parseMarkdown } : {}
+                  });
+                  rememberSent(sent.messageId);
+                  delivered = true;
+                } catch (error48) {
+                  runtime2.error?.(`inline media upload failed; falling back to url text (${String(error48)})`);
+                  const fallbackText = caption ? `${caption}
 
 Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
-                      await sendTextFallback(fallbackText, isFirst, isFirst);
-                    }
-                  }
-                  statusSink?.({ lastOutboundAt: Date.now() });
-                },
-                onSkip: (_payload, info) => {
-                  if (info?.reason !== "silent") {
-                    skippedNonSilent = true;
-                  }
-                },
-                onError: (err, info) => {
-                  failedNonSilent = true;
-                  runtime2.error?.(`inline ${info?.kind ?? "final"} reply failed: ${String(err)}`);
+                  await sendTextFallback(fallbackText, isFirst, isFirst);
                 }
-              },
-              replyOptions
-            });
-          } catch (error48) {
-            dispatchError = error48;
-            runtime2.error?.(`inline dispatch failed: ${String(error48)}`);
-          }
-          if (!delivered && streamViaEditMessage && editStreamState.messageId != null) {
-            delivered = true;
-          }
-          if (!delivered && (dispatchError != null || skippedNonSilent || failedNonSilent)) {
-            const fallbackText = dispatchError != null ? "Something went wrong while processing your request. Please try again." : EMPTY_RESPONSE_FALLBACK;
-            const sent = await client.sendMessage({
-              chatId,
-              text: fallbackText,
-              ...defaultReplyToMsgId != null ? { replyToMsgId: defaultReplyToMsgId } : {},
-              parseMarkdown
-            });
-            if (sent.messageId != null) {
-              rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+              }
+              statusSink?.({ lastOutboundAt: Date.now() });
+            },
+            onSkip: (_payload, info) => {
+              if (info?.reason !== "silent") {
+                skippedNonSilent = true;
+              }
+            },
+            onError: (err, info) => {
+              failedNonSilent = true;
+              runtime2.error?.(`inline ${info?.kind ?? "final"} reply failed: ${String(err)}`);
             }
-            statusSink?.({ lastOutboundAt: Date.now() });
-          }
-        } finally {
-          if (callbackActionEvent && !callbackActionAnswered) {
-            try {
-              await answerCallbackIfNeeded();
-            } catch (error48) {
-              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+          },
+          replyOptions
+        });
+      } catch (error48) {
+        dispatchError = error48;
+        runtime2.error?.(`inline dispatch failed: ${String(error48)}`);
+      }
+      if (!delivered && streamViaEditMessage && editStreamState.messageId != null) {
+        delivered = true;
+      }
+      if (!delivered && (dispatchError != null || skippedNonSilent || failedNonSilent)) {
+        const fallbackText = dispatchError != null ? "Something went wrong while processing your request. Please try again." : EMPTY_RESPONSE_FALLBACK;
+        const sent = await client.sendMessage({
+          chatId,
+          text: fallbackText,
+          ...defaultReplyToMsgId != null ? { replyToMsgId: defaultReplyToMsgId } : {},
+          parseMarkdown
+        });
+        if (sent.messageId != null) {
+          rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+        }
+        statusSink?.({ lastOutboundAt: Date.now() });
+      }
+    } finally {
+      if (callbackActionEvent && !callbackActionAnswered) {
+        try {
+          await answerCallbackIfNeeded();
+        } catch (error48) {
+          runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+        }
+      }
+    }
+    if (isGroup && groupHistoryKey) {
+      clearHistoryEntriesIfEnabled({
+        historyMap: groupPendingHistories,
+        historyKey: groupHistoryKey,
+        limit: historyLimit
+      });
+    }
+  };
+  const { debouncer: inboundDebouncer } = createChannelInboundDebouncer({
+    cfg,
+    channel: CHANNEL_ID,
+    buildKey: (entry) => buildInlineDebounceKey({
+      accountId: account.accountId,
+      chatId: entry.chatId,
+      senderId: entry.msg.fromId
+    }),
+    shouldDebounce: (entry) => {
+      const content = summarizeInlineMessageContent(entry.msg);
+      return shouldDebounceTextInbound({
+        text: buildInlineInboundBodyText(content),
+        cfg,
+        hasMedia: Boolean(content.media || content.attachments.length > 0),
+        ...botUsername ? { commandOptions: { botUsername } } : {}
+      });
+    },
+    onFlush: async (entries) => {
+      const last = entries.at(-1);
+      if (!last)
+        return;
+      if (entries.length === 1) {
+        await handleInboundNow({
+          chatId: last.chatId,
+          msg: last.msg
+        });
+        return;
+      }
+      const combinedText = entries.map((entry) => buildInlineInboundBodyText(summarizeInlineMessageContent(entry.msg))).filter(Boolean).join(`
+`);
+      if (!combinedText.trim()) {
+        return;
+      }
+      await handleInboundNow({
+        chatId: last.chatId,
+        msg: buildSyntheticInlineTextMessage({
+          base: last.msg,
+          text: combinedText,
+          mentioned: entries.some((entry) => entry.msg.mentioned === true)
+        }),
+        rawBodyOverride: combinedText
+      });
+    },
+    onError: (err, items) => {
+      runtime2.error?.(`inline debounce flush failed: ${String(err)}`);
+      const chatId = items[0]?.chatId;
+      if (chatId == null)
+        return;
+      client.sendMessage({
+        chatId,
+        text: "Something went wrong while processing your message. Please try again."
+      }).then(() => {
+        statusSink?.({ lastOutboundAt: Date.now() });
+      }).catch((sendErr) => {
+        runtime2.error?.(`inline debounce fallback send failed: ${String(sendErr)}`);
+      });
+    }
+  });
+  const loop = (async () => {
+    try {
+      for await (const event of client.events()) {
+        if (abortSignal.aborted)
+          break;
+        const rawEvent = event;
+        if (event.kind === "message.new") {
+          const msg = {
+            ...event.message,
+            chatId: event.chatId
+          };
+          if (msg.out || msg.fromId === meId)
+            continue;
+          await inboundDebouncer.enqueue({
+            chatId: event.chatId,
+            msg
+          });
+          continue;
+        }
+        if (event.kind === "reaction.add") {
+          if (event.reaction.userId === meId)
+            continue;
+          const onBotMessage = await isReactionTargetBotMessage({
+            client,
+            chatId: event.chatId,
+            messageId: event.reaction.messageId,
+            meId,
+            botMessageIdsByChat
+          }).catch((err) => {
+            statusSink?.({ lastError: `getChatHistory (reaction target) failed: ${String(err)}` });
+            return false;
+          });
+          if (!onBotMessage)
+            continue;
+          await handleInboundNow({
+            chatId: event.chatId,
+            msg: {
+              id: event.reaction.messageId,
+              chatId: event.chatId,
+              date: event.date,
+              fromId: event.reaction.userId,
+              message: "",
+              out: false,
+              mentioned: false,
+              replyToMsgId: event.reaction.messageId
+            },
+            reactionEvent: {
+              action: "added",
+              emoji: event.reaction.emoji,
+              targetMessageId: event.reaction.messageId
             }
-          }
+          });
+          continue;
         }
-        if (isGroup && groupHistoryKey) {
-          clearHistoryEntriesIfEnabled({
-            historyMap: groupPendingHistories,
-            historyKey: groupHistoryKey,
-            limit: historyLimit
+        if (event.kind === "reaction.delete") {
+          if (event.userId === meId)
+            continue;
+          const onBotMessage = await isReactionTargetBotMessage({
+            client,
+            chatId: event.chatId,
+            messageId: event.messageId,
+            meId,
+            botMessageIdsByChat
+          }).catch((err) => {
+            statusSink?.({ lastError: `getChatHistory (reaction target) failed: ${String(err)}` });
+            return false;
+          });
+          if (!onBotMessage)
+            continue;
+          await handleInboundNow({
+            chatId: event.chatId,
+            msg: {
+              id: event.messageId,
+              chatId: event.chatId,
+              date: event.date,
+              fromId: event.userId,
+              message: "",
+              out: false,
+              mentioned: false,
+              replyToMsgId: event.messageId
+            },
+            reactionEvent: {
+              action: "removed",
+              emoji: event.emoji,
+              targetMessageId: event.messageId
+            }
           });
+          continue;
+        }
+        if (rawEvent["kind"] === "message.action.invoke") {
+          const actorUserId = rawEvent["actorUserId"];
+          const interactionId = rawEvent["interactionId"];
+          const actionId = rawEvent["actionId"];
+          const targetMessageId = rawEvent["messageId"];
+          const data = rawEvent["data"];
+          const eventChatId = rawEvent["chatId"];
+          const eventDate = rawEvent["date"];
+          if (!actorUserId || !interactionId || !actionId || !targetMessageId || !eventChatId || !eventDate || !data) {
+            continue;
+          }
+          if (actorUserId === meId)
+            continue;
+          await handleInboundNow({
+            chatId: eventChatId,
+            msg: {
+              id: targetMessageId,
+              chatId: eventChatId,
+              date: eventDate,
+              fromId: actorUserId,
+              message: "",
+              out: false,
+              mentioned: false,
+              replyToMsgId: targetMessageId
+            },
+            callbackActionEvent: {
+              interactionId,
+              actionId,
+              targetMessageId,
+              data
+            }
+          });
+          continue;
         }
       }
     } catch (err) {
@@ -36790,6 +37132,10 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
       runtime2.error?.(`inline monitor loop crashed: ${String(err)}`);
     }
   })();
+  const diagnosticsTimer = setInterval(() => {
+    pushDiagnostics();
+  }, 15000);
+  diagnosticsTimer.unref?.();
   let stopPromise = null;
   const stop = async () => {
     if (stopPromise) {
@@ -36797,6 +37143,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
       return;
     }
     stopPromise = (async () => {
+      clearInterval(diagnosticsTimer);
       await client.close().catch(() => {});
       await loop.catch(() => {});
     })();
@@ -36809,6 +37156,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
 }
 
 // src/inline/actions.ts
+import { createMessageToolButtonsSchema } from "openclaw/plugin-sdk/channel-actions";
 import {
   normalizeInteractiveReply,
   reduceInteractiveReply
@@ -37597,7 +37945,7 @@ function describeInlineMessageTool({
   const schema = buttonsEnabled ? [
     {
       properties: {
-        buttons: createMessageToolButtonsSchemaCompat()
+        buttons: createMessageToolButtonsSchema()
       }
     }
   ] : [];
@@ -38649,6 +38997,7 @@ async function probeInlineAccount(account, timeoutMs) {
 
 // src/inline/status-issues.ts
 import { asString, isRecord as isRecord5 } from "openclaw/plugin-sdk/status-helpers";
+var RECENT_RUNTIME_ISSUE_MS = 30 * 60 * 1000;
 function readInlineProbeSummary(value) {
   if (!isRecord5(value)) {
     return {};
@@ -38666,6 +39015,38 @@ function readInlineProbeSummary(value) {
 function looksLikeAuthError(text) {
   return /(401|403|unauth|forbidden|invalid token|token invalid|unauthorized)/i.test(text);
 }
+function readInlineDiagnosticsSummary(value) {
+  if (!isRecord5(value)) {
+    return {};
+  }
+  const protocolValue = isRecord5(value.protocol) ? value.protocol : undefined;
+  const transportValue = (protocolValue && isRecord5(protocolValue.transport) ? protocolValue.transport : undefined) ?? (isRecord5(value.transport) ? value.transport : undefined);
+  const pingValue = protocolValue && isRecord5(protocolValue.ping) ? protocolValue.ping : undefined;
+  return {
+    ...protocolValue ? {
+      protocol: {
+        ...typeof protocolValue.lastFailureAt === "number" ? { lastFailureAt: protocolValue.lastFailureAt } : {},
+        ...asString(protocolValue.lastFailureReason) ? { lastFailureReason: asString(protocolValue.lastFailureReason) } : {},
+        ...pingValue && typeof pingValue.lastTimeoutAt === "number" ? {
+          ping: {
+            lastTimeoutAt: pingValue.lastTimeoutAt
+          }
+        } : {}
+      }
+    } : {},
+    ...transportValue ? {
+      transport: {
+        ...typeof transportValue.reconnectCount === "number" ? { reconnectCount: transportValue.reconnectCount } : {},
+        ...asString(transportValue.lastReconnectCause) ? { lastReconnectCause: asString(transportValue.lastReconnectCause) } : {}
+      }
+    } : {}
+  };
+}
+function isRecentTimestamp(timestamp) {
+  if (typeof timestamp !== "number" || !Number.isFinite(timestamp) || timestamp <= 0)
+    return false;
+  return Date.now() - timestamp <= RECENT_RUNTIME_ISSUE_MS;
+}
 function collectInlineStatusIssues(accounts) {
   const issues = [];
   for (const entry of accounts) {
@@ -38721,6 +39102,25 @@ function collectInlineStatusIssues(accounts) {
         fix: "Verify token/baseUrl connectivity, then re-run channel status."
       });
     }
+    const diagnostics = readInlineDiagnosticsSummary(entry.diagnostics);
+    if (isRecentTimestamp(diagnostics.protocol?.lastFailureAt) && (diagnostics.transport?.reconnectCount ?? 0) >= 3) {
+      issues.push({
+        channel: "inline",
+        accountId,
+        kind: "runtime",
+        message: `Inline connection is flapping (${diagnostics.transport?.reconnectCount ?? 0} reconnects). ` + `${diagnostics.protocol?.lastFailureReason ?? diagnostics.transport?.lastReconnectCause ?? "Recent reconnect failures detected."}`,
+        fix: "Inspect gateway logs for websocket close/error details and verify Inline API/network stability."
+      });
+    }
+    if (isRecentTimestamp(diagnostics.protocol?.ping?.lastTimeoutAt)) {
+      issues.push({
+        channel: "inline",
+        accountId,
+        kind: "runtime",
+        message: "Inline ping watchdog triggered a reconnect recently.",
+        fix: "Check websocket latency/packet loss and compare last pong timing in the Inline diagnostics snapshot."
+      });
+    }
   }
   return issues;
 }
@@ -39735,22 +40135,29 @@ var inlineChannelPlugin = {
     buildChannelSummary: ({ snapshot }) => buildTokenChannelStatusSummary(snapshot),
     probeAccount: async ({ account, timeoutMs }) => await probeInlineAccount(account, timeoutMs),
     formatCapabilitiesProbe: ({ probe }) => formatInlineCapabilitiesProbeLines(probe),
-    buildAccountSnapshot: ({ account, runtime: runtime2, probe }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      baseUrl: account.baseUrl ? "[set]" : "[missing]",
-      tokenSource: account.token ? "config" : account.tokenFile ? "file" : "missing",
-      running: runtime2?.running ?? false,
-      lastStartAt: runtime2?.lastStartAt ?? null,
-      lastStopAt: runtime2?.lastStopAt ?? null,
-      lastError: runtime2?.lastError ?? null,
-      lastInboundAt: runtime2?.lastInboundAt ?? null,
-      lastOutboundAt: runtime2?.lastOutboundAt ?? null,
-      lastProbeAt: runtime2?.lastProbeAt ?? null,
-      ...probe !== undefined ? { probe } : {}
-    })
+    buildAccountSnapshot: ({ account, runtime: runtime2, probe }) => {
+      const snapshot = {
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: account.configured,
+        baseUrl: account.baseUrl ? "[set]" : "[missing]",
+        tokenSource: account.token ? "config" : account.tokenFile ? "file" : "missing",
+        running: runtime2?.running ?? false,
+        lastStartAt: runtime2?.lastStartAt ?? null,
+        lastStopAt: runtime2?.lastStopAt ?? null,
+        lastError: runtime2?.lastError ?? null,
+        lastInboundAt: runtime2?.lastInboundAt ?? null,
+        lastOutboundAt: runtime2?.lastOutboundAt ?? null,
+        lastProbeAt: runtime2?.lastProbeAt ?? null,
+        ...probe !== undefined ? { probe } : {}
+      };
+      const diagnostics = runtime2?.diagnostics;
+      if (diagnostics !== undefined) {
+        snapshot.diagnostics = diagnostics;
+      }
+      return snapshot;
+    }
   },
   gateway: {
     startAccount: async (ctx) => {
@@ -40516,7 +40923,12 @@ async function callInlineBotApi(params) {
     if (params.body !== undefined) {
       request.body = JSON.stringify(params.body);
     }
-    const response = await fetch(url2, request);
+    let response;
+    try {
+      response = await fetch(url2, request);
+    } catch (error48) {
+      throw new Error(`inline_bot_commands: ${params.method} ${redactInlineBotApiUrl(url2)} fetch failed: ${summarizeInlineBotApiError(error48)}`);
+    }
     const payload = await response.json().catch(() => null);
     return { response, payload };
   };
@@ -40546,6 +40958,20 @@ async function callInlineBotApi(params) {
   }
   return resolve(headerResult);
 }
+function summarizeInlineBotApiError(error48) {
+  if (error48 instanceof Error) {
+    return `${error48.name}: ${error48.message}`;
+  }
+  return String(error48);
+}
+function redactInlineBotApiUrl(raw) {
+  try {
+    const url2 = new URL(raw);
+    return `${url2.protocol}//${url2.host}${url2.pathname.replace(/\/bot[^/]*\//, "/bot<redacted>/")}`;
+  } catch {
+    return raw.replace(/\/bot[^/]*\//, "/bot<redacted>/");
+  }
+}
 
 // src/inline/bot-commands-tool.ts
 var BOT_COMMAND_LIMIT = 100;
@@ -40706,6 +41132,9 @@ function createInlineBotCommandsTool(ctx) {
 }
 
 // src/inline/bot-commands-sync.ts
+import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
+import { getPluginCommandSpecs } from "openclaw/plugin-sdk/plugin-runtime";
+import { listSkillCommandsForAgents } from "openclaw/plugin-sdk/skill-commands-runtime";
 var INLINE_BASE_NATIVE_COMMANDS = [
   { command: "help", description: "Show available commands." },
   { command: "commands", description: "List all slash commands." },
@@ -40735,15 +41164,6 @@ var INLINE_BASE_NATIVE_COMMANDS = [
 ];
 var INLINE_COMMAND_NAME_RE = /^[a-z0-9_]{1,32}$/;
 var INLINE_COMMAND_LIMIT = 100;
-var FALLBACK_NATIVE_COMMAND_HELPERS = {
-  available: false,
-  listNativeCommandSpecsForConfig: () => [],
-  listSkillCommandsForAgents: () => []
-};
-var FALLBACK_PLUGIN_COMMAND_SPECS = {
-  available: false,
-  specs: []
-};
 function normalizeDynamicCommandName(raw) {
   const trimmed = raw.trim().toLowerCase();
   const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
@@ -40777,10 +41197,12 @@ async function buildInlineNativeCommandsForConfig(params) {
   if (params.cfg.commands?.debug === true) {
     commands.push({ command: "debug", description: "Set runtime debug overrides." });
   }
-  const { listNativeCommandSpecsForConfig, listSkillCommandsForAgents } = params.nativeHelpers;
   const skillCommands = shouldSyncInlineNativeSkills(params.cfg) ? listSkillCommandsForAgents({ cfg: params.cfg }) : [];
-  const nativeSpecs = listNativeCommandSpecsForConfig(params.cfg, { skillCommands });
-  const { specs: pluginSpecs } = params.pluginSpecs;
+  const nativeSpecs = listNativeCommandSpecsForConfig(params.cfg, {
+    skillCommands,
+    provider: "telegram"
+  });
+  const pluginSpecs = getPluginCommandSpecs("inline");
   const seen = new Set;
   const resolved = [];
   for (const base of commands) {
@@ -40797,19 +41219,13 @@ async function buildInlineNativeCommandsForConfig(params) {
 async function syncInlineNativeCommands(params) {
   const accountIds = listInlineAccountIds(params.cfg);
   const nativeEnabled = shouldSyncInlineNativeCommands(params.cfg);
-  const nativeHelpers = nativeEnabled ? await loadNativeCommandHelpersCompat() : FALLBACK_NATIVE_COMMAND_HELPERS;
-  const pluginSpecs = nativeEnabled ? await loadPluginCommandSpecsCompat("inline") : FALLBACK_PLUGIN_COMMAND_SPECS;
-  const usingSdkSource = nativeHelpers.available || pluginSpecs.available;
   const allCommands = nativeEnabled ? await buildInlineNativeCommandsForConfig({
-    cfg: params.cfg,
-    nativeHelpers,
-    pluginSpecs
+    cfg: params.cfg
   }) : [];
   const commands = allCommands.slice(0, INLINE_COMMAND_LIMIT);
   if (allCommands.length > INLINE_COMMAND_LIMIT) {
     params.logger?.warn?.(`[inline] native command sync truncating ${allCommands.length} commands to ${INLINE_COMMAND_LIMIT}`);
   }
-  params.logger?.info?.(`[inline] native command source: ${usingSdkSource ? "plugin-sdk" : "fallback"}`);
   let synced = 0;
   let failed = 0;
   for (const accountId of accountIds) {
@@ -40895,5 +41311,5 @@ export {
   src_default as default
 };
 
-//# debugId=CE0AB31A68AAA68C64756E2164756E21
+//# debugId=1C8239561365068664756E2164756E21
 //# sourceMappingURL=index.js.map