@soimy/dingtalk 3.5.2 → 3.5.3

package/src/targeting/agent-routing.ts

@@ -14,11 +14,20 @@ import { resolveRobotCode } from "../config";
 import { parseLearnCommand } from "../learning-command-service";
 import { getDingTalkRuntime } from "../runtime";
 import { sendBySession } from "../send-service";
+import { getErrorMessage } from "../utils";
 import type { AgentNameMatch, DingTalkConfig, DingTalkInboundMessage, HandleDingTalkMessageParams, Logger, MessageContent } from "../types";
 
+export class HostRoutingHelperUnavailableError extends Error {
+  constructor(message = "DingTalk sub-agent routing requires runtime.channel.routing.buildAgentSessionKey from the host runtime.") {
+    super(message);
+    this.name = "HostRoutingHelperUnavailableError";
+  }
+}
+
 /**
  * Build a session key for a specific agent using the runtime API.
- * Falls back to framework's resolveAgentRoute if buildAgentSessionKey is unavailable.
+ * On supported host versions, sub-agent routing must use the shared helper
+ * instead of synthesizing plugin-local fallback keys.
  */
 export function buildAgentSessionKey(params: {
   rt: ReturnType<typeof getDingTalkRuntime>;
@@ -30,31 +39,19 @@ export function buildAgentSessionKey(params: {
 }): string {
   const { rt, cfg, accountId, agentId, peerKind, peerId } = params;
   const routing = rt.channel.routing as Record<string, unknown>;
-  if (typeof routing.buildAgentSessionKey === "function") {
-    return (
-      (routing.buildAgentSessionKey as (p: unknown) => string)({
-        agentId,
-        channel: "dingtalk",
-        accountId,
-        peer: { kind: peerKind, id: peerId },
-        dmScope: cfg.session?.dmScope,
-        identityLinks: cfg.session?.identityLinks,
-      })
-    ).toLowerCase();
+  if (typeof routing.buildAgentSessionKey !== "function") {
+    throw new HostRoutingHelperUnavailableError();
   }
-  // Fallback: derive a session key with agentId suffix to ensure isolation.
-  // resolveAgentRoute routes to the default agent, so we append the target
-  // agentId to prevent session key collisions between sub-agents.
-  // @migration-note: When SDK exposes buildAgentSessionKey in type definitions,
-  // sessions created via this fallback path will become orphaned. Remove this
-  // fallback and the typeof check once the SDK is updated.
-  const fallbackRoute = rt.channel.routing.resolveAgentRoute({
-    cfg,
-    channel: "dingtalk",
-    accountId,
-    peer: { kind: peerKind, id: peerId },
-  });
-  return `${fallbackRoute.sessionKey}:subagent:${agentId}`;
+  return (
+    (routing.buildAgentSessionKey as (p: unknown) => string)({
+      agentId,
+      channel: "dingtalk",
+      accountId,
+      peer: { kind: peerKind, id: peerId },
+      dmScope: cfg.session?.dmScope,
+      identityLinks: cfg.session?.identityLinks,
+    })
+  ).toLowerCase();
 }
 
 /**
@@ -131,8 +128,8 @@ export async function resolveSubAgentRoute(params: {
       await sendBySession(dingtalkConfig, sessionWebhook, `⚠️ ${fallbackReason}`, {
         ...sendOptions,
       });
-    } catch (err: any) {
-      log?.debug?.(`[DingTalk] Failed to send fallback notice: ${err.message}`);
+    } catch (err: unknown) {
+      log?.debug?.(`[DingTalk] Failed to send fallback notice: ${getErrorMessage(err)}`);
     }
   }
 
@@ -168,6 +165,7 @@ export async function dispatchSubAgents(params: {
       preDownloadedMedia = { mediaPath: media.path, mediaType: media.mimeType };
     }
   }
+  let helperMissingWarningSent = false;
 
   for (const agentMatch of matchedAgents) {
     try {
@@ -186,9 +184,27 @@ export async function dispatchSubAgents(params: {
         preDownloadedMedia,
       });
     } catch (error) {
+      const message = getErrorMessage(error);
       log?.error?.(
-        `[DingTalk] Sub-agent ${agentMatch.agentId} failed: ${error instanceof Error ? error.message : String(error)}`,
+        `[DingTalk] Sub-agent ${agentMatch.agentId} failed: ${message}`,
       );
+      if (error instanceof HostRoutingHelperUnavailableError && !helperMissingWarningSent) {
+        helperMissingWarningSent = true;
+        try {
+          const isGroup = data.conversationType !== "1";
+          const sendOptions = isGroup ? { atUserId: data.senderId, log } : { log };
+          await sendBySession(
+            dingtalkConfig,
+            sessionWebhook,
+            "⚠️ 当前宿主版本不支持 DingTalk 子助手路由所需的 session helper，请升级 OpenClaw 后重试。",
+            sendOptions,
+          );
+        } catch (notifyError: unknown) {
+          log?.debug?.(
+            `[DingTalk] Failed to send sub-agent helper-missing notice: ${getErrorMessage(notifyError)}`,
+          );
+        }
+      }
     }
   }
 }

package/src/types.ts

@@ -25,6 +25,8 @@ export type AckReactionMode = "off" | "emoji" | "kaomoji";
 // Accept arbitrary strings for backward compatibility; the recommended
 // explicit modes remain: "off" | "emoji" | "kaomoji".
 export type AckReactionConfigValue = string;
+export type CardStreamingMode = "off" | "answer" | "all";
+export type ContextVisibilityMode = "all" | "allowlist" | "allowlist_quote";
 
 /**
  * DingTalk channel configuration (extends base OpenClaw config)
@@ -39,6 +41,7 @@ export interface DingTalkConfig extends OpenClawConfig {
   allowFrom?: string[];
   groupAllowFrom?: string[];
   displayNameResolution?: "disabled" | "all";
+  contextVisibility?: ContextVisibilityMode;
   mediaUrlAllowlist?: string[];
   journalTTLDays?: number;
   ackReaction?: AckReactionConfigValue;
@@ -71,8 +74,15 @@ export interface DingTalkConfig extends OpenClawConfig {
     enabled?: boolean;
     cooldownHours?: number;
   };
-  /** Enable real-time card streaming (default false, true = 300ms throttled per-token updates) */
+  /** Card streaming mode.
+   *  - off: disable incremental streaming
+   *  - answer: stream answer text
+   *  - all: stream answer + reasoning text */
+  cardStreamingMode?: CardStreamingMode;
+  /** @deprecated Use `cardStreamingMode` instead. */
   cardRealTimeStream?: boolean;
+  /** Throttle interval in ms for card stream updates (default 1000) */
+  cardStreamInterval?: number;
   /** AICard degrade duration in milliseconds after trigger errors (default 30m) */
   aicardDegradeMs?: number;
   /** Enable local learning loop (events/reflections/session notes/global rules) */
@@ -100,6 +110,7 @@ export interface DingTalkChannelConfig {
   allowFrom?: string[];
   groupAllowFrom?: string[];
   displayNameResolution?: "disabled" | "all";
+  contextVisibility?: ContextVisibilityMode;
   mediaUrlAllowlist?: string[];
   journalTTLDays?: number;
   ackReaction?: AckReactionConfigValue;
@@ -131,8 +142,15 @@ export interface DingTalkChannelConfig {
     enabled?: boolean;
     cooldownHours?: number;
   };
-  /** Enable real-time card streaming (default false, true = 300ms throttled per-token updates) */
+  /** Card streaming mode.
+   *  - off: disable incremental streaming
+   *  - answer: stream answer text
+   *  - all: stream answer + reasoning text */
+  cardStreamingMode?: CardStreamingMode;
+  /** @deprecated Use `cardStreamingMode` instead. */
   cardRealTimeStream?: boolean;
+  /** Throttle interval in ms for card stream updates (default 1000) */
+  cardStreamInterval?: number;
   /** AICard degrade duration in milliseconds after trigger errors (default 30m) */
   aicardDegradeMs?: number;
   /** Enable local learning loop (events/reflections/session notes/global rules) */
@@ -234,6 +252,10 @@ export interface DingTalkInboundMessage {
           atName?: string;
           downloadCode?: string;
         }>;
+        /** chatRecord 消息摘要 */
+        summary?: string;
+        /** chatRecord 消息标题 */
+        title?: string;
       };
     };
   };
@@ -243,6 +265,8 @@ export interface DingTalkInboundMessage {
     recognition?: string;
     spaceId?: string;
     fileId?: string;
+    text?: string;
+    title?: string;
     biz_custom_action_url?: string;
     richText?: Array<{
       type: string;
@@ -712,6 +736,33 @@ export interface ConnectionAttemptResult {
 
 const DEFAULT_ACCOUNT_ID = "default";
 
+function stripRemovedLegacyFieldsFromPublicAccount(
+  config: DingTalkConfig,
+): DingTalkConfig {
+  const {
+    cardStreamReasoning: _cardStreamReasoning,
+    verboseRealtimeStream: _verboseRealtimeStream,
+    accounts,
+    ...rest
+  } = config as DingTalkConfig & {
+    cardStreamReasoning?: unknown;
+    verboseRealtimeStream?: unknown;
+    accounts?: Record<string, DingTalkConfig | undefined>;
+  };
+  const sanitizedAccounts = accounts
+    ? Object.fromEntries(
+        Object.entries(accounts).map(([accountId, accountConfig]) => [
+          accountId,
+          accountConfig ? stripRemovedLegacyFieldsFromPublicAccount(accountConfig) : accountConfig,
+        ]),
+      )
+    : undefined;
+  if (sanitizedAccounts) {
+    return { ...rest, accounts: sanitizedAccounts } as DingTalkConfig;
+  }
+  return rest as DingTalkConfig;
+}
+
 /**
  * List all DingTalk account IDs from config
  */
@@ -756,7 +807,7 @@ export function resolveDingTalkAccount(
 
   // If default account, return top-level config
   if (id === DEFAULT_ACCOUNT_ID) {
-    const config: DingTalkConfig = {
+    const rawConfig: DingTalkConfig = {
       clientId: dingtalk?.clientId ?? "",
       clientSecret: dingtalk?.clientSecret ?? "",
       name: dingtalk?.name,
@@ -766,6 +817,7 @@ export function resolveDingTalkAccount(
       allowFrom: dingtalk?.allowFrom,
       groupAllowFrom: dingtalk?.groupAllowFrom,
       displayNameResolution: dingtalk?.displayNameResolution,
+      contextVisibility: dingtalk?.contextVisibility,
       journalTTLDays: dingtalk?.journalTTLDays,
       ackReaction: dingtalk?.ackReaction,
       debug: dingtalk?.debug,
@@ -785,7 +837,9 @@ export function resolveDingTalkAccount(
       keepAlive: dingtalk?.keepAlive,
       bypassProxyForSend: dingtalk?.bypassProxyForSend,
       proactivePermissionHint: dingtalk?.proactivePermissionHint,
+      cardStreamingMode: dingtalk?.cardStreamingMode,
       cardRealTimeStream: dingtalk?.cardRealTimeStream,
+      cardStreamInterval: dingtalk?.cardStreamInterval,
       aicardDegradeMs: dingtalk?.aicardDegradeMs,
       learningEnabled: dingtalk?.learningEnabled,
       learningAutoApply: dingtalk?.learningAutoApply,
@@ -793,6 +847,7 @@ export function resolveDingTalkAccount(
       convertMarkdownTables: dingtalk?.convertMarkdownTables,
       cardAtSender: dingtalk?.cardAtSender,
     };
+    const config = stripRemovedLegacyFieldsFromPublicAccount(rawConfig);
     return {
       ...config,
       accountId: id,
@@ -807,8 +862,9 @@ export function resolveDingTalkAccount(
       dingtalk as DingTalkConfig,
       accountConfig,
     );
+    const publicMerged = stripRemovedLegacyFieldsFromPublicAccount(merged);
     return {
-      ...merged,
+      ...publicMerged,
       accountId: id,
       configured: Boolean(merged.clientId && merged.clientSecret),
     };

package/src/utils.ts

@@ -224,6 +224,31 @@ export function stringifyUnknown(value: unknown): string {
   }
 }
 
+export function parseBooleanLike(value: unknown): boolean | undefined {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+    return undefined;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "y", "on"].includes(normalized)) {
+      return true;
+    }
+    if (["0", "false", "no", "n", "off"].includes(normalized)) {
+      return false;
+    }
+  }
+  return undefined;
+}
+
 export function getErrorMessage(err: unknown): string {
   if (err instanceof Error && err.message) {
     return err.message;