@inline-openclaw/inline 0.0.25 → 0.0.26

package/dist/index.js

@@ -5547,6 +5547,14 @@ var require_websocket_server = __commonJS((exports, module) => {
   }
 });
 
+// src/inline/channel.ts
+import {
+  deleteAccountFromConfigSection,
+  setAccountEnabledInConfigSection
+} from "openclaw/plugin-sdk/core";
+import { buildDmGroupAccountAllowlistAdapter } from "openclaw/plugin-sdk/allowlist-config-edit";
+import { buildTokenChannelStatusSummary } from "openclaw/plugin-sdk/status-helpers";
+
 // ../protocol/dist/core.js
 var import_runtime = __toESM(require_commonjs(), 1);
 var import_runtime2 = __toESM(require_commonjs(), 1);
@@ -35176,6 +35184,7 @@ var REACTION_TARGET_LOOKUP_LIMIT = 8;
 var REPLY_TARGET_LOOKUP_LIMIT = 8;
 var ATTACHMENT_CONTEXT_LIMIT = 6;
 var DEFAULT_INLINE_MEDIA_MAX_BYTES = 300 * 1024 * 1024;
+var EMPTY_RESPONSE_FALLBACK = "No response generated. Please try again.";
 var GET_MESSAGES_METHOD2 = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : null;
 function normalizeAllowEntry(raw) {
   return raw.trim().replace(/^inline:/i, "").replace(/^user:/i, "");
@@ -36488,193 +36497,287 @@ ${currentEntityText}` : null
           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)}`);
+                }
+              }
+              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) => {
-              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) {
+              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 (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)
+                      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;
-            }
-          } : {},
-          ...typeof disableBlockStreaming === "boolean" ? { disableBlockStreaming } : {}
-        };
-        try {
-          await core3.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-            ctx: ctxPayload,
-            cfg,
-            dispatcherOptions: {
-              ...prefixOptions,
-              ...typingCallbacks ? { typingCallbacks } : {},
-              deliver: async (payload) => {
-                const rawText = payload.text ?? "";
-                const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
-                const outboundText = rewriteNumericMentionsToUsernames(rawText, senderProfilesById);
-                const outboundActions = resolveInlineReplyActions(payload);
-                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,
-                    ...includeReplyTo && replyToMsgId != null ? { replyToMsgId } : {},
-                    ...includeActions && outboundActions !== undefined ? { actions: outboundActions } : {},
-                    parseMarkdown
-                  });
-                  rememberSent(sent.messageId);
-                };
-                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 (!shouldSkipTextUpdate) {
+                      editStreamState.accumulatedText = textForEdit;
+                      editStreamState.lastPartialText = textForEdit;
                     }
-                  });
-                  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 && editStreamState.messageId != null) {
-                    if (outboundText.trim()) {
-                      editStreamState.finalTextAccumulator += outboundText;
+                    editStreamState.failed = false;
+                    return true;
+                  };
+                  if (mediaList.length === 0) {
+                    if (streamViaEditMessage && infoKind === "final" && finalDeliveredForCurrentAssistantMessage && editStreamState.messageId != null) {
+                      await resetEditStreamForAssistantMessage();
                     }
-                    if (!editStreamState.finalTextAccumulator.trim() && outboundActions === undefined) {
+                    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;
                     }
-                    await updateStreamedMessage(editStreamState.finalTextAccumulator, outboundActions);
+                    if (!outboundText.trim())
+                      return;
+                    await sendTextFallback(outboundText, true, true);
                     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);
-                  } catch (error48) {
-                    runtime2.error?.(`inline media upload failed; falling back to url text (${String(error48)})`);
-                    const fallbackText = caption ? `${caption}
+                  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);
+                      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)}`);
                 }
-                statusSink?.({ lastOutboundAt: Date.now() });
               },
-              onError: (err, info) => runtime2.error?.(`inline ${info.kind} reply failed: ${String(err)}`)
-            },
-            replyOptions
-          });
+              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 {
@@ -36936,12 +37039,33 @@ function parseInlineId(raw, label) {
       throw new Error(`inline action: missing ${label}`);
     }
     if (!/^[0-9]+$/.test(trimmed)) {
+      if (/message/i.test(label)) {
+        const prefixed = trimmed.match(/^(?:message|msg)\s*#?\s*([0-9]+)$/i)?.[1];
+        if (prefixed) {
+          return BigInt(prefixed);
+        }
+      }
       throw new Error(`inline action: invalid ${label} "${raw}"`);
     }
     return BigInt(trimmed);
   }
   throw new Error(`inline action: missing ${label}`);
 }
+function resolveReactionMessageId(params) {
+  const explicit = readFlexibleId(params.args, "messageId") ?? readStringParam(params.args, "messageId");
+  if (explicit) {
+    return explicit;
+  }
+  const fromContext = params.toolContext?.currentMessageId;
+  if (typeof fromContext === "number" && Number.isFinite(fromContext)) {
+    return String(Math.trunc(fromContext));
+  }
+  if (typeof fromContext === "string") {
+    const trimmed = fromContext.trim();
+    return trimmed || undefined;
+  }
+  return;
+}
 function parseOptionalInlineId(raw, label) {
   if (raw == null)
     return;
@@ -37195,6 +37319,7 @@ function mapChatEntry(params) {
   }
   return {
     id: String(params.chat.id),
+    target: `chat:${String(params.chat.id)}`,
     title: params.chat.title,
     spaceId: params.chat.spaceId != null ? String(params.chat.spaceId) : null,
     isPublic: params.chat.isPublic ?? false,
@@ -37206,11 +37331,29 @@ function mapChatEntry(params) {
     peer: peer?.oneofKind === "user" ? {
       kind: "user",
       id: String(peer.user.userId),
+      target: `user:${String(peer.user.userId)}`,
       username: peerUser?.username ?? null,
       name: peerUser ? buildInlineUserDisplayName(peerUser) : null
-    } : peer?.oneofKind === "chat" ? { kind: "chat", id: String(peer.chat.chatId) } : null
+    } : peer?.oneofKind === "chat" ? { kind: "chat", id: String(peer.chat.chatId), target: `chat:${String(peer.chat.chatId)}` } : null
   };
 }
+function normalizeInlineListQuery(query) {
+  return query?.trim().toLowerCase() ?? "";
+}
+function mapUserPeerEntry(user) {
+  return {
+    id: String(user.id),
+    target: `user:${String(user.id)}`,
+    username: user.username ?? null,
+    name: buildInlineUserDisplayName(user),
+    bot: user.bot ?? false
+  };
+}
+function matchesInlineListQuery(text, query) {
+  if (!query)
+    return true;
+  return text.toLowerCase().includes(query);
+}
 async function loadMessageReactions(params) {
   const target = await findMessageById({
     client: params.client,
@@ -37239,6 +37382,28 @@ async function loadMessageReactions(params) {
   }
   return Array.from(byEmoji.values());
 }
+function getErrorMessage(error48) {
+  if (error48 instanceof Error)
+    return error48.message;
+  if (typeof error48 === "string")
+    return error48;
+  if (error48 && typeof error48 === "object" && "message" in error48 && typeof error48.message === "string") {
+    return error48.message;
+  }
+  return String(error48);
+}
+function isDuplicateReactionError(error48) {
+  const text = getErrorMessage(error48).toLowerCase();
+  return text.includes("unique_reaction_per_emoji") || text.includes("duplicate") && text.includes("reaction") || text.includes("duplicate key value violates unique constraint");
+}
+async function reactionAlreadyExists(params) {
+  const me = await params.client.getMe().catch(() => null);
+  if (!me?.userId)
+    return false;
+  const myId = String(me.userId);
+  const reactions = await loadMessageReactions(params).catch(() => []);
+  return reactions.some((reaction) => reaction.emoji === params.emoji && reaction.userIds.includes(myId));
+}
 async function findMessageById(params) {
   const directResult = GET_MESSAGES_METHOD3 == null ? null : await params.client.invokeRaw(GET_MESSAGES_METHOD3, {
     oneofKind: "getMessages",
@@ -37423,11 +37588,18 @@ var inlineMessageActions = {
       return null;
     return { to: normalized };
   },
-  handleAction: async ({ action, params, cfg, accountId }) => {
+  handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
     if (!SUPPORTED_ACTIONS.includes(action)) {
       throw new Error(`Action ${action} is not supported for provider inline.`);
     }
     if (!isActionEnabled({ cfg, accountId: accountId ?? null, action })) {
+      if (action === "react") {
+        return jsonResult({
+          ok: false,
+          reason: "disabled",
+          hint: "Inline reactions are disabled via channels.inline.actions.reactions. Do not retry."
+        });
+      }
       throw new Error(`inline action: ${action} is disabled by channels.inline.actions`);
     }
     const normalizedAction = action;
@@ -37552,7 +37724,24 @@ var inlineMessageActions = {
         accountId,
         fn: async (client) => {
           const chatId = resolveChatIdFromParams(params);
-          const messageId = parseInlineId(readFlexibleId(params, "messageId") ?? readStringParam(params, "messageId", { required: true }), "messageId");
+          const rawMessageId = resolveReactionMessageId(toolContext != null ? { args: params, toolContext } : { args: params });
+          if (!rawMessageId) {
+            return jsonResult({
+              ok: false,
+              reason: "missing_message_id",
+              hint: "Inline reaction requires a valid messageId (or inbound context fallback). Do not retry."
+            });
+          }
+          let messageId;
+          try {
+            messageId = parseInlineId(rawMessageId, "messageId");
+          } catch {
+            return jsonResult({
+              ok: false,
+              reason: "missing_message_id",
+              hint: "Inline reaction requires a valid messageId (or inbound context fallback). Do not retry."
+            });
+          }
           const { emoji: emoji3, remove, isEmpty } = readReactionParams(params, {
             removeErrorMessage: "Emoji is required to remove an Inline reaction."
           });
@@ -37560,28 +37749,72 @@ var inlineMessageActions = {
             throw new Error("inline action: react requires emoji");
           }
           if (remove) {
-            const result = await client.invokeRaw(Method.DELETE_REACTION, {
-              oneofKind: "deleteReaction",
-              deleteReaction: {
-                emoji: emoji3,
-                peerId: buildChatPeer3(chatId),
-                messageId
+            try {
+              const result = await client.invokeRaw(Method.DELETE_REACTION, {
+                oneofKind: "deleteReaction",
+                deleteReaction: {
+                  emoji: emoji3,
+                  peerId: buildChatPeer3(chatId),
+                  messageId
+                }
+              });
+              if (result.oneofKind !== "deleteReaction") {
+                throw new Error(`inline action: expected deleteReaction result, got ${String(result.oneofKind)}`);
               }
-            });
-            if (result.oneofKind !== "deleteReaction") {
-              throw new Error(`inline action: expected deleteReaction result, got ${String(result.oneofKind)}`);
+            } catch {
+              return jsonResult({
+                ok: false,
+                reason: "error",
+                emoji: emoji3,
+                remove: true,
+                hint: "Reaction failed. Do not retry."
+              });
             }
           } else {
-            const result = await client.invokeRaw(Method.ADD_REACTION, {
-              oneofKind: "addReaction",
-              addReaction: {
+            if (await reactionAlreadyExists({
+              client,
+              chatId,
+              messageId,
+              emoji: emoji3
+            })) {
+              return jsonResult({
+                ok: true,
+                chatId: String(chatId),
+                messageId: String(messageId),
                 emoji: emoji3,
-                messageId,
-                peerId: buildChatPeer3(chatId)
+                remove: false,
+                alreadyPresent: true
+              });
+            }
+            try {
+              const result = await client.invokeRaw(Method.ADD_REACTION, {
+                oneofKind: "addReaction",
+                addReaction: {
+                  emoji: emoji3,
+                  messageId,
+                  peerId: buildChatPeer3(chatId)
+                }
+              });
+              if (result.oneofKind !== "addReaction") {
+                throw new Error(`inline action: expected addReaction result, got ${String(result.oneofKind)}`);
               }
-            });
-            if (result.oneofKind !== "addReaction") {
-              throw new Error(`inline action: expected addReaction result, got ${String(result.oneofKind)}`);
+            } catch (error48) {
+              if (!isDuplicateReactionError(error48)) {
+                return jsonResult({
+                  ok: false,
+                  reason: "error",
+                  emoji: emoji3,
+                  hint: "Reaction failed. Do not retry."
+                });
+              }
+              return jsonResult({
+                ok: true,
+                chatId: String(chatId),
+                messageId: String(messageId),
+                emoji: emoji3,
+                remove: false,
+                alreadyPresent: true
+              });
             }
           }
           return jsonResult({
@@ -37755,6 +37988,7 @@ var inlineMessageActions = {
         fn: async (client) => {
           const query = readStringParam(params, "query") ?? readStringParam(params, "q") ?? undefined;
           const limit = Math.max(1, Math.min(200, readNumberParam(params, "limit", { integer: true }) ?? 50));
+          const scope = (readStringParam(params, "scope") ?? readStringParam(params, "kind") ?? "all").toLowerCase();
           const result = await client.invokeRaw(Method.GET_CHATS, {
             oneofKind: "getChats",
             getChats: {}
@@ -37764,23 +37998,26 @@ var inlineMessageActions = {
           }
           const dialogByChatId = buildDialogMap(result.getChats.dialogs ?? []);
           const usersById = buildUserMap2(result.getChats.users ?? []);
-          const entries = (result.getChats.chats ?? []).map((chat) => mapChatEntry({ chat, dialogByChatId, usersById }));
-          const normalizedQuery = query?.trim().toLowerCase() ?? "";
-          const filtered = normalizedQuery ? entries.filter((entry) => {
-            const haystack = [
-              entry.id,
-              entry.title,
-              entry.peer?.kind === "user" ? entry.peer.username ?? "" : "",
-              entry.peer?.kind === "user" ? entry.peer.name ?? "" : ""
-            ].join(`
-`).toLowerCase();
-            return haystack.includes(normalizedQuery);
-          }) : entries;
+          const chats = (result.getChats.chats ?? []).map((chat) => mapChatEntry({ chat, dialogByChatId, usersById }));
+          const groups = chats.filter((entry) => entry.peer?.kind !== "user");
+          const peers = (result.getChats.users ?? []).map((user) => mapUserPeerEntry(user));
+          const normalizedQuery = normalizeInlineListQuery(query);
+          const filteredChats = chats.filter((entry) => matchesInlineListQuery([entry.id, entry.target, entry.title, entry.peer?.kind === "user" ? entry.peer.username ?? "" : "", entry.peer?.kind === "user" ? entry.peer.name ?? "" : ""].join(`
+`), normalizedQuery));
+          const filteredGroups = groups.filter((entry) => matchesInlineListQuery([entry.id, entry.target, entry.title].join(`
+`), normalizedQuery));
+          const filteredPeers = peers.filter((entry) => matchesInlineListQuery([entry.id, entry.target, entry.username ?? "", entry.name ?? ""].join(`
+`), normalizedQuery));
           return jsonResult(toJsonSafe({
             ok: true,
+            scope,
             query: query ?? null,
-            count: filtered.length,
-            chats: filtered.slice(0, limit)
+            count: filteredChats.length,
+            groupsCount: filteredGroups.length,
+            peersCount: filteredPeers.length,
+            chats: scope === "groups" || scope === "group" || scope === "channels" || scope === "channel" ? [] : scope === "peers" || scope === "peer" || scope === "members" || scope === "member" || scope === "users" || scope === "user" ? [] : filteredChats.slice(0, limit),
+            groups: scope === "peers" || scope === "peer" || scope === "members" || scope === "member" || scope === "users" || scope === "user" ? [] : filteredGroups.slice(0, limit),
+            peers: scope === "groups" || scope === "group" || scope === "channels" || scope === "channel" ? [] : filteredPeers.slice(0, limit)
           }));
         }
       });
@@ -38204,6 +38441,239 @@ var inlineMessageActions = {
 };
 var inlineSupportedActions = listAllActions();
 
+// src/inline/setup-core.ts
+import { createEnvPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup";
+var channel = "inline";
+var INLINE_TOKEN_HELP_LINES = [
+  "1) Open Inline and generate a bot token for your workspace/account",
+  "2) Copy the token",
+  "3) Paste it here, or set INLINE_TOKEN in your environment",
+  "Docs: https://inline.chat/docs/openclaw",
+  "Website: https://openclaw.ai"
+];
+var inlineSetupAdapter = createEnvPatchedAccountSetupAdapter({
+  channelKey: channel,
+  defaultAccountOnlyEnvError: "INLINE_TOKEN can only be used for the default account.",
+  missingCredentialError: "Inline requires token or --token-file (or --use-env).",
+  hasCredentials: (input) => Boolean(input.token || input.tokenFile),
+  buildPatch: (input) => input.tokenFile ? { tokenFile: input.tokenFile } : input.token ? { token: input.token } : {}
+});
+
+// src/inline/setup-surface.ts
+import {
+  DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID2,
+  setSetupChannelEnabled
+} from "openclaw/plugin-sdk/setup";
+var channel2 = "inline";
+var inlineSetupWizard = {
+  channel: channel2,
+  status: {
+    configuredLabel: "configured",
+    unconfiguredLabel: "needs token",
+    configuredHint: "configured",
+    unconfiguredHint: "recommended",
+    configuredScore: 1,
+    unconfiguredScore: 10,
+    resolveConfigured: ({ cfg }) => listInlineAccountIds(cfg).some((accountId) => resolveInlineAccount({ cfg, accountId }).configured)
+  },
+  credentials: [
+    {
+      inputKey: "token",
+      providerHint: channel2,
+      credentialLabel: "Inline token",
+      preferredEnvVar: "INLINE_TOKEN",
+      helpTitle: "Inline token",
+      helpLines: INLINE_TOKEN_HELP_LINES,
+      envPrompt: "INLINE_TOKEN detected. Use env var?",
+      keepPrompt: "Inline token already configured. Keep it?",
+      inputPrompt: "Enter Inline token",
+      allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID2,
+      inspect: ({ cfg, accountId }) => {
+        const resolved = resolveInlineAccount({ cfg, accountId });
+        const hasConfiguredValue = Boolean((resolved.config.token ?? "").trim() || (resolved.config.tokenFile ?? "").trim());
+        const resolvedValue = resolved.token?.trim();
+        const envValue = accountId === DEFAULT_ACCOUNT_ID2 ? process.env.INLINE_TOKEN?.trim() : undefined;
+        return {
+          accountConfigured: resolved.configured || hasConfiguredValue,
+          hasConfiguredValue,
+          ...resolvedValue ? { resolvedValue } : {},
+          ...envValue ? { envValue } : {}
+        };
+      }
+    }
+  ],
+  disable: (cfg) => setSetupChannelEnabled(cfg, channel2, false)
+};
+
+// src/inline/probe.ts
+function formatInlineProbeUserName(user) {
+  const explicit = [user.firstName?.trim(), user.lastName?.trim()].filter(Boolean).join(" ");
+  if (explicit)
+    return explicit;
+  const username = user.username?.trim();
+  if (username)
+    return `@${username}`;
+  return "Unknown";
+}
+async function withTimeout(promise2, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return await promise2;
+  }
+  return await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`probe timeout after ${Math.trunc(timeoutMs)}ms`));
+    }, timeoutMs);
+    promise2.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error48) => {
+      clearTimeout(timer);
+      reject(error48);
+    });
+  });
+}
+async function probeInlineAccountDirect(account) {
+  if (!account.baseUrl?.trim()) {
+    throw new Error("missing baseUrl");
+  }
+  const token = await resolveInlineToken(account);
+  const client = new InlineSdkClient({
+    baseUrl: account.baseUrl,
+    token
+  });
+  await client.connect();
+  try {
+    const result = await client.invokeRaw(Method.GET_ME, {
+      oneofKind: "getMe",
+      getMe: {}
+    });
+    if (result.oneofKind !== "getMe") {
+      throw new Error(`expected getMe result, got ${String(result.oneofKind)}`);
+    }
+    if (!result.getMe.user) {
+      throw new Error("missing current user from getMe");
+    }
+    const user = result.getMe.user;
+    return {
+      ok: true,
+      accountId: account.accountId,
+      baseUrl: account.baseUrl,
+      user: {
+        id: String(user.id),
+        username: user.username?.trim() || null,
+        name: formatInlineProbeUserName(user),
+        bot: user.bot ?? false
+      }
+    };
+  } finally {
+    await client.close().catch(() => {});
+  }
+}
+function toErrorText(error48) {
+  if (error48 instanceof Error && error48.message.trim()) {
+    return error48.message;
+  }
+  return String(error48);
+}
+async function probeInlineAccount(account, timeoutMs) {
+  if (!account.configured) {
+    return {
+      ok: false,
+      accountId: account.accountId,
+      baseUrl: account.baseUrl,
+      error: "missing token"
+    };
+  }
+  try {
+    return await withTimeout(probeInlineAccountDirect(account), timeoutMs);
+  } catch (error48) {
+    return {
+      ok: false,
+      accountId: account.accountId,
+      baseUrl: account.baseUrl,
+      error: toErrorText(error48)
+    };
+  }
+}
+
+// src/inline/status-issues.ts
+import { asString, isRecord as isRecord5 } from "openclaw/plugin-sdk/status-helpers";
+function readInlineProbeSummary(value) {
+  if (!isRecord5(value)) {
+    return {};
+  }
+  const summary = {};
+  if (typeof value.ok === "boolean") {
+    summary.ok = value.ok;
+  }
+  const error48 = asString(value.error);
+  if (error48) {
+    summary.error = error48;
+  }
+  return summary;
+}
+function looksLikeAuthError(text) {
+  return /(401|403|unauth|forbidden|invalid token|token invalid|unauthorized)/i.test(text);
+}
+function collectInlineStatusIssues(accounts) {
+  const issues = [];
+  for (const entry of accounts) {
+    if (!isRecord5(entry)) {
+      continue;
+    }
+    const accountId = asString(entry.accountId);
+    if (!accountId) {
+      continue;
+    }
+    const enabled = entry.enabled !== false;
+    if (!enabled) {
+      continue;
+    }
+    const configured = entry.configured !== false;
+    if (!configured) {
+      issues.push({
+        channel: "inline",
+        accountId,
+        kind: "config",
+        message: "Inline account is enabled but missing token/tokenFile.",
+        fix: "Set channels.inline.token (or tokenFile), then restart the gateway."
+      });
+      continue;
+    }
+    const baseUrl = asString(entry.baseUrl);
+    if (!baseUrl || baseUrl === "[missing]") {
+      issues.push({
+        channel: "inline",
+        accountId,
+        kind: "config",
+        message: "Inline account is configured but baseUrl is missing.",
+        fix: 'Set channels.inline.baseUrl (for example "https://api.inline.chat"), then restart the gateway.'
+      });
+    }
+    const lastError = asString(entry.lastError);
+    if (lastError) {
+      issues.push({
+        channel: "inline",
+        accountId,
+        kind: looksLikeAuthError(lastError) ? "auth" : "runtime",
+        message: `Inline runtime error: ${lastError}`,
+        fix: "Verify token/baseUrl and restart the gateway."
+      });
+    }
+    const probe = readInlineProbeSummary(entry.probe);
+    if (probe.ok === false && probe.error) {
+      issues.push({
+        channel: "inline",
+        accountId,
+        kind: looksLikeAuthError(probe.error) ? "auth" : "runtime",
+        message: `Inline probe failed: ${probe.error}`,
+        fix: "Verify token/baseUrl connectivity, then re-run channel status."
+      });
+    }
+  }
+  return issues;
+}
+
 // src/inline/channel.ts
 var activeMonitors = new Map;
 var meta3 = {
@@ -38242,6 +38712,82 @@ function parseInlineId2(raw) {
   }
   return;
 }
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function clearInlineCredentialFields(record2) {
+  let changed = false;
+  let cleared = false;
+  for (const key of ["token", "tokenFile"]) {
+    if (!Object.hasOwn(record2, key)) {
+      continue;
+    }
+    const raw = record2[key];
+    if (typeof raw === "string" && raw.trim()) {
+      cleared = true;
+    }
+    delete record2[key];
+    changed = true;
+  }
+  return { changed, cleared };
+}
+function clearInlineAccountCredentials(params) {
+  const channels = asRecord(params.cfg.channels);
+  const inline = asRecord(channels?.inline);
+  if (!channels || !inline) {
+    return { cfg: params.cfg, changed: false, cleared: false };
+  }
+  const nextInline = { ...inline };
+  let changed = false;
+  let cleared = false;
+  if (params.accountId === DEFAULT_ACCOUNT_ID) {
+    const base = clearInlineCredentialFields(nextInline);
+    changed = changed || base.changed;
+    cleared = cleared || base.cleared;
+  }
+  const accounts = asRecord(nextInline.accounts);
+  if (accounts) {
+    const nextAccounts = { ...accounts };
+    const accountEntry = asRecord(nextAccounts[params.accountId]);
+    if (accountEntry) {
+      const nextAccountEntry = { ...accountEntry };
+      const entry = clearInlineCredentialFields(nextAccountEntry);
+      if (entry.changed) {
+        changed = true;
+        cleared = cleared || entry.cleared;
+        if (Object.keys(nextAccountEntry).length > 0) {
+          nextAccounts[params.accountId] = nextAccountEntry;
+        } else {
+          delete nextAccounts[params.accountId];
+        }
+      }
+    }
+    if (changed) {
+      if (Object.keys(nextAccounts).length > 0) {
+        nextInline.accounts = nextAccounts;
+      } else {
+        delete nextInline.accounts;
+      }
+    }
+  }
+  if (!changed) {
+    return { cfg: params.cfg, changed: false, cleared: false };
+  }
+  return {
+    cfg: {
+      ...params.cfg,
+      channels: {
+        ...channels,
+        inline: nextInline
+      }
+    },
+    changed: true,
+    cleared
+  };
+}
 function parseInlineOutboundTarget(params) {
   let normalizedTarget = params.raw.trim();
   const hadInlinePrefix = /^inline:/i.test(normalizedTarget);
@@ -38277,6 +38823,46 @@ function parseInlineOutboundTarget(params) {
     raw: params.raw
   };
 }
+function parseInlineExplicitTarget(raw) {
+  const parsed = parseInlineOutboundTarget({
+    raw,
+    context: "sendText"
+  });
+  if (parsed.kind === "user") {
+    return { to: `user:${parsed.normalizedNumeric}`, chatType: "direct" };
+  }
+  return { to: `chat:${parsed.normalizedNumeric}`, chatType: "group" };
+}
+function formatInlineTargetDisplay(params) {
+  const explicit = params.display?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const parsed = parseInlineExplicitTarget(params.target.trim());
+  if (!parsed) {
+    return params.target.trim();
+  }
+  if (parsed.chatType === "direct" || params.kind === "user") {
+    return parsed.to;
+  }
+  return parsed.to;
+}
+function normalizeInlineConversationId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return null;
+  const withoutProvider = trimmed.replace(/^inline:/i, "").trim();
+  if (!withoutProvider)
+    return null;
+  try {
+    const parsed = parseInlineExplicitTarget(withoutProvider);
+    if (!parsed)
+      return null;
+    return `inline:${parsed.to}`;
+  } catch {
+    return null;
+  }
+}
 async function listInlineTargetIds(client) {
   const result = await client.invokeRaw(Method.GET_CHATS, {
     oneofKind: "getChats",
@@ -38350,6 +38936,31 @@ function buildInlineDisplayName(params) {
     return `@${username}`;
   return "Unknown";
 }
+function formatInlineCapabilitiesProbeLines(probe) {
+  const details = probe;
+  if (!details) {
+    return [];
+  }
+  if (!details.ok) {
+    if (details.error?.trim()) {
+      return [{ text: `Probe failed: ${details.error}`, tone: "error" }];
+    }
+    return [{ text: "Probe failed", tone: "error" }];
+  }
+  const lines = [];
+  if (details.user) {
+    const username = details.user.username ? ` @${details.user.username}` : "";
+    const botLabel = details.user.bot ? " [bot]" : "";
+    lines.push({
+      text: `Identity: ${details.user.name}${username} (${details.user.id})${botLabel}`,
+      tone: "success"
+    });
+  }
+  if (details.baseUrl) {
+    lines.push({ text: `Base URL: ${details.baseUrl}` });
+  }
+  return lines;
+}
 function toInlineUserDirectoryEntry(user) {
   return {
     kind: "user",
@@ -38653,10 +39264,25 @@ var inlineChannelPlugin = {
   },
   reload: { configPrefixes: ["channels.inline"] },
   configSchema: buildChannelConfigSchema(InlineConfigSchema),
+  setup: inlineSetupAdapter,
+  setupWizard: inlineSetupWizard,
   config: {
     listAccountIds: (cfg) => listInlineAccountIds(cfg),
     resolveAccount: (cfg, accountId) => resolveInlineAccount({ cfg, accountId: accountId ?? null }),
     defaultAccountId: (cfg) => resolveDefaultInlineAccountId(cfg),
+    setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+      cfg,
+      sectionKey: "inline",
+      accountId,
+      enabled,
+      allowTopLevel: true
+    }),
+    deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+      cfg,
+      sectionKey: "inline",
+      accountId,
+      clearBaseFields: ["token", "tokenFile", "name", "enabled"]
+    }),
     isConfigured: (account) => account.configured,
     describeAccount: (account) => ({
       accountId: account.accountId,
@@ -38707,6 +39333,47 @@ var inlineChannelPlugin = {
       ];
     }
   },
+  allowlist: buildDmGroupAccountAllowlistAdapter({
+    channelId: "inline",
+    resolveAccount: ({ cfg, accountId }) => resolveInlineAccount({ cfg, accountId: accountId ?? null }),
+    normalize: ({ values }) => values.map((entry) => String(entry).trim()).filter(Boolean).map((entry) => normalizeInlineAllowEntry(entry)),
+    resolveDmAllowFrom: (account) => account.config.allowFrom ?? [],
+    resolveGroupAllowFrom: (account) => account.config.groupAllowFrom ?? [],
+    resolveDmPolicy: (account) => account.config.dmPolicy,
+    resolveGroupPolicy: (account) => account.config.groupPolicy
+  }),
+  bindings: {
+    compileConfiguredBinding: ({ conversationId }) => {
+      const normalized = normalizeInlineConversationId(conversationId);
+      if (!normalized) {
+        return null;
+      }
+      return { conversationId: normalized };
+    },
+    matchInboundConversation: ({ compiledBinding, conversationId, parentConversationId }) => {
+      const expected = normalizeInlineConversationId(compiledBinding.conversationId);
+      if (!expected) {
+        return null;
+      }
+      const incoming = normalizeInlineConversationId(conversationId);
+      const parent = parentConversationId ? normalizeInlineConversationId(parentConversationId) : null;
+      if (incoming && incoming === expected) {
+        return {
+          conversationId: incoming,
+          ...parent ? { parentConversationId: parent } : {},
+          matchPriority: 2
+        };
+      }
+      if (incoming && parent && parent === expected) {
+        return {
+          conversationId: incoming,
+          parentConversationId: parent,
+          matchPriority: 1
+        };
+      }
+      return null;
+    }
+  },
   groups: {
     resolveRequireMention: ({ cfg, accountId, groupId }) => {
       const resolved = resolveInlineAccount({ cfg, accountId: accountId ?? null });
@@ -38759,7 +39426,9 @@ var inlineChannelPlugin = {
     messageToolHints: ({ cfg, accountId }) => [
       "- Inline targeting: omit `target` to reply in the current chat.",
       "- Inline explicit targets: `chat:<chatId>` for chats and `user:<userId>` for direct users. Prefer `user:` for DM user targets.",
-      "- Inline history tools: `read` and `search` return media-aware message payloads (`media`, `attachments`, `attachmentUrls`) so image-only history remains discoverable.",
+      "- Inline discovery: use `channel-list` to discover available chats and users. Use `scope: groups|peers|all` when helpful, and reuse returned `target` values.",
+      "- Inline reactions: pass `messageId` for `react` when you have it; on inbound turns, the current inbound message id can be used as fallback.",
+      "- Inline history tools: `read` and `search` return media-aware message payloads (`media`, `attachments`, `attachmentUrls`) so image-only history remains discoverable. `search` is chat-scoped; run it per chat.",
       "- Inline special tools: use `inline_nudge` to send a nudge, and `inline_forward` to forward message ids between chats or users.",
       ...isInlineReplyThreadsEnabled({ cfg, accountId: accountId ?? null }) ? [
         "- Inline reply threads are enabled: use `thread-reply` to send into a real reply thread, with `threadId` set to the reply-thread chat id."
@@ -38768,6 +39437,29 @@ var inlineChannelPlugin = {
   },
   messaging: {
     normalizeTarget: normalizeInlineTarget,
+    parseExplicitTarget: ({ raw }) => {
+      try {
+        const parsed = parseInlineExplicitTarget(raw);
+        if (!parsed)
+          return null;
+        return { to: parsed.to, chatType: parsed.chatType };
+      } catch {
+        return null;
+      }
+    },
+    inferTargetChatType: ({ to }) => {
+      try {
+        const parsed = parseInlineExplicitTarget(to);
+        return parsed?.chatType;
+      } catch {
+        return;
+      }
+    },
+    formatTargetDisplay: ({ target, display, kind }) => formatInlineTargetDisplay({
+      target,
+      ...display !== undefined ? { display } : {},
+      ...kind !== undefined ? { kind } : {}
+    }),
     targetResolver: {
       looksLikeId: looksLikeInlineTargetId,
       hint: "<chatId | chat:<chatId> | user:<userId>>"
@@ -38985,18 +39677,14 @@ var inlineChannelPlugin = {
       running: false,
       lastStartAt: null,
       lastStopAt: null,
-      lastError: null
+      lastError: null,
+      lastProbeAt: null
     },
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      running: snapshot.running ?? false,
-      lastStartAt: snapshot.lastStartAt ?? null,
-      lastStopAt: snapshot.lastStopAt ?? null,
-      lastError: snapshot.lastError ?? null,
-      lastInboundAt: snapshot.lastInboundAt ?? null,
-      lastOutboundAt: snapshot.lastOutboundAt ?? null
-    }),
-    buildAccountSnapshot: ({ account, runtime: runtime2 }) => ({
+    collectStatusIssues: collectInlineStatusIssues,
+    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,
@@ -39008,7 +39696,9 @@ var inlineChannelPlugin = {
       lastStopAt: runtime2?.lastStopAt ?? null,
       lastError: runtime2?.lastError ?? null,
       lastInboundAt: runtime2?.lastInboundAt ?? null,
-      lastOutboundAt: runtime2?.lastOutboundAt ?? null
+      lastOutboundAt: runtime2?.lastOutboundAt ?? null,
+      lastProbeAt: runtime2?.lastProbeAt ?? null,
+      ...probe !== undefined ? { probe } : {}
     })
   },
   gateway: {
@@ -39061,6 +39751,30 @@ var inlineChannelPlugin = {
         running: false,
         lastStopAt: Date.now()
       });
+    },
+    logoutAccount: async ({ accountId, cfg }) => {
+      const cleanup = clearInlineAccountCredentials({ cfg, accountId });
+      if (cleanup.changed) {
+        return {
+          cleared: cleanup.cleared,
+          loggedOut: cleanup.cleared,
+          cfg: cleanup.cfg,
+          message: cleanup.cleared ? "Inline credentials cleared from config. Restart gateway to apply." : "Inline credential fields removed from config."
+        };
+      }
+      const envToken = process.env.INLINE_TOKEN?.trim() ?? "";
+      if (accountId === DEFAULT_ACCOUNT_ID && envToken) {
+        return {
+          cleared: false,
+          loggedOut: false,
+          message: "No Inline credentials found in config. INLINE_TOKEN is set in env; unset it and restart gateway to fully log out."
+        };
+      }
+      return {
+        cleared: false,
+        loggedOut: false,
+        message: "No Inline credentials found in config for this account."
+      };
     }
   }
 };
@@ -40130,5 +40844,5 @@ export {
   src_default as default
 };
 
-//# debugId=DA562915BABAD00064756E2164756E21
+//# debugId=AB3E531CE13839CA64756E2164756E21
 //# sourceMappingURL=index.js.map