@inline-openclaw/inline 0.0.39 → 0.0.40

package/dist/channel-plugin-api.js

@@ -5589,7 +5589,7 @@ function hasInlineConfiguredState(params) {
 
 // src/inline/channel.ts
 import { unlink } from "node:fs/promises";
-import path4 from "node:path";
+import path5 from "node:path";
 import {
   buildChannelOutboundSessionRoute,
   buildThreadAwareOutboundSessionRoute
@@ -5630,6 +5630,8 @@ var MessageEntity_Type;
   MessageEntity_Type2[MessageEntity_Type2["CODE"] = 8] = "CODE";
   MessageEntity_Type2[MessageEntity_Type2["PRE"] = 9] = "PRE";
   MessageEntity_Type2[MessageEntity_Type2["PHONE_NUMBER"] = 10] = "PHONE_NUMBER";
+  MessageEntity_Type2[MessageEntity_Type2["THREAD"] = 11] = "THREAD";
+  MessageEntity_Type2[MessageEntity_Type2["THREAD_TITLE"] = 12] = "THREAD_TITLE";
 })(MessageEntity_Type || (MessageEntity_Type = {}));
 var Member_Role;
 (function(Member_Role2) {
@@ -7760,7 +7762,9 @@ class MessageEntity$Type extends import_runtime4.MessageType {
       { no: 3, name: "length", kind: "scalar", T: 3, L: 0 },
       { no: 4, name: "mention", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityMention },
       { no: 5, name: "text_url", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityTextUrl },
-      { no: 6, name: "pre", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityPre }
+      { no: 6, name: "pre", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityPre },
+      { no: 7, name: "thread", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityThread },
+      { no: 8, name: "thread_title", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityThreadTitle }
     ]);
   }
   create(value) {
@@ -7805,6 +7809,18 @@ class MessageEntity$Type extends import_runtime4.MessageType {
             pre: MessageEntity_MessageEntityPre.internalBinaryRead(reader, reader.uint32(), options, message.entity.pre)
           };
           break;
+        case 7:
+          message.entity = {
+            oneofKind: "thread",
+            thread: MessageEntity_MessageEntityThread.internalBinaryRead(reader, reader.uint32(), options, message.entity.thread)
+          };
+          break;
+        case 8:
+          message.entity = {
+            oneofKind: "threadTitle",
+            threadTitle: MessageEntity_MessageEntityThreadTitle.internalBinaryRead(reader, reader.uint32(), options, message.entity.threadTitle)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -7829,6 +7845,10 @@ class MessageEntity$Type extends import_runtime4.MessageType {
       MessageEntity_MessageEntityTextUrl.internalBinaryWrite(message.entity.textUrl, writer.tag(5, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.entity.oneofKind === "pre")
       MessageEntity_MessageEntityPre.internalBinaryWrite(message.entity.pre, writer.tag(6, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.entity.oneofKind === "thread")
+      MessageEntity_MessageEntityThread.internalBinaryWrite(message.entity.thread, writer.tag(7, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.entity.oneofKind === "threadTitle")
+      MessageEntity_MessageEntityThreadTitle.internalBinaryWrite(message.entity.threadTitle, writer.tag(8, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -7966,6 +7986,99 @@ class MessageEntity_MessageEntityPre$Type extends import_runtime4.MessageType {
 }
 var MessageEntity_MessageEntityPre = new MessageEntity_MessageEntityPre$Type;
 
+class MessageEntity_MessageEntityThread$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageEntity.MessageEntityThread", [
+      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chatId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chatId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageEntity_MessageEntityThread = new MessageEntity_MessageEntityThread$Type;
+
+class MessageEntity_MessageEntityThreadTitle$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageEntity.MessageEntityThreadTitle", [
+      { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "title", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.spaceId = 0n;
+    message.title = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.spaceId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.title = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.spaceId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.spaceId);
+    if (message.title !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.title);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageEntity_MessageEntityThreadTitle = new MessageEntity_MessageEntityThreadTitle$Type;
+
 class MessageReactions$Type extends import_runtime4.MessageType {
   constructor() {
     super("MessageReactions", [
@@ -36567,27 +36680,6 @@ var GET_CHAT_METHOD = typeof Method.GET_CHAT === "number" && Number.isInteger(Me
 var GET_CHAT_HISTORY_METHOD = typeof Method.GET_CHAT_HISTORY === "number" && Number.isInteger(Method.GET_CHAT_HISTORY) && Method.GET_CHAT_HISTORY > 0 ? Method.GET_CHAT_HISTORY : 5;
 var GET_MESSAGES_METHOD = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : 38;
 var CREATE_SUBTHREAD_METHOD = typeof Method.CREATE_SUBTHREAD === "number" && Number.isInteger(Method.CREATE_SUBTHREAD) && Method.CREATE_SUBTHREAD > 0 ? Method.CREATE_SUBTHREAD : 42;
-function isPlacementMode(raw) {
-  return raw === "thread" || raw === "main";
-}
-function hasReplyThreadConfig(config2) {
-  if (isPlacementMode(config2.replyThreadMode))
-    return true;
-  if (typeof config2.replyThreadAutoCreateMinMessages === "number")
-    return true;
-  if (typeof config2.replyThreadRequireExplicitMention === "boolean")
-    return true;
-  if (typeof config2.replyThreadParentHistoryLimit === "number")
-    return true;
-  if (!config2.groups || typeof config2.groups !== "object" || Array.isArray(config2.groups))
-    return false;
-  return Object.values(config2.groups).some((group) => {
-    if (!group || typeof group !== "object" || Array.isArray(group))
-      return false;
-    const groupConfig = group;
-    return isPlacementMode(groupConfig.replyThreadMode) || typeof groupConfig.replyThreadAutoCreateMinMessages === "number" || typeof groupConfig.replyThreadRequireExplicitMention === "boolean" || typeof groupConfig.replyThreadParentHistoryLimit === "number";
-  });
-}
 function buildChatPeer(chatId) {
   return {
     type: {
@@ -36597,21 +36689,14 @@ function buildChatPeer(chatId) {
   };
 }
 function getInlineReplyThreadsCapabilityConfig(params) {
-  const account = resolveInlineAccount({
-    cfg: params.cfg,
-    accountId: params.accountId ?? null
-  });
-  return {
-    replyThreads: account.config.capabilities?.replyThreads === true || hasReplyThreadConfig(account.config)
-  };
+  return { replyThreads: true };
 }
 function isInlineReplyThreadsEnabled(params) {
   return getInlineReplyThreadsCapabilityConfig(params).replyThreads;
 }
 function resolveInlineReplyThreadChatId(params) {
-  if (!isInlineReplyThreadsEnabled({ cfg: params.cfg, accountId: params.accountId ?? null })) {
-    return params.parentChatId;
-  }
+  params.cfg;
+  params.accountId;
   if (params.parentChatId == null) {
     return null;
   }
@@ -36726,7 +36811,7 @@ function looksLikeInlineTargetId(raw, normalizedInput) {
 
 // src/inline/monitor.ts
 import { mkdir } from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 import {
   buildCommandTextFromArgs,
   findCommandByNativeName,
@@ -37529,6 +37614,315 @@ function sanitizeInlineOutgoingText(text) {
   });
 }
 
+// src/inline/thread-routes.ts
+import path2 from "node:path";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { readJsonFileWithFallback, writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
+var TTL_MS = 7 * 24 * 60 * 60 * 1000;
+var MAX_ENTRIES = 5000;
+var PERSISTENT_MAX_ENTRIES = 2000;
+var STORE_VERSION = 1;
+var PERSISTENT_NAMESPACE = "inline.reply-thread-routes";
+var INLINE_REPLY_THREAD_ROUTE_KEY = Symbol.for("openclaw.inlineReplyThreadRoutes");
+var DEFAULT_AGENT_KEY = "__any__";
+var DEFAULT_STORE_KEY = "__default__";
+var routeState;
+var persistentStore;
+var persistentStoreDisabled = false;
+function getRouteState() {
+  if (routeState)
+    return routeState;
+  const globalStore = globalThis;
+  const existing = globalStore[INLINE_REPLY_THREAD_ROUTE_KEY];
+  routeState = existing ?? {
+    memory: new Map,
+    fileWrites: new Map
+  };
+  globalStore[INLINE_REPLY_THREAD_ROUTE_KEY] = routeState;
+  return routeState;
+}
+function normalizePositiveId(raw) {
+  if (raw == null)
+    return;
+  if (typeof raw === "bigint")
+    return raw >= 0n ? String(raw) : undefined;
+  if (typeof raw === "number") {
+    return Number.isInteger(raw) && raw >= 0 ? String(raw) : undefined;
+  }
+  const trimmed = raw.trim();
+  if (!/^\d+$/.test(trimmed))
+    return;
+  return trimmed;
+}
+function normalizeOptionalText(raw) {
+  const trimmed = raw?.trim();
+  return trimmed || undefined;
+}
+function safePathSegment(value) {
+  return value.trim().replace(/[^a-z0-9._-]+/gi, "_").slice(0, 80) || "global";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(record2, key) {
+  const value = record2[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readTimestamp(record2, key, fallback) {
+  const value = record2[key];
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : fallback;
+}
+function normalizeRecord(value) {
+  if (!isRecord3(value))
+    return null;
+  const accountId = readString(value, "accountId");
+  const parentChatId = normalizePositiveId(readString(value, "parentChatId"));
+  const threadId = normalizePositiveId(readString(value, "threadId"));
+  if (!accountId || !parentChatId || !threadId)
+    return null;
+  const now = Date.now();
+  const parentMessageId = normalizePositiveId(readString(value, "parentMessageId"));
+  const title = normalizeOptionalText(readString(value, "title"));
+  const threadLabel = normalizeOptionalText(readString(value, "threadLabel"));
+  const agentId = normalizeOptionalText(readString(value, "agentId"));
+  return {
+    accountId,
+    parentChatId,
+    threadId,
+    createdAt: readTimestamp(value, "createdAt", now),
+    updatedAt: readTimestamp(value, "updatedAt", now),
+    ...parentMessageId ? { parentMessageId } : {},
+    ...title ? { title } : {},
+    ...threadLabel ? { threadLabel } : {},
+    ...agentId ? { agentId } : {}
+  };
+}
+function isExpired(record2, now) {
+  return now - record2.updatedAt > TTL_MS;
+}
+function reportRouteStateError(error51) {
+  try {
+    getOptionalInlineRuntime()?.logging.getChildLogger({ plugin: "inline", feature: "reply-thread-route-state" }).warn("Inline reply-thread route state failed", { error: String(error51) });
+  } catch {}
+}
+function disablePersistentStore(error51) {
+  persistentStoreDisabled = true;
+  persistentStore = undefined;
+  if (!String(error51).includes("openKeyedStore is only available")) {
+    reportRouteStateError(error51);
+  }
+}
+function getPersistentStore() {
+  if (persistentStoreDisabled)
+    return;
+  if (persistentStore)
+    return persistentStore;
+  const openKeyedStore = getOptionalInlineRuntime()?.state?.openKeyedStore;
+  if (typeof openKeyedStore !== "function")
+    return;
+  try {
+    persistentStore = openKeyedStore({
+      namespace: PERSISTENT_NAMESPACE,
+      maxEntries: PERSISTENT_MAX_ENTRIES,
+      defaultTtlMs: TTL_MS
+    });
+    return persistentStore;
+  } catch (error51) {
+    disablePersistentStore(error51);
+    return;
+  }
+}
+function resolveRoutesPath(accountId) {
+  const resolveStateDir = getOptionalInlineRuntime()?.state?.resolveStateDir;
+  if (typeof resolveStateDir !== "function")
+    return;
+  return path2.join(resolveStateDir(), "inline", "reply-thread-routes", `${safePathSegment(accountId)}.json`);
+}
+function activeKey(accountId, parentChatId, agentId) {
+  return `${accountId}:parent:${parentChatId}:agent:${agentId || DEFAULT_AGENT_KEY}`;
+}
+function messageKey(accountId, parentChatId, parentMessageId) {
+  return `${accountId}:parent:${parentChatId}:message:${parentMessageId}`;
+}
+function keysForRecord(record2) {
+  const keys = new Set;
+  if (record2.parentMessageId) {
+    keys.add(messageKey(record2.accountId, record2.parentChatId, record2.parentMessageId));
+  }
+  if (record2.agentId) {
+    keys.add(activeKey(record2.accountId, record2.parentChatId, record2.agentId));
+  }
+  keys.add(activeKey(record2.accountId, record2.parentChatId));
+  return [...keys];
+}
+function keysForLookup(params) {
+  const keys = new Set;
+  if (params.parentMessageId) {
+    keys.add(messageKey(params.accountId, params.parentChatId, params.parentMessageId));
+  }
+  if (params.agentId) {
+    keys.add(activeKey(params.accountId, params.parentChatId, params.agentId));
+  }
+  keys.add(activeKey(params.accountId, params.parentChatId));
+  return [...keys];
+}
+function setMemory(key, value, now) {
+  const memory = getRouteState().memory;
+  memory.delete(key);
+  memory.set(key, { value, updatedAt: now });
+  pruneMapToMaxSize(memory, MAX_ENTRIES);
+}
+function getMemory(key, now) {
+  const memory = getRouteState().memory;
+  const entry = memory.get(key);
+  if (!entry)
+    return;
+  if (now - entry.updatedAt > TTL_MS) {
+    memory.delete(key);
+    return;
+  }
+  memory.delete(key);
+  memory.set(key, { ...entry, updatedAt: now });
+  return entry.value;
+}
+async function readFileRoutes(accountId) {
+  const filePath = resolveRoutesPath(accountId);
+  if (!filePath)
+    return new Map;
+  const fallback = { version: STORE_VERSION, routes: {} };
+  const now = Date.now();
+  try {
+    const { value } = await readJsonFileWithFallback(filePath, fallback);
+    if (value.version !== STORE_VERSION || !isRecord3(value.routes)) {
+      return new Map;
+    }
+    const routes = new Map;
+    for (const [key, raw] of Object.entries(value.routes)) {
+      const route = normalizeRecord(raw);
+      if (route && !isExpired(route, now))
+        routes.set(key, route);
+    }
+    return routes;
+  } catch (error51) {
+    reportRouteStateError(error51);
+    return new Map;
+  }
+}
+async function writeFileRoutes(accountId, routes) {
+  const filePath = resolveRoutesPath(accountId);
+  if (!filePath)
+    return;
+  const pruned = [...routes.entries()].sort((left, right) => right[1].updatedAt - left[1].updatedAt).slice(0, PERSISTENT_MAX_ENTRIES);
+  await writeJsonFileAtomically(filePath, {
+    version: STORE_VERSION,
+    routes: Object.fromEntries(pruned)
+  });
+}
+function rememberFileRoutes(params) {
+  const state = getRouteState();
+  const queueKey = params.accountId || DEFAULT_STORE_KEY;
+  const previous = state.fileWrites.get(queueKey) ?? Promise.resolve();
+  const next = previous.catch(() => {
+    return;
+  }).then(async () => {
+    const routes = await readFileRoutes(params.accountId);
+    for (const key of params.keys) {
+      routes.set(key, params.record);
+    }
+    await writeFileRoutes(params.accountId, routes);
+  });
+  state.fileWrites.set(queueKey, next);
+  const cleanup = () => {
+    if (state.fileWrites.get(queueKey) === next) {
+      state.fileWrites.delete(queueKey);
+    }
+  };
+  next.then(cleanup, cleanup);
+  next.catch(reportRouteStateError);
+}
+function rememberInlineReplyThreadRoute(params) {
+  const accountId = params.accountId.trim();
+  const parentChatId = normalizePositiveId(params.parentChatId);
+  const threadId = normalizePositiveId(params.threadId);
+  if (!accountId || !parentChatId || !threadId)
+    return null;
+  const now = Date.now();
+  const parentMessageId = normalizePositiveId(params.parentMessageId);
+  const title = normalizeOptionalText(params.title);
+  const threadLabel = normalizeOptionalText(params.threadLabel);
+  const agentId = normalizeOptionalText(params.agentId);
+  const record2 = {
+    accountId,
+    parentChatId,
+    threadId,
+    createdAt: now,
+    updatedAt: now,
+    ...parentMessageId ? { parentMessageId } : {},
+    ...title ? { title } : {},
+    ...threadLabel ? { threadLabel } : {},
+    ...agentId ? { agentId } : {}
+  };
+  const keys = keysForRecord(record2);
+  for (const key of keys) {
+    setMemory(key, record2, now);
+  }
+  const store = getPersistentStore();
+  if (store) {
+    for (const key of keys) {
+      store.register(key, record2, { ttlMs: TTL_MS }).catch(disablePersistentStore);
+    }
+    return record2;
+  }
+  rememberFileRoutes({ accountId, keys, record: record2 });
+  return record2;
+}
+async function lookupInlineReplyThreadRoute(params) {
+  const accountId = params.accountId.trim();
+  const parentChatId = normalizePositiveId(params.parentChatId);
+  if (!accountId || !parentChatId)
+    return null;
+  const parentMessageId = normalizePositiveId(params.parentMessageId);
+  const agentId = normalizeOptionalText(params.agentId);
+  const keys = keysForLookup({
+    accountId,
+    parentChatId,
+    ...parentMessageId ? { parentMessageId } : {},
+    ...agentId ? { agentId } : {}
+  });
+  const now = Date.now();
+  for (const key of keys) {
+    const cached3 = getMemory(key, now);
+    if (cached3)
+      return cached3;
+  }
+  const store = getPersistentStore();
+  if (store) {
+    for (const key of keys) {
+      try {
+        const found = await store.lookup(key);
+        const normalized = normalizeRecord(found);
+        if (normalized && !isExpired(normalized, now)) {
+          setMemory(key, normalized, now);
+          return normalized;
+        }
+      } catch (error51) {
+        disablePersistentStore(error51);
+        break;
+      }
+    }
+  }
+  const fileRoutes = await readFileRoutes(accountId);
+  for (const key of keys) {
+    const found = fileRoutes.get(key);
+    const normalized = normalizeRecord(found);
+    if (normalized) {
+      setMemory(key, normalized, now);
+      return normalized;
+    }
+  }
+  return null;
+}
+
 // src/inline/outbound-sanitize.ts
 var HEARTBEAT_TOKEN = "HEARTBEAT_OK";
 var OPENCLAW_RUNTIME_CONTEXT_NOTICE = "This context is runtime-generated, not user-authored. Keep internal details private.";
@@ -37942,7 +38336,7 @@ function optionalVisibleActionText(raw, label) {
   }
   return visible.text.trim() || undefined;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function normalizeReplyMarkupButtons(raw) {
@@ -37954,7 +38348,7 @@ function normalizeReplyMarkupButtons(raw) {
       continue;
     const row = [];
     for (const candidateButton of candidateRow) {
-      if (!isRecord3(candidateButton))
+      if (!isRecord4(candidateButton))
         continue;
       const text = sanitizeInlineActionLabel(typeof candidateButton.text === "string" ? candidateButton.text : "");
       const callbackData = sanitizeInlineActionCallbackData(typeof candidateButton.callback_data === "string" ? candidateButton.callback_data : "");
@@ -38536,7 +38930,7 @@ async function withInlineClient(params) {
   });
   await client.connect();
   try {
-    return await params.fn(client);
+    return await params.fn(client, account);
   } finally {
     await client.close().catch(() => {});
   }
@@ -38805,16 +39199,16 @@ var inlineMessageActions = {
     }
     if (normalizedAction === "reply" || normalizedAction === "thread-reply") {
       const parseMarkdown = resolveInlineAccount({ cfg, accountId: accountId ?? null }).config.parseMarkdown ?? true;
-      const replyThreadsEnabled = normalizedAction === "thread-reply" && isInlineReplyThreadsEnabled({ cfg, accountId: accountId ?? null });
+      const isThreadReply = normalizedAction === "thread-reply";
       return await withInlineClient({
         cfg,
         accountId,
         fn: async (client) => {
           const actions = resolveInlineMessageActionsParam(params);
-          if (replyThreadsEnabled) {
+          if (isThreadReply) {
             const rawThreadId = readFlexibleId(params, "threadId") ?? readStringParam(params, "threadId");
             if (!rawThreadId) {
-              throw new Error("inline thread-reply: threadId is required when reply threads are enabled");
+              throw new Error("inline thread-reply: threadId is required. Call thread-create first or use reply for the parent chat.");
             }
             const chatId2 = parseInlineId(rawThreadId, "threadId");
             const replyToMsgId2 = parseOptionalInlineId(readFlexibleId(params, "messageId") ?? readFlexibleId(params, "replyTo") ?? readFlexibleId(params, "replyToId") ?? readStringParam(params, "messageId") ?? readStringParam(params, "replyTo") ?? readStringParam(params, "replyToId"), "messageId");
@@ -38838,7 +39232,7 @@ var inlineMessageActions = {
               replyToId: replyToMsgId2 != null ? String(replyToMsgId2) : null
             });
           }
-          const replyParams = normalizedAction === "thread-reply" && params.threadId != null && params.to == null && params.chatId == null && params.channelId == null ? { ...params, to: params.threadId } : params;
+          const replyParams = params;
           const chatId = resolveChatIdFromParams(replyParams);
           const replyToMsgId = parseInlineId(readFlexibleId(replyParams, "messageId") ?? readFlexibleId(replyParams, "replyTo") ?? readFlexibleId(replyParams, "replyToId") ?? readStringParam(replyParams, "messageId") ?? readStringParam(replyParams, "replyTo") ?? readStringParam(replyParams, "replyToId", { required: true }), "messageId");
           const text = resolveInlineActionText(replyParams, { required: true });
@@ -39177,11 +39571,11 @@ var inlineMessageActions = {
       });
     }
     if (normalizedAction === "channel-create" || normalizedAction === "thread-create") {
-      const replyThreadsEnabled = normalizedAction === "thread-create" && isInlineReplyThreadsEnabled({ cfg, accountId: accountId ?? null });
+      const isThreadCreate = normalizedAction === "thread-create";
       return await withInlineClient({
         cfg,
         accountId,
-        fn: async (client) => {
+        fn: async (client, account) => {
           const title = requireVisibleActionText(readStringParam(params, "title") ?? readStringParam(params, "name") ?? readStringParam(params, "threadName") ?? readStringParam(params, "message", { required: true }), "title");
           const description = optionalVisibleActionText(readStringParam(params, "description"), "description");
           const emoji3 = readStringParam(params, "emoji");
@@ -39200,7 +39594,7 @@ var inlineMessageActions = {
             values: participantRefs,
             label: "participant"
           });
-          if (replyThreadsEnabled) {
+          if (isThreadCreate) {
             const parentChatId = resolveChatIdFromParams(params);
             const parentMessageId = parseOptionalInlineId(resolveThreadParentMessageId({
               args: params,
@@ -39220,12 +39614,23 @@ var inlineMessageActions = {
             if (result2.oneofKind !== "createSubthread") {
               throw new Error(`inline action: expected createSubthread result, got ${String(result2.oneofKind)}`);
             }
+            const createdChat = result2.createSubthread.chat ?? null;
+            if (createdChat?.id != null) {
+              const routeParentMessageId = createdChat.parentMessageId ?? parentMessageId;
+              rememberInlineReplyThreadRoute({
+                accountId: account.accountId,
+                parentChatId: createdChat.parentChatId ?? parentChatId,
+                threadId: createdChat.id,
+                title: createdChat.title ?? title,
+                ...routeParentMessageId != null ? { parentMessageId: routeParentMessageId } : {}
+              });
+            }
             return jsonResult(toJsonSafe({
               ok: true,
               title,
               parentChatId: String(parentChatId),
               parentMessageId: parentMessageId != null ? String(parentMessageId) : null,
-              chat: result2.createSubthread.chat ?? null,
+              chat: createdChat,
               dialog: result2.createSubthread.dialog ?? null,
               anchorMessage: result2.createSubthread.anchorMessage ?? null
             }));
@@ -40054,26 +40459,26 @@ function buildInlineModelBrowseChannelData() {
 }
 
 // src/inline/thread-participation.ts
-import path2 from "node:path";
+import path3 from "node:path";
 import { resolveGlobalDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 import { createPersistentDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
-var TTL_MS = 24 * 60 * 60 * 1000;
-var MAX_ENTRIES = 5000;
-var PERSISTENT_MAX_ENTRIES = 1000;
-var PERSISTENT_NAMESPACE = "inline.thread-participation";
+var TTL_MS2 = 24 * 60 * 60 * 1000;
+var MAX_ENTRIES2 = 5000;
+var PERSISTENT_MAX_ENTRIES2 = 1000;
+var PERSISTENT_NAMESPACE2 = "inline.thread-participation";
 var PERSISTENT_DEDUPE_NAMESPACE = "participation";
 var INLINE_THREAD_PARTICIPATION_KEY = Symbol.for("openclaw.inlineThreadParticipation");
 var threadParticipation = resolveGlobalDedupeCache(INLINE_THREAD_PARTICIPATION_KEY, {
-  ttlMs: TTL_MS,
-  maxSize: MAX_ENTRIES
+  ttlMs: TTL_MS2,
+  maxSize: MAX_ENTRIES2
 });
-var persistentStore;
-var persistentStoreDisabled = false;
+var persistentStore2;
+var persistentStoreDisabled2 = false;
 var persistentDedupe;
 function makeKey(accountId, parentChatId, threadId) {
   return `${accountId}:${String(parentChatId)}:${String(threadId)}`;
 }
-function safePathSegment(value) {
+function safePathSegment2(value) {
   return value.trim().replace(/[^a-z0-9._-]+/gi, "_").slice(0, 80) || "global";
 }
 function isExpectedOpenKeyedStoreUnavailable(error51) {
@@ -40085,28 +40490,28 @@ function reportPersistentThreadParticipationError(error51) {
   } catch {}
 }
 function disablePersistentThreadParticipation(error51) {
-  persistentStoreDisabled = true;
-  persistentStore = undefined;
+  persistentStoreDisabled2 = true;
+  persistentStore2 = undefined;
   if (!isExpectedOpenKeyedStoreUnavailable(error51)) {
     reportPersistentThreadParticipationError(error51);
   }
 }
 function getPersistentThreadParticipationStore() {
-  if (persistentStoreDisabled)
+  if (persistentStoreDisabled2)
     return;
-  if (persistentStore)
-    return persistentStore;
+  if (persistentStore2)
+    return persistentStore2;
   const runtime = getOptionalInlineRuntime();
   const openKeyedStore = runtime?.state?.openKeyedStore;
   if (typeof openKeyedStore !== "function")
     return;
   try {
-    persistentStore = openKeyedStore({
-      namespace: PERSISTENT_NAMESPACE,
-      maxEntries: PERSISTENT_MAX_ENTRIES,
-      defaultTtlMs: TTL_MS
+    persistentStore2 = openKeyedStore({
+      namespace: PERSISTENT_NAMESPACE2,
+      maxEntries: PERSISTENT_MAX_ENTRIES2,
+      defaultTtlMs: TTL_MS2
     });
-    return persistentStore;
+    return persistentStore2;
   } catch (error51) {
     disablePersistentThreadParticipation(error51);
     return;
@@ -40121,10 +40526,10 @@ function getPersistentThreadParticipationDedupe() {
   try {
     const stateDir = resolveStateDir();
     persistentDedupe = createPersistentDedupe({
-      ttlMs: TTL_MS,
-      memoryMaxSize: MAX_ENTRIES,
-      fileMaxEntries: PERSISTENT_MAX_ENTRIES,
-      resolveFilePath: (namespace) => path2.join(stateDir, "inline", "thread-participation", `${safePathSegment(namespace)}.json`),
+      ttlMs: TTL_MS2,
+      memoryMaxSize: MAX_ENTRIES2,
+      fileMaxEntries: PERSISTENT_MAX_ENTRIES2,
+      resolveFilePath: (namespace) => path3.join(stateDir, "inline", "thread-participation", `${safePathSegment2(namespace)}.json`),
       onDiskError: reportPersistentThreadParticipationError
     });
     return persistentDedupe;
@@ -40139,7 +40544,7 @@ function rememberPersistentThreadParticipation(params) {
     store.register(params.key, {
       ...params.agentId ? { agentId: params.agentId } : {},
       repliedAt: Date.now()
-    }, { ttlMs: TTL_MS }).catch(disablePersistentThreadParticipation);
+    }, { ttlMs: TTL_MS2 }).catch(disablePersistentThreadParticipation);
     return;
   }
   getPersistentThreadParticipationDedupe()?.checkAndRecord(params.key, { namespace: PERSISTENT_DEDUPE_NAMESPACE }).catch(reportPersistentThreadParticipationError);
@@ -40832,7 +41237,7 @@ function buildSyntheticInlineTextMessage(params) {
 }
 var INLINE_ACTION_MAX_ROWS2 = 8;
 var INLINE_ACTION_MAX_PER_ROW2 = 8;
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeOptionalString2(value) {
@@ -40853,7 +41258,7 @@ function normalizeInlineStreamingMode(value) {
   }
 }
 function resolveExplicitInlineStreamingMode(config2) {
-  const streaming = isRecord4(config2.streaming) ? config2.streaming : null;
+  const streaming = isRecord5(config2.streaming) ? config2.streaming : null;
   return normalizeInlineStreamingMode(streaming?.mode) ?? normalizeInlineStreamingMode(config2.streaming) ?? normalizeInlineStreamingMode(config2.streamMode);
 }
 function resolveInlineStreamingMode(config2) {
@@ -40873,14 +41278,14 @@ function resolveInlineProgressPlaceholderEnabled(config2) {
     return true;
   if (config2.streaming === false)
     return false;
-  if (isRecord4(config2.streaming) && isRecord4(config2.streaming.progress))
+  if (isRecord5(config2.streaming) && isRecord5(config2.streaming.progress))
     return true;
   return config2.streaming === undefined && config2.streamMode === undefined && config2.streamViaEditMessage !== true;
 }
 function resolveInlineBlockStreamingEnabled(config2) {
   const mode = resolveInlineStreamingMode(config2);
-  const streaming = isRecord4(config2.streaming) ? config2.streaming : null;
-  const block = streaming && isRecord4(streaming.block) ? streaming.block : null;
+  const streaming = isRecord5(config2.streaming) ? config2.streaming : null;
+  const block = streaming && isRecord5(streaming.block) ? streaming.block : null;
   if (typeof block?.enabled === "boolean")
     return block.enabled;
   if (typeof config2.blockStreaming === "boolean")
@@ -41104,7 +41509,7 @@ function normalizeReplyMarkupButtonsWith(raw, options) {
       continue;
     const row = [];
     for (const candidateButton of candidateRow) {
-      if (!isRecord4(candidateButton))
+      if (!isRecord5(candidateButton))
         continue;
       const text = sanitizeInlineActionLabel(typeof candidateButton.text === "string" ? candidateButton.text : "");
       const callbackDataRaw = typeof candidateButton.callback_data === "string" ? candidateButton.callback_data.trim() : "";
@@ -41125,9 +41530,9 @@ function normalizeReplyMarkupButtonsWith(raw, options) {
   return rows;
 }
 function resolveInlineReplyActions(payload) {
-  const channelData = isRecord4(payload.channelData) ? payload.channelData : undefined;
-  const inlineData = channelData && isRecord4(channelData.inline) ? channelData.inline : undefined;
-  const telegramData = channelData && isRecord4(channelData.telegram) ? channelData.telegram : undefined;
+  const channelData = isRecord5(payload.channelData) ? payload.channelData : undefined;
+  const inlineData = channelData && isRecord5(channelData.inline) ? channelData.inline : undefined;
+  const telegramData = channelData && isRecord5(channelData.telegram) ? channelData.telegram : undefined;
   let rawButtons = undefined;
   let hasExplicitButtons = false;
   let mapCallbackData;
@@ -41223,6 +41628,14 @@ function rememberInlineBotDelivery(params) {
   if (!params.replyThreadContext || params.chatId !== params.replyThreadContext.childChatId)
     return;
   recordInlineThreadParticipation(params.accountId, params.replyThreadContext.parentChatId, params.replyThreadContext.childChatId, { agentId: params.agentId });
+  rememberInlineReplyThreadRoute({
+    accountId: params.accountId,
+    parentChatId: params.replyThreadContext.parentChatId,
+    threadId: params.replyThreadContext.childChatId,
+    parentMessageId: params.replyThreadContext.parentMessageId,
+    threadLabel: params.replyThreadContext.threadLabel,
+    agentId: params.agentId
+  });
 }
 function hasBotMessageId(cache, chatId, messageId) {
   const key = String(chatId);
@@ -41637,7 +42050,7 @@ function resolveFilePathHint(params) {
     return preferred;
   try {
     const pathname = new URL(params.sourceUrl).pathname;
-    const base = path3.basename(pathname).trim();
+    const base = path4.basename(pathname).trim();
     if (base)
       return base;
   } catch {}
@@ -41712,6 +42125,44 @@ async function resolveInlineInboundReplyThreadContext(params) {
     anchorMessage
   };
 }
+function parseCachedInlineId(raw) {
+  if (!raw || !/^\d+$/.test(raw))
+    return null;
+  try {
+    return BigInt(raw);
+  } catch {
+    return null;
+  }
+}
+async function resolveInlineReplyThreadContextFromRoute(params) {
+  const parentChatId = parseCachedInlineId(params.route.parentChatId);
+  const childChatId = parseCachedInlineId(params.route.threadId);
+  if (parentChatId == null || childChatId == null) {
+    return null;
+  }
+  const parentMessageId = parseCachedInlineId(params.route.parentMessageId);
+  const parentChatInfo = await resolveChatInfo(params.client, params.chatCache, parentChatId).catch(() => ({
+    kind: "group",
+    title: params.fallbackParentChatTitle
+  }));
+  const anchorMessage = parentMessageId != null ? await loadInlineReplyThreadAnchorMessage({
+    client: params.client,
+    parentChatId,
+    parentMessageId
+  }).catch(() => null) : null;
+  const labelSource = params.route.threadLabel ?? params.route.title ?? null;
+  return {
+    childChatId,
+    parentChatId,
+    parentChatTitle: parentChatInfo.title ?? params.fallbackParentChatTitle,
+    parentMessageId,
+    threadLabel: buildInlineReplyThreadLabel({
+      title: labelSource,
+      anchorMessage
+    }),
+    anchorMessage
+  };
+}
 function normalizeInlineReplyThreadMode(raw) {
   return raw === "thread" || raw === "main" ? raw : "auto";
 }
@@ -41840,8 +42291,8 @@ async function monitorInlineProvider(params) {
   }
   const token = await resolveInlineToken(account);
   const stateDir = core3.state.resolveStateDir();
-  const statePath = path3.join(stateDir, "channels", "inline", `${account.accountId}.json`);
-  await mkdir(path3.dirname(statePath), { recursive: true });
+  const statePath = path4.join(stateDir, "channels", "inline", `${account.accountId}.json`);
+  await mkdir(path4.dirname(statePath), { recursive: true });
   let client = null;
   const pushDiagnostics = (patch) => {
     statusSink?.({
@@ -41953,7 +42404,7 @@ async function monitorInlineProvider(params) {
       statusSink?.({ lastError: `getChat failed: ${String(err)}` });
     }
     const isGroup = chatInfo.kind !== "direct";
-    const replyThreadsEnabled = account.config.capabilities?.replyThreads === true || isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
+    const replyThreadsEnabled = isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
     const replyThreadContext = await resolveInlineInboundReplyThreadContext({
       replyThreadsEnabled,
       client,
@@ -42193,7 +42644,7 @@ async function monitorInlineProvider(params) {
       statusSink?.({ lastError: `getChat failed: ${String(err)}` });
     }
     const isGroup = chatInfo.kind !== "direct";
-    const replyThreadsEnabled = account.config.capabilities?.replyThreads === true || isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
+    const replyThreadsEnabled = isInlineReplyThreadsEnabled({ cfg, accountId: account.accountId });
     const replyThreadContext = await resolveInlineInboundReplyThreadContext({
       replyThreadsEnabled,
       client,
@@ -42290,6 +42741,16 @@ async function monitorInlineProvider(params) {
       }
     });
     const inboundSessionKey = replyThreadContext && isGroup ? buildInlineReplyThreadSessionKey(route.sessionKey, replyThreadContext.childChatId) : route.sessionKey;
+    if (replyThreadContext && isGroup) {
+      rememberInlineReplyThreadRoute({
+        accountId: account.accountId,
+        parentChatId: replyThreadContext.parentChatId,
+        threadId: replyThreadContext.childChatId,
+        parentMessageId: replyThreadContext.parentMessageId,
+        threadLabel: replyThreadContext.threadLabel,
+        agentId: route.agentId
+      });
+    }
     const rememberSentBotMessage = (params2) => {
       if (params2.messageId == null)
         return;
@@ -42723,6 +43184,30 @@ This model will be used for your next message.`, []);
       minMessages: replyThreadAutoCreateMinMessages
     }) && !shouldEditCallbackTargetInPlace;
     if (shouldCreateDeliveryThread) {
+      const cachedRoute = await lookupInlineReplyThreadRoute({
+        accountId: account.accountId,
+        parentChatId: effectiveChatId,
+        parentMessageId: msg.id,
+        agentId: route.agentId
+      }).catch((error51) => {
+        statusSink?.({ lastError: `reply-thread route lookup failed: ${String(error51)}` });
+        runtime.error?.(`inline reply-thread route lookup failed: ${String(error51)}`);
+        return null;
+      });
+      if (cachedRoute) {
+        deliveryReplyThreadContext = await resolveInlineReplyThreadContextFromRoute({
+          route: cachedRoute,
+          client,
+          chatCache,
+          fallbackParentChatTitle: effectiveGroupTitle
+        }).catch((error51) => {
+          statusSink?.({ lastError: `reply-thread route restore failed: ${String(error51)}` });
+          runtime.error?.(`inline reply-thread route restore failed: ${String(error51)}`);
+          return null;
+        });
+      }
+    }
+    if (shouldCreateDeliveryThread && !deliveryReplyThreadContext) {
       const createdThread = await createInlineReplyThreadForMessage({
         client,
         parentChatId: effectiveChatId,
@@ -42744,13 +43229,35 @@ This model will be used for your next message.`, []);
           }),
           anchorMessage: createdThread.anchorMessage
         };
+        rememberInlineReplyThreadRoute({
+          accountId: account.accountId,
+          parentChatId: deliveryReplyThreadContext.parentChatId,
+          threadId: deliveryReplyThreadContext.childChatId,
+          parentMessageId: deliveryReplyThreadContext.parentMessageId,
+          title: createdThread.title,
+          threadLabel: deliveryReplyThreadContext.threadLabel,
+          agentId: route.agentId
+        });
       }
     }
     if (shouldCreateDeliveryThread && !deliveryReplyThreadContext) {
-      await answerCallbackIfNeeded().catch((error51) => {
-        runtime.error?.(`inline callback answer failed: ${String(error51)}`);
-      });
-      return;
+      const cachedRoute = await lookupInlineReplyThreadRoute({
+        accountId: account.accountId,
+        parentChatId: effectiveChatId,
+        parentMessageId: msg.id,
+        agentId: route.agentId
+      }).catch(() => null);
+      if (cachedRoute) {
+        deliveryReplyThreadContext = await resolveInlineReplyThreadContextFromRoute({
+          route: cachedRoute,
+          client,
+          chatCache,
+          fallbackParentChatTitle: effectiveGroupTitle
+        }).catch(() => null);
+      }
+    }
+    if (shouldCreateDeliveryThread && !deliveryReplyThreadContext) {
+      runtime.error?.("inline create reply thread failed; falling back to parent chat delivery");
     }
     if (!replyThreadContext && deliveryReplyThreadContext?.anchorMessage != null) {
       effectiveHistoryContext = prependInlineReplyThreadAnchor({
@@ -43688,7 +44195,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
 }
 
 // src/inline/doctor.ts
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function readInherited(account, parent, key) {
@@ -43699,12 +44206,12 @@ function hasEntries(value) {
 }
 function hasConfiguredGroups(account, parent) {
   const groups = readInherited(account, parent, "groups");
-  return isRecord5(groups) && Object.keys(groups).length > 0;
+  return isRecord6(groups) && Object.keys(groups).length > 0;
 }
 function hasGroupScopedSenders(groups) {
-  if (!isRecord5(groups))
+  if (!isRecord6(groups))
     return false;
-  return Object.values(groups).some((group) => isRecord5(group) && hasEntries(group.allowFrom));
+  return Object.values(groups).some((group) => isRecord6(group) && hasEntries(group.allowFrom));
 }
 function hasGroupSenders(account, parent) {
   return hasEntries(readInherited(account, parent, "groupAllowFrom")) || hasGroupScopedSenders(readInherited(account, parent, "groups"));
@@ -44291,11 +44798,11 @@ async function probeInlineAccount(account, timeoutMs) {
 }
 
 // src/inline/status-issues.ts
-import { asString, isRecord as isRecord6 } from "openclaw/plugin-sdk/status-helpers";
+import { asString, isRecord as isRecord7 } from "openclaw/plugin-sdk/status-helpers";
 var RECENT_RUNTIME_ISSUE_MS = 30 * 60 * 1000;
 var INLINE_CONNECT_GRACE_MS = 120 * 1000;
 function readInlineProbeSummary(value) {
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     return {};
   }
   const summary = {};
@@ -44312,12 +44819,12 @@ function looksLikeAuthError(text) {
   return /(401|403|unauth|forbidden|invalid token|token invalid|unauthorized)/i.test(text);
 }
 function readInlineDiagnosticsSummary(value) {
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     return {};
   }
-  const protocolValue = isRecord6(value.protocol) ? value.protocol : undefined;
-  const transportValue = (protocolValue && isRecord6(protocolValue.transport) ? protocolValue.transport : undefined) ?? (isRecord6(value.transport) ? value.transport : undefined);
-  const pingValue = protocolValue && isRecord6(protocolValue.ping) ? protocolValue.ping : undefined;
+  const protocolValue = isRecord7(value.protocol) ? value.protocol : undefined;
+  const transportValue = (protocolValue && isRecord7(protocolValue.transport) ? protocolValue.transport : undefined) ?? (isRecord7(value.transport) ? value.transport : undefined);
+  const pingValue = protocolValue && isRecord7(protocolValue.ping) ? protocolValue.ping : undefined;
   return {
     ...protocolValue ? {
       protocol: {
@@ -44349,7 +44856,7 @@ function asFiniteNumber(value) {
 function collectInlineStatusIssues(accounts) {
   const issues = [];
   for (const entry of accounts) {
-    if (!isRecord6(entry)) {
+    if (!isRecord7(entry)) {
       continue;
     }
     const accountId = asString(entry.accountId);
@@ -44848,7 +45355,7 @@ var inlineNativeApprovalAdapter = splitChannelApprovalCapability(inlineApprovalC
 // src/inline/channel.ts
 var activeMonitors = new Map;
 function resolveInlineStatePath(accountId) {
-  return path4.join(getInlineRuntime().state.resolveStateDir(), "channels", "inline", `${accountId}.json`);
+  return path5.join(getInlineRuntime().state.resolveStateDir(), "channels", "inline", `${accountId}.json`);
 }
 async function deleteInlineAccountState(accountId) {
   try {
@@ -45974,13 +46481,10 @@ 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.",
-      ...isInlineReplyThreadsEnabled({ cfg, accountId: accountId ?? null }) ? [
-        "- Inline reply threads are enabled: use `thread-create` to create 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 are enabled: use `thread-reply` to send into a real reply thread, with `threadId` set to the reply-thread chat id returned by `thread-create`.",
-        "- Inline reply-thread turns include nearby parent-chat context by default. If that context is incomplete, call `inline_parent_context` before answering."
-      ] : [
-        "- Inline reply threads are disabled: `thread-reply` uses the legacy reply path and `thread-create` creates a normal chat, not a dedicated Inline reply-thread chat."
-      ]
+      "- 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-thread turns include nearby parent-chat context by default. If that context is incomplete, call `inline_parent_context` before answering."
     ]
   },
   messaging: {
@@ -46343,5 +46847,5 @@ export {
   inlineChannelPlugin
 };
 
-//# debugId=8D08B1A22511109264756E2164756E21
+//# debugId=A439BD5C99EA226864756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map