@soimy/dingtalk 3.5.2 → 3.6.0

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

@@ -19,12 +19,13 @@ import type {
   ChannelLogSink as SDKChannelLogSink,
 } from "openclaw/plugin-sdk/channel-runtime";
 import type { ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
-import { mergeAccountWithDefaults } from "./config";
 
 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 +40,7 @@ export interface DingTalkConfig extends OpenClawConfig {
   allowFrom?: string[];
   groupAllowFrom?: string[];
   displayNameResolution?: "disabled" | "all";
+  contextVisibility?: ContextVisibilityMode;
   mediaUrlAllowlist?: string[];
   journalTTLDays?: number;
   ackReaction?: AckReactionConfigValue;
@@ -71,8 +73,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) */
@@ -85,6 +94,15 @@ export interface DingTalkConfig extends OpenClawConfig {
   convertMarkdownTables?: boolean;
   /** @mention the sender after card finalization in group chats; value is the message text */
   cardAtSender?: string;
+  /** Status line visibility toggles for the AI card footer */
+  cardStatusLine?: {
+    model?: boolean;
+    effort?: boolean;
+    agent?: boolean;
+    taskTime?: boolean;
+    tokens?: boolean;
+    dapiUsage?: boolean;
+  };
 }
 
 /**
@@ -100,6 +118,7 @@ export interface DingTalkChannelConfig {
   allowFrom?: string[];
   groupAllowFrom?: string[];
   displayNameResolution?: "disabled" | "all";
+  contextVisibility?: ContextVisibilityMode;
   mediaUrlAllowlist?: string[];
   journalTTLDays?: number;
   ackReaction?: AckReactionConfigValue;
@@ -131,8 +150,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 +260,10 @@ export interface DingTalkInboundMessage {
           atName?: string;
           downloadCode?: string;
         }>;
+        /** chatRecord 消息摘要 */
+        summary?: string;
+        /** chatRecord 消息标题 */
+        title?: string;
       };
     };
   };
@@ -243,6 +273,8 @@ export interface DingTalkInboundMessage {
     recognition?: string;
     spaceId?: string;
     fileId?: string;
+    text?: string;
+    title?: string;
     biz_custom_action_url?: string;
     richText?: Array<{
       type: string;
@@ -646,8 +678,11 @@ export interface AICardInstance {
   lastUpdated: number;
   state: AICardState; // Current card state: PROCESSING, INPUTING, FINISHED, STOPPED, FAILED
   config?: DingTalkConfig; // Store config reference for token refresh
-  lastStreamedContent?: string;
+  lastStreamedContent?: string; // Latest copy/content text shown to user
+  lastBlockListJson?: string; // Latest rendered CardBlock[] JSON for V2 instances API
   outTrackId?: string;
+  /** Cumulative DingTalk API call count for this card instance. */
+  dapiUsage?: number;
 }
 
 /**
@@ -707,118 +742,15 @@ export interface ConnectionAttemptResult {
   error?: Error;
   nextDelay?: number;
 }
-
-// ============ Onboarding Helper Functions ============
-
-const DEFAULT_ACCOUNT_ID = "default";
-
-/**
- * List all DingTalk account IDs from config
- */
-export function listDingTalkAccountIds(cfg: OpenClawConfig): string[] {
-  const dingtalk = cfg.channels?.dingtalk as DingTalkChannelConfig | undefined;
-  if (!dingtalk) {
-    return [];
-  }
-
-  const accountIds: string[] = [];
-
-  // Check for direct configuration (default account)
-  if (dingtalk.clientId || dingtalk.clientSecret) {
-    accountIds.push(DEFAULT_ACCOUNT_ID);
-  }
-
-  // Check accounts object
-  if (dingtalk.accounts) {
-    accountIds.push(...Object.keys(dingtalk.accounts));
-  }
-
-  return accountIds;
-}
-
 /**
- * Resolved DingTalk account with configuration status
+ * CardBlock types for AI Card v2 blockList.
+ * - 0 = answer (markdown text)
+ * - 1 = thinking process
+ * - 2 = tool result
+ * - 3 = image (uploaded mediaId)
  */
-export interface ResolvedDingTalkAccount extends DingTalkConfig {
-  accountId: string;
-  configured: boolean;
-}
-
-/**
- * Resolve a specific DingTalk account configuration
- */
-export function resolveDingTalkAccount(
-  cfg: OpenClawConfig,
-  accountId?: string | null,
-): ResolvedDingTalkAccount {
-  const id = accountId || DEFAULT_ACCOUNT_ID;
-  const dingtalk = cfg.channels?.dingtalk as DingTalkChannelConfig | undefined;
-
-  // If default account, return top-level config
-  if (id === DEFAULT_ACCOUNT_ID) {
-    const config: DingTalkConfig = {
-      clientId: dingtalk?.clientId ?? "",
-      clientSecret: dingtalk?.clientSecret ?? "",
-      name: dingtalk?.name,
-      enabled: dingtalk?.enabled,
-      dmPolicy: dingtalk?.dmPolicy,
-      groupPolicy: dingtalk?.groupPolicy,
-      allowFrom: dingtalk?.allowFrom,
-      groupAllowFrom: dingtalk?.groupAllowFrom,
-      displayNameResolution: dingtalk?.displayNameResolution,
-      journalTTLDays: dingtalk?.journalTTLDays,
-      ackReaction: dingtalk?.ackReaction,
-      debug: dingtalk?.debug,
-      messageType: dingtalk?.messageType,
-      cardTemplateId: dingtalk?.cardTemplateId,
-      cardTemplateKey: dingtalk?.cardTemplateKey,
-      groups: dingtalk?.groups,
-      accounts: dingtalk?.accounts,
-      maxConnectionAttempts: dingtalk?.maxConnectionAttempts,
-      initialReconnectDelay: dingtalk?.initialReconnectDelay,
-      maxReconnectDelay: dingtalk?.maxReconnectDelay,
-      reconnectJitter: dingtalk?.reconnectJitter,
-      maxReconnectCycles: dingtalk?.maxReconnectCycles,
-      reconnectDeadlineMs: dingtalk?.reconnectDeadlineMs,
-      useConnectionManager: dingtalk?.useConnectionManager,
-      mediaMaxMb: dingtalk?.mediaMaxMb,
-      keepAlive: dingtalk?.keepAlive,
-      bypassProxyForSend: dingtalk?.bypassProxyForSend,
-      proactivePermissionHint: dingtalk?.proactivePermissionHint,
-      cardRealTimeStream: dingtalk?.cardRealTimeStream,
-      aicardDegradeMs: dingtalk?.aicardDegradeMs,
-      learningEnabled: dingtalk?.learningEnabled,
-      learningAutoApply: dingtalk?.learningAutoApply,
-      learningNoteTtlMs: dingtalk?.learningNoteTtlMs,
-      convertMarkdownTables: dingtalk?.convertMarkdownTables,
-      cardAtSender: dingtalk?.cardAtSender,
-    };
-    return {
-      ...config,
-      accountId: id,
-      configured: Boolean(config.clientId && config.clientSecret),
-    };
-  }
-
-  // If named account, merge channel-level defaults with account-level overrides
-  const accountConfig = dingtalk?.accounts?.[id];
-  if (accountConfig) {
-    const merged = mergeAccountWithDefaults(
-      dingtalk as DingTalkConfig,
-      accountConfig,
-    );
-    return {
-      ...merged,
-      accountId: id,
-      configured: Boolean(merged.clientId && merged.clientSecret),
-    };
-  }
-
-  // Account doesn't exist, return empty config
-  return {
-    clientId: "",
-    clientSecret: "",
-    accountId: id,
-    configured: false,
-  };
-}
+export type CardBlock =
+  | { type: 0; markdown: string }
+  | { type: 1; markdown: string }
+  | { type: 2; markdown: string }
+  | { type: 3; mediaId: string; text?: string };

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;