@inline-openclaw/inline 0.0.21 → 0.0.23

package/dist/index.js

@@ -5539,17 +5539,6 @@ var require_websocket_server = __commonJS((exports, module) => {
   }
 });
 
-// src/index.ts
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
-
-// src/inline/channel.ts
-import {
-  buildChannelConfigSchema,
-  DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID2,
-  formatPairingApproveHint,
-  PAIRING_APPROVED_MESSAGE
-} from "openclaw/plugin-sdk";
-
 // ../protocol/dist/core.js
 var import_runtime = __toESM(require_commonjs(), 1);
 var import_runtime2 = __toESM(require_commonjs(), 1);
@@ -19960,15 +19949,6 @@ class JsonFileStateStore {
     await rename(tempPath, this.path);
   }
 }
-// src/inline/config-schema.ts
-import {
-  BlockStreamingCoalesceSchema,
-  DmPolicySchema,
-  GroupPolicySchema,
-  ToolPolicySchema,
-  requireOpenAllowFrom
-} from "openclaw/plugin-sdk";
-
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -33501,6 +33481,246 @@ function date4(params) {
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 config(en_default());
+// src/openclaw-compat.ts
+var MB = 1024 * 1024;
+var VALID_ACCOUNT_ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
+var INVALID_ACCOUNT_ID_CHARS_RE = /[^a-z0-9_-]+/g;
+var LEADING_DASH_RE = /^-+/g;
+var TRAILING_DASH_RE = /-+$/g;
+var BLOCKED_OBJECT_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+var DEFAULT_ACCOUNT_ID = "default";
+var PAIRING_APPROVED_MESSAGE = "✅ OpenClaw access approved. Send a message to start chatting.";
+function normalizeAccountId(value) {
+  const trimmed = (value ?? "").trim();
+  if (!trimmed)
+    return DEFAULT_ACCOUNT_ID;
+  const normalized = VALID_ACCOUNT_ID_RE.test(trimmed) ? trimmed.toLowerCase() : trimmed.toLowerCase().replace(INVALID_ACCOUNT_ID_CHARS_RE, "-").replace(LEADING_DASH_RE, "").replace(TRAILING_DASH_RE, "").slice(0, 64);
+  if (!normalized || BLOCKED_OBJECT_KEYS.has(normalized)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return normalized;
+}
+function emptyPluginConfigSchema() {
+  function error48(message) {
+    return { success: false, error: { issues: [{ path: [], message }] } };
+  }
+  return {
+    safeParse(value) {
+      if (value === undefined) {
+        return { success: true, data: undefined };
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return error48("expected config object");
+      }
+      if (Object.keys(value).length > 0) {
+        return error48("config must be empty");
+      }
+      return { success: true, data: value };
+    },
+    jsonSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {}
+    }
+  };
+}
+function buildChannelConfigSchema(schema) {
+  const schemaWithJson = schema;
+  if (typeof schemaWithJson.toJSONSchema === "function") {
+    return {
+      schema: schemaWithJson.toJSONSchema({
+        target: "draft-07",
+        unrepresentable: "any"
+      })
+    };
+  }
+  return {
+    schema: {
+      type: "object",
+      additionalProperties: true
+    }
+  };
+}
+function formatPairingApproveHint(channelId) {
+  return `Approve via: openclaw pairing list ${channelId} / openclaw pairing approve ${channelId} <code>`;
+}
+var GroupPolicySchema = exports_external.enum(["open", "disabled", "allowlist"]);
+var DmPolicySchema = exports_external.enum(["pairing", "allowlist", "open", "disabled"]);
+var BlockStreamingCoalesceSchema = exports_external.object({
+  minChars: exports_external.number().int().positive().optional(),
+  maxChars: exports_external.number().int().positive().optional(),
+  idleMs: exports_external.number().int().nonnegative().optional()
+}).strict();
+var ToolPolicyBaseSchema = exports_external.object({
+  allow: exports_external.array(exports_external.string()).optional(),
+  alsoAllow: exports_external.array(exports_external.string()).optional(),
+  deny: exports_external.array(exports_external.string()).optional()
+}).strict();
+var ToolPolicySchema = ToolPolicyBaseSchema.superRefine((value, ctx) => {
+  if (value.allow && value.allow.length > 0 && value.alsoAllow && value.alsoAllow.length > 0) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "tools policy cannot set both allow and alsoAllow in the same scope (merge alsoAllow into allow, or remove allow and use profile + alsoAllow)"
+    });
+  }
+}).optional();
+function requireOpenAllowFrom(params) {
+  if (params.policy !== "open") {
+    return;
+  }
+  const allow = (params.allowFrom ?? []).map((entry) => String(entry).trim()).filter(Boolean);
+  if (allow.includes("*")) {
+    return;
+  }
+  params.ctx.addIssue({
+    code: exports_external.ZodIssueCode.custom,
+    path: params.path,
+    message: params.message
+  });
+}
+function resolveControlCommandGate(params) {
+  const mode = params.modeWhenAccessGroupsOff ?? "allow";
+  let commandAuthorized = false;
+  if (!params.useAccessGroups) {
+    if (mode === "allow") {
+      commandAuthorized = true;
+    } else if (mode === "deny") {
+      commandAuthorized = false;
+    } else {
+      const anyConfigured = params.authorizers.some((entry) => entry.configured);
+      commandAuthorized = !anyConfigured || params.authorizers.some((entry) => entry.configured && entry.allowed);
+    }
+  } else {
+    commandAuthorized = params.authorizers.some((entry) => entry.configured && entry.allowed);
+  }
+  return {
+    commandAuthorized,
+    shouldBlock: params.allowTextCommands && params.hasControlCommand && !commandAuthorized
+  };
+}
+function resolveMentionGatingWithBypass(params) {
+  const shouldBypassMention = params.isGroup && params.requireMention && !params.wasMentioned && !(params.hasAnyMention ?? false) && params.allowTextCommands && params.commandAuthorized && params.hasControlCommand;
+  const effectiveWasMentioned = params.wasMentioned || params.implicitMention === true || shouldBypassMention;
+  return {
+    effectiveWasMentioned,
+    shouldSkip: params.requireMention && params.canDetectMention && !effectiveWasMentioned,
+    shouldBypassMention
+  };
+}
+function logInboundDrop(params) {
+  const target = params.target ? ` target=${params.target}` : "";
+  params.log(`${params.channel}: drop ${params.reason}${target}`);
+}
+function resolveChannelMediaMaxBytes(params) {
+  const accountId = normalizeAccountId(params.accountId);
+  const channelLimit = params.resolveChannelLimitMb({
+    cfg: params.cfg,
+    accountId
+  });
+  if (channelLimit) {
+    return channelLimit * MB;
+  }
+  if (params.cfg.agents?.defaults?.mediaMaxMb) {
+    return params.cfg.agents.defaults.mediaMaxMb * MB;
+  }
+  return;
+}
+function createActionGate(actions) {
+  return (key, defaultValue = true) => {
+    const value = actions?.[key];
+    if (value === undefined) {
+      return defaultValue;
+    }
+    return value !== false;
+  };
+}
+function toSnakeCaseKey(key) {
+  return key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function readSnakeCaseParamRaw(params, key) {
+  if (Object.hasOwn(params, key)) {
+    return params[key];
+  }
+  const snakeKey = toSnakeCaseKey(key);
+  if (snakeKey !== key && Object.hasOwn(params, snakeKey)) {
+    return params[snakeKey];
+  }
+  return;
+}
+
+class ToolInputError extends Error {
+  status = 400;
+  constructor(message) {
+    super(message);
+    this.name = "ToolInputError";
+  }
+}
+function readStringParam(params, key, options = {}) {
+  const { required: required2 = false, trim = true, label = key, allowEmpty = false } = options;
+  const raw = readSnakeCaseParamRaw(params, key);
+  if (typeof raw !== "string") {
+    if (required2) {
+      throw new ToolInputError(`${label} required`);
+    }
+    return;
+  }
+  const value = trim ? raw.trim() : raw;
+  if (!value && !allowEmpty) {
+    if (required2) {
+      throw new ToolInputError(`${label} required`);
+    }
+    return;
+  }
+  return value;
+}
+function readNumberParam(params, key, options = {}) {
+  const { required: required2 = false, label = key, integer: integer2 = false, strict = false } = options;
+  const raw = readSnakeCaseParamRaw(params, key);
+  let value;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    value = raw;
+  } else if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed) {
+      const parsed = strict ? Number(trimmed) : Number.parseFloat(trimmed);
+      if (Number.isFinite(parsed)) {
+        value = parsed;
+      }
+    }
+  }
+  if (value === undefined) {
+    if (required2) {
+      throw new ToolInputError(`${label} required`);
+    }
+    return;
+  }
+  return integer2 ? Math.trunc(value) : value;
+}
+function readReactionParams(params, options) {
+  const emojiKey = options.emojiKey ?? "emoji";
+  const removeKey = options.removeKey ?? "remove";
+  const remove = typeof params[removeKey] === "boolean" ? params[removeKey] : false;
+  const emoji3 = readStringParam(params, emojiKey, {
+    required: true,
+    allowEmpty: true
+  });
+  if (remove && !emoji3) {
+    throw new ToolInputError(options.removeErrorMessage);
+  }
+  return { emoji: emoji3 ?? "", remove, isEmpty: !emoji3 };
+}
+function jsonResult(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2)
+      }
+    ],
+    details: payload
+  };
+}
+
 // src/inline/config-schema.ts
 var InlineActionsSchema = exports_external.object({
   send: exports_external.boolean().optional(),
@@ -33515,6 +33735,9 @@ var InlineActionsSchema = exports_external.object({
   pins: exports_external.boolean().optional(),
   permissions: exports_external.boolean().optional()
 }).strict();
+var InlineCapabilitiesSchema = exports_external.object({
+  replyThreads: exports_external.boolean().optional()
+}).strict();
 var InlineGroupSchema = exports_external.object({
   requireMention: exports_external.boolean().optional(),
   systemPrompt: exports_external.string().optional(),
@@ -33531,6 +33754,7 @@ var InlineAccountSchemaBase = exports_external.object({
   baseUrl: exports_external.string().optional(),
   token: exports_external.string().optional(),
   tokenFile: exports_external.string().optional(),
+  capabilities: InlineCapabilitiesSchema.optional(),
   dmPolicy: DmPolicySchema.optional().default("pairing"),
   allowFrom: exports_external.array(exports_external.string()).optional(),
   systemPrompt: exports_external.string().optional(),
@@ -33577,7 +33801,6 @@ var InlineConfigSchema = InlineAccountSchemaBase.extend({
 });
 
 // src/inline/accounts.ts
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
 import { readFile as readFile2 } from "node:fs/promises";
 var DEFAULT_BASE_URL = "https://api.inline.chat";
 function normalizeInlineAccountId(raw) {
@@ -33655,6 +33878,97 @@ async function resolveInlineToken(account) {
   return token;
 }
 
+// src/inline/reply-threads.ts
+var GET_CHAT_METHOD = typeof Method.GET_CHAT === "number" && Number.isInteger(Method.GET_CHAT) && Method.GET_CHAT > 0 ? Method.GET_CHAT : 25;
+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;
+function buildChatPeer(chatId) {
+  return {
+    type: {
+      oneofKind: "chat",
+      chat: { chatId }
+    }
+  };
+}
+function getInlineReplyThreadsCapabilityConfig(params) {
+  const account = resolveInlineAccount({
+    cfg: params.cfg,
+    accountId: params.accountId ?? null
+  });
+  return {
+    replyThreads: account.config.capabilities?.replyThreads === true
+  };
+}
+function isInlineReplyThreadsEnabled(params) {
+  return getInlineReplyThreadsCapabilityConfig(params).replyThreads;
+}
+function resolveInlineReplyThreadChatId(params) {
+  if (!isInlineReplyThreadsEnabled({ cfg: params.cfg, accountId: params.accountId ?? null })) {
+    return params.parentChatId;
+  }
+  if (params.parentChatId == null) {
+    return null;
+  }
+  if (params.threadId == null) {
+    return params.parentChatId;
+  }
+  const normalized = typeof params.threadId === "number" ? Number.isFinite(params.threadId) && Number.isInteger(params.threadId) && params.threadId >= 0 ? BigInt(params.threadId) : null : typeof params.threadId === "string" ? params.threadId.trim() ? (() => {
+    try {
+      return BigInt(params.threadId.trim());
+    } catch {
+      return null;
+    }
+  })() : null : null;
+  return normalized ?? params.parentChatId;
+}
+async function loadInlineReplyThreadMetadata(params) {
+  const result = await params.client.invokeRaw(GET_CHAT_METHOD, {
+    oneofKind: "getChat",
+    getChat: { peerId: buildChatPeer(params.chatId) }
+  }).catch(() => null);
+  if (result?.oneofKind !== "getChat") {
+    return null;
+  }
+  const chat = result.getChat.chat;
+  const parentChatId = chat?.parentChatId;
+  if (parentChatId == null) {
+    return null;
+  }
+  return {
+    childChatId: chat?.id ?? params.chatId,
+    parentChatId,
+    parentMessageId: chat?.parentMessageId ?? null,
+    title: chat?.title?.trim() || null
+  };
+}
+async function loadInlineReplyThreadAnchorMessage(params) {
+  const directResult = await params.client.invokeRaw(GET_MESSAGES_METHOD, {
+    oneofKind: "getMessages",
+    getMessages: {
+      peerId: buildChatPeer(params.parentChatId),
+      messageIds: [params.parentMessageId]
+    }
+  }).catch(() => null);
+  if (directResult?.oneofKind === "getMessages") {
+    const directTarget = (directResult.getMessages.messages ?? []).find((item) => item.id === params.parentMessageId) ?? null;
+    if (directTarget) {
+      return directTarget;
+    }
+  }
+  const historyResult = await params.client.invokeRaw(GET_CHAT_HISTORY_METHOD, {
+    oneofKind: "getChatHistory",
+    getChatHistory: {
+      peerId: buildChatPeer(params.parentChatId),
+      offsetId: params.parentMessageId + 1n,
+      limit: 8
+    }
+  }).catch(() => null);
+  if (historyResult?.oneofKind !== "getChatHistory") {
+    return null;
+  }
+  return (historyResult.getChatHistory.messages ?? []).find((item) => item.id === params.parentMessageId) ?? null;
+}
+
 // src/inline/normalize.ts
 function normalizeInlineTarget(raw) {
   let normalized = raw.trim();
@@ -33683,17 +33997,255 @@ function looksLikeInlineTargetId(raw, normalizedInput) {
 // src/inline/monitor.ts
 import { mkdir } from "node:fs/promises";
 import path2 from "node:path";
-import {
-  buildPendingHistoryContextFromMap,
-  clearHistoryEntriesIfEnabled,
-  createReplyPrefixOptions,
-  createTypingCallbacks,
-  logInboundDrop,
-  recordPendingHistoryEntryIfEnabled,
-  resolveChannelMediaMaxBytes as resolveChannelMediaMaxBytes2,
-  resolveControlCommandGate,
-  resolveMentionGatingWithBypass
-} from "openclaw/plugin-sdk";
+
+// src/sdk-runtime-compat.ts
+var HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
+var CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
+var MAX_HISTORY_KEYS = 1000;
+var DEFAULT_GROUP_HISTORY_LIMIT = 50;
+function evictOldHistoryKeys(historyMap, maxKeys = MAX_HISTORY_KEYS) {
+  if (historyMap.size <= maxKeys) {
+    return;
+  }
+  const keysToDelete = historyMap.size - maxKeys;
+  const iterator = historyMap.keys();
+  for (let index = 0;index < keysToDelete; index += 1) {
+    const key = iterator.next().value;
+    if (key !== undefined) {
+      historyMap.delete(key);
+    }
+  }
+}
+function buildHistoryContext(params) {
+  const lineBreak = params.lineBreak ?? `
+`;
+  if (!params.historyText.trim()) {
+    return params.currentMessage;
+  }
+  return [
+    HISTORY_CONTEXT_MARKER,
+    params.historyText,
+    "",
+    CURRENT_MESSAGE_MARKER,
+    params.currentMessage
+  ].join(lineBreak);
+}
+function appendHistoryEntry(params) {
+  if (params.limit <= 0) {
+    return [];
+  }
+  const history = params.historyMap.get(params.historyKey) ?? [];
+  history.push(params.entry);
+  while (history.length > params.limit) {
+    history.shift();
+  }
+  if (params.historyMap.has(params.historyKey)) {
+    params.historyMap.delete(params.historyKey);
+  }
+  params.historyMap.set(params.historyKey, history);
+  evictOldHistoryKeys(params.historyMap);
+  return history;
+}
+function buildHistoryContextFromEntries(params) {
+  const lineBreak = params.lineBreak ?? `
+`;
+  const entries = params.excludeLast === false ? params.entries : params.entries.slice(0, -1);
+  if (entries.length === 0) {
+    return params.currentMessage;
+  }
+  return buildHistoryContext({
+    historyText: entries.map(params.formatEntry).join(lineBreak),
+    currentMessage: params.currentMessage,
+    lineBreak
+  });
+}
+function buildPendingHistoryContextFromMap(params) {
+  if (params.limit <= 0) {
+    return params.currentMessage;
+  }
+  const entries = params.historyMap.get(params.historyKey) ?? [];
+  return buildHistoryContextFromEntries({
+    entries,
+    currentMessage: params.currentMessage,
+    formatEntry: params.formatEntry,
+    ...params.lineBreak !== undefined ? { lineBreak: params.lineBreak } : {},
+    excludeLast: false
+  });
+}
+function clearHistoryEntriesIfEnabled(params) {
+  if (params.limit <= 0) {
+    return;
+  }
+  params.historyMap.set(params.historyKey, []);
+}
+function recordPendingHistoryEntryIfEnabled(params) {
+  if (!params.entry || params.limit <= 0) {
+    return [];
+  }
+  return appendHistoryEntry({
+    historyMap: params.historyMap,
+    historyKey: params.historyKey,
+    entry: params.entry,
+    limit: params.limit
+  });
+}
+function createMessageToolButtonsSchemaCompat() {
+  return {
+    type: "array",
+    description: "Button rows for channels that support button-style actions.",
+    items: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["text", "callback_data"],
+        properties: {
+          text: { type: "string" },
+          callback_data: { type: "string" },
+          style: { type: "string", enum: ["danger", "success", "primary"] }
+        }
+      }
+    }
+  };
+}
+function extensionForMimeCompat(mime) {
+  const normalized = mime?.trim().toLowerCase();
+  if (!normalized)
+    return;
+  const directMap = {
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "video/mp4": "mp4",
+    "audio/mpeg": "mp3",
+    "audio/mp4": "m4a",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg",
+    "application/pdf": "pdf",
+    "text/plain": "txt"
+  };
+  const mapped = directMap[normalized];
+  if (mapped)
+    return mapped;
+  const [, subtype] = normalized.split("/", 2);
+  return subtype?.split("+", 1)[0] || undefined;
+}
+function createInlineTypingCallbacks(params) {
+  const keepaliveIntervalMs = params.keepaliveIntervalMs ?? 3000;
+  const maxConsecutiveFailures = Math.max(1, params.maxConsecutiveFailures ?? 2);
+  const maxDurationMs = params.maxDurationMs ?? 60000;
+  let closed = false;
+  let stopSent = false;
+  let consecutiveFailures = 0;
+  let keepaliveTimer;
+  let ttlTimer;
+  const clearTimers = () => {
+    if (keepaliveTimer) {
+      clearInterval(keepaliveTimer);
+      keepaliveTimer = undefined;
+    }
+    if (ttlTimer) {
+      clearTimeout(ttlTimer);
+      ttlTimer = undefined;
+    }
+  };
+  const fireStop = () => {
+    closed = true;
+    clearTimers();
+    if (!params.stop || stopSent) {
+      return;
+    }
+    stopSent = true;
+    params.stop().catch((err) => (params.onStopError ?? params.onStartError)(err));
+  };
+  const fireStart = async () => {
+    if (closed)
+      return;
+    try {
+      await params.start();
+      consecutiveFailures = 0;
+    } catch (err) {
+      consecutiveFailures += 1;
+      params.onStartError(err);
+      if (consecutiveFailures >= maxConsecutiveFailures) {
+        fireStop();
+      }
+    }
+  };
+  return {
+    onReplyStart: async () => {
+      if (closed)
+        return;
+      stopSent = false;
+      consecutiveFailures = 0;
+      clearTimers();
+      await fireStart();
+      if (closed)
+        return;
+      keepaliveTimer = setInterval(() => {
+        fireStart();
+      }, keepaliveIntervalMs);
+      if (maxDurationMs > 0) {
+        ttlTimer = setTimeout(() => {
+          fireStop();
+        }, maxDurationMs);
+      }
+    },
+    onIdle: fireStop,
+    onCleanup: fireStop
+  };
+}
+async function createChannelReplyPipelineCompat(params) {
+  try {
+    const sdk = await import("openclaw/plugin-sdk/channel-reply-pipeline");
+    return sdk.createChannelReplyPipeline(params);
+  } catch {
+    return {
+      onModelSelected: () => {},
+      ...params.typingCallbacks ? { typingCallbacks: params.typingCallbacks } : params.typing ? { typingCallbacks: createInlineTypingCallbacks(params.typing) } : {}
+    };
+  }
+}
+async function loadNativeCommandHelpersCompat() {
+  try {
+    const sdk = await import("openclaw/plugin-sdk/command-auth");
+    const listNativeCommandSpecsForConfig = typeof sdk.listNativeCommandSpecsForConfig === "function" ? sdk.listNativeCommandSpecsForConfig : null;
+    const listSkillCommandsForAgents = typeof sdk.listSkillCommandsForAgents === "function" ? sdk.listSkillCommandsForAgents : null;
+    if (!listNativeCommandSpecsForConfig || !listSkillCommandsForAgents) {
+      throw new Error("command-auth helpers unavailable");
+    }
+    return {
+      available: true,
+      listNativeCommandSpecsForConfig,
+      listSkillCommandsForAgents
+    };
+  } catch {
+    return {
+      available: false,
+      listNativeCommandSpecsForConfig: () => [],
+      listSkillCommandsForAgents: () => []
+    };
+  }
+}
+async function loadPluginCommandSpecsCompat(provider) {
+  try {
+    const sdk = await import("openclaw/plugin-sdk/plugin-runtime");
+    if (typeof sdk.getPluginCommandSpecs !== "function") {
+      throw new Error("plugin runtime command helper unavailable");
+    }
+    return {
+      available: true,
+      specs: sdk.getPluginCommandSpecs(provider)
+    };
+  } catch {
+    return {
+      available: false,
+      specs: []
+    };
+  }
+}
 
 // src/inline/message-formatting.ts
 var INLINE_FORMATTING_NOTE = "Inline formatting note: prefer bullet lists over markdown tables. If a table is necessary, render it inside a fenced code block. Do not wrap bare URLs in inline code or backticks. Use plain URLs or markdown links. Use inline code only for actual code, commands, file paths, env vars, or identifiers.";
@@ -33720,9 +34272,8 @@ function sanitizeInlineOutgoingText(text) {
 }
 
 // src/inline/policy.ts
-import { normalizeAccountId as normalizePluginAccountId } from "openclaw/plugin-sdk";
 function normalizeAccountId2(raw) {
-  return normalizePluginAccountId(raw);
+  return normalizeAccountId(raw);
 }
 function resolveInlineGroups(cfg, accountId) {
   const inline = cfg.channels?.inline;
@@ -33840,19 +34391,12 @@ function getInlineRuntime() {
 
 // src/inline/media.ts
 import path from "node:path";
-import {
-  detectMime,
-  extensionForMime,
-  loadWebMedia,
-  resolveChannelMediaMaxBytes
-} from "openclaw/plugin-sdk";
 var DEFAULT_MEDIA_MAX_MB = 300;
 var SUPPORTED_INLINE_PHOTO_MIME = new Set(["image/jpeg", "image/png", "image/gif"]);
 var SUPPORTED_INLINE_VIDEO_MIME = new Set(["video/mp4"]);
 var DEFAULT_VIDEO_WIDTH = 1280;
 var DEFAULT_VIDEO_HEIGHT = 720;
 var DEFAULT_VIDEO_DURATION = 1;
-var loadWebMediaCompat = loadWebMedia;
 function looksLikeLocalMediaSource(mediaUrl) {
   return !/^https?:\/\//i.test(mediaUrl.trim());
 }
@@ -33895,7 +34439,7 @@ function ensureUploadFileName(params) {
     if (ext)
       return baseName;
   }
-  const inferredExt = params.ext ?? extensionForMime(params.mime) ?? undefined;
+  const inferredExt = params.ext ?? extensionForMimeCompat(params.mime) ?? undefined;
   const fallbackExt = inferredExt ?? (params.uploadType === "photo" ? "jpg" : params.uploadType === "video" ? "mp4" : "bin");
   return `attachment.${fallbackExt}`;
 }
@@ -33973,13 +34517,15 @@ async function uploadInlineMediaFromUrl(params) {
     cfg: params.cfg,
     accountId: params.accountId ?? null
   });
+  const runtimeMedia = getInlineRuntime().media;
+  const loadWebMediaCompat = runtimeMedia.loadWebMedia;
   let loaded;
   let detectedMime;
   let uploadType;
   let fileName;
   try {
     try {
-      loaded = await loadWebMedia(params.mediaUrl, maxBytes);
+      loaded = await runtimeMedia.loadWebMedia(params.mediaUrl, maxBytes);
     } catch (error48) {
       const message = String(error48);
       const deniedLocalPath = /not under an allowed directory/i.test(message);
@@ -33993,7 +34539,7 @@ async function uploadInlineMediaFromUrl(params) {
     if (!loaded) {
       throw new Error("inline media upload: media load returned no data");
     }
-    detectedMime = normalizeMime(loaded.contentType ?? await detectMime({
+    detectedMime = normalizeMime(loaded.contentType ?? await runtimeMedia.detectMime({
       buffer: loaded.buffer,
       ...loaded.fileName ? { filePath: loaded.fileName } : {}
     }));
@@ -34583,7 +35129,6 @@ function resolveInlineCompatNativeCommandMenu(commandBody) {
 
 // src/inline/monitor.ts
 var CHANNEL_ID = "inline";
-var DEFAULT_GROUP_HISTORY_LIMIT = 12;
 var DEFAULT_DM_HISTORY_LIMIT = 6;
 var HISTORY_LINE_MAX_CHARS = 280;
 var BOT_MESSAGE_CACHE_LIMIT = 500;
@@ -34591,7 +35136,7 @@ var REACTION_TARGET_LOOKUP_LIMIT = 8;
 var REPLY_TARGET_LOOKUP_LIMIT = 8;
 var ATTACHMENT_CONTEXT_LIMIT = 6;
 var DEFAULT_INLINE_MEDIA_MAX_BYTES = 300 * 1024 * 1024;
-var GET_MESSAGES_METHOD = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : null;
+var GET_MESSAGES_METHOD2 = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : null;
 function normalizeAllowEntry(raw) {
   return raw.trim().replace(/^inline:/i, "").replace(/^user:/i, "");
 }
@@ -34815,7 +35360,7 @@ function rememberBotMessagesFromList(params) {
     }
   }
 }
-function buildChatPeer(chatId) {
+function buildChatPeer2(chatId) {
   return {
     type: {
       oneofKind: "chat",
@@ -34827,7 +35372,7 @@ async function loadChatHistoryMessages(params) {
   const result = await params.client.invokeRaw(Method.GET_CHAT_HISTORY, {
     oneofKind: "getChatHistory",
     getChatHistory: {
-      peerId: buildChatPeer(params.chatId),
+      peerId: buildChatPeer2(params.chatId),
       ...params.offsetId != null ? { offsetId: params.offsetId } : {},
       limit: params.limit
     }
@@ -34838,10 +35383,10 @@ async function loadChatHistoryMessages(params) {
   return result.getChatHistory.messages ?? [];
 }
 async function findChatMessageById(params) {
-  const directResult = GET_MESSAGES_METHOD == null ? null : await params.client.invokeRaw(GET_MESSAGES_METHOD, {
+  const directResult = GET_MESSAGES_METHOD2 == null ? null : await params.client.invokeRaw(GET_MESSAGES_METHOD2, {
     oneofKind: "getMessages",
     getMessages: {
-      peerId: buildChatPeer(params.chatId),
+      peerId: buildChatPeer2(params.chatId),
       messageIds: [params.messageId]
     }
   }).catch(() => null);
@@ -34939,12 +35484,129 @@ function resolveHistorySenderLabel(params) {
 }
 function resolveHistoryLimit(params) {
   if (params.isGroup) {
-    return params.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT;
+    return Math.max(0, params.historyLimit ?? params.cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+  }
+  return Math.max(0, params.dmHistoryLimit ?? params.historyLimit ?? DEFAULT_DM_HISTORY_LIMIT);
+}
+function historyEntryDedupeKey(entry) {
+  if (entry.messageId)
+    return `id:${entry.messageId}`;
+  return `ts:${entry.timestamp ?? "unknown"}:${entry.sender}:${entry.body}`;
+}
+function mergeInboundHistoryEntries(params) {
+  if (params.limit <= 0)
+    return [];
+  const deduped = [];
+  const seen = new Set;
+  for (const entry of [...params.historyContextEntries, ...params.pendingEntries]) {
+    const key = historyEntryDedupeKey(entry);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    deduped.push(entry);
   }
-  return params.dmHistoryLimit ?? params.historyLimit ?? DEFAULT_DM_HISTORY_LIMIT;
+  return deduped.slice(-params.limit).map((entry) => ({
+    sender: entry.sender,
+    body: entry.body,
+    ...entry.timestamp != null ? { timestamp: entry.timestamp } : {}
+  }));
+}
+function buildInlineHistoryEntryPayload(params) {
+  const content = summarizeInlineMessageContent(params.message);
+  const text = normalizeHistoryText(content.text);
+  if (!text) {
+    return {
+      line: null,
+      attachmentLine: null,
+      entityLine: null,
+      inboundEntry: null
+    };
+  }
+  const label = resolveHistorySenderLabel({
+    senderId: params.message.fromId,
+    meId: params.meId,
+    senderProfilesById: params.senderProfilesById
+  });
+  const replySuffix = params.message.replyToMsgId != null ? ` ->${String(params.message.replyToMsgId)}` : "";
+  const messageId = params.syntheticMessageId ?? String(params.message.id);
+  const attachmentText = normalizeHistoryText(content.attachmentText);
+  const entityText = normalizeHistoryText(content.entityText);
+  return {
+    line: `#${String(params.message.id)}${replySuffix} ${label}: ${text}`,
+    attachmentLine: attachmentText ? `#${String(params.message.id)}${replySuffix} ${label}: ${attachmentText}` : null,
+    entityLine: entityText ? `#${String(params.message.id)}${replySuffix} ${label}: ${entityText}` : null,
+    inboundEntry: {
+      sender: label,
+      body: text,
+      ...params.message.date != null ? { timestamp: Number(params.message.date) * 1000 } : {},
+      messageId
+    }
+  };
+}
+function appendInlineHistoryEntry(target, entry) {
+  if (!entry.inboundEntry || !entry.line)
+    return;
+  target.inboundHistory.push(entry.inboundEntry);
+  target.lines.push(entry.line);
+  if (entry.attachmentLine) {
+    target.attachmentLines.push(entry.attachmentLine);
+  }
+  if (entry.entityLine) {
+    target.entityLines.push(entry.entityLine);
+  }
+}
+function prependLabeledHistoryLine(params) {
+  if (!params.line)
+    return params.existing;
+  const prefix = `${params.heading}
+`;
+  const existingBody = params.existing?.startsWith(prefix) ? params.existing.slice(prefix.length) : params.existing;
+  return existingBody ? `${prefix}${params.line}
+${existingBody}` : `${prefix}${params.line}`;
+}
+function prependInlineReplyThreadAnchor(params) {
+  const entry = buildInlineHistoryEntryPayload({
+    message: params.anchorMessage,
+    senderProfilesById: params.senderProfilesById,
+    meId: params.meId,
+    syntheticMessageId: `anchor:${String(params.parentChatId)}:${String(params.anchorMessage.id)}`
+  });
+  if (!entry.inboundEntry || !entry.line) {
+    return params.historyContext;
+  }
+  return {
+    ...params.historyContext,
+    inboundHistory: [entry.inboundEntry, ...params.historyContext.inboundHistory],
+    historyText: prependLabeledHistoryLine({
+      existing: params.historyContext.historyText,
+      heading: "Recent thread messages (oldest -> newest):",
+      line: entry.line
+    }),
+    attachmentText: prependLabeledHistoryLine({
+      existing: params.historyContext.attachmentText,
+      heading: "Recent media/attachments:",
+      line: entry.attachmentLine
+    }),
+    entityText: prependLabeledHistoryLine({
+      existing: params.historyContext.entityText,
+      heading: "Recent message entities:",
+      line: entry.entityLine
+    })
+  };
+}
+function buildInlineBodyForAgent(params) {
+  return [
+    params.rawBody,
+    params.currentAttachmentText && params.currentAttachmentText !== params.rawBody ? `Current media/attachments:
+${params.currentAttachmentText}` : null,
+    params.currentEntityText ? `Current message entities:
+${params.currentEntityText}` : null
+  ].filter(Boolean).join(`
+
+`) || params.rawBody;
 }
 function resolveInlineMediaMaxBytes(params) {
-  return resolveChannelMediaMaxBytes2({
+  return resolveChannelMediaMaxBytes({
     cfg: params.cfg,
     accountId: params.account.accountId,
     resolveChannelLimitMb: ({ accountId }) => {
@@ -35035,7 +35697,35 @@ async function resolveInlineInboundMedia(params) {
   }
   return out;
 }
-async function buildHistoryContext(params) {
+async function resolveInlineInboundReplyThreadContext(params) {
+  if (params.chatInfo.kind === "direct" || !params.replyThreadsEnabled) {
+    return null;
+  }
+  const metadata = await loadInlineReplyThreadMetadata({
+    client: params.client,
+    chatId: params.chatId
+  });
+  if (!metadata) {
+    return null;
+  }
+  const parentChatInfo = metadata.parentChatId === params.chatId ? params.chatInfo : await resolveChatInfo(params.client, params.chatCache, metadata.parentChatId).catch(() => ({
+    kind: "group",
+    title: null
+  }));
+  const anchorMessage = metadata.parentMessageId != null ? await loadInlineReplyThreadAnchorMessage({
+    client: params.client,
+    parentChatId: metadata.parentChatId,
+    parentMessageId: metadata.parentMessageId
+  }).catch(() => null) : null;
+  return {
+    childChatId: metadata.childChatId,
+    parentChatId: metadata.parentChatId,
+    parentChatTitle: parentChatInfo.title ?? null,
+    threadLabel: metadata.title ?? params.chatInfo.title ?? null,
+    anchorMessage
+  };
+}
+async function buildHistoryContext2(params) {
   const cachedReplyToBot = params.replyToMsgId != null && hasBotMessageId(params.botMessageIdsByChat, params.chatId, params.replyToMsgId);
   let repliedToBot = cachedReplyToBot;
   let replyToSenderId = null;
@@ -35043,6 +35733,7 @@ async function buildHistoryContext(params) {
   const lines = [];
   const attachmentLines = [];
   const entityLines = [];
+  const inboundHistory = [];
   if (params.historyLimit > 0) {
     const messages = await loadChatHistoryMessages({
       client: params.client,
@@ -35070,25 +35761,16 @@ async function buildHistoryContext(params) {
           replyToSenderId = String(item.fromId);
           repliedToBot = item.fromId === params.meId;
         }
-        const content = summarizeInlineMessageContent(item);
-        const text = normalizeHistoryText(content.text);
-        if (!text)
-          continue;
-        const label = resolveHistorySenderLabel({
-          senderId: item.fromId,
-          meId: params.meId,
-          senderProfilesById: params.senderProfilesById
-        });
-        const replySuffix = item.replyToMsgId != null ? ` ->${String(item.replyToMsgId)}` : "";
-        lines.push(`#${String(item.id)}${replySuffix} ${label}: ${text}`);
-        const attachmentText = normalizeHistoryText(content.attachmentText);
-        if (attachmentText) {
-          attachmentLines.push(`#${String(item.id)}${replySuffix} ${label}: ${attachmentText}`);
-        }
-        const entityText = normalizeHistoryText(content.entityText);
-        if (entityText) {
-          entityLines.push(`#${String(item.id)}${replySuffix} ${label}: ${entityText}`);
-        }
+        appendInlineHistoryEntry({
+          lines,
+          attachmentLines,
+          entityLines,
+          inboundHistory
+        }, buildInlineHistoryEntryPayload({
+          message: item,
+          senderProfilesById: params.senderProfilesById,
+          meId: params.meId
+        }));
       }
     }
   }
@@ -35115,6 +35797,7 @@ async function buildHistoryContext(params) {
 `) : null,
       entityText: entityLines.length ? entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
 `) : null,
+      inboundHistory,
       repliedToBot,
       replyToSenderId
     };
@@ -35129,6 +35812,7 @@ ${attachmentLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
     entityText: entityLines.length ? `Recent message entities:
 ${entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
 `)}` : null,
+    inboundHistory,
     repliedToBot,
     replyToSenderId
   };
@@ -35344,6 +36028,19 @@ 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 replyThreadContext = await resolveInlineInboundReplyThreadContext({
+          replyThreadsEnabled,
+          client,
+          chatId,
+          chatInfo,
+          chatCache
+        }).catch((err) => {
+          statusSink?.({ lastError: `getChat (reply thread) failed: ${String(err)}` });
+          return null;
+        });
+        const effectiveChatId = replyThreadContext?.parentChatId ?? chatId;
+        const effectiveGroupTitle = replyThreadContext?.parentChatTitle ?? chatInfo.title ?? null;
         const senderId = String(msg.fromId);
         await hydrateChatParticipants(chatId);
         const senderProfile = senderProfilesById.get(senderId);
@@ -35477,7 +36174,7 @@ ${JSON.stringify(payload)}`;
             }
           }
         }
-        if (commandGate.shouldBlock) {
+        if (isGroup && commandGate.shouldBlock) {
           logInboundDrop({
             log: (m) => runtime2.log?.(m),
             channel: CHANNEL_ID,
@@ -35495,7 +36192,7 @@ ${JSON.stringify(payload)}`;
           accountId: account.accountId,
           peer: {
             kind: isGroup ? "group" : "direct",
-            id: isGroup ? String(chatId) : senderId
+            id: isGroup ? String(effectiveChatId) : senderId
           }
         });
         const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
@@ -35503,14 +36200,15 @@ ${JSON.stringify(payload)}`;
         const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
         const wasMentioned = nativeMentioned || patternMentioned;
         const messageTimestamp = Number(msg.date) * 1000;
-        const groupHistoryKey = isGroup ? route.sessionKey : null;
+        const groupHistoryKey = isGroup ? replyThreadContext ? `${route.sessionKey}:thread:${String(replyThreadContext.childChatId)}` : route.sessionKey : null;
         const pendingHistorySender = senderUsername ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
         const historyLimit = resolveHistoryLimit({
+          cfg,
           isGroup,
           historyLimit: account.config.historyLimit,
           dmHistoryLimit: account.config.dmHistoryLimit
         });
-        const historyContext = await buildHistoryContext({
+        const historyContext = await buildHistoryContext2({
           client,
           chatId,
           currentMessageId: msg.id,
@@ -35521,12 +36219,26 @@ ${JSON.stringify(payload)}`;
           botMessageIdsByChat
         }).catch((err) => {
           statusSink?.({ lastError: `getChatHistory failed: ${String(err)}` });
-          return { historyText: null, attachmentText: null, entityText: null, repliedToBot: false, replyToSenderId: null };
+          return {
+            historyText: null,
+            attachmentText: null,
+            entityText: null,
+            inboundHistory: [],
+            repliedToBot: false,
+            replyToSenderId: null
+          };
         });
-        const implicitMention = (reactionEvent != null || callbackActionEvent != null) && isGroup || isGroup && (account.config.replyToBotWithoutMention ?? false) && msg.replyToMsgId != null && historyContext.repliedToBot;
+        const effectiveHistoryContext = replyThreadContext?.anchorMessage != null ? prependInlineReplyThreadAnchor({
+          historyContext,
+          anchorMessage: replyThreadContext.anchorMessage,
+          parentChatId: replyThreadContext.parentChatId,
+          senderProfilesById,
+          meId
+        }) : historyContext;
+        const implicitMention = (reactionEvent != null || callbackActionEvent != null) && isGroup || isGroup && (account.config.replyToBotWithoutMention ?? false) && msg.replyToMsgId != null && effectiveHistoryContext.repliedToBot;
         const requireMention = isGroup ? resolveInlineGroupRequireMention({
           cfg,
-          groupId: String(chatId),
+          groupId: String(effectiveChatId),
           accountId: account.accountId,
           requireMentionDefault: account.config.requireMention ?? false
         }) : false;
@@ -35589,14 +36301,14 @@ ${JSON.stringify(payload)}`;
           ...log ? { log } : {}
         });
         const timestamp = messageTimestamp;
-        const fromLabel = isGroup ? `chat:${chatInfo.title ?? String(chatId)}` : `user:${senderId}`;
+        const fromLabel = isGroup ? `chat:${effectiveGroupTitle ?? String(effectiveChatId)}` : `user:${senderId}`;
         const storePath = core3.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
         const envelopeOptions = core3.channel.reply.resolveEnvelopeFormatOptions(cfg);
         const previousTimestamp = core3.channel.session.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey });
         const combinedBody = [
-          historyContext.historyText,
-          historyContext.attachmentText,
-          historyContext.entityText,
+          effectiveHistoryContext.historyText,
+          effectiveHistoryContext.attachmentText,
+          effectiveHistoryContext.entityText,
           INLINE_FORMATTING_NOTE,
           `Current message:
 ${rawBody}`,
@@ -35630,31 +36342,46 @@ ${currentEntityText}` : null
             })
           });
         }
+        const inboundHistory = isGroup && groupHistoryKey ? mergeInboundHistoryEntries({
+          historyContextEntries: effectiveHistoryContext.inboundHistory,
+          pendingEntries: groupPendingHistories.get(groupHistoryKey) ?? [],
+          limit: historyLimit
+        }) : [];
+        const bodyForAgent = buildInlineBodyForAgent({
+          rawBody,
+          currentAttachmentText,
+          currentEntityText
+        });
         const effectiveSurface = shouldUseTelegramSurfaceForModelCommands(normalizedCommandBody) ? "telegram" : CHANNEL_ID;
         const systemPrompt = resolveInlineSystemPrompt({
           account,
-          ...isGroup ? { groupId: String(chatId) } : {}
+          ...isGroup ? { groupId: String(effectiveChatId) } : {}
         });
         const ctxPayload = core3.channel.reply.finalizeInboundContext({
           Body: body,
+          BodyForAgent: bodyForAgent,
+          ...isGroup ? { InboundHistory: inboundHistory } : {},
           RawBody: rawBody,
           CommandBody: normalizedCommandBody,
-          From: isGroup ? `inline:chat:${String(chatId)}` : `inline:${senderId}`,
-          To: `inline:${String(chatId)}`,
+          From: isGroup ? `inline:chat:${String(effectiveChatId)}` : `inline:${senderId}`,
+          To: `inline:${String(effectiveChatId)}`,
           SessionKey: route.sessionKey,
+          ...replyThreadContext ? { ParentSessionKey: route.sessionKey } : {},
           AccountId: route.accountId,
           ChatType: isGroup ? "group" : "direct",
           ConversationLabel: fromLabel,
-          ...isGroup ? { GroupSubject: chatInfo.title ?? String(chatId) } : {},
+          ...isGroup ? { GroupSubject: effectiveGroupTitle ?? String(effectiveChatId) } : {},
           SenderId: senderId,
           ...senderName ? { SenderName: senderName } : {},
           ...senderUsername ? { SenderUsername: senderUsername } : {},
           Provider: CHANNEL_ID,
           Surface: effectiveSurface,
           MessageSid: String(msg.id),
+          ...replyThreadContext ? { MessageThreadId: String(replyThreadContext.childChatId) } : {},
+          ...replyThreadContext?.threadLabel ? { ThreadLabel: replyThreadContext.threadLabel } : {},
           ...msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {},
-          ...historyContext.replyToSenderId != null ? { ReplyToSenderId: historyContext.replyToSenderId } : {},
-          ...msg.replyToMsgId != null ? { ReplyToWasBot: historyContext.repliedToBot } : {},
+          ...effectiveHistoryContext.replyToSenderId != null ? { ReplyToSenderId: effectiveHistoryContext.replyToSenderId } : {},
+          ...msg.replyToMsgId != null ? { ReplyToWasBot: effectiveHistoryContext.repliedToBot } : {},
           ...callbackActionEvent ? {
             MessageActionInteractionId: String(callbackActionEvent.interactionId),
             MessageActionId: callbackActionEvent.actionId,
@@ -35667,7 +36394,7 @@ ${currentEntityText}` : null
           CommandAuthorized: commandAuthorized,
           GroupSystemPrompt: systemPrompt,
           OriginatingChannel: CHANNEL_ID,
-          OriginatingTo: `inline:${String(chatId)}`
+          OriginatingTo: `inline:${String(effectiveChatId)}`
         });
         await core3.channel.session.recordInboundSession({
           storePath,
@@ -35677,26 +36404,33 @@ ${currentEntityText}` : null
             updateLastRoute: {
               sessionKey: route.mainSessionKey,
               channel: CHANNEL_ID,
-              to: `inline:${String(chatId)}`,
+              to: `inline:${String(effectiveChatId)}`,
               accountId: route.accountId
             }
           } : {},
           onRecordError: (err) => runtime2.error?.(`inline: failed updating session meta: ${String(err)}`)
         });
-        const prefixConfig = typeof createReplyPrefixOptions === "function" ? createReplyPrefixOptions({
+        const replyPipeline = await createChannelReplyPipelineCompat({
           cfg,
           agentId: route.agentId,
           channel: CHANNEL_ID,
-          accountId: account.accountId
-        }) : {};
-        const onModelSelected = typeof prefixConfig.onModelSelected === "function" ? prefixConfig.onModelSelected : undefined;
-        const { onModelSelected: _ignoredOnModelSelected, ...prefixOptions } = prefixConfig;
-        const typingCallbacks = typeof createTypingCallbacks === "function" ? createTypingCallbacks({
-          start: () => client.sendTyping({ chatId, typing: true }),
-          stop: () => client.sendTyping({ chatId, typing: false }),
-          onStartError: (err) => runtime2.error?.(`inline typing start failed: ${String(err)}`),
-          onStopError: (err) => runtime2.error?.(`inline typing stop failed: ${String(err)}`)
-        }) : {};
+          accountId: account.accountId,
+          typing: {
+            start: () => client.sendTyping({ chatId, typing: true }),
+            stop: () => client.sendTyping({ chatId, typing: false }),
+            onStartError: (err) => runtime2.error?.(`inline typing start failed: ${String(err)}`),
+            onStopError: (err) => runtime2.error?.(`inline typing stop failed: ${String(err)}`)
+          }
+        });
+        const onModelSelected = replyPipeline.onModelSelected;
+        const typingCallbacks = replyPipeline.typingCallbacks;
+        const prefixOptions = {
+          ...replyPipeline.responsePrefix !== undefined ? { responsePrefix: replyPipeline.responsePrefix } : {},
+          ...replyPipeline.enableSlackInteractiveReplies !== undefined ? { enableSlackInteractiveReplies: replyPipeline.enableSlackInteractiveReplies } : {},
+          ...replyPipeline.responsePrefixContextProvider ? {
+            responsePrefixContextProvider: replyPipeline.responsePrefixContextProvider
+          } : {}
+        };
         const streamViaEditMessage = account.config.streamViaEditMessage === true && !shouldEditCallbackTargetInPlace;
         const defaultReplyToMsgId = isGroup && msg.replyToMsgId != null ? msg.id : undefined;
         const disableBlockStreaming = streamViaEditMessage ? true : typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : undefined;
@@ -35747,7 +36481,7 @@ ${currentEntityText}` : null
                       oneofKind: "editMessage",
                       editMessage: {
                         messageId: editStreamState.messageId,
-                        peerId: buildChatPeer(chatId),
+                        peerId: buildChatPeer2(chatId),
                         text: nextText,
                         parseMarkdown
                       }
@@ -35774,7 +36508,7 @@ ${currentEntityText}` : null
             cfg,
             dispatcherOptions: {
               ...prefixOptions,
-              ...typingCallbacks,
+              ...typingCallbacks ? { typingCallbacks } : {},
               deliver: async (payload) => {
                 const rawText = payload.text ?? "";
                 const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
@@ -35821,7 +36555,7 @@ ${currentEntityText}` : null
                     oneofKind: "editMessage",
                     editMessage: {
                       messageId: editStreamState.messageId,
-                      peerId: buildChatPeer(chatId),
+                      peerId: buildChatPeer2(chatId),
                       text: textForEdit,
                       parseMarkdown,
                       ...actions !== undefined ? { actions } : {}
@@ -35935,15 +36669,6 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
   return { stop, done: loop.catch(() => {}) };
 }
 
-// src/inline/actions.ts
-import {
-  createActionGate,
-  jsonResult,
-  readReactionParams,
-  readNumberParam,
-  readStringParam
-} from "openclaw/plugin-sdk";
-
 // src/inline/space-members.ts
 function buildInlineUserDisplayName(user) {
   const explicit = [user.firstName?.trim(), user.lastName?.trim()].filter(Boolean).join(" ");
@@ -36038,7 +36763,8 @@ for (const group of ACTION_GROUPS) {
   }
 }
 var SUPPORTED_ACTIONS = Array.from(ACTION_TO_GATE_KEY.keys());
-var GET_MESSAGES_METHOD2 = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : null;
+var GET_MESSAGES_METHOD3 = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : null;
+var CREATE_SUBTHREAD_METHOD = typeof Method.CREATE_SUBTHREAD === "number" && Number.isInteger(Method.CREATE_SUBTHREAD) && Method.CREATE_SUBTHREAD > 0 ? Method.CREATE_SUBTHREAD : 43;
 var INLINE_ACTION_MAX_ROWS2 = 8;
 var INLINE_ACTION_MAX_PER_ROW2 = 8;
 function isRecord4(value) {
@@ -36379,7 +37105,7 @@ function resolveMessageSendTargetFromParams(params) {
     chatId: BigInt(normalized)
   };
 }
-function buildChatPeer2(chatId) {
+function buildChatPeer3(chatId) {
   return {
     type: {
       oneofKind: "chat",
@@ -36468,10 +37194,10 @@ async function loadMessageReactions(params) {
   return Array.from(byEmoji.values());
 }
 async function findMessageById(params) {
-  const directResult = GET_MESSAGES_METHOD2 == null ? null : await params.client.invokeRaw(GET_MESSAGES_METHOD2, {
+  const directResult = GET_MESSAGES_METHOD3 == null ? null : await params.client.invokeRaw(GET_MESSAGES_METHOD3, {
     oneofKind: "getMessages",
     getMessages: {
-      peerId: buildChatPeer2(params.chatId),
+      peerId: buildChatPeer3(params.chatId),
       messageIds: [params.messageId]
     }
   }).catch(() => null);
@@ -36481,7 +37207,7 @@ async function findMessageById(params) {
   const result = await params.client.invokeRaw(Method.GET_CHAT_HISTORY, {
     oneofKind: "getChatHistory",
     getChatHistory: {
-      peerId: buildChatPeer2(params.chatId),
+      peerId: buildChatPeer3(params.chatId),
       offsetId: params.messageId + 1n,
       limit: 8
     }
@@ -36555,7 +37281,7 @@ async function resolveSpaceIdFromParams(params) {
   const chatId = BigInt(normalizeChatId(chatTarget));
   const chatResult = await params.client.invokeRaw(Method.GET_CHAT, {
     oneofKind: "getChat",
-    getChat: { peerId: buildChatPeer2(chatId) }
+    getChat: { peerId: buildChatPeer3(chatId) }
   });
   if (chatResult.oneofKind !== "getChat") {
     throw new Error(`inline action: expected getChat result, got ${String(chatResult.oneofKind)}`);
@@ -36575,6 +37301,50 @@ function listAllActions() {
   }
   return Array.from(out);
 }
+function listEnabledInlineActions(cfg) {
+  const account = resolveInlineAccount({ cfg, accountId: null });
+  if (!account.enabled || !account.configured)
+    return [];
+  const gate = createActionGate(account.config.actions ?? {});
+  const actions = new Set;
+  for (const group of ACTION_GROUPS) {
+    if (!gate(group.key, group.defaultEnabled))
+      continue;
+    for (const action of group.actions) {
+      actions.add(action);
+    }
+  }
+  return Array.from(actions);
+}
+function supportsInlineMessageButtons(actions) {
+  return actions.some((action) => action === "send" || action === "reply" || action === "thread-reply" || action === "edit");
+}
+function describeInlineMessageTool({
+  cfg
+}) {
+  const actions = listEnabledInlineActions(cfg);
+  if (actions.length === 0) {
+    return {
+      actions: [],
+      capabilities: [],
+      schema: null
+    };
+  }
+  const buttonsEnabled = supportsInlineMessageButtons(actions);
+  const capabilities = buttonsEnabled ? ["interactive", "buttons"] : [];
+  const schema = buttonsEnabled ? [
+    {
+      properties: {
+        buttons: createMessageToolButtonsSchemaCompat()
+      }
+    }
+  ] : [];
+  return {
+    actions,
+    capabilities,
+    schema
+  };
+}
 function isActionEnabled(params) {
   const key = ACTION_TO_GATE_KEY.get(params.action);
   if (!key)
@@ -36590,21 +37360,10 @@ function isActionEnabled(params) {
   return gate(key, group.defaultEnabled);
 }
 var inlineMessageActions = {
-  listActions: ({ cfg }) => {
-    const account = resolveInlineAccount({ cfg, accountId: null });
-    if (!account.enabled || !account.configured)
-      return [];
-    const gate = createActionGate(account.config.actions ?? {});
-    const actions = new Set;
-    for (const group of ACTION_GROUPS) {
-      if (!gate(group.key, group.defaultEnabled))
-        continue;
-      for (const action of group.actions) {
-        actions.add(action);
-      }
-    }
-    return Array.from(actions);
-  },
+  describeMessageTool: describeInlineMessageTool,
+  listActions: ({ cfg }) => listEnabledInlineActions(cfg),
+  supportsButtons: ({ cfg }) => supportsInlineMessageButtons(listEnabledInlineActions(cfg)),
+  supportsCards: () => false,
   supportsAction: ({ action }) => SUPPORTED_ACTIONS.includes(action),
   extractToolSend: ({ args }) => {
     const action = typeof args.action === "string" ? args.action.trim() : "";
@@ -36692,11 +37451,35 @@ 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 });
       return await withInlineClient({
         cfg,
         accountId,
         fn: async (client) => {
           const actions = resolveInlineMessageActionsParam(params);
+          if (replyThreadsEnabled) {
+            const rawThreadId = readFlexibleId(params, "threadId") ?? readStringParam(params, "threadId");
+            if (!rawThreadId) {
+              throw new Error("inline thread-reply: threadId is required when reply threads are enabled");
+            }
+            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");
+            const text2 = readStringParam(params, "message") ?? readStringParam(params, "text", { required: true, allowEmpty: true });
+            const sent2 = await client.sendMessage({
+              chatId: chatId2,
+              text: text2,
+              ...actions !== undefined ? { actions } : {},
+              ...replyToMsgId2 != null ? { replyToMsgId: replyToMsgId2 } : {},
+              parseMarkdown
+            });
+            return jsonResult({
+              ok: true,
+              chatId: String(chatId2),
+              threadId: String(chatId2),
+              messageId: sent2.messageId != null ? String(sent2.messageId) : null,
+              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 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");
@@ -36735,7 +37518,7 @@ var inlineMessageActions = {
               oneofKind: "deleteReaction",
               deleteReaction: {
                 emoji: emoji3,
-                peerId: buildChatPeer2(chatId),
+                peerId: buildChatPeer3(chatId),
                 messageId
               }
             });
@@ -36748,7 +37531,7 @@ var inlineMessageActions = {
               addReaction: {
                 emoji: emoji3,
                 messageId,
-                peerId: buildChatPeer2(chatId)
+                peerId: buildChatPeer3(chatId)
               }
             });
             if (result.oneofKind !== "addReaction") {
@@ -36797,7 +37580,7 @@ var inlineMessageActions = {
           const result = await client.invokeRaw(Method.GET_CHAT_HISTORY, {
             oneofKind: "getChatHistory",
             getChatHistory: {
-              peerId: buildChatPeer2(chatId),
+              peerId: buildChatPeer3(chatId),
               ...offsetId != null ? { offsetId } : {},
               limit
             }
@@ -36825,7 +37608,7 @@ var inlineMessageActions = {
           const result = await client.invokeRaw(Method.SEARCH_MESSAGES, {
             oneofKind: "searchMessages",
             searchMessages: {
-              peerId: buildChatPeer2(chatId),
+              peerId: buildChatPeer3(chatId),
               queries: [query],
               limit,
               ...offsetId != null ? { offsetId } : {}
@@ -36857,7 +37640,7 @@ var inlineMessageActions = {
             oneofKind: "editMessage",
             editMessage: {
               messageId,
-              peerId: buildChatPeer2(chatId),
+              peerId: buildChatPeer3(chatId),
               text,
               ...actions !== undefined ? { actions } : {},
               parseMarkdown
@@ -36878,7 +37661,7 @@ var inlineMessageActions = {
           const chatId = resolveChatIdFromParams(params);
           const result = await client.invokeRaw(Method.GET_CHAT, {
             oneofKind: "getChat",
-            getChat: { peerId: buildChatPeer2(chatId) }
+            getChat: { peerId: buildChatPeer3(chatId) }
           });
           if (result.oneofKind !== "getChat") {
             throw new Error(`inline action: expected getChat result, got ${String(result.oneofKind)}`);
@@ -36957,6 +37740,7 @@ var inlineMessageActions = {
       });
     }
     if (normalizedAction === "channel-create" || normalizedAction === "thread-create") {
+      const replyThreadsEnabled = normalizedAction === "thread-create" && isInlineReplyThreadsEnabled({ cfg, accountId: accountId ?? null });
       return await withInlineClient({
         cfg,
         accountId,
@@ -36979,6 +37763,33 @@ var inlineMessageActions = {
             values: participantRefs,
             label: "participant"
           });
+          if (replyThreadsEnabled) {
+            const parentChatId = resolveChatIdFromParams(params);
+            const parentMessageId = parseOptionalInlineId(readFlexibleId(params, "parentMessageId") ?? readFlexibleId(params, "messageId") ?? readFlexibleId(params, "replyTo") ?? readFlexibleId(params, "replyToId") ?? readStringParam(params, "parentMessageId") ?? readStringParam(params, "messageId") ?? readStringParam(params, "replyTo") ?? readStringParam(params, "replyToId"), "parentMessageId");
+            const result2 = await client.invokeRaw(CREATE_SUBTHREAD_METHOD, {
+              oneofKind: "createSubthread",
+              createSubthread: {
+                parentChatId,
+                ...parentMessageId != null ? { parentMessageId } : {},
+                title,
+                ...description ? { description } : {},
+                ...emoji3 ? { emoji: emoji3 } : {},
+                participants: dedupedParticipants.map((userId) => ({ userId }))
+              }
+            });
+            if (result2.oneofKind !== "createSubthread") {
+              throw new Error(`inline action: expected createSubthread result, got ${String(result2.oneofKind)}`);
+            }
+            return jsonResult(toJsonSafe({
+              ok: true,
+              title,
+              parentChatId: String(parentChatId),
+              parentMessageId: parentMessageId != null ? String(parentMessageId) : null,
+              chat: result2.createSubthread.chat ?? null,
+              dialog: result2.createSubthread.dialog ?? null,
+              anchorMessage: result2.createSubthread.anchorMessage ?? null
+            }));
+          }
           const result = await client.invokeRaw(Method.CREATE_CHAT, {
             oneofKind: "createChat",
             createChat: {
@@ -37014,7 +37825,7 @@ var inlineMessageActions = {
           const result = await client.invokeRaw(Method.DELETE_CHAT, {
             oneofKind: "deleteChat",
             deleteChat: {
-              peerId: buildChatPeer2(chatId)
+              peerId: buildChatPeer3(chatId)
             }
           });
           if (result.oneofKind !== "deleteChat") {
@@ -37224,7 +38035,7 @@ var inlineMessageActions = {
           const result = await client.invokeRaw(Method.DELETE_MESSAGES, {
             oneofKind: "deleteMessages",
             deleteMessages: {
-              peerId: buildChatPeer2(chatId),
+              peerId: buildChatPeer3(chatId),
               messageIds: deduped
             }
           });
@@ -37250,7 +38061,7 @@ var inlineMessageActions = {
           const result = await client.invokeRaw(Method.PIN_MESSAGE, {
             oneofKind: "pinMessage",
             pinMessage: {
-              peerId: buildChatPeer2(chatId),
+              peerId: buildChatPeer3(chatId),
               messageId,
               unpin
             }
@@ -37275,7 +38086,7 @@ var inlineMessageActions = {
           const chatId = resolveChatIdFromParams(params);
           const result = await client.invokeRaw(Method.GET_CHAT, {
             oneofKind: "getChat",
-            getChat: { peerId: buildChatPeer2(chatId) }
+            getChat: { peerId: buildChatPeer3(chatId) }
           });
           if (result.oneofKind !== "getChat") {
             throw new Error(`inline action: expected getChat result, got ${String(result.oneofKind)}`);
@@ -37624,8 +38435,14 @@ async function sendMessageInline(params) {
       context: "sendText",
       target
     });
+    const effectiveChatId = resolvedTarget.kind === "chat" ? resolveInlineReplyThreadChatId({
+      cfg: params.cfg,
+      accountId: account.accountId,
+      parentChatId: resolvedTarget.targetId,
+      threadId: params.threadId ?? null
+    }) : null;
     const result = await client.sendMessage({
-      ...buildInlineSendTarget(resolvedTarget),
+      ...effectiveChatId != null ? { chatId: effectiveChatId } : buildInlineSendTarget(resolvedTarget),
       text: params.text,
       ...replyToMsgId != null ? { replyToMsgId } : {},
       parseMarkdown: account.config.parseMarkdown ?? true
@@ -37640,7 +38457,7 @@ async function sendMessageInline(params) {
     const bestEffort = result.messageId != null ? String(result.messageId) : BigInt(Date.now()).toString();
     return {
       messageId: bestEffort,
-      chatId: formatInlineResultChatId(resolvedTarget)
+      chatId: effectiveChatId != null ? String(effectiveChatId) : formatInlineResultChatId(resolvedTarget)
     };
   } finally {
     await client.close().catch(() => {});
@@ -37669,6 +38486,12 @@ async function sendMediaInline(params) {
       context: "sendMedia",
       target
     });
+    const effectiveChatId = resolvedTarget.kind === "chat" ? resolveInlineReplyThreadChatId({
+      cfg: params.cfg,
+      accountId: account.accountId,
+      parentChatId: resolvedTarget.targetId,
+      threadId: params.threadId ?? null
+    }) : null;
     const media = await uploadInlineMediaFromUrl({
       client,
       cfg: params.cfg,
@@ -37676,7 +38499,7 @@ async function sendMediaInline(params) {
       mediaUrl: params.mediaUrl
     });
     const result = await client.sendMessage({
-      ...buildInlineSendTarget(resolvedTarget),
+      ...effectiveChatId != null ? { chatId: effectiveChatId } : buildInlineSendTarget(resolvedTarget),
       ...caption ? { text: caption } : {},
       media,
       ...replyToMsgId != null ? { replyToMsgId } : {},
@@ -37692,7 +38515,7 @@ async function sendMediaInline(params) {
     const bestEffort = result.messageId != null ? String(result.messageId) : BigInt(Date.now()).toString();
     return {
       messageId: bestEffort,
-      chatId: formatInlineResultChatId(resolvedTarget)
+      chatId: effectiveChatId != null ? String(effectiveChatId) : formatInlineResultChatId(resolvedTarget)
     };
   } finally {
     await client.close().catch(() => {});
@@ -37775,7 +38598,7 @@ var inlineChannelPlugin = {
     edit: true,
     reply: true,
     groupManagement: true,
-    threads: false,
+    threads: true,
     nativeCommands: true,
     blockStreaming: true
   },
@@ -37809,7 +38632,7 @@ var inlineChannelPlugin = {
   },
   security: {
     resolveDmPolicy: ({ cfg, accountId, account }) => {
-      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID2;
+      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
       const useAccountPath = Boolean(cfg.channels?.inline?.accounts?.[resolvedAccountId]);
       const basePath = useAccountPath ? `channels.inline.accounts.${resolvedAccountId}.` : "channels.inline.";
       return {
@@ -37858,11 +38681,42 @@ var inlineChannelPlugin = {
       senderE164
     })
   },
+  threading: {
+    resolveReplyToMode: () => "off",
+    buildToolContext: ({ cfg, accountId, context, hasRepliedRef }) => {
+      if (!isInlineReplyThreadsEnabled({ cfg, accountId: accountId ?? null })) {
+        return;
+      }
+      const currentChannelId = context.To?.trim() || undefined;
+      if (!currentChannelId) {
+        return;
+      }
+      return {
+        currentChannelId,
+        ...context.MessageThreadId != null ? { currentThreadTs: String(context.MessageThreadId) } : {},
+        ...context.CurrentMessageId != null ? { currentMessageId: context.CurrentMessageId } : {},
+        replyToMode: "off",
+        ...hasRepliedRef ? { hasRepliedRef } : {}
+      };
+    },
+    resolveReplyTransport: ({ cfg, accountId, threadId, replyToId }) => {
+      if (!isInlineReplyThreadsEnabled({ cfg, accountId: accountId ?? null })) {
+        return null;
+      }
+      return {
+        threadId: threadId != null ? String(threadId) : null,
+        replyToId: replyToId ?? null
+      };
+    }
+  },
   agentPrompt: {
-    messageToolHints: () => [
+    messageToolHints: ({ cfg, accountId }) => [
       "- Inline targeting: omit `target` to reply in the current chat.",
       "- Inline explicit targets: `chat:<chatId>` for chats and `user:<userId>` for direct users. Prefer `user:` for DM user targets.",
-      "- Inline special tools: use `inline_nudge` to send a nudge, and `inline_forward` to forward message ids between chats or users."
+      "- Inline special tools: use `inline_nudge` to send a nudge, and `inline_forward` to forward message ids between chats or users.",
+      ...isInlineReplyThreadsEnabled({ cfg, accountId: accountId ?? null }) ? [
+        "- Inline reply threads are enabled: use `thread-reply` to send into a real reply thread, with `threadId` set to the reply-thread chat id."
+      ] : []
     ]
   },
   messaging: {
@@ -38009,7 +38863,8 @@ var inlineChannelPlugin = {
           to,
           text,
           accountId: accountId ?? null,
-          replyToId: effectiveReplyToId
+          replyToId: effectiveReplyToId,
+          threadId: null
         });
         return { channel: "inline", to, messageId: result.messageId, chatId: result.chatId };
       }
@@ -38025,7 +38880,8 @@ var inlineChannelPlugin = {
           text: isFirst ? text : "",
           mediaUrl,
           accountId: accountId ?? null,
-          replyToId: isFirst ? effectiveReplyToId : null
+          replyToId: isFirst ? effectiveReplyToId : null,
+          threadId: null
         });
       }
       if (!finalResult) {
@@ -38034,7 +38890,8 @@ var inlineChannelPlugin = {
           to,
           text,
           accountId: accountId ?? null,
-          replyToId: effectiveReplyToId
+          replyToId: effectiveReplyToId,
+          threadId: null
         });
         return { channel: "inline", to, messageId: result.messageId, chatId: result.chatId };
       }
@@ -38046,7 +38903,8 @@ var inlineChannelPlugin = {
         to,
         text,
         accountId: accountId ?? null,
-        replyToId: replyToId ?? null
+        replyToId: replyToId ?? null,
+        threadId: threadId ?? null
       });
       return { channel: "inline", to, messageId: result.messageId, chatId: result.chatId };
     },
@@ -38057,7 +38915,8 @@ var inlineChannelPlugin = {
           to,
           text,
           accountId: accountId ?? null,
-          replyToId: replyToId ?? null
+          replyToId: replyToId ?? null,
+          threadId: threadId ?? null
         });
         return { channel: "inline", to, messageId: result2.messageId, chatId: result2.chatId };
       }
@@ -38067,14 +38926,15 @@ var inlineChannelPlugin = {
         text,
         mediaUrl,
         accountId: accountId ?? null,
-        replyToId: replyToId ?? null
+        replyToId: replyToId ?? null,
+        threadId: threadId ?? null
       });
       return { channel: "inline", to, messageId: result.messageId, chatId: result.chatId };
     }
   },
   status: {
     defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID2,
+      accountId: DEFAULT_ACCOUNT_ID,
       running: false,
       lastStartAt: null,
       lastStopAt: null,
@@ -38159,9 +39019,6 @@ var inlineChannelPlugin = {
 };
 
 // src/inline/message-tools.ts
-import {
-  jsonResult as jsonResult2
-} from "openclaw/plugin-sdk";
 var InlineNudgeToolParameters = {
   type: "object",
   additionalProperties: false,
@@ -38473,7 +39330,7 @@ function createInlineNudgeTool(ctx) {
             }
           });
           const messageId = result.oneofKind === "sendMessage" ? extractFirstMessageId2(result.sendMessage.updates) : null;
-          return jsonResult2({
+          return jsonResult({
             ok: true,
             accountId: resolvedAccountId,
             nudged: true,
@@ -38527,7 +39384,7 @@ function createInlineForwardTool(ctx) {
             }
           });
           const forwardedMessageId = result.oneofKind === "forwardMessages" ? extractFirstMessageId2(result.forwardMessages.updates) : null;
-          return jsonResult2({
+          return jsonResult({
             ok: true,
             accountId: resolvedAccountId,
             from: source.normalized,
@@ -38613,7 +39470,7 @@ function filterSpaceMembers(params) {
     target: `user:${member.userId}`
   }));
 }
-function jsonResult3(payload) {
+function jsonResult2(payload) {
   return {
     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
     details: payload
@@ -38664,7 +39521,7 @@ function createInlineMembersTool(ctx) {
             userId,
             limit
           });
-          return jsonResult3({
+          return jsonResult2({
             ok: true,
             accountId: resolvedAccountId,
             spaceId: String(spaceId),
@@ -38680,10 +39537,6 @@ function createInlineMembersTool(ctx) {
 }
 
 // src/inline/profile-tool.ts
-import {
-  detectMime as detectMime2,
-  loadWebMedia as loadWebMedia2
-} from "openclaw/plugin-sdk";
 var InlineProfileToolParameters = {
   type: "object",
   additionalProperties: false,
@@ -38710,7 +39563,7 @@ var InlineProfileToolParameters = {
     }
   }
 };
-function jsonResult4(payload) {
+function jsonResult3(payload) {
   return {
     content: [
       {
@@ -38747,9 +39600,24 @@ function readTrimmedString(value) {
 function resolvePhotoSource(args) {
   return readTrimmedString(args.photoPath) ?? readTrimmedString(args.photoUrl);
 }
+function looksLikeLocalMediaSource2(mediaUrl) {
+  return !/^https?:\/\//i.test(mediaUrl.trim());
+}
 async function uploadProfilePhoto(client, rawSource) {
-  const loaded = await loadWebMedia2(rawSource);
-  const contentType = loaded.contentType ?? await detectMime2({
+  const runtimeMedia = getInlineRuntime().media;
+  const loadWebMediaCompat = runtimeMedia.loadWebMedia;
+  let loaded;
+  try {
+    loaded = await runtimeMedia.loadWebMedia(rawSource);
+  } catch (error48) {
+    const message = String(error48);
+    const deniedLocalPath = /not under an allowed directory/i.test(message);
+    if (!deniedLocalPath || !looksLikeLocalMediaSource2(rawSource)) {
+      throw error48;
+    }
+    loaded = await loadWebMediaCompat(rawSource, undefined, { localRoots: "any" });
+  }
+  const contentType = loaded.contentType ?? await runtimeMedia.detectMime({
     buffer: loaded.buffer,
     ...loaded.fileName ? { filePath: loaded.fileName } : {}
   }) ?? undefined;
@@ -38799,7 +39667,7 @@ function createInlineProfileTool(ctx) {
           if (result.oneofKind !== "updateBotProfile") {
             throw new Error(`inline_update_profile: expected updateBotProfile result, got ${String(result.oneofKind)}`);
           }
-          return jsonResult4({
+          return jsonResult3({
             ok: true,
             accountId: resolvedAccountId,
             botUserId: String(me.userId),
@@ -38815,9 +39683,6 @@ function createInlineProfileTool(ctx) {
   };
 }
 
-// src/inline/bot-commands-tool.ts
-import { jsonResult as jsonResult5 } from "openclaw/plugin-sdk";
-
 // src/inline/bot-commands-api.ts
 function normalizeInlineBotBaseUrl(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
@@ -38988,7 +39853,7 @@ function createInlineBotCommandsTool(ctx) {
           method: "GET"
         });
         const commands = Array.isArray(result.commands) ? result.commands : [];
-        return jsonResult5({
+        return jsonResult({
           ok: true,
           action,
           accountId: account.accountId,
@@ -39005,7 +39870,7 @@ function createInlineBotCommandsTool(ctx) {
           method: "POST",
           body: { commands }
         });
-        return jsonResult5({
+        return jsonResult({
           ok: true,
           action,
           accountId: account.accountId,
@@ -39019,7 +39884,7 @@ function createInlineBotCommandsTool(ctx) {
         methodName: "deleteMyCommands",
         method: "POST"
       });
-      return jsonResult5({
+      return jsonResult({
         ok: true,
         action,
         accountId: account.accountId
@@ -39029,7 +39894,6 @@ function createInlineBotCommandsTool(ctx) {
 }
 
 // src/inline/bot-commands-sync.ts
-import * as pluginSdk from "openclaw/plugin-sdk";
 var INLINE_BASE_NATIVE_COMMANDS = [
   { command: "help", description: "Show available commands." },
   { command: "commands", description: "List all slash commands." },
@@ -39059,12 +39923,15 @@ var INLINE_BASE_NATIVE_COMMANDS = [
 ];
 var INLINE_COMMAND_NAME_RE = /^[a-z0-9_]{1,32}$/;
 var INLINE_COMMAND_LIMIT = 100;
-function getPluginSdkFunction(name) {
-  const raw = pluginSdk[name];
-  if (typeof raw !== "function")
-    return null;
-  return raw;
-}
+var FALLBACK_NATIVE_COMMAND_HELPERS = {
+  available: false,
+  listNativeCommandSpecsForConfig: () => [],
+  listSkillCommandsForAgents: () => []
+};
+var FALLBACK_PLUGIN_COMMAND_SPECS = {
+  available: false,
+  specs: []
+};
 function normalizeDynamicCommandName(raw) {
   const trimmed = raw.trim().toLowerCase();
   const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
@@ -39090,41 +39957,42 @@ function shouldSyncInlineNativeSkills(cfg) {
   const effective = inlineNativeSkillsSetting ?? cfg.commands?.nativeSkills ?? "auto";
   return effective !== false;
 }
-function buildInlineNativeCommandsForConfig(cfg) {
-  const listNativeCommandSpecsForConfig = getPluginSdkFunction("listNativeCommandSpecsForConfig");
-  const listSkillCommandsForAgents = getPluginSdkFunction("listSkillCommandsForAgents");
-  const getPluginCommandSpecs = getPluginSdkFunction("getPluginCommandSpecs");
-  if (!listNativeCommandSpecsForConfig) {
-    const commands2 = [...INLINE_BASE_NATIVE_COMMANDS];
-    if (cfg.commands?.config === true) {
-      commands2.push({ command: "config", description: "Show or set config values." });
-    }
-    if (cfg.commands?.debug === true) {
-      commands2.push({ command: "debug", description: "Set runtime debug overrides." });
-    }
-    return commands2;
+async function buildInlineNativeCommandsForConfig(params) {
+  const commands = [...INLINE_BASE_NATIVE_COMMANDS];
+  if (params.cfg.commands?.config === true) {
+    commands.push({ command: "config", description: "Show or set config values." });
+  }
+  if (params.cfg.commands?.debug === true) {
+    commands.push({ command: "debug", description: "Set runtime debug overrides." });
   }
-  const skillCommands = shouldSyncInlineNativeSkills(cfg) && listSkillCommandsForAgents ? listSkillCommandsForAgents({ cfg }) : [];
-  const nativeSpecs = listNativeCommandSpecsForConfig(cfg, { skillCommands });
-  const pluginSpecs = getPluginCommandSpecs?.() ?? [];
-  const commands = [];
+  const { listNativeCommandSpecsForConfig, listSkillCommandsForAgents } = params.nativeHelpers;
+  const skillCommands = shouldSyncInlineNativeSkills(params.cfg) ? listSkillCommandsForAgents({ cfg: params.cfg }) : [];
+  const nativeSpecs = listNativeCommandSpecsForConfig(params.cfg, { skillCommands });
+  const { specs: pluginSpecs } = params.pluginSpecs;
   const seen = new Set;
+  const resolved = [];
+  for (const base of commands) {
+    appendUniqueCommand(resolved, seen, base.command, base.description);
+  }
   for (const spec of nativeSpecs) {
-    appendUniqueCommand(commands, seen, spec.name, spec.description);
+    appendUniqueCommand(resolved, seen, spec.name, spec.description);
   }
   for (const spec of pluginSpecs) {
-    appendUniqueCommand(commands, seen, spec.name, spec.description);
+    appendUniqueCommand(resolved, seen, spec.name, spec.description);
   }
-  return commands;
-}
-function isSdkNativeCommandSourceAvailable() {
-  return Boolean(getPluginSdkFunction("listNativeCommandSpecsForConfig"));
+  return resolved;
 }
 async function syncInlineNativeCommands(params) {
   const accountIds = listInlineAccountIds(params.cfg);
   const nativeEnabled = shouldSyncInlineNativeCommands(params.cfg);
-  const usingSdkSource = isSdkNativeCommandSourceAvailable();
-  const allCommands = nativeEnabled ? buildInlineNativeCommandsForConfig(params.cfg) : [];
+  const nativeHelpers = nativeEnabled ? await loadNativeCommandHelpersCompat() : FALLBACK_NATIVE_COMMAND_HELPERS;
+  const pluginSpecs = nativeEnabled ? await loadPluginCommandSpecsCompat("inline") : FALLBACK_PLUGIN_COMMAND_SPECS;
+  const usingSdkSource = nativeHelpers.available || pluginSpecs.available;
+  const allCommands = nativeEnabled ? await buildInlineNativeCommandsForConfig({
+    cfg: params.cfg,
+    nativeHelpers,
+    pluginSpecs
+  }) : [];
   const commands = allCommands.slice(0, INLINE_COMMAND_LIMIT);
   if (allCommands.length > INLINE_COMMAND_LIMIT) {
     params.logger?.warn?.(`[inline] native command sync truncating ${allCommands.length} commands to ${INLINE_COMMAND_LIMIT}`);
@@ -39215,5 +40083,5 @@ export {
   src_default as default
 };
 
-//# debugId=ECFAEB3746DF293B64756E2164756E21
+//# debugId=FEB892391BE8BCD464756E2164756E21
 //# sourceMappingURL=index.js.map