@inline-openclaw/inline 0.0.41 → 0.0.43

package/dist/runtime-register-api.js

@@ -20562,6 +20562,8 @@ class InlineSdkClient {
   saveInFlight = null;
   catchUpInFlightByChatId = new Map;
   catchUpRequestedByChatId = new Map;
+  catchUpInFlightBySpaceId = new Map;
+  catchUpRequestedBySpaceId = new Map;
   userCatchUpInFlight = null;
   constructor(options) {
     this.options = options;
@@ -20626,7 +20628,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();
   }
@@ -20650,6 +20656,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 } : {}
     };
   }
@@ -20670,12 +20677,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");
@@ -21004,32 +21006,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": {
@@ -21113,6 +21140,7 @@ class InlineSdkClient {
           seq,
           date
         });
+        this.requestCatchUpSpace({ spaceId: payload.spaceId, updateSeq: payload.updateSeq });
         return;
       }
       default:
@@ -21131,6 +21159,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;
@@ -21310,6 +21350,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 } } });
@@ -21390,6 +21536,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) => {
@@ -21607,7 +21754,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);
 };
@@ -21619,10 +21768,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;
@@ -21630,14 +21790,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;
 };
 
@@ -38202,6 +38360,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 = [
@@ -38777,6 +38936,482 @@ async function syncInlineNativeCommands(params) {
   };
 }
 
+// src/inline/policy.ts
+function normalizeAccountId2(raw) {
+  return normalizeAccountId(raw);
+}
+function resolveInlineGroups(cfg, accountId) {
+  const inline = cfg.channels?.inline;
+  if (!inline)
+    return;
+  const normalized = normalizeAccountId2(accountId);
+  const accounts = inline.accounts ?? {};
+  const accountEntry = accounts[normalized] ?? accounts[Object.keys(accounts).find((key) => key.toLowerCase() === normalized) ?? ""];
+  return accountEntry?.groups ?? inline.groups;
+}
+function normalizeGroupId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed === "*")
+    return trimmed;
+  const normalized = normalizeInlineTarget(trimmed);
+  return normalized && /^[0-9]+$/.test(normalized) ? normalized : trimmed;
+}
+function resolveGroupConfig(groups, groupId) {
+  if (!groups)
+    return;
+  const normalizedGroupId = normalizeGroupId(groupId ?? "");
+  if (!normalizedGroupId)
+    return;
+  const direct = groups[normalizedGroupId];
+  if (direct)
+    return direct;
+  const lowered = normalizedGroupId.toLowerCase();
+  const matchedKey = Object.keys(groups).find((key) => key !== "*" && normalizeGroupId(key).toLowerCase() === lowered);
+  return matchedKey ? groups[matchedKey] : undefined;
+}
+function normalizeSenderKey(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return "";
+  const withoutAt = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+  return withoutAt.toLowerCase();
+}
+function resolveToolsBySender(params) {
+  const entries = Object.entries(params.toolsBySender ?? {});
+  if (!entries.length)
+    return;
+  const normalizedMap = new Map;
+  let wildcard;
+  for (const [rawKey, policy] of entries) {
+    if (!policy)
+      continue;
+    const key = normalizeSenderKey(rawKey);
+    if (!key)
+      continue;
+    if (key === "*") {
+      wildcard = policy;
+      continue;
+    }
+    if (!normalizedMap.has(key)) {
+      normalizedMap.set(key, policy);
+    }
+  }
+  const candidates = [
+    params.senderId,
+    params.senderE164,
+    params.senderUsername,
+    params.senderName
+  ];
+  for (const candidate of candidates) {
+    const key = normalizeSenderKey(candidate ?? "");
+    if (!key)
+      continue;
+    const matched = normalizedMap.get(key);
+    if (matched)
+      return matched;
+  }
+  return wildcard;
+}
+function resolveInlineGroupRequireMention(params) {
+  const groups = resolveInlineGroups(params.cfg, params.accountId);
+  const groupConfig = resolveGroupConfig(groups, params.groupId);
+  const defaultConfig = groups?.["*"];
+  if (typeof groupConfig?.requireMention === "boolean")
+    return groupConfig.requireMention;
+  if (typeof defaultConfig?.requireMention === "boolean")
+    return defaultConfig.requireMention;
+  return params.requireMentionDefault;
+}
+function resolveInlineGroupReplyThreadMode(params) {
+  const groups = resolveInlineGroups(params.cfg, params.accountId);
+  const groupConfig = resolveGroupConfig(groups, params.groupId);
+  const defaultConfig = groups?.["*"];
+  return groupConfig?.replyThreadMode ?? defaultConfig?.replyThreadMode ?? params.defaultMode;
+}
+function resolveInlineGroupReplyThreadAutoCreateMinMessages(params) {
+  const groups = resolveInlineGroups(params.cfg, params.accountId);
+  const groupConfig = resolveGroupConfig(groups, params.groupId);
+  const defaultConfig = groups?.["*"];
+  return groupConfig?.replyThreadAutoCreateMinMessages ?? defaultConfig?.replyThreadAutoCreateMinMessages ?? params.defaultMinMessages;
+}
+function resolveInlineGroupReplyThreadRequireExplicitMention(params) {
+  const groups = resolveInlineGroups(params.cfg, params.accountId);
+  const groupConfig = resolveGroupConfig(groups, params.groupId);
+  const defaultConfig = groups?.["*"];
+  if (typeof groupConfig?.replyThreadRequireExplicitMention === "boolean") {
+    return groupConfig.replyThreadRequireExplicitMention;
+  }
+  if (typeof defaultConfig?.replyThreadRequireExplicitMention === "boolean") {
+    return defaultConfig.replyThreadRequireExplicitMention;
+  }
+  return params.defaultRequireExplicitMention;
+}
+function resolveInlineGroupReplyThreadParentHistoryLimit(params) {
+  const groups = resolveInlineGroups(params.cfg, params.accountId);
+  const groupConfig = resolveGroupConfig(groups, params.groupId);
+  const defaultConfig = groups?.["*"];
+  return groupConfig?.replyThreadParentHistoryLimit ?? defaultConfig?.replyThreadParentHistoryLimit ?? params.defaultLimit;
+}
+function resolveInlineGroupSystemPrompt(params) {
+  return resolveGroupConfig(params.groups, params.groupId)?.systemPrompt?.trim() || undefined;
+}
+function resolveInlineGroupAccessPolicy(params) {
+  const groups = resolveInlineGroups(params.cfg, params.accountId);
+  const hasGroups = Boolean(groups && Object.keys(groups).length > 0);
+  const allowlistEnabled = params.groupPolicy === "allowlist" || hasGroups;
+  const groupConfig = resolveGroupConfig(groups, params.groupId);
+  const defaultConfig = groups?.["*"];
+  const allowAll = allowlistEnabled && Boolean(groups && Object.hasOwn(groups, "*"));
+  const senderFilterBypass = params.groupPolicy === "allowlist" && !hasGroups && params.hasGroupAllowFrom;
+  return {
+    allowlistEnabled,
+    allowed: params.groupPolicy === "disabled" ? false : !allowlistEnabled || allowAll || Boolean(groupConfig) || senderFilterBypass,
+    groupConfig,
+    defaultConfig
+  };
+}
+function resolveInlineGroupToolPolicy(params) {
+  const groups = resolveInlineGroups(params.cfg, params.accountId);
+  const groupConfig = resolveGroupConfig(groups, params.groupId);
+  const defaultConfig = groups?.["*"];
+  const groupSenderPolicy = resolveToolsBySender({
+    toolsBySender: groupConfig?.toolsBySender,
+    senderId: params.senderId,
+    senderName: params.senderName,
+    senderUsername: params.senderUsername,
+    senderE164: params.senderE164
+  });
+  if (groupSenderPolicy)
+    return groupSenderPolicy;
+  if (groupConfig?.tools)
+    return groupConfig.tools;
+  const defaultSenderPolicy = resolveToolsBySender({
+    toolsBySender: defaultConfig?.toolsBySender,
+    senderId: params.senderId,
+    senderName: params.senderName,
+    senderUsername: params.senderUsername,
+    senderE164: params.senderE164
+  });
+  if (defaultSenderPolicy)
+    return defaultSenderPolicy;
+  return defaultConfig?.tools;
+}
+function resolveInlineGroupAllowFrom(params) {
+  const groups = resolveInlineGroups(params.cfg, params.accountId);
+  const groupConfig = resolveGroupConfig(groups, params.groupId);
+  const defaultConfig = groups?.["*"];
+  if (groupConfig?.allowFrom && groupConfig.allowFrom.length > 0)
+    return groupConfig.allowFrom;
+  if (defaultConfig?.allowFrom && defaultConfig.allowFrom.length > 0)
+    return defaultConfig.allowFrom;
+  return params.accountAllowFrom;
+}
+
+// src/inline/threadreply-command.ts
+var MODE_LABELS = {
+  auto: "auto",
+  thread: "thread",
+  main: "main"
+};
+var DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES = 50;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asInlineConfig(value) {
+  return isRecord3(value) ? value : undefined;
+}
+function normalizeMode(raw) {
+  if (typeof raw !== "string")
+    return null;
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "on" || normalized === "threads")
+    return "thread";
+  if (normalized === "off" || normalized === "parent" || normalized === "parentchat")
+    return "main";
+  if (normalized === "auto" || normalized === "thread" || normalized === "main")
+    return normalized;
+  return null;
+}
+function normalizeMin(raw) {
+  if (typeof raw !== "number")
+    return null;
+  if (!Number.isInteger(raw) || raw < 0)
+    return null;
+  return raw;
+}
+function parseMinArg(raw) {
+  const value = raw?.trim().toLowerCase();
+  if (!value)
+    return null;
+  if (value === "inherit" || value === "default" || value === "unset")
+    return "inherit";
+  if (!/^\d+$/.test(value))
+    return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function resolveInlineGroupId(ctx) {
+  const raw = ctx.from?.trim() ?? "";
+  if (!/(^|:)chat:/i.test(raw))
+    return null;
+  const normalized = normalizeInlineTarget(raw);
+  return normalized && /^[0-9]+$/.test(normalized) ? normalized : null;
+}
+function resolveInlineConfigForAccount(inline, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  const accounts = isRecord3(inline.accounts) ? inline.accounts : undefined;
+  const accountKey = accounts ? Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized) : undefined;
+  if (accountKey && accounts?.[accountKey]) {
+    return accounts[accountKey];
+  }
+  if (normalized !== DEFAULT_ACCOUNT_ID) {
+    return {};
+  }
+  return inline;
+}
+function resolveCurrentMode(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline) ?? {};
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  return resolveInlineGroupReplyThreadMode({
+    cfg: params.cfg,
+    accountId: params.accountId ?? null,
+    groupId: params.groupId,
+    defaultMode: normalizeMode(accountConfig.replyThreadMode) ?? "auto"
+  });
+}
+function resolveCurrentMinMessages(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline) ?? {};
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  return resolveInlineGroupReplyThreadAutoCreateMinMessages({
+    cfg: params.cfg,
+    accountId: params.accountId ?? null,
+    groupId: params.groupId,
+    defaultMinMessages: normalizeMin(accountConfig.replyThreadAutoCreateMinMessages) ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES
+  });
+}
+function readExplicitMode(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline);
+  if (!inline)
+    return null;
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  const group = accountConfig.groups?.[params.groupId];
+  return normalizeMode(group?.replyThreadMode);
+}
+function readExplicitMinMessages(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline);
+  if (!inline)
+    return null;
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  const group = accountConfig.groups?.[params.groupId];
+  return normalizeMin(group?.replyThreadAutoCreateMinMessages);
+}
+function ensureRecordField(parent, key) {
+  const current = parent[key];
+  if (isRecord3(current))
+    return current;
+  const next = {};
+  parent[key] = next;
+  return next;
+}
+function resolveMutableInlineConfigForAccount(inline, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  if (normalized === DEFAULT_ACCOUNT_ID) {
+    const accounts2 = isRecord3(inline.accounts) ? inline.accounts : undefined;
+    const defaultKey = accounts2 ? Object.keys(accounts2).find((key) => normalizeAccountId(key) === DEFAULT_ACCOUNT_ID) : undefined;
+    const defaultAccount = defaultKey ? accounts2?.[defaultKey] : undefined;
+    return defaultAccount ?? inline;
+  }
+  const accounts = ensureRecordField(inline, "accounts");
+  const accountKey = Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized) ?? normalized;
+  const account = asInlineConfig(accounts[accountKey]) ?? {};
+  accounts[accountKey] = account;
+  return account;
+}
+function setGroupMode(params) {
+  const root = params.draft;
+  const channels = root.channels ?? {};
+  root.channels = channels;
+  const inline = asInlineConfig(channels.inline) ?? {};
+  channels.inline = inline;
+  const accountConfig = resolveMutableInlineConfigForAccount(inline, params.accountId);
+  const groups = ensureRecordField(accountConfig, "groups");
+  const group = isRecord3(groups[params.groupId]) ? groups[params.groupId] : {};
+  groups[params.groupId] = group;
+  if (params.mode === "inherit") {
+    delete group.replyThreadMode;
+    return;
+  }
+  group.replyThreadMode = params.mode;
+}
+function setGroupMinMessages(params) {
+  const root = params.draft;
+  const channels = root.channels ?? {};
+  root.channels = channels;
+  const inline = asInlineConfig(channels.inline) ?? {};
+  channels.inline = inline;
+  const accountConfig = resolveMutableInlineConfigForAccount(inline, params.accountId);
+  const groups = ensureRecordField(accountConfig, "groups");
+  const group = isRecord3(groups[params.groupId]) ? groups[params.groupId] : {};
+  groups[params.groupId] = group;
+  if (params.minMessages === "inherit") {
+    delete group.replyThreadAutoCreateMinMessages;
+    return;
+  }
+  group.replyThreadAutoCreateMinMessages = params.minMessages;
+}
+function buildStatusText(params) {
+  const explicit = readExplicitMode(params);
+  const current = resolveCurrentMode(params);
+  const explicitMin = readExplicitMinMessages(params);
+  const currentMin = resolveCurrentMinMessages(params);
+  return [
+    `Thread reply mode for chat ${params.groupId}: ${MODE_LABELS[current]}.`,
+    explicit ? `Explicit chat override: ${MODE_LABELS[explicit]}.` : "Explicit chat override: inherit.",
+    `Auto-create minimum messages: ${currentMin}.`,
+    explicitMin != null ? `Explicit minimum override: ${explicitMin}.` : "Explicit minimum override: inherit."
+  ].join(`
+`);
+}
+function buildMenuText(params) {
+  return [
+    buildStatusText(params),
+    "",
+    "Choose where automatic replies for this group should go."
+  ].join(`
+`);
+}
+function buildModeButtons() {
+  return {
+    inline: {
+      buttons: [
+        [
+          { text: "Thread", callback_data: "/threadreply thread" },
+          { text: "Main", callback_data: "/threadreply main" },
+          { text: "Auto", callback_data: "/threadreply auto" }
+        ],
+        [{ text: "Inherit Mode", callback_data: "/threadreply inherit" }],
+        [
+          { text: "Min 0", callback_data: "/threadreply min 0" },
+          { text: "Min 50", callback_data: "/threadreply min 50" },
+          { text: "Inherit Min", callback_data: "/threadreply min inherit" }
+        ]
+      ]
+    }
+  };
+}
+function normalizeAction(args) {
+  const [first = ""] = args.split(/\s+/).filter(Boolean);
+  const normalized = first.trim().toLowerCase();
+  if (!normalized || normalized === "help" || normalized === "options")
+    return "help";
+  if (normalized === "status" || normalized === "show")
+    return "status";
+  if (normalized === "inherit" || normalized === "default" || normalized === "unset")
+    return "inherit";
+  return normalizeMode(normalized);
+}
+async function handleInlineThreadReplyCommand(api2, ctx) {
+  if (!ctx.isAuthorizedSender) {
+    return { text: "This command requires authorization." };
+  }
+  const groupId = resolveInlineGroupId(ctx);
+  if (!groupId) {
+    return { text: "/threadreply is only available in Inline group chats." };
+  }
+  const currentConfig = api2.runtime.config.current();
+  const args = ctx.args?.trim() ?? "";
+  const [first = "", second, ...rest] = args.split(/\s+/).filter(Boolean);
+  if (["min", "minimum", "threshold", "limit"].includes(first.trim().toLowerCase())) {
+    const minMessages = parseMinArg(second);
+    if (minMessages == null || rest.length > 0) {
+      return { text: "Usage: /threadreply min <0-or-greater>|inherit" };
+    }
+    const committed2 = await api2.runtime.config.mutateConfigFile({
+      afterWrite: { mode: "auto" },
+      mutate: (draft) => {
+        setGroupMinMessages({
+          draft,
+          accountId: ctx.accountId,
+          groupId,
+          minMessages
+        });
+      }
+    });
+    const nextConfig2 = committed2.nextConfig;
+    return {
+      text: buildStatusText({
+        cfg: nextConfig2,
+        accountId: ctx.accountId,
+        groupId
+      })
+    };
+  }
+  const action = normalizeAction(args);
+  if (action === "help") {
+    return {
+      text: buildMenuText({
+        cfg: currentConfig,
+        accountId: ctx.accountId,
+        groupId
+      }),
+      channelData: buildModeButtons()
+    };
+  }
+  if (action === "status") {
+    return {
+      text: buildStatusText({
+        cfg: currentConfig,
+        accountId: ctx.accountId,
+        groupId
+      })
+    };
+  }
+  if (!action) {
+    return {
+      text: [
+        "Usage: /threadreply thread|main|auto|inherit|status",
+        "       /threadreply min <0-or-greater>|inherit",
+        "",
+        "- thread: auto-route parent-chat replies into per-message Inline reply threads once the minimum is reached.",
+        "- main: keep automatic replies in the parent chat.",
+        "- auto: use Inline's automatic default behavior for this chat.",
+        "- inherit: remove this chat override and use account/default config.",
+        "- min: set how many parent-chat messages must exist before automatic thread creation."
+      ].join(`
+`)
+    };
+  }
+  const committed = await api2.runtime.config.mutateConfigFile({
+    afterWrite: { mode: "auto" },
+    mutate: (draft) => {
+      setGroupMode({
+        draft,
+        accountId: ctx.accountId,
+        groupId,
+        mode: action
+      });
+    }
+  });
+  const nextConfig = committed.nextConfig;
+  return {
+    text: buildStatusText({
+      cfg: nextConfig,
+      accountId: ctx.accountId,
+      groupId
+    })
+  };
+}
+function createInlineThreadReplyCommand(api2) {
+  return {
+    name: "threadreply",
+    nativeNames: { inline: "threadreply" },
+    description: "Set Inline reply-thread mode for this chat.",
+    channels: ["inline"],
+    acceptsArgs: true,
+    handler: async (ctx) => await handleInlineThreadReplyCommand(api2, ctx)
+  };
+}
+
 // src/runtime-register-api.ts
 function registerInlinePluginFull(api2) {
   api2.registerTool((ctx) => createInlineMembersTool(ctx), {
@@ -38794,6 +39429,10 @@ function registerInlinePluginFull(api2) {
   api2.registerTool((ctx) => createInlineParentContextTool(ctx), {
     names: ["inline_parent_context"]
   });
+  const registerCommand = api2.registerCommand;
+  if (typeof registerCommand === "function") {
+    registerCommand(createInlineThreadReplyCommand(api2));
+  }
   api2.on("message_sending", (event, ctx) => {
     if (ctx.channelId !== "inline")
       return;
@@ -38821,5 +39460,5 @@ export {
   registerInlinePluginFull
 };
 
-//# debugId=D767F13C52B346E664756E2164756E21
+//# debugId=6281D0C5544F91C564756E2164756E21
 //# sourceMappingURL=runtime-register-api.js.map