@inline-openclaw/inline 0.0.42 → 0.0.43

package/dist/channel-plugin-api.js

@@ -37728,6 +37728,7 @@ var INLINE_FORMATTING_RULES = [
   "Prefer bullet lists over markdown tables.",
   "If a table is necessary, render it inside a fenced code block.",
   "Use plain URLs or markdown links; do not wrap bare URLs in inline code or backticks.",
+  "Mention Inline users with markdown links like [@FirstName](inline://user?id=123); use inline://user?username=username only when the user id is unavailable.",
   "Use inline code only for actual code, commands, file paths, env vars, or identifiers."
 ];
 var INLINE_COPY_REPLACEMENTS = [
@@ -40985,6 +40986,40 @@ function buildInlineTypingDispatcherOptions(typingCallbacks) {
     ...typingCallbacks.onCleanup ? { onCleanup: typingCallbacks.onCleanup } : {}
   };
 }
+function uniqueInlineChatIds(chatIds) {
+  const seen = new Set;
+  const out = [];
+  for (const chatId of chatIds) {
+    if (chatId == null)
+      continue;
+    const key = String(chatId);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(chatId);
+  }
+  return out;
+}
+async function sendInlineTypingToChats(params) {
+  if (params.chatIds.length === 0)
+    return;
+  const failures = [];
+  await Promise.all(params.chatIds.map(async (chatId) => {
+    try {
+      await params.client.sendTyping({ chatId, typing: params.typing });
+    } catch (error51) {
+      failures.push({ chatId, error: error51 });
+    }
+  }));
+  if (failures.length === 0)
+    return;
+  if (failures.length === params.chatIds.length) {
+    throw failures[0]?.error ?? new Error("inline typing failed");
+  }
+  for (const failure of failures) {
+    params.onPartialError?.(failure.chatId, failure.error);
+  }
+}
 function buildInlineReplyThreadSessionKey(parentSessionKey, threadChatId) {
   const suffix = `:thread:${String(threadChatId)}`;
   return parentSessionKey.endsWith(suffix) ? parentSessionKey : `${parentSessionKey}${suffix}`;
@@ -42803,6 +42838,7 @@ async function monitorInlineProvider(params) {
       statusSink?.({ lastError: `getChat failed: ${String(err)}` });
     }
     const isGroup = chatInfo.kind !== "direct";
+    const inlineThreadDefaults = cfg.channels?.inline ?? {};
     const replyThreadsEnabled = isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
     const replyThreadContext = await resolveInlineInboundReplyThreadContext({
       replyThreadsEnabled,
@@ -42820,25 +42856,25 @@ async function monitorInlineProvider(params) {
       cfg,
       accountId: account.accountId,
       groupId: String(effectiveChatId),
-      defaultMode: normalizeInlineReplyThreadMode(account.config.replyThreadMode)
+      defaultMode: normalizeInlineReplyThreadMode(account.config.replyThreadMode ?? inlineThreadDefaults.replyThreadMode)
     }) : "auto";
     const replyThreadAutoCreateMinMessages = isGroup && replyThreadsEnabled ? resolveInlineGroupReplyThreadAutoCreateMinMessages({
       cfg,
       accountId: account.accountId,
       groupId: String(effectiveChatId),
-      defaultMinMessages: account.config.replyThreadAutoCreateMinMessages ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES
+      defaultMinMessages: account.config.replyThreadAutoCreateMinMessages ?? inlineThreadDefaults.replyThreadAutoCreateMinMessages ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES
     }) : DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES;
     const replyThreadRequireExplicitMention = isGroup && replyThreadsEnabled ? resolveInlineGroupReplyThreadRequireExplicitMention({
       cfg,
       accountId: account.accountId,
       groupId: String(effectiveChatId),
-      defaultRequireExplicitMention: account.config.replyThreadRequireExplicitMention ?? false
+      defaultRequireExplicitMention: account.config.replyThreadRequireExplicitMention ?? inlineThreadDefaults.replyThreadRequireExplicitMention ?? false
     }) : false;
     const replyThreadParentHistoryLimit = isGroup && replyThreadsEnabled ? resolveInlineGroupReplyThreadParentHistoryLimit({
       cfg,
       accountId: account.accountId,
       groupId: String(effectiveChatId),
-      defaultLimit: account.config.replyThreadParentHistoryLimit ?? DEFAULT_REPLY_THREAD_PARENT_HISTORY_LIMIT
+      defaultLimit: account.config.replyThreadParentHistoryLimit ?? inlineThreadDefaults.replyThreadParentHistoryLimit ?? DEFAULT_REPLY_THREAD_PARENT_HISTORY_LIMIT
     }) : DEFAULT_REPLY_THREAD_PARENT_HISTORY_LIMIT;
     const senderId = String(msg.fromId);
     await hydrateChatParticipants(chatId);
@@ -42922,14 +42958,15 @@ async function monitorInlineProvider(params) {
         replyThreadContext: params2.replyThreadContext ?? null
       });
     };
-    const nativeCallbackCommandBody = callbackActionEvent ? parseInlineNativeCommandCallbackData(callbackDataToUtf8(callbackActionEvent.data)) : null;
-    const hasControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
-    const commandSource = hasControlCommand ? (nativeCallbackCommandBody != null || !callbackActionEvent) && isInlineNativeCommandBody({
+    const hasTextControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
+    const isRegisteredNativeCommand = isInlineNativeCommandBody({
       cfg,
       account,
       commandBody: normalizedCommandBody,
       agentId: route.agentId
-    }) ? "native" : "text" : undefined;
+    });
+    const hasControlCommand = hasTextControlCommand || isRegisteredNativeCommand;
+    const commandSource = hasControlCommand ? isRegisteredNativeCommand ? "native" : "text" : undefined;
     const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
       cfg,
       surface: CHANNEL_ID,
@@ -43342,7 +43379,15 @@ This model will be used for your next message.`, []);
       messageId: msg.id,
       minMessages: replyThreadAutoCreateMinMessages
     }) && !shouldEditCallbackTargetInPlace;
+    let parentThreadCreationTyping = false;
+    const setParentThreadCreationTyping = async (typing) => {
+      if (!shouldCreateDeliveryThread || parentThreadCreationTyping === typing)
+        return;
+      parentThreadCreationTyping = typing;
+      await client.sendTyping({ chatId: effectiveChatId, typing }).catch((error51) => runtime.error?.(`inline parent reply-thread typing failed: ${String(error51)}`));
+    };
     if (shouldCreateDeliveryThread) {
+      await setParentThreadCreationTyping(true);
       const cachedRoute = await lookupInlineReplyThreadRoute({
         accountId: account.accountId,
         parentChatId: effectiveChatId,
@@ -43418,6 +43463,7 @@ This model will be used for your next message.`, []);
     if (shouldCreateDeliveryThread && !deliveryReplyThreadContext) {
       runtime.error?.("inline create reply thread failed; falling back to parent chat delivery");
     }
+    await setParentThreadCreationTyping(false);
     if (!replyThreadContext && deliveryReplyThreadContext?.anchorMessage != null) {
       effectiveHistoryContext = prependInlineReplyThreadAnchor({
         historyContext: {
@@ -43455,6 +43501,10 @@ This model will be used for your next message.`, []);
       }
     }
     const deliveryChatId = deliveryReplyThreadContext?.childChatId ?? chatId;
+    const typingChatIds = uniqueInlineChatIds([
+      deliveryChatId,
+      !replyThreadContext && deliveryReplyThreadContext ? deliveryReplyThreadContext.parentChatId : null
+    ]);
     const deliverySessionKey = deliveryReplyThreadContext && isGroup ? buildInlineReplyThreadSessionKey(route.sessionKey, deliveryReplyThreadContext.childChatId) : route.sessionKey;
     const groupHistoryKey = isGroup ? deliveryReplyThreadContext ? deliverySessionKey : route.sessionKey : null;
     const inboundMedia = await resolveInlineInboundMedia({
@@ -43592,8 +43642,18 @@ This model will be used for your next message.`, []);
       channel: CHANNEL_ID,
       accountId: account.accountId,
       typing: {
-        start: () => client.sendTyping({ chatId: deliveryChatId, typing: true }),
-        stop: () => client.sendTyping({ chatId: deliveryChatId, typing: false }),
+        start: () => sendInlineTypingToChats({
+          client,
+          chatIds: typingChatIds,
+          typing: true,
+          onPartialError: (chatId2, error51) => runtime.error?.(`inline typing start failed for chat ${String(chatId2)}: ${String(error51)}`)
+        }),
+        stop: () => sendInlineTypingToChats({
+          client,
+          chatIds: typingChatIds,
+          typing: false,
+          onPartialError: (chatId2, error51) => runtime.error?.(`inline typing stop failed for chat ${String(chatId2)}: ${String(error51)}`)
+        }),
         onStartError: (err) => runtime.error?.(`inline typing start failed: ${String(err)}`),
         onStopError: (err) => runtime.error?.(`inline typing stop failed: ${String(err)}`)
       }
@@ -44136,6 +44196,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
         statusSink?.({ lastOutboundAt: Date.now() });
       }
     } finally {
+      await setParentThreadCreationTyping(false);
       if (callbackActionEvent && !callbackActionAnswered) {
         try {
           await answerCallbackIfNeeded();
@@ -47007,5 +47068,5 @@ export {
   inlineChannelPlugin
 };
 
-//# debugId=D09AEA19262D181164756E2164756E21
+//# debugId=FEB3F6CD06C6A7CC64756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map