@inline-openclaw/inline 0.0.27 → 0.0.29

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;
+    const oldestPendingAgeMs = now - oldestPendingPingAt;
+    if (oldestPendingAgeMs <= 30000)
       return;
-    this.log.warn?.("Ping timeout, reconnecting");
-    await client.reconnect();
+    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,17 @@ 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 { 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 +34371,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 +34471,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 +35129,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 +35213,125 @@ function callbackDataToUtf8(data) {
     return;
   }
 }
+function buildInlineInboundMessageSid(params) {
+  if (params.callbackActionEvent) {
+    return `callback:${String(params.callbackActionEvent.targetMessageId)}:${String(params.callbackActionEvent.interactionId)}`;
+  }
+  return String(params.msgId);
+}
 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 +35339,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 +35388,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 +35953,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 +35992,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;
@@ -36140,7 +36240,12 @@ ${JSON.stringify(payload)}`;
           await answerInlineMessageAction(client, callbackActionEvent.interactionId);
           callbackActionAnswered = true;
         };
-        const shouldEditCallbackTargetInPlace = false;
+        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,
@@ -36316,7 +36421,10 @@ ${JSON.stringify(payload)}`;
           continue;
         }
         const parseMarkdown = account.config.parseMarkdown ?? true;
-        const nativeCommandMenu = resolveInlineCompatNativeCommandMenu(normalizedCommandBody);
+        const nativeCommandMenu = resolveInlineNativeCommandMenu({
+          commandBody: normalizedCommandBody,
+          cfg
+        });
         if (nativeCommandMenu) {
           const menuActions = resolveInlineReplyActions({
             channelData: {
@@ -36325,13 +36433,132 @@ ${JSON.stringify(payload)}`;
               }
             }
           });
-          const sent = await client.sendMessage({
-            chatId,
-            text: nativeCommandMenu.title,
-            ...menuActions ? { actions: menuActions } : {}
+          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,
+              text: nativeCommandMenu.title,
+              ...menuActions ? { actions: menuActions } : {}
+            });
+            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 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,
+                actions,
+                parseMarkdown
+              });
+              if (sent.messageId != null) {
+                rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+              }
+            }
+          };
+          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 (sent.messageId != null) {
-            rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+          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) => {
@@ -36421,7 +36648,10 @@ ${currentEntityText}` : null
           ...senderUsername ? { SenderUsername: senderUsername } : {},
           Provider: CHANNEL_ID,
           Surface: effectiveSurface,
-          MessageSid: String(msg.id),
+          MessageSid: buildInlineInboundMessageSid({
+            msgId: msg.id,
+            ...callbackActionEvent ? { callbackActionEvent } : {}
+          }),
           ...replyThreadContext ? { MessageThreadId: String(replyThreadContext.childChatId) } : {},
           ...replyThreadContext?.threadLabel ? { ThreadLabel: replyThreadContext.threadLabel } : {},
           ...msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {},
@@ -36476,12 +36706,20 @@ ${currentEntityText}` : null
             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: null,
-          accumulatedText: "",
+          messageId: shouldEditCallbackTargetInPlace ? callbackActionEvent?.targetMessageId ?? null : null,
+          accumulatedText: callbackTargetMessage?.message ?? "",
           lastPartialText: "",
           finalTextAccumulator: "",
           failed: false,
@@ -36649,7 +36887,7 @@ ${currentEntityText}` : null
                       return false;
                     const nextText = text.trim();
                     const textForEdit = nextText || editStreamState.accumulatedText;
-                    if (!textForEdit)
+                    if (!textForEdit && actions === undefined)
                       return true;
                     const shouldSkipTextUpdate = !editStreamState.failed && textForEdit === editStreamState.accumulatedText;
                     if (shouldSkipTextUpdate && actions === undefined)
@@ -36675,6 +36913,16 @@ ${currentEntityText}` : null
                     return true;
                   };
                   if (mediaList.length === 0) {
+                    if (shouldEditCallbackTargetInPlace && editStreamState.messageId != null) {
+                      const callbackEditActions = outboundActions ?? { rows: [] };
+                      if (!outboundText.trim() && outboundActions === undefined) {
+                        return;
+                      }
+                      await updateStreamedMessage(outboundText, callbackEditActions);
+                      delivered = true;
+                      statusSink?.({ lastOutboundAt: Date.now() });
+                      return;
+                    }
                     if (streamViaEditMessage && infoKind === "final" && finalDeliveredForCurrentAssistantMessage && editStreamState.messageId != null) {
                       await resetEditStreamForAssistantMessage();
                     }
@@ -36790,6 +37038,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 +37049,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
       return;
     }
     stopPromise = (async () => {
+      clearInterval(diagnosticsTimer);
       await client.close().catch(() => {});
       await loop.catch(() => {});
     })();
@@ -36809,6 +37062,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
 }
 
 // src/inline/actions.ts
+import { createMessageToolButtonsSchema } from "openclaw/plugin-sdk/channel-actions";
 import {
   normalizeInteractiveReply,
   reduceInteractiveReply
@@ -37597,7 +37851,7 @@ function describeInlineMessageTool({
   const schema = buttonsEnabled ? [
     {
       properties: {
-        buttons: createMessageToolButtonsSchemaCompat()
+        buttons: createMessageToolButtonsSchema()
       }
     }
   ] : [];
@@ -38649,6 +38903,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 +38921,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 +39008,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 +40041,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 +40829,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 +40864,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 +41038,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 +41070,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 +41103,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 +41125,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 +41217,5 @@ export {
   src_default as default
 };
 
-//# debugId=CE0AB31A68AAA68C64756E2164756E21
+//# debugId=3B7100874DF4D61664756E2164756E21
 //# sourceMappingURL=index.js.map