@nextclaw/openclaw-compat 0.3.27 → 0.3.29

package/dist/index.d.ts

@@ -329,6 +329,15 @@ type PluginRuntime = {
         loadConfig: () => Record<string, unknown>;
         writeConfigFile: (next: Record<string, unknown>) => Promise<void>;
     };
+    logging: {
+        shouldLogVerbose: () => boolean;
+    };
+    media: {
+        detectMime: (params: {
+            buffer: Buffer;
+        }) => Promise<string | undefined>;
+        loadWebMedia: (url: string, options?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    };
     tools: {
         createMemorySearchTool: (params: {
             config?: Config;
@@ -340,9 +349,70 @@ type PluginRuntime = {
         }) => OpenClawPluginTool | null;
     };
     channel: {
+        media: {
+            fetchRemoteMedia: (params: {
+                url: string;
+                maxBytes?: number;
+            }) => Promise<Record<string, unknown>>;
+            saveMediaBuffer: (buffer: Buffer, contentType?: string, direction?: string, maxBytes?: number, fileName?: string) => Promise<{
+                path: string;
+                contentType?: string;
+            }>;
+        };
+        text: {
+            chunkMarkdownText: (text: string, limit: number) => string[];
+            resolveMarkdownTableMode: (params: Record<string, unknown>) => unknown;
+            convertMarkdownTables: (text: string, mode?: unknown) => string;
+            resolveTextChunkLimit: (cfg: Config, channel: string, accountId?: string, options?: Record<string, unknown>) => number;
+            resolveChunkMode: (cfg: Config, channel: string, accountId?: string) => string;
+            chunkTextWithMode: (text: string, limit: number, mode?: unknown) => string[];
+            hasControlCommand: (text: string, cfg?: Config) => boolean;
+        };
         reply: {
+            resolveEnvelopeFormatOptions: (cfg: Config) => Record<string, unknown>;
+            formatAgentEnvelope: (params: Record<string, unknown>) => string;
+            finalizeInboundContext: (params: Record<string, unknown>) => Record<string, unknown>;
+            withReplyDispatcher: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+            dispatchReplyFromConfig: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+            createReplyDispatcherWithTyping: (params: Record<string, unknown>) => {
+                dispatcher: {
+                    sendToolResult: (payload: Record<string, unknown>) => boolean;
+                    sendBlockReply: (payload: Record<string, unknown>) => boolean;
+                    sendFinalReply: (payload: Record<string, unknown>) => boolean;
+                    waitForIdle: () => Promise<void>;
+                    getQueuedCounts: () => Record<string, number>;
+                    markComplete: () => void;
+                };
+                replyOptions: Record<string, unknown>;
+                markDispatchIdle: () => void;
+            };
+            resolveHumanDelayConfig: (cfg: Config, agentId: string) => unknown;
             dispatchReplyWithBufferedBlockDispatcher: (params: PluginReplyDispatchParams) => Promise<void>;
         };
+        routing: {
+            resolveAgentRoute: (params: Record<string, unknown>) => Record<string, unknown>;
+        };
+        pairing: {
+            readAllowFromStore: (params: {
+                channel: string;
+                accountId?: string;
+            }) => Promise<string[]>;
+            upsertPairingRequest: (params: Record<string, unknown>) => Promise<{
+                code: string;
+                created: boolean;
+            }>;
+        };
+        commands: {
+            shouldComputeCommandAuthorized: (text: string, cfg?: Config) => boolean;
+            resolveCommandAuthorizedFromAuthorizers: (params: Record<string, unknown>) => boolean;
+        };
+        debounce: {
+            resolveInboundDebounceMs: (params: Record<string, unknown>) => number;
+            createInboundDebouncer: <T>(params: Record<string, unknown>) => {
+                enqueue: (item: T) => Promise<void>;
+                flushKey: (key: string) => Promise<void>;
+            };
+        };
     };
 };
 type OpenClawPluginApi = {

package/dist/index.js

@@ -31,7 +31,7 @@ function buildOauthProviderAuthResult(params) {
   };
 }
 async function sleep(ms) {
-  await new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+  await new Promise((resolve2) => setTimeout(resolve2, Math.max(0, ms)));
 }
 function normalizePluginHttpPath(rawPath) {
   const trimmed = rawPath.trim();
@@ -883,7 +883,7 @@ async function ensureOpenClawExtensions(manifest) {
   return list;
 }
 async function runCommand(command, args, cwd) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const child = spawn(command, args, {
       cwd,
       env: {
@@ -902,10 +902,10 @@ async function runCommand(command, args, cwd) {
       stderr += String(chunk);
     });
     child.on("close", (code) => {
-      resolve({ code: code ?? 1, stdout, stderr });
+      resolve2({ code: code ?? 1, stdout, stderr });
     });
     child.on("error", (error) => {
-      resolve({ code: 1, stdout, stderr: `${stderr}
+      resolve2({ code: 1, stdout, stderr: `${stderr}
 ${String(error)}` });
     });
   });
@@ -1767,8 +1767,520 @@ function registerPluginNcpAgentRuntime(params) {
 }
 
 // src/plugins/runtime.ts
+import { randomUUID as randomUUID2 } from "crypto";
 import { getPackageVersion } from "@nextclaw/core";
 import { MemoryGetTool, MemorySearchTool } from "@nextclaw/core";
+
+// src/plugins/runtime-shared.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function asNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.trunc(value);
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => asString(entry)).filter((entry) => Boolean(entry));
+}
+function resolveChannelConfig(cfg, channel) {
+  const channels = asRecord(asRecord(cfg).channels);
+  return asRecord(channels[channel]);
+}
+function resolveDefaultAgentId(cfg) {
+  const agents = asRecord(cfg).agents;
+  const list = Array.isArray(asRecord(agents).list) ? asRecord(agents).list : [];
+  for (const entry of list) {
+    const agent = asRecord(entry);
+    if (agent.default === true) {
+      return asString(agent.id) ?? "main";
+    }
+  }
+  for (const entry of list) {
+    const agentId = asString(asRecord(entry).id);
+    if (agentId) {
+      return agentId;
+    }
+  }
+  return "main";
+}
+function resolveAccountId(value) {
+  return asString(value) ?? "default";
+}
+function resolvePeer(params) {
+  const peer = asRecord(params.peer);
+  return {
+    kind: asString(peer.kind) ?? "direct",
+    id: asString(peer.id) ?? "default"
+  };
+}
+function resolveSessionKey(params) {
+  return [
+    "agent",
+    params.agentId,
+    params.channel || "unknown",
+    params.accountId || "default",
+    params.peerKind || "direct",
+    params.peerId || "default"
+  ].join(":");
+}
+function splitTextIntoChunks(text, limit) {
+  const maxLength = Number.isFinite(limit) && limit > 0 ? Math.trunc(limit) : 4e3;
+  const normalized = text ?? "";
+  if (normalized.length <= maxLength) {
+    return [normalized];
+  }
+  const chunks = [];
+  let remaining = normalized;
+  while (remaining.length > maxLength) {
+    let splitAt = remaining.lastIndexOf("\n", maxLength);
+    if (splitAt <= 0 || splitAt < Math.floor(maxLength * 0.5)) {
+      splitAt = maxLength;
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
+  }
+  if (remaining.length > 0) {
+    chunks.push(remaining);
+  }
+  return chunks;
+}
+function resolveTextChunkLimit(cfg, channel, _accountId, options) {
+  const channelConfig = resolveChannelConfig(cfg, channel);
+  const explicit = asNumber(channelConfig.textChunkLimit);
+  if (explicit !== void 0 && explicit > 0) {
+    return explicit;
+  }
+  const fallback = asNumber(options?.fallbackLimit);
+  return fallback && fallback > 0 ? fallback : 4e3;
+}
+function hasControlCommand(text) {
+  const body = text?.trim() ?? "";
+  if (!body) {
+    return false;
+  }
+  if (/^(?:\/|!)[a-z0-9_-]+(?:\s|$)/i.test(body)) {
+    return true;
+  }
+  return /(?:^|\s)(?:\/|!)[a-z0-9_-]+(?:\s|$)/i.test(body);
+}
+function resolveCommandAuthorizedFromAuthorizers(params) {
+  const authorizers = Array.isArray(params.authorizers) ? params.authorizers : [];
+  const configured = authorizers.filter((entry) => asRecord(entry).configured === true);
+  if (configured.length === 0) {
+    return true;
+  }
+  return configured.some((entry) => asRecord(entry).allowed === true);
+}
+function resolveAgentRoute(params) {
+  const cfg = params.cfg;
+  const channel = asString(params.channel) ?? "unknown";
+  const accountId = resolveAccountId(params.accountId);
+  const peer = resolvePeer(params);
+  const agentId = resolveDefaultAgentId(cfg);
+  const sessionKey = resolveSessionKey({
+    channel,
+    accountId,
+    agentId,
+    peerKind: peer.kind,
+    peerId: peer.id
+  });
+  return {
+    agentId,
+    accountId,
+    channel,
+    sessionKey,
+    mainSessionKey: sessionKey,
+    lastRoutePolicy: "main",
+    matchedBy: "default"
+  };
+}
+
+// src/plugins/runtime-debounce.ts
+function resolveInboundDebounceMs(params) {
+  const cfg = asRecord(params.cfg);
+  const inbound = asRecord(asRecord(cfg.messages).inbound);
+  const override = asNumber(params.overrideMs);
+  const byChannel = asRecord(inbound.byChannel);
+  const channelOverride = asNumber(byChannel[asString(params.channel) ?? ""]);
+  const base = asNumber(inbound.debounceMs);
+  return Math.max(0, override ?? channelOverride ?? base ?? 0);
+}
+function createInboundDebouncer(params) {
+  const buffers = /* @__PURE__ */ new Map();
+  const defaultDebounceMs = Math.max(0, Math.trunc(params.debounceMs ?? 0));
+  const flushBuffer = async (key, buffer) => {
+    buffers.delete(key);
+    if (buffer.timeout) {
+      clearTimeout(buffer.timeout);
+      buffer.timeout = null;
+    }
+    if (buffer.items.length === 0 || !params.onFlush) {
+      return;
+    }
+    try {
+      await params.onFlush(buffer.items);
+    } catch (error) {
+      params.onError?.(error, buffer.items);
+    }
+  };
+  const flushKey = async (key) => {
+    const buffer = buffers.get(key);
+    if (!buffer) {
+      return;
+    }
+    await flushBuffer(key, buffer);
+  };
+  const scheduleFlush = (key, buffer) => {
+    if (buffer.timeout) {
+      clearTimeout(buffer.timeout);
+    }
+    buffer.timeout = setTimeout(() => {
+      void flushBuffer(key, buffer);
+    }, buffer.debounceMs);
+    buffer.timeout.unref?.();
+  };
+  const enqueue = async (item) => {
+    const key = params.buildKey?.(item);
+    const resolvedDebounceMs = params.resolveDebounceMs?.(item);
+    const debounceMs = typeof resolvedDebounceMs === "number" && Number.isFinite(resolvedDebounceMs) ? Math.max(0, Math.trunc(resolvedDebounceMs)) : defaultDebounceMs;
+    const canDebounce = debounceMs > 0 && (params.shouldDebounce?.(item) ?? true);
+    if (!key || !canDebounce) {
+      if (key && buffers.has(key)) {
+        await flushKey(key);
+      }
+      if (!params.onFlush) {
+        return;
+      }
+      try {
+        await params.onFlush([item]);
+      } catch (error) {
+        params.onError?.(error, [item]);
+      }
+      return;
+    }
+    const existing = buffers.get(key);
+    if (existing) {
+      existing.items.push(item);
+      existing.debounceMs = debounceMs;
+      scheduleFlush(key, existing);
+      return;
+    }
+    const buffer = {
+      items: [item],
+      timeout: null,
+      debounceMs
+    };
+    buffers.set(key, buffer);
+    scheduleFlush(key, buffer);
+  };
+  return { enqueue, flushKey };
+}
+
+// src/plugins/runtime-reply.ts
+function normalizeTextField(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  return value.replace(/\r\n/g, "\n").trim() || void 0;
+}
+function countMediaEntries(ctx) {
+  const paths = Array.isArray(ctx.MediaPaths) ? ctx.MediaPaths.length : 0;
+  const urls = Array.isArray(ctx.MediaUrls) ? ctx.MediaUrls.length : 0;
+  const single = ctx.MediaPath || ctx.MediaUrl ? 1 : 0;
+  return Math.max(paths, urls, single);
+}
+function resolveEnvelopeFormatOptions(_cfg) {
+  return {
+    includeTimestamp: true,
+    includeElapsed: true
+  };
+}
+function formatAgentEnvelope(params) {
+  const channel = typeof params.channel === "string" && params.channel.trim() ? params.channel.trim() : "Channel";
+  const from = typeof params.from === "string" && params.from.trim() ? params.from.trim() : void 0;
+  const body = typeof params.body === "string" ? params.body : "";
+  const timestamp = params.timestamp instanceof Date ? params.timestamp : void 0;
+  const parts = [channel];
+  if (from) {
+    parts.push(from);
+  }
+  if (timestamp) {
+    parts.push(timestamp.toISOString());
+  }
+  return `[${parts.join(" ")}] ${body}`.trim();
+}
+function finalizeInboundContext(params) {
+  const ctx = { ...params };
+  const body = normalizeTextField(ctx.Body) ?? "";
+  const rawBody = normalizeTextField(ctx.RawBody);
+  const commandBody = normalizeTextField(ctx.CommandBody);
+  ctx.Body = body;
+  ctx.RawBody = rawBody;
+  ctx.CommandBody = commandBody;
+  ctx.BodyForAgent = normalizeTextField(ctx.BodyForAgent) ?? commandBody ?? rawBody ?? body;
+  ctx.BodyForCommands = normalizeTextField(ctx.BodyForCommands) ?? commandBody ?? rawBody ?? body;
+  ctx.CommandAuthorized = ctx.CommandAuthorized === true;
+  const mediaCount = countMediaEntries(ctx);
+  if (mediaCount > 0) {
+    const mediaTypes = readStringArray(ctx.MediaTypes);
+    const fallbackType = typeof ctx.MediaType === "string" && ctx.MediaType.trim() ? ctx.MediaType.trim() : "application/octet-stream";
+    const padded = mediaTypes.slice();
+    while (padded.length < mediaCount) {
+      padded.push(fallbackType);
+    }
+    ctx.MediaTypes = padded;
+    ctx.MediaType = padded[0] ?? fallbackType;
+  }
+  return ctx;
+}
+function createReplyDispatcher(options) {
+  let chain = Promise.resolve();
+  let pending = 1;
+  let completeCalled = false;
+  const counts = {
+    tool: 0,
+    block: 0,
+    final: 0
+  };
+  const enqueue = (kind, payload) => {
+    counts[kind] += 1;
+    pending += 1;
+    chain = chain.then(async () => {
+      await options.deliver(payload, { kind });
+    }).catch((error) => {
+      options.onError?.(error, { kind });
+    }).finally(() => {
+      pending -= 1;
+      if (pending === 1 && completeCalled) {
+        pending -= 1;
+      }
+      if (pending === 0) {
+        options.onIdle?.();
+      }
+    });
+    return true;
+  };
+  const markComplete = () => {
+    if (completeCalled) {
+      return;
+    }
+    completeCalled = true;
+    void Promise.resolve().then(() => {
+      if (pending === 1) {
+        pending -= 1;
+        if (pending === 0) {
+          options.onIdle?.();
+        }
+      }
+    });
+  };
+  return {
+    sendToolResult: (payload) => enqueue("tool", payload),
+    sendBlockReply: (payload) => enqueue("block", payload),
+    sendFinalReply: (payload) => enqueue("final", payload),
+    waitForIdle: () => chain,
+    getQueuedCounts: () => ({ ...counts }),
+    markComplete
+  };
+}
+function createReplyDispatcherWithTyping(options) {
+  const dispatcher = createReplyDispatcher({
+    deliver: options.deliver,
+    onError: options.onError,
+    onIdle: options.onIdle
+  });
+  return {
+    dispatcher,
+    replyOptions: {
+      onReplyStart: options.onReplyStart
+    },
+    markDispatchIdle: () => {
+      options.onIdle?.();
+    }
+  };
+}
+async function withReplyDispatcher(params) {
+  try {
+    return await params.run();
+  } finally {
+    params.dispatcher.markComplete();
+    try {
+      await params.dispatcher.waitForIdle();
+    } finally {
+      await params.onSettled?.();
+    }
+  }
+}
+async function dispatchReplyFromConfig(params) {
+  const finalized = finalizeInboundContext(params.ctx);
+  let queuedFinal = false;
+  await params.bridgeDispatch({
+    ctx: finalized,
+    cfg: params.cfg,
+    dispatcherOptions: {
+      deliver: async (payload, info) => {
+        if (info.kind === "tool") {
+          params.dispatcher.sendToolResult(payload);
+          return;
+        }
+        if (info.kind === "block") {
+          params.dispatcher.sendBlockReply(payload);
+          return;
+        }
+        queuedFinal = params.dispatcher.sendFinalReply(payload);
+      },
+      onError: () => void 0,
+      ...params.replyOptions ?? {}
+    }
+  });
+  return {
+    queuedFinal,
+    counts: params.dispatcher.getQueuedCounts()
+  };
+}
+function resolveHumanDelayConfig(_cfg, _agentId) {
+  return void 0;
+}
+
+// src/plugins/runtime-media.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { tmpdir } from "os";
+import { basename, extname, isAbsolute, resolve } from "path";
+function detectMimeFromBuffer(buffer) {
+  if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
+    return "image/jpeg";
+  }
+  if (buffer.length >= 6 && buffer.subarray(0, 6).toString("ascii") === "GIF87a") {
+    return "image/gif";
+  }
+  if (buffer.length >= 6 && buffer.subarray(0, 6).toString("ascii") === "GIF89a") {
+    return "image/gif";
+  }
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  if (buffer.length >= 4 && buffer.subarray(0, 4).toString("ascii") === "%PDF") {
+    return "application/pdf";
+  }
+  if (buffer.length >= 12 && buffer.subarray(4, 8).toString("ascii") === "ftyp") {
+    return "video/mp4";
+  }
+  return void 0;
+}
+function mimeToExtension(contentType, fileName) {
+  const byName = extname(fileName ?? "").trim();
+  if (byName) {
+    return byName;
+  }
+  switch (contentType) {
+    case "image/png":
+      return ".png";
+    case "image/jpeg":
+      return ".jpg";
+    case "image/gif":
+      return ".gif";
+    case "image/webp":
+      return ".webp";
+    case "application/pdf":
+      return ".pdf";
+    case "video/mp4":
+      return ".mp4";
+    default:
+      return ".bin";
+  }
+}
+async function saveMediaBuffer(buffer, contentType, direction, maxBytes, fileName) {
+  if (typeof maxBytes === "number" && Number.isFinite(maxBytes) && buffer.length > maxBytes) {
+    throw new Error(`media exceeds maxBytes (${buffer.length} > ${maxBytes})`);
+  }
+  const detectedContentType = contentType ?? detectMimeFromBuffer(buffer) ?? "application/octet-stream";
+  const targetDir = resolve(tmpdir(), "nextclaw-media", direction ?? "shared");
+  await mkdir(targetDir, { recursive: true });
+  const targetPath = resolve(
+    targetDir,
+    `${randomUUID()}${mimeToExtension(detectedContentType, fileName)}`
+  );
+  await writeFile(targetPath, buffer);
+  return {
+    path: targetPath,
+    contentType: detectedContentType
+  };
+}
+async function fetchRemoteMedia(params) {
+  const response = await fetch(params.url);
+  if (!response.ok) {
+    throw new Error(`failed to fetch media: ${response.status} ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  if (typeof params.maxBytes === "number" && Number.isFinite(params.maxBytes) && buffer.length > params.maxBytes) {
+    throw new Error(`media exceeds maxBytes (${buffer.length} > ${params.maxBytes})`);
+  }
+  return {
+    buffer,
+    contentType: asString(response.headers.get("content-type")) ?? detectMimeFromBuffer(buffer),
+    fileName: basename(new URL(params.url).pathname) || "file"
+  };
+}
+function isRemoteUrl(value) {
+  return /^https?:\/\//i.test(value);
+}
+function assertAllowedLocalPath(filePath, localRoots) {
+  if (localRoots.length === 0) {
+    return;
+  }
+  const resolvedPath = resolve(filePath);
+  const allowed = localRoots.some((root) => {
+    const resolvedRoot = resolve(root);
+    return resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}/`);
+  });
+  if (!allowed) {
+    throw new Error(`local media path is outside allowed roots: ${resolvedPath}`);
+  }
+}
+async function loadWebMedia(url, options) {
+  if (isRemoteUrl(url)) {
+    return fetchRemoteMedia({
+      url,
+      maxBytes: asNumber(options?.maxBytes)
+    });
+  }
+  const localRoots = readStringArray(options?.localRoots);
+  const candidate = isAbsolute(url) ? url : resolve(url);
+  if (!existsSync(candidate)) {
+    throw new Error(`local media file not found: ${candidate}`);
+  }
+  assertAllowedLocalPath(candidate, localRoots);
+  const buffer = await readFile(candidate);
+  const maxBytes = asNumber(options?.maxBytes);
+  if (typeof maxBytes === "number" && buffer.length > maxBytes) {
+    throw new Error(`media exceeds maxBytes (${buffer.length} > ${maxBytes})`);
+  }
+  return {
+    buffer,
+    fileName: basename(candidate),
+    contentType: detectMimeFromBuffer(buffer)
+  };
+}
+
+// src/plugins/runtime.ts
 var bridge = {};
 function setPluginRuntimeBridge(next) {
   bridge = next ?? {};
@@ -1806,13 +2318,83 @@ function createPluginRuntime(params) {
       loadConfig: () => loadConfigWithFallback(params.config),
       writeConfigFile: async (next) => writeConfigWithFallback(next)
     },
+    logging: {
+      shouldLogVerbose: () => false
+    },
+    media: {
+      detectMime: async ({ buffer }) => detectMimeFromBuffer(buffer),
+      loadWebMedia: async (url, options) => loadWebMedia(url, options)
+    },
     tools: {
       createMemorySearchTool: () => toPluginTool(new MemorySearchTool(params.workspace)),
       createMemoryGetTool: () => toPluginTool(new MemoryGetTool(params.workspace))
     },
     channel: {
+      media: {
+        fetchRemoteMedia: async (input) => fetchRemoteMedia({
+          url: asString(input.url) ?? "",
+          maxBytes: asNumber(input.maxBytes)
+        }),
+        saveMediaBuffer: async (buffer, contentType, direction, maxBytes, fileName) => saveMediaBuffer(buffer, contentType, direction, maxBytes, fileName)
+      },
+      text: {
+        chunkMarkdownText: (text, limit) => splitTextIntoChunks(text, limit),
+        resolveMarkdownTableMode: () => "preserve",
+        convertMarkdownTables: (text) => text,
+        resolveTextChunkLimit,
+        resolveChunkMode: () => "length",
+        chunkTextWithMode: (text, limit) => splitTextIntoChunks(text, limit),
+        hasControlCommand: (text) => hasControlCommand(text)
+      },
       reply: {
+        resolveEnvelopeFormatOptions,
+        formatAgentEnvelope,
+        finalizeInboundContext,
+        withReplyDispatcher: async (input) => withReplyDispatcher({
+          dispatcher: input.dispatcher,
+          run: input.run,
+          onSettled: typeof input.onSettled === "function" ? input.onSettled : void 0
+        }),
+        dispatchReplyFromConfig: async (input) => dispatchReplyFromConfig({
+          ctx: asRecord(input.ctx),
+          cfg: input.cfg,
+          dispatcher: input.dispatcher,
+          bridgeDispatch: dispatchReplyWithFallback,
+          replyOptions: asRecord(input.replyOptions)
+        }),
+        createReplyDispatcherWithTyping: (input) => createReplyDispatcherWithTyping({
+          deliver: input.deliver,
+          onError: typeof input.onError === "function" ? input.onError : void 0,
+          onIdle: typeof input.onIdle === "function" ? input.onIdle : void 0,
+          onReplyStart: typeof input.onReplyStart === "function" ? input.onReplyStart : void 0
+        }),
+        resolveHumanDelayConfig,
         dispatchReplyWithBufferedBlockDispatcher: async (dispatchParams) => dispatchReplyWithFallback(dispatchParams)
+      },
+      routing: {
+        resolveAgentRoute
+      },
+      pairing: {
+        readAllowFromStore: async () => [],
+        upsertPairingRequest: async () => ({
+          code: randomUUID2().replace(/-/g, "").slice(0, 8).toUpperCase(),
+          created: true
+        })
+      },
+      commands: {
+        shouldComputeCommandAuthorized: (text) => hasControlCommand(text),
+        resolveCommandAuthorizedFromAuthorizers
+      },
+      debounce: {
+        resolveInboundDebounceMs,
+        createInboundDebouncer: (input) => createInboundDebouncer({
+          debounceMs: asNumber(input.debounceMs),
+          buildKey: typeof input.buildKey === "function" ? input.buildKey : void 0,
+          shouldDebounce: typeof input.shouldDebounce === "function" ? input.shouldDebounce : void 0,
+          resolveDebounceMs: typeof input.resolveDebounceMs === "function" ? input.resolveDebounceMs : void 0,
+          onFlush: typeof input.onFlush === "function" ? input.onFlush : void 0,
+          onError: typeof input.onError === "function" ? input.onError : void 0
+        })
       }
     }
   };
@@ -2686,7 +3268,7 @@ function buildPluginStatusReport(params) {
 
 // src/plugins/uninstall.ts
 import fs8 from "fs/promises";
-import { existsSync, statSync } from "fs";
+import { existsSync as existsSync2, statSync } from "fs";
 import path9 from "path";
 import { getWorkspacePathFromConfig as getWorkspacePathFromConfig3 } from "@nextclaw/core";
 function isLinkedPathInstall(record) {
@@ -2827,7 +3409,7 @@ function matchesPluginLoadPath(rawPath, pluginId) {
     return false;
   }
   const resolvedPath = path9.resolve(normalizedPath);
-  if (!existsSync(resolvedPath)) {
+  if (!existsSync2(resolvedPath)) {
     return false;
   }
   const candidateRoot = (() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/openclaw-compat",
-  "version": "0.3.27",
+  "version": "0.3.29",
   "private": false,
   "description": "OpenClaw plugin compatibility layer for NextClaw.",
   "type": "module",
@@ -19,21 +19,21 @@
     "jiti": "^1.21.7",
     "jszip": "^3.10.1",
     "tar": "^7.4.3",
-    "@nextclaw/channel-plugin-dingtalk": "0.2.15",
-    "@nextclaw/channel-plugin-discord": "0.2.15",
-    "@nextclaw/channel-plugin-mochat": "0.2.15",
-    "@nextclaw/channel-plugin-email": "0.2.15",
-    "@nextclaw/channel-plugin-slack": "0.2.15",
-    "@nextclaw/channel-plugin-qq": "0.2.15",
-    "@nextclaw/channel-plugin-telegram": "0.2.15",
-    "@nextclaw/channel-plugin-whatsapp": "0.2.15",
-    "@nextclaw/channel-plugin-weixin": "0.1.9",
-    "@nextclaw/core": "0.11.1",
-    "@nextclaw/channel-plugin-wecom": "0.2.15",
-    "@nextclaw/channel-runtime": "0.4.1",
-    "@nextclaw/ncp": "0.3.2",
+    "@nextclaw/channel-plugin-email": "0.2.16",
+    "@nextclaw/channel-plugin-dingtalk": "0.2.16",
+    "@nextclaw/channel-plugin-slack": "0.2.16",
+    "@nextclaw/channel-plugin-mochat": "0.2.16",
+    "@nextclaw/channel-plugin-feishu": "0.2.19",
+    "@nextclaw/channel-plugin-discord": "0.2.16",
+    "@nextclaw/channel-plugin-qq": "0.2.16",
+    "@nextclaw/channel-plugin-wecom": "0.2.16",
     "@nextclaw/ncp-toolkit": "0.4.2",
-    "@nextclaw/channel-plugin-feishu": "0.2.19"
+    "@nextclaw/channel-runtime": "0.4.2",
+    "@nextclaw/ncp": "0.3.2",
+    "@nextclaw/channel-plugin-telegram": "0.2.16",
+    "@nextclaw/channel-plugin-weixin": "0.1.9",
+    "@nextclaw/channel-plugin-whatsapp": "0.2.16",
+    "@nextclaw/core": "0.11.1"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",