@soimy/dingtalk 3.6.10 → 3.6.11

package/dist/index.js

@@ -1035,8 +1035,238 @@ async function updateCardVariables(outTrackId, params, token, config) {
 // src/inbound-handler.ts
 import fs6 from "node:fs";
 import * as path10 from "node:path";
+import { formatInboundEnvelope } from "openclaw/plugin-sdk/channel-inbound";
 import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/reply-runtime";
-import { parseInlineDirectives } from "openclaw/plugin-sdk/text-runtime";
+
+// src/messaging/inline-directives.ts
+import { findCodeRegions, isInsideCode } from "openclaw/plugin-sdk/text-chunking";
+var AUDIO_TAG_RE = /\[\[\s*audio_as_voice\s*\]\]/gi;
+var REPLY_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:\s*([^\]\n]+))\s*\]\]/gi;
+var MAX_REPLY_DIRECTIVE_ID_LENGTH = 256;
+var BLOCK_SENTINEL_SEED = "\uE000";
+var INDENTED_CODE_LINE_RE = /(?:^|\n)((?: {4}|\t)[^\n]*)(?:\n(?: {4}|\t)[^\n]*)*/g;
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function resolveCodeRegions(text) {
+  const indentedRegions = [];
+  const indentRe = new RegExp(INDENTED_CODE_LINE_RE.source, "g");
+  let match;
+  while ((match = indentRe.exec(text)) !== null) {
+    const start = match.index + (match[0].charCodeAt(0) === 10 ? 1 : 0);
+    indentedRegions.push({ start, end: match.index + match[0].length });
+  }
+  const sdkRegions = findCodeRegions(text).filter(
+    (region) => (text[region.start] !== "`" || !isEscaped(text, region.start)) && !indentedRegions.some(
+      (indented) => region.start >= indented.start && region.start < indented.end
+    )
+  );
+  const knownRegions = mergeCodeRegions([...sdkRegions, ...indentedRegions]);
+  return mergeCodeRegions([...knownRegions, ...findDelimiterCodeRegions(text, knownRegions)]);
+}
+function isEscaped(text, offset) {
+  let slashes = 0;
+  for (let index = offset - 1; text[index] === "\\"; index--) {
+    slashes++;
+  }
+  return slashes % 2 === 1;
+}
+function isStrictlyInsideCode(offset, regions) {
+  return regions.some((region) => offset > region.start && offset < region.end);
+}
+function findDelimiterCodeRegions(text, knownRegions) {
+  const regions = [];
+  let match;
+  const fences = /^( {0,3})(`{3,}|~{3,})[^\n]*(?:\n|$)/gm;
+  let open;
+  while ((match = fences.exec(text)) !== null) {
+    const delimiter = match[2];
+    if (!open) {
+      const suffix = match[0].slice(match[1].length + delimiter.length).trim();
+      if (isStrictlyInsideCode(match.index, knownRegions) || delimiter[0] === "`" && suffix.includes("`")) {
+        continue;
+      }
+      open = { char: delimiter[0], length: delimiter.length, start: match.index };
+    } else if (delimiter[0] === open.char && delimiter.length >= open.length && match[0].slice(match[1].length + delimiter.length).trim() === "") {
+      regions.push({ start: open.start, end: fences.lastIndex });
+      open = void 0;
+    }
+  }
+  if (open) {
+    regions.push({ start: open.start, end: text.length });
+  }
+  const fencedRegions = [...regions];
+  const pendingTicks = /* @__PURE__ */ new Map();
+  const ticks = /`+/g;
+  while ((match = ticks.exec(text)) !== null) {
+    const length = match[0].length;
+    if (isEscaped(text, match.index) || isInsideCode(match.index, fencedRegions) || pendingTicks.get(length) === void 0 && isStrictlyInsideCode(match.index, knownRegions)) {
+      continue;
+    }
+    const start = pendingTicks.get(length);
+    if (start === void 0) {
+      pendingTicks.set(length, match.index);
+      continue;
+    }
+    regions.push({ start, end: ticks.lastIndex });
+    for (const [pendingLength, pendingStart] of pendingTicks) {
+      if (pendingStart >= start) {
+        pendingTicks.delete(pendingLength);
+      }
+    }
+  }
+  return regions;
+}
+function mergeCodeRegions(regions) {
+  if (regions.length <= 1) {
+    return regions;
+  }
+  const sorted = [...regions].toSorted((a, b) => a.start - b.start || a.end - b.end);
+  const merged = [];
+  for (const region of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && region.start <= last.end) {
+      last.end = Math.max(last.end, region.end);
+    } else {
+      merged.push({ start: region.start, end: region.end });
+    }
+  }
+  return merged;
+}
+function createBlockSentinel(text) {
+  let sentinel = BLOCK_SENTINEL_SEED;
+  while (text.includes(sentinel)) {
+    sentinel += BLOCK_SENTINEL_SEED;
+  }
+  return sentinel;
+}
+function normalizeDirectiveWhitespace(text, codeRegions = []) {
+  const blockSentinel = createBlockSentinel(text);
+  const blockPlaceholderRe = new RegExp(`${blockSentinel}(\\d+)${blockSentinel}`, "g");
+  const blocks = [];
+  let masked = "";
+  let cursor = 0;
+  for (const region of codeRegions) {
+    if (region.start < cursor) {
+      continue;
+    }
+    blocks.push(text.slice(region.start, region.end));
+    masked += `${text.slice(cursor, region.start)}${blockSentinel}${blocks.length - 1}${blockSentinel}`;
+    cursor = region.end;
+  }
+  masked += text.slice(cursor);
+  return masked.replace(/\r\n/g, "\n").replace(/([^\s])[ \t]{2,}([^\s])/g, "$1 $2").replace(/^\n+/, "").replace(/^[ \t](?=\S)/, "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trimEnd().replace(blockPlaceholderRe, (_full, index) => blocks[Number(index)] ?? "");
+}
+function replacementPreservesWordBoundary(source, offset, length) {
+  const before = source[offset - 1];
+  const after = source[offset + length];
+  return before && after && !/\s/u.test(before) && !/\s/u.test(after) ? " " : "";
+}
+function stripUnsafeReplyDirectiveChars(value) {
+  const chars = [];
+  for (const ch of value) {
+    const code = ch.charCodeAt(0);
+    if (code >= 0 && code <= 31 || code === 127 || code >= 128 && code <= 159 || ch === "[" || ch === "]") {
+      continue;
+    }
+    chars.push(ch);
+  }
+  return chars.join("");
+}
+function sanitizeReplyDirectiveId(rawReplyToId) {
+  const trimmed = rawReplyToId?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const sanitized = stripUnsafeReplyDirectiveChars(trimmed).trim();
+  if (!sanitized) {
+    return void 0;
+  }
+  const chars = Array.from(sanitized);
+  if (chars.length > MAX_REPLY_DIRECTIVE_ID_LENGTH) {
+    return chars.slice(0, MAX_REPLY_DIRECTIVE_ID_LENGTH).join("");
+  }
+  return sanitized;
+}
+function parseInlineDirectives(text, options = {}) {
+  const { currentMessageId, stripAudioTag = true, stripReplyTags = true } = options;
+  if (!text) {
+    return {
+      text: "",
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false
+    };
+  }
+  if (!text.includes("[[")) {
+    return {
+      text: normalizeDirectiveWhitespace(text, resolveCodeRegions(text)),
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false
+    };
+  }
+  const codeRegions = resolveCodeRegions(text);
+  let cleaned = text;
+  let audioAsVoice = false;
+  let hasAudioTag = false;
+  let hasReplyTag = false;
+  let sawCurrent = false;
+  let lastExplicitId;
+  cleaned = cleaned.replace(AUDIO_TAG_RE, (match, offset, source) => {
+    if (isInsideCode(offset, codeRegions)) {
+      return match;
+    }
+    audioAsVoice = true;
+    hasAudioTag = true;
+    return stripAudioTag ? replacementPreservesWordBoundary(source, offset, match.length) : match;
+  });
+  const codeRegionsAfterAudioStrip = resolveCodeRegions(cleaned);
+  cleaned = cleaned.replace(
+    REPLY_TAG_RE,
+    (match, idRaw, offset, source) => {
+      if (isInsideCode(offset, codeRegionsAfterAudioStrip)) {
+        return match;
+      }
+      hasReplyTag = true;
+      if (idRaw === void 0) {
+        sawCurrent = true;
+      } else {
+        const id = sanitizeReplyDirectiveId(idRaw);
+        if (id) {
+          lastExplicitId = id;
+        }
+      }
+      return stripReplyTags ? replacementPreservesWordBoundary(source, offset, match.length) : match;
+    }
+  );
+  if (!hasAudioTag && !hasReplyTag) {
+    return {
+      text,
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false
+    };
+  }
+  cleaned = normalizeDirectiveWhitespace(cleaned, resolveCodeRegions(cleaned));
+  const replyToId = lastExplicitId ?? (sawCurrent ? normalizeOptionalString(currentMessageId) : void 0);
+  return {
+    text: cleaned,
+    audioAsVoice,
+    replyToId,
+    replyToExplicitId: lastExplicitId,
+    replyToCurrent: sawCurrent,
+    hasAudioTag,
+    hasReplyTag
+  };
+}
 
 // src/access-control.ts
 function normalizeAllowFrom(list) {
@@ -12041,7 +12271,7 @@ ${attachmentExtractedText}` : inboundBody;
     }
     const groupMembers = !isDirect ? formatGroupMembers(storePath, groupId) : void 0;
     const fromLabel = isDirect ? `${senderName} (${senderId})` : `${groupName} - ${senderName}`;
-    const body = rt.channel.reply.formatInboundEnvelope({
+    const body = formatInboundEnvelope({
       channel: "DingTalk",
       from: fromLabel,
       timestamp: data.createAt,

package/dist/src/docs-service.d.ts

@@ -3,9 +3,9 @@ export declare class DocCreateAppendError extends Error {
     readonly doc: DocInfo;
     constructor(doc: DocInfo, cause?: unknown);
 }
-export declare function createDoc(config: DingTalkConfig, spaceId: string, title: string, content?: string, log?: import("openclaw/plugin-sdk/channel-runtime").ChannelLogSink | undefined, parentId?: string): Promise<DocInfo>;
-export declare function appendToDoc(config: DingTalkConfig, docId: string, content: string, log?: import("openclaw/plugin-sdk/channel-runtime").ChannelLogSink | undefined, index?: number): Promise<{
+export declare function createDoc(config: DingTalkConfig, spaceId: string, title: string, content?: string, log?: import("openclaw/plugin-sdk/channel-contract").ChannelLogSink | undefined, parentId?: string): Promise<DocInfo>;
+export declare function appendToDoc(config: DingTalkConfig, docId: string, content: string, log?: import("openclaw/plugin-sdk/channel-contract").ChannelLogSink | undefined, index?: number): Promise<{
     success: true;
 }>;
-export declare function searchDocs(config: DingTalkConfig, keyword: string, spaceId?: string, log?: import("openclaw/plugin-sdk/channel-runtime").ChannelLogSink | undefined): Promise<DocInfo[]>;
-export declare function listDocs(config: DingTalkConfig, spaceId: string, parentId?: string, log?: import("openclaw/plugin-sdk/channel-runtime").ChannelLogSink | undefined): Promise<DocInfo[]>;
+export declare function searchDocs(config: DingTalkConfig, keyword: string, spaceId?: string, log?: import("openclaw/plugin-sdk/channel-contract").ChannelLogSink | undefined): Promise<DocInfo[]>;
+export declare function listDocs(config: DingTalkConfig, spaceId: string, parentId?: string, log?: import("openclaw/plugin-sdk/channel-contract").ChannelLogSink | undefined): Promise<DocInfo[]>;

package/dist/src/messaging/inline-directives.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Inline directive parsing (local implementation).
+ *
+ * OpenClaw retired the `openclaw/plugin-sdk/text-runtime` subpath in
+ * 2026.8.x (docs/plugins/sdk-migration.md: "The August 15 compatibility
+ * subpaths ... `text-runtime` ... were retired early"). Its replacement
+ * `openclaw/plugin-sdk/text-chunking` only re-exports the directive-tag
+ * *stripping* helpers and the `InlineDirectiveParseResult` type - not
+ * `parseInlineDirectives` itself.
+ *
+ * This module reproduces the previous host behaviour inside the plugin so no
+ * removed SDK internals are imported. Code-region awareness (fenced,
+ * indented, and inline code) is sourced from the public SDK helpers
+ * `findCodeRegions` / `isInsideCode` (available since 2026.7.1-2), plus a
+ * lenient indented-block fallback matching the host whitespace normalizer so
+ * directives inside code are never treated as real voice/reply commands.
+ *
+ * The shipped 2026.7.1-2 SDK `findCodeRegions` is a simplified heuristic: it
+ * pairs backtick runs of different lengths, lets shorter fences close longer
+ * ones, treats escaped backticks as real delimiters, and pairs backticks
+ * inside indented code with prose. `findDelimiterCodeRegions` therefore layers
+ * a CommonMark-style fence/inline-code supplement over the SDK regions (union,
+ * conservative: in doubt the text stays literal) so protection holds on every
+ * supported host. Ponytail: remove the supplement once the minimum host is
+ * 2026.8+ and its SDK regions are verified to cover these cases.
+ */
+export type ParseInlineDirectivesOptions = {
+    currentMessageId?: string;
+    stripAudioTag?: boolean;
+    stripReplyTags?: boolean;
+};
+export type InlineDirectiveParseResult = {
+    text: string;
+    audioAsVoice: boolean;
+    replyToId?: string;
+    replyToExplicitId?: string;
+    replyToCurrent: boolean;
+    hasAudioTag: boolean;
+    hasReplyTag: boolean;
+};
+export declare function sanitizeReplyDirectiveId(rawReplyToId: string | undefined): string | undefined;
+export declare function parseInlineDirectives(text: string | undefined, options?: ParseInlineDirectivesOptions): InlineDirectiveParseResult;

package/dist/src/types.d.ts

@@ -8,7 +8,7 @@
  * - Media files and streams
  * - Session and token management
  */
-import type { ChannelAccountSnapshot as SDKChannelAccountSnapshot, ChannelGatewayContext as SDKChannelGatewayContext, ChannelLogSink as SDKChannelLogSink } from "openclaw/plugin-sdk/channel-runtime";
+import type { ChannelAccountSnapshot as SDKChannelAccountSnapshot, ChannelGatewayContext as SDKChannelGatewayContext, ChannelLogSink as SDKChannelLogSink } from "openclaw/plugin-sdk/channel-contract";
 import type { ChannelPlugin as SDKChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
 import type { SecretInput } from "./secret-input";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.6.10",
+  "version": "3.6.11",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",

package/src/inbound-handler.ts

@@ -1,7 +1,8 @@
 import fs from "node:fs";
 import * as path from "node:path";
+import { formatInboundEnvelope } from "openclaw/plugin-sdk/channel-inbound";
 import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/reply-runtime";
-import { parseInlineDirectives } from "openclaw/plugin-sdk/text-runtime";
+import { parseInlineDirectives } from "./messaging/inline-directives";
 import { normalizeAllowFrom, isSenderAllowed, resolveGroupAccess } from "./access-control";
 import { classifyAckReactionEmoji } from "./ack-reaction-classifier";
 import { attachNativeAckReaction } from "./ack-reaction-service";
@@ -1792,7 +1793,10 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     const groupMembers = !isDirect ? formatGroupMembers(storePath, groupId) : undefined;
 
     const fromLabel = isDirect ? `${senderName} (${senderId})` : `${groupName} - ${senderName}`;
-    const body = rt.channel.reply.formatInboundEnvelope({
+    // `rt.channel.reply.formatInboundEnvelope` was removed from the runtime
+    // facade in OpenClaw 2026.8.x; the helper is still exported from the
+    // `channel-inbound` SDK subpath.
+    const body = formatInboundEnvelope({
       channel: "DingTalk",
       from: fromLabel,
       timestamp: data.createAt,

package/src/messaging/inline-directives.ts

@@ -0,0 +1,342 @@
+/**
+ * Inline directive parsing (local implementation).
+ *
+ * OpenClaw retired the `openclaw/plugin-sdk/text-runtime` subpath in
+ * 2026.8.x (docs/plugins/sdk-migration.md: "The August 15 compatibility
+ * subpaths ... `text-runtime` ... were retired early"). Its replacement
+ * `openclaw/plugin-sdk/text-chunking` only re-exports the directive-tag
+ * *stripping* helpers and the `InlineDirectiveParseResult` type - not
+ * `parseInlineDirectives` itself.
+ *
+ * This module reproduces the previous host behaviour inside the plugin so no
+ * removed SDK internals are imported. Code-region awareness (fenced,
+ * indented, and inline code) is sourced from the public SDK helpers
+ * `findCodeRegions` / `isInsideCode` (available since 2026.7.1-2), plus a
+ * lenient indented-block fallback matching the host whitespace normalizer so
+ * directives inside code are never treated as real voice/reply commands.
+ *
+ * The shipped 2026.7.1-2 SDK `findCodeRegions` is a simplified heuristic: it
+ * pairs backtick runs of different lengths, lets shorter fences close longer
+ * ones, treats escaped backticks as real delimiters, and pairs backticks
+ * inside indented code with prose. `findDelimiterCodeRegions` therefore layers
+ * a CommonMark-style fence/inline-code supplement over the SDK regions (union,
+ * conservative: in doubt the text stays literal) so protection holds on every
+ * supported host. Ponytail: remove the supplement once the minimum host is
+ * 2026.8+ and its SDK regions are verified to cover these cases.
+ */
+
+import { findCodeRegions, isInsideCode, type CodeRegion } from "openclaw/plugin-sdk/text-chunking";
+
+const AUDIO_TAG_RE = /\[\[\s*audio_as_voice\s*\]\]/gi;
+const REPLY_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:\s*([^\]\n]+))\s*\]\]/gi;
+const MAX_REPLY_DIRECTIVE_ID_LENGTH = 256;
+const BLOCK_SENTINEL_SEED = "\uE000";
+/** Lenient indented-code-block lines (4 spaces or tab), same rule as the host whitespace normalizer. */
+const INDENTED_CODE_LINE_RE = /(?:^|\n)((?: {4}|\t)[^\n]*)(?:\n(?: {4}|\t)[^\n]*)*/g;
+
+export type ParseInlineDirectivesOptions = {
+  currentMessageId?: string;
+  stripAudioTag?: boolean;
+  stripReplyTags?: boolean;
+};
+
+export type InlineDirectiveParseResult = {
+  text: string;
+  audioAsVoice: boolean;
+  replyToId?: string;
+  replyToExplicitId?: string;
+  replyToCurrent: boolean;
+  hasAudioTag: boolean;
+  hasReplyTag: boolean;
+};
+
+function normalizeOptionalString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+/**
+ * CommonMark code regions (fenced / indented / inline) from the SDK, extended
+ * with a lenient indented-block fallback for lines indented by 4 spaces or a
+ * tab that follow a paragraph without a blank separator (the host normalizer
+ * protects those too).
+ */
+function resolveCodeRegions(text: string): CodeRegion[] {
+  const indentedRegions: CodeRegion[] = [];
+  const indentRe = new RegExp(INDENTED_CODE_LINE_RE.source, "g");
+  let match: RegExpExecArray | null;
+  while ((match = indentRe.exec(text)) !== null) {
+    const start = match.index + (match[0].charCodeAt(0) === 10 ? 1 : 0);
+    indentedRegions.push({ start, end: match.index + match[0].length });
+  }
+  const sdkRegions = findCodeRegions(text).filter(
+    (region) =>
+      (text[region.start] !== "`" || !isEscaped(text, region.start)) &&
+      !indentedRegions.some(
+        (indented) => region.start >= indented.start && region.start < indented.end,
+      ),
+  );
+  const knownRegions = mergeCodeRegions([...sdkRegions, ...indentedRegions]);
+  return mergeCodeRegions([...knownRegions, ...findDelimiterCodeRegions(text, knownRegions)]);
+}
+
+function isEscaped(text: string, offset: number): boolean {
+  let slashes = 0;
+  for (let index = offset - 1; text[index] === "\\"; index--) {
+    slashes++;
+  }
+  return slashes % 2 === 1;
+}
+
+function isStrictlyInsideCode(offset: number, regions: CodeRegion[]): boolean {
+  return regions.some((region) => offset > region.start && offset < region.end);
+}
+
+// ponytail: small 2026.7.x delimiter supplement; delete when the minimum host is 2026.8+.
+function findDelimiterCodeRegions(text: string, knownRegions: CodeRegion[]): CodeRegion[] {
+  const regions: CodeRegion[] = [];
+  let match: RegExpExecArray | null;
+  const fences = /^( {0,3})(`{3,}|~{3,})[^\n]*(?:\n|$)/gm;
+  let open: { char: string; length: number; start: number } | undefined;
+  while ((match = fences.exec(text)) !== null) {
+    const delimiter = match[2];
+    if (!open) {
+      const suffix = match[0].slice(match[1].length + delimiter.length).trim();
+      if (
+        isStrictlyInsideCode(match.index, knownRegions) ||
+        (delimiter[0] === "`" && suffix.includes("`"))
+      ) {
+        continue;
+      }
+      open = { char: delimiter[0], length: delimiter.length, start: match.index };
+    } else if (
+      delimiter[0] === open.char &&
+      delimiter.length >= open.length &&
+      match[0].slice(match[1].length + delimiter.length).trim() === ""
+    ) {
+      regions.push({ start: open.start, end: fences.lastIndex });
+      open = undefined;
+    }
+  }
+  if (open) {
+    regions.push({ start: open.start, end: text.length });
+  }
+
+  const fencedRegions = [...regions];
+  const pendingTicks = new Map<number, number>();
+  const ticks = /`+/g;
+  while ((match = ticks.exec(text)) !== null) {
+    const length = match[0].length;
+    if (
+      isEscaped(text, match.index) ||
+      isInsideCode(match.index, fencedRegions) ||
+      (pendingTicks.get(length) === undefined && isStrictlyInsideCode(match.index, knownRegions))
+    ) {
+      continue;
+    }
+    const start = pendingTicks.get(length);
+    if (start === undefined) {
+      pendingTicks.set(length, match.index);
+      continue;
+    }
+    regions.push({ start, end: ticks.lastIndex });
+    for (const [pendingLength, pendingStart] of pendingTicks) {
+      if (pendingStart >= start) {
+        pendingTicks.delete(pendingLength);
+      }
+    }
+  }
+  return regions;
+}
+
+function mergeCodeRegions(regions: CodeRegion[]): CodeRegion[] {
+  if (regions.length <= 1) {
+    return regions;
+  }
+  const sorted = [...regions].toSorted((a, b) => a.start - b.start || a.end - b.end);
+  const merged: CodeRegion[] = [];
+  for (const region of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && region.start <= last.end) {
+      last.end = Math.max(last.end, region.end);
+    } else {
+      merged.push({ start: region.start, end: region.end });
+    }
+  }
+  return merged;
+}
+
+function createBlockSentinel(text: string): string {
+  let sentinel = BLOCK_SENTINEL_SEED;
+  while (text.includes(sentinel)) {
+    sentinel += BLOCK_SENTINEL_SEED;
+  }
+  return sentinel;
+}
+
+function normalizeDirectiveWhitespace(text: string, codeRegions: CodeRegion[] = []): string {
+  const blockSentinel = createBlockSentinel(text);
+  const blockPlaceholderRe = new RegExp(`${blockSentinel}(\\d+)${blockSentinel}`, "g");
+  const blocks: string[] = [];
+
+  let masked = "";
+  let cursor = 0;
+  for (const region of codeRegions) {
+    if (region.start < cursor) {
+      continue;
+    }
+    blocks.push(text.slice(region.start, region.end));
+    masked += `${text.slice(cursor, region.start)}${blockSentinel}${blocks.length - 1}${blockSentinel}`;
+    cursor = region.end;
+  }
+  masked += text.slice(cursor);
+
+  return masked
+    .replace(/\r\n/g, "\n")
+    .replace(/([^\s])[ \t]{2,}([^\s])/g, "$1 $2")
+    .replace(/^\n+/, "")
+    .replace(/^[ \t](?=\S)/, "")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trimEnd()
+    .replace(blockPlaceholderRe, (_full, index: string) => blocks[Number(index)] ?? "");
+}
+
+function replacementPreservesWordBoundary(source: string, offset: number, length: number): string {
+  const before = source[offset - 1];
+  const after = source[offset + length];
+  return before && after && !/\s/u.test(before) && !/\s/u.test(after) ? " " : "";
+}
+
+function stripUnsafeReplyDirectiveChars(value: string): string {
+  const chars: string[] = [];
+  for (const ch of value) {
+    const code = ch.charCodeAt(0);
+    if (
+      (code >= 0 && code <= 31) ||
+      code === 127 ||
+      (code >= 128 && code <= 159) ||
+      ch === "[" ||
+      ch === "]"
+    ) {
+      continue;
+    }
+    chars.push(ch);
+  }
+  return chars.join("");
+}
+
+export function sanitizeReplyDirectiveId(rawReplyToId: string | undefined): string | undefined {
+  const trimmed = rawReplyToId?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const sanitized = stripUnsafeReplyDirectiveChars(trimmed).trim();
+  if (!sanitized) {
+    return undefined;
+  }
+  const chars = Array.from(sanitized);
+  if (chars.length > MAX_REPLY_DIRECTIVE_ID_LENGTH) {
+    return chars.slice(0, MAX_REPLY_DIRECTIVE_ID_LENGTH).join("");
+  }
+  return sanitized;
+}
+
+export function parseInlineDirectives(
+  text: string | undefined,
+  options: ParseInlineDirectivesOptions = {},
+): InlineDirectiveParseResult {
+  const { currentMessageId, stripAudioTag = true, stripReplyTags = true } = options;
+
+  if (!text) {
+    return {
+      text: "",
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false,
+    };
+  }
+
+  if (!text.includes("[[")) {
+    return {
+      text: normalizeDirectiveWhitespace(text, resolveCodeRegions(text)),
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false,
+    };
+  }
+
+  // Directives inside code regions are literal text: never voice/reply semantics.
+  // Stripping a tag shortens the string, so every pass re-derives regions from
+  // the text it actually runs against; offsets from an earlier pass are stale
+  // once a preceding tag has been removed.
+  const codeRegions = resolveCodeRegions(text);
+  let cleaned = text;
+  let audioAsVoice = false;
+  let hasAudioTag = false;
+  let hasReplyTag = false;
+  let sawCurrent = false;
+  let lastExplicitId: string | undefined;
+
+  cleaned = cleaned.replace(AUDIO_TAG_RE, (match: string, offset: number, source: string) => {
+    if (isInsideCode(offset, codeRegions)) {
+      return match;
+    }
+    audioAsVoice = true;
+    hasAudioTag = true;
+    return stripAudioTag ? replacementPreservesWordBoundary(source, offset, match.length) : match;
+  });
+  const codeRegionsAfterAudioStrip = resolveCodeRegions(cleaned);
+
+  cleaned = cleaned.replace(
+    REPLY_TAG_RE,
+    (match: string, idRaw: string | undefined, offset: number, source: string) => {
+      if (isInsideCode(offset, codeRegionsAfterAudioStrip)) {
+        return match;
+      }
+      hasReplyTag = true;
+      if (idRaw === undefined) {
+        sawCurrent = true;
+      } else {
+        const id = sanitizeReplyDirectiveId(idRaw);
+        if (id) {
+          lastExplicitId = id;
+        }
+      }
+      return stripReplyTags
+        ? replacementPreservesWordBoundary(source, offset, match.length)
+        : match;
+    },
+  );
+
+  // Early return when `[[...]]` matched no known directive: keep the original
+  // text untouched instead of running whitespace normalization.
+  if (!hasAudioTag && !hasReplyTag) {
+    return {
+      text,
+      audioAsVoice: false,
+      replyToCurrent: false,
+      hasAudioTag: false,
+      hasReplyTag: false,
+    };
+  }
+
+  cleaned = normalizeDirectiveWhitespace(cleaned, resolveCodeRegions(cleaned));
+  const replyToId =
+    lastExplicitId ?? (sawCurrent ? normalizeOptionalString(currentMessageId) : undefined);
+
+  return {
+    text: cleaned,
+    audioAsVoice,
+    replyToId,
+    replyToExplicitId: lastExplicitId,
+    replyToCurrent: sawCurrent,
+    hasAudioTag,
+    hasReplyTag,
+  };
+}

package/src/types.ts

@@ -13,7 +13,7 @@ import type {
   ChannelAccountSnapshot as SDKChannelAccountSnapshot,
   ChannelGatewayContext as SDKChannelGatewayContext,
   ChannelLogSink as SDKChannelLogSink,
-} from "openclaw/plugin-sdk/channel-runtime";
+} from "openclaw/plugin-sdk/channel-contract";
 import type { ChannelPlugin as SDKChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
 import type { SecretInput } from "./secret-input";