@inline-openclaw/inline 0.0.21 → 0.0.22

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(),
@@ -33577,7 +33797,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) {
@@ -33683,17 +33902,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 +34177,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 +34296,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 +34344,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 +34422,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 +34444,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 +35034,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;
@@ -34939,12 +35389,46 @@ 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 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 +35519,7 @@ async function resolveInlineInboundMedia(params) {
   }
   return out;
 }
-async function buildHistoryContext(params) {
+async function buildHistoryContext2(params) {
   const cachedReplyToBot = params.replyToMsgId != null && hasBotMessageId(params.botMessageIdsByChat, params.chatId, params.replyToMsgId);
   let repliedToBot = cachedReplyToBot;
   let replyToSenderId = null;
@@ -35043,6 +35527,7 @@ async function buildHistoryContext(params) {
   const lines = [];
   const attachmentLines = [];
   const entityLines = [];
+  const inboundHistory = [];
   if (params.historyLimit > 0) {
     const messages = await loadChatHistoryMessages({
       client: params.client,
@@ -35079,6 +35564,12 @@ async function buildHistoryContext(params) {
           meId: params.meId,
           senderProfilesById: params.senderProfilesById
         });
+        inboundHistory.push({
+          sender: label,
+          body: text,
+          ...item.date != null ? { timestamp: Number(item.date) * 1000 } : {},
+          messageId: String(item.id)
+        });
         const replySuffix = item.replyToMsgId != null ? ` ->${String(item.replyToMsgId)}` : "";
         lines.push(`#${String(item.id)}${replySuffix} ${label}: ${text}`);
         const attachmentText = normalizeHistoryText(content.attachmentText);
@@ -35115,6 +35606,7 @@ async function buildHistoryContext(params) {
 `) : null,
       entityText: entityLines.length ? entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
 `) : null,
+      inboundHistory,
       repliedToBot,
       replyToSenderId
     };
@@ -35129,6 +35621,7 @@ ${attachmentLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
     entityText: entityLines.length ? `Recent message entities:
 ${entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
 `)}` : null,
+    inboundHistory,
     repliedToBot,
     replyToSenderId
   };
@@ -35477,7 +35970,7 @@ ${JSON.stringify(payload)}`;
             }
           }
         }
-        if (commandGate.shouldBlock) {
+        if (isGroup && commandGate.shouldBlock) {
           logInboundDrop({
             log: (m) => runtime2.log?.(m),
             channel: CHANNEL_ID,
@@ -35506,11 +35999,12 @@ ${JSON.stringify(payload)}`;
         const groupHistoryKey = isGroup ? 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,7 +36015,14 @@ ${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 requireMention = isGroup ? resolveInlineGroupRequireMention({
@@ -35630,6 +36131,16 @@ ${currentEntityText}` : null
             })
           });
         }
+        const inboundHistory = isGroup && groupHistoryKey ? mergeInboundHistoryEntries({
+          historyContextEntries: historyContext.inboundHistory,
+          pendingEntries: groupPendingHistories.get(groupHistoryKey) ?? [],
+          limit: historyLimit
+        }) : [];
+        const bodyForAgent = buildInlineBodyForAgent({
+          rawBody,
+          currentAttachmentText,
+          currentEntityText
+        });
         const effectiveSurface = shouldUseTelegramSurfaceForModelCommands(normalizedCommandBody) ? "telegram" : CHANNEL_ID;
         const systemPrompt = resolveInlineSystemPrompt({
           account,
@@ -35637,6 +36148,8 @@ ${currentEntityText}` : null
         });
         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}`,
@@ -35683,20 +36196,27 @@ ${currentEntityText}` : null
           } : {},
           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;
@@ -35774,7 +36294,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] : [];
@@ -35935,15 +36455,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(" ");
@@ -36575,6 +37086,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 +37145,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() : "";
@@ -37809,7 +38353,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 {
@@ -38074,7 +38618,7 @@ var inlineChannelPlugin = {
   },
   status: {
     defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID2,
+      accountId: DEFAULT_ACCOUNT_ID,
       running: false,
       lastStartAt: null,
       lastStopAt: null,
@@ -38159,9 +38703,6 @@ var inlineChannelPlugin = {
 };
 
 // src/inline/message-tools.ts
-import {
-  jsonResult as jsonResult2
-} from "openclaw/plugin-sdk";
 var InlineNudgeToolParameters = {
   type: "object",
   additionalProperties: false,
@@ -38473,7 +39014,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 +39068,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 +39154,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 +39205,7 @@ function createInlineMembersTool(ctx) {
             userId,
             limit
           });
-          return jsonResult3({
+          return jsonResult2({
             ok: true,
             accountId: resolvedAccountId,
             spaceId: String(spaceId),
@@ -38680,10 +39221,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 +39247,7 @@ var InlineProfileToolParameters = {
     }
   }
 };
-function jsonResult4(payload) {
+function jsonResult3(payload) {
   return {
     content: [
       {
@@ -38747,9 +39284,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 +39351,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 +39367,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 +39537,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 +39554,7 @@ function createInlineBotCommandsTool(ctx) {
           method: "POST",
           body: { commands }
         });
-        return jsonResult5({
+        return jsonResult({
           ok: true,
           action,
           accountId: account.accountId,
@@ -39019,7 +39568,7 @@ function createInlineBotCommandsTool(ctx) {
         methodName: "deleteMyCommands",
         method: "POST"
       });
-      return jsonResult5({
+      return jsonResult({
         ok: true,
         action,
         accountId: account.accountId
@@ -39029,7 +39578,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 +39607,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 +39641,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 +39767,5 @@ export {
   src_default as default
 };
 
-//# debugId=ECFAEB3746DF293B64756E2164756E21
+//# debugId=7535F56BE481336764756E2164756E21
 //# sourceMappingURL=index.js.map