@inline-openclaw/inline 0.0.41 → 0.0.43

package/dist/channel-plugin-api.js

@@ -20589,6 +20589,8 @@ class InlineSdkClient {
   saveInFlight = null;
   catchUpInFlightByChatId = new Map;
   catchUpRequestedByChatId = new Map;
+  catchUpInFlightBySpaceId = new Map;
+  catchUpRequestedBySpaceId = new Map;
   userCatchUpInFlight = null;
   constructor(options) {
     this.options = options;
@@ -20653,7 +20655,11 @@ class InlineSdkClient {
     this.started = false;
     this.rejectOpen(new Error("closed"));
     this.eventStream.close();
-    await Promise.allSettled(this.catchUpInFlightByChatId.values());
+    await Promise.allSettled([
+      ...this.catchUpInFlightByChatId.values(),
+      ...this.catchUpInFlightBySpaceId.values(),
+      ...this.userCatchUpInFlight ? [this.userCatchUpInFlight] : []
+    ]);
     await this.flushStateSave();
     await this.protocol.stopTransport();
   }
@@ -20677,6 +20683,7 @@ class InlineSdkClient {
       version: 1,
       ...this.state.dateCursor != null ? { dateCursor: this.state.dateCursor } : {},
       ...this.state.lastSeqByChatId != null ? { lastSeqByChatId: { ...this.state.lastSeqByChatId } } : {},
+      ...this.state.lastSeqBySpaceId != null ? { lastSeqBySpaceId: { ...this.state.lastSeqBySpaceId } } : {},
       ...this.state.lastUserSeq != null ? { lastUserSeq: this.state.lastUserSeq } : {}
     };
   }
@@ -20697,12 +20704,7 @@ class InlineSdkClient {
     const chat = result.getChat.chat;
     if (!chat)
       throw new Error("getChat: missing chat");
-    return {
-      chatId: chat.id,
-      peer: chat.peerId,
-      title: chat.title,
-      ...chat.lastMsgId != null ? { lastMsgId: chat.lastMsgId } : {}
-    };
+    return { chatId: chat.id, peer: chat.peerId, title: chat.title };
   }
   async getMessages(params) {
     const peerId = this.inputPeerFromTarget(params, "getMessages");
@@ -21031,32 +21033,57 @@ class InlineSdkClient {
       }
       case "clearChatHistory": {
         const payload = update.update.clearChatHistory;
+        if (!payload.target) {
+          this.log.warn?.("Skipping clearChatHistory update without target");
+          return;
+        }
         if (payload.target.oneofKind === "spaceId") {
+          this.bumpSpaceSeq(payload.target.spaceId, seq);
           await this.eventStream.send({
             kind: "space.history.clear",
             spaceId: payload.target.spaceId,
             ...payload.beforeDate != null ? { beforeDate: payload.beforeDate } : {},
             deleteReplyThreads: payload.deleteReplyThreads,
+            deletedChatIds: payload.deletedChatIds,
+            orphanedChatIds: payload.orphanedChatIds,
+            detachedChatIds: payload.detachedChatIds,
             seq,
             date
           });
           return;
         }
         const peerId = payload.target.oneofKind === "peerId" ? payload.target.peerId : undefined;
-        const chatId = peerId?.type.oneofKind === "chat" ? peerId.type.chat.chatId : null;
-        if (!chatId) {
-          this.log.warn?.("Skipping clearChatHistory update without chat peer", peerId);
+        if (peerId?.type.oneofKind === "chat") {
+          const chatId = peerId.type.chat.chatId;
+          this.bumpChatSeq(chatId, seq);
+          await this.eventStream.send({
+            kind: "message.history.clear",
+            chatId,
+            ...payload.beforeDate != null ? { beforeDate: payload.beforeDate } : {},
+            deleteReplyThreads: payload.deleteReplyThreads,
+            deletedChatIds: payload.deletedChatIds,
+            orphanedChatIds: payload.orphanedChatIds,
+            detachedChatIds: payload.detachedChatIds,
+            seq,
+            date
+          });
           return;
         }
-        this.bumpChatSeq(chatId, seq);
-        await this.eventStream.send({
-          kind: "message.history.clear",
-          chatId,
-          ...payload.beforeDate != null ? { beforeDate: payload.beforeDate } : {},
-          deleteReplyThreads: payload.deleteReplyThreads,
-          seq,
-          date
-        });
+        if (peerId?.type.oneofKind === "user") {
+          await this.eventStream.send({
+            kind: "message.history.clear",
+            userId: peerId.type.user.userId,
+            ...payload.beforeDate != null ? { beforeDate: payload.beforeDate } : {},
+            deleteReplyThreads: payload.deleteReplyThreads,
+            deletedChatIds: payload.deletedChatIds,
+            orphanedChatIds: payload.orphanedChatIds,
+            detachedChatIds: payload.detachedChatIds,
+            seq,
+            date
+          });
+          return;
+        }
+        this.log.warn?.("Skipping clearChatHistory update without peer target", peerId);
         return;
       }
       case "updateReaction": {
@@ -21140,6 +21167,7 @@ class InlineSdkClient {
           seq,
           date
         });
+        this.requestCatchUpSpace({ spaceId: payload.spaceId, updateSeq: payload.updateSeq });
         return;
       }
       default:
@@ -21158,6 +21186,18 @@ class InlineSdkClient {
       this.scheduleStateSave();
     }
   }
+  bumpSpaceSeq(spaceId, seq) {
+    if (!Number.isFinite(seq))
+      return;
+    if (!this.state.lastSeqBySpaceId)
+      this.state.lastSeqBySpaceId = {};
+    const key = spaceId.toString();
+    const prev = this.state.lastSeqBySpaceId[key] ?? 0;
+    if (seq > prev) {
+      this.state.lastSeqBySpaceId[key] = seq;
+      this.scheduleStateSave();
+    }
+  }
   shouldSkipUserSeq(seq) {
     if (!Number.isFinite(seq))
       return false;
@@ -21337,6 +21377,112 @@ class InlineSdkClient {
     }
     return false;
   }
+  requestCatchUpSpace(params) {
+    const previous = this.catchUpRequestedBySpaceId.get(params.spaceId);
+    this.catchUpRequestedBySpaceId.set(params.spaceId, {
+      endSeq: Math.max(previous?.endSeq ?? 0, params.updateSeq)
+    });
+    if (this.catchUpInFlightBySpaceId.has(params.spaceId)) {
+      return;
+    }
+    const task = this.drainCatchUpSpace(params.spaceId).catch((error) => {
+      this.catchUpRequestedBySpaceId.delete(params.spaceId);
+      this.log.warn?.("GET_UPDATES space catch-up failed; continuing live delivery", {
+        spaceId: params.spaceId.toString(),
+        error: extractErrorMessage(error)
+      });
+    }).finally(() => {
+      this.catchUpInFlightBySpaceId.delete(params.spaceId);
+    });
+    this.catchUpInFlightBySpaceId.set(params.spaceId, task);
+  }
+  async drainCatchUpSpace(spaceId) {
+    const key = spaceId.toString();
+    while (true) {
+      const request = this.catchUpRequestedBySpaceId.get(spaceId);
+      if (!request)
+        return;
+      const lastSeq = this.state.lastSeqBySpaceId?.[key];
+      const startSeq = lastSeq ?? Math.max(0, request.endSeq - defaultColdStartCatchUpWindow);
+      if (request.endSeq <= startSeq) {
+        this.catchUpRequestedBySpaceId.delete(spaceId);
+        return;
+      }
+      const stop = await this.doCatchUpSpace(spaceId, startSeq, request.endSeq);
+      if (stop) {
+        this.catchUpRequestedBySpaceId.delete(spaceId);
+        return;
+      }
+      const latest = this.catchUpRequestedBySpaceId.get(spaceId);
+      const syncedSeq = this.state.lastSeqBySpaceId?.[key] ?? 0;
+      if (!latest || latest.endSeq <= syncedSeq) {
+        this.catchUpRequestedBySpaceId.delete(spaceId);
+        return;
+      }
+    }
+  }
+  async doCatchUpSpace(spaceId, startSeq, endSeq) {
+    let cursor = startSeq;
+    while (cursor < endSeq) {
+      const result = await this.invoke(Method.GET_UPDATES, {
+        oneofKind: "getUpdates",
+        getUpdates: GetUpdatesInput.create({
+          bucket: UpdateBucket.create({
+            type: {
+              oneofKind: "space",
+              space: {
+                spaceId
+              }
+            }
+          }),
+          startSeq: BigInt(cursor),
+          seqEnd: BigInt(endSeq),
+          totalLimit: defaultCatchUpTotalLimit,
+          limit: defaultCatchUpPageLimit
+        })
+      });
+      const payload = result.getUpdates;
+      if (payload.resultType === GetUpdatesResult_ResultType.TOO_LONG) {
+        this.log.warn?.("GET_UPDATES space too long; fast-forwarding cursor", {
+          spaceId: spaceId.toString(),
+          seq: payload.seq
+        });
+        this.bumpSpaceSeq(spaceId, endSeq);
+        if (payload.date !== 0n) {
+          this.state.dateCursor = payload.date;
+        }
+        this.scheduleStateSave();
+        return true;
+      }
+      const deliveredSeq = Number(payload.seq ?? 0n);
+      if (!Number.isSafeInteger(deliveredSeq)) {
+        this.log.warn?.("GET_UPDATES space returned non-integer seq; aborting catch-up", {
+          spaceId: spaceId.toString()
+        });
+        return true;
+      }
+      this.bumpSpaceSeq(spaceId, deliveredSeq);
+      for (const update of payload.updates) {
+        await this.handleUpdate(update);
+      }
+      if (payload.date !== 0n) {
+        this.state.dateCursor = payload.date;
+      }
+      this.scheduleStateSave();
+      if (payload.final)
+        return true;
+      if (deliveredSeq <= cursor) {
+        this.log.warn?.("GET_UPDATES space made no progress; aborting catch-up", {
+          spaceId: spaceId.toString(),
+          cursor,
+          deliveredSeq
+        });
+        return true;
+      }
+      cursor = deliveredSeq;
+    }
+    return false;
+  }
   peerToInputPeer(peer, chatId) {
     if (!peer) {
       return InputPeer.create({ type: { oneofKind: "chat", chat: { chatId } } });
@@ -21417,6 +21563,7 @@ class InlineSdkClient {
       version: 1,
       ...this.state.dateCursor != null ? { dateCursor: this.state.dateCursor } : {},
       ...this.state.lastSeqByChatId != null ? { lastSeqByChatId: { ...this.state.lastSeqByChatId } } : {},
+      ...this.state.lastSeqBySpaceId != null ? { lastSeqBySpaceId: { ...this.state.lastSeqBySpaceId } } : {},
       ...this.state.lastUserSeq != null ? { lastUserSeq: this.state.lastUserSeq } : {}
     };
     this.saveInFlight = store.save(snapshot).catch((error) => {
@@ -21634,7 +21781,9 @@ var serializeStateV1 = (state) => {
   const json = {
     version: 1,
     ...state.dateCursor != null ? { dateCursor: state.dateCursor.toString() } : {},
-    ...state.lastSeqByChatId != null ? { lastSeqByChatId: state.lastSeqByChatId } : {}
+    ...state.lastSeqByChatId != null ? { lastSeqByChatId: state.lastSeqByChatId } : {},
+    ...state.lastSeqBySpaceId != null ? { lastSeqBySpaceId: state.lastSeqBySpaceId } : {},
+    ...state.lastUserSeq != null ? { lastUserSeq: state.lastUserSeq } : {}
   };
   return JSON.stringify(json, null, 2);
 };
@@ -21646,10 +21795,21 @@ var deserializeStateV1 = (raw) => {
   return {
     version: 1,
     ...parsed.dateCursor != null ? { dateCursor: BigInt(parsed.dateCursor) } : {},
-    ...parsed.lastSeqByChatId != null ? { lastSeqByChatId: parsed.lastSeqByChatId } : {}
+    ...parsed.lastSeqByChatId != null ? { lastSeqByChatId: parsed.lastSeqByChatId } : {},
+    ...parsed.lastSeqBySpaceId != null ? { lastSeqBySpaceId: parsed.lastSeqBySpaceId } : {},
+    ...parsed.lastUserSeq != null ? { lastUserSeq: parsed.lastUserSeq } : {}
   };
 };
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isSeqRecord = (value) => {
+  if (!isRecord2(value))
+    return false;
+  for (const v of Object.values(value)) {
+    if (typeof v !== "number" || !Number.isFinite(v))
+      return false;
+  }
+  return true;
+};
 var isStateJsonV1 = (value) => {
   if (!isRecord2(value))
     return false;
@@ -21657,14 +21817,12 @@ var isStateJsonV1 = (value) => {
     return false;
   if (value.dateCursor != null && typeof value.dateCursor !== "string")
     return false;
-  if (value.lastSeqByChatId != null) {
-    if (!isRecord2(value.lastSeqByChatId))
-      return false;
-    for (const v of Object.values(value.lastSeqByChatId)) {
-      if (typeof v !== "number" || !Number.isFinite(v))
-        return false;
-    }
-  }
+  if (value.lastSeqByChatId != null && !isSeqRecord(value.lastSeqByChatId))
+    return false;
+  if (value.lastSeqBySpaceId != null && !isSeqRecord(value.lastSeqBySpaceId))
+    return false;
+  if (value.lastUserSeq != null && (typeof value.lastUserSeq !== "number" || !Number.isFinite(value.lastUserSeq)))
+    return false;
   return true;
 };
 
@@ -37570,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 = [
@@ -37759,6 +37918,7 @@ function keysForLookup(params) {
   const keys = new Set;
   if (params.parentMessageId) {
     keys.add(messageKey(params.accountId, params.parentChatId, params.parentMessageId));
+    return [...keys];
   }
   if (params.agentId) {
     keys.add(activeKey(params.accountId, params.parentChatId, params.agentId));
@@ -40826,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}`;
@@ -42644,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,
@@ -42661,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);
@@ -42763,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,
@@ -43183,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,
@@ -43259,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: {
@@ -43296,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({
@@ -43433,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)}`)
       }
@@ -43977,6 +44196,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
         statusSink?.({ lastOutboundAt: Date.now() });
       }
     } finally {
+      await setParentThreadCreationTyping(false);
       if (callbackActionEvent && !callbackActionAnswered) {
         try {
           await answerCallbackIfNeeded();
@@ -46482,8 +46702,9 @@ var inlineChannelPlugin = {
       "- 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.",
       "- Inline reply threads: use normal `reply` for short or newly started parent-chat conversations unless the user asks for a thread.",
-      "- Inline reply threads: use `thread-create` to create or reuse a real reply thread under the current/target chat. On inbound turns, omit `messageId` to anchor it to the current message, or pass `messageId`/`parentMessageId` explicitly.",
-      "- Inline reply threads: use `thread-reply` to send into a real reply thread, with `threadId` set to the reply-thread chat id returned by `thread-create`. Reuse that `threadId`; do not create one thread per message.",
+      "- Inline reply threads: use `thread-create` to create or reuse a real reply thread under the current/target chat. On parent-chat inbound turns, omit `messageId` to anchor it to the current message, or pass `messageId`/`parentMessageId` explicitly.",
+      "- Inline reply threads: use `thread-reply` to send into a real reply thread, with `threadId` set to the reply-thread chat id returned by `thread-create`. Reuse that `threadId` only for the same reply-thread session; unrelated parent-chat messages need separate parent-message anchors.",
+      "- Inline reply threads: when already inside a reply-thread chat, continue in that reply thread and do not create nested reply threads.",
       "- Inline reply-thread turns include nearby parent-chat context by default. If that context is incomplete, call `inline_parent_context` before answering."
     ]
   },
@@ -46847,5 +47068,5 @@ export {
   inlineChannelPlugin
 };
 
-//# debugId=A439BD5C99EA226864756E2164756E21
+//# debugId=FEB3F6CD06C6A7CC64756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map