@soimy/dingtalk 3.6.10 → 3.7.0

package/dist/src/platform/runtime-events.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Cross-domain runtime agent-event infrastructure.
+ *
+ * Owns the generic OpenClaw `events.onAgentEvent` surface that several
+ * domains consume: event typing, reference-counted fan-out, field accessors,
+ * and run correlation. Domain owners (ack reactions, AI card task progress)
+ * build their own behavior on top of these primitives instead of importing
+ * each other's private modules.
+ */
+export type RuntimeEventsLogger = {
+    debug?: (msg: string) => void;
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+};
+export type RuntimeAgentEvent = {
+    stream?: string;
+    runId?: string;
+    sessionKey?: string;
+    data?: {
+        phase?: string;
+        name?: string;
+        args?: unknown;
+        runId?: string;
+        sessionKey?: string;
+        toolCallId?: string;
+        meta?: {
+            runId?: string;
+            sessionKey?: string;
+        } | null;
+    };
+};
+export type RuntimeEventsSurface = {
+    onAgentEvent?: (listener: (event: unknown) => void) => () => void;
+};
+/**
+ * Fan one upstream `onAgentEvent` subscription out to multiple local consumers.
+ *
+ * The upstream subscription is reference-counted: it is created with the first
+ * local listener and released with the last one. Each listener is isolated so a
+ * throwing consumer can neither starve the remaining consumers nor bubble back
+ * into the host event emitter.
+ */
+export declare function createRuntimeEventsFanout(upstream: RuntimeEventsSurface | undefined, options?: {
+    log?: RuntimeEventsLogger;
+}): RuntimeEventsSurface;
+export declare function getEventRunId(event: RuntimeAgentEvent | undefined): string | undefined;
+export declare function getEventSessionKey(event: RuntimeAgentEvent | undefined): string | undefined;
+export declare function describeEvent(event: RuntimeAgentEvent | undefined): string;
+/**
+ * Build a predicate that decides whether an agent event belongs to one reply.
+ *
+ * Correlation prefers an already captured `runId`; otherwise it accepts events
+ * whose `sessionKey` matches, and finally falls back to optimistically
+ * capturing the first session-less lifecycle start inside a short window.
+ *
+ * `consumer` labels the debug logs so two consumers sharing the same session
+ * (ack reactions and card task progress) stay distinguishable while triaging.
+ */
+export declare function createAgentEventCorrelator(params: {
+    /** Short label identifying the consuming domain in debug logs. */
+    consumer: string;
+    sessionKey: string;
+    enabled: boolean;
+    createdAt: number;
+    optimisticCaptureWindowMs: number;
+    log?: RuntimeEventsLogger;
+}): (event: RuntimeAgentEvent | undefined) => boolean;

package/dist/src/{types.d.ts → platform/types.d.ts}

@@ -8,14 +8,39 @@
  * - 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";
 export type AckReactionMode = "off" | "emoji" | "kaomoji";
 export type AckReactionConfigValue = string;
 export type CardStreamingMode = "off" | "answer" | "all";
+/** How tool-driven task-progress changes reach the card:
+ *  - `heartbeat` (default): coalesced into the 30s progress heartbeat
+ *  - `interval`: pushed on every correlated tool event, throttled by `cardStreamInterval` */
+export type CardTaskProgressRefresh = "heartbeat" | "interval";
 export type ContextVisibilityMode = "all" | "allowlist" | "allowlist_quote";
+/**
+ * Gateway RPC capability configuration (Issue #608, 问题 3).
+ * Aligns with the official connector's `tools: { docs, media }` gate shape.
+ * All capabilities default to enabled for backward compatibility.
+ */
+export interface DingTalkGatewayCapabilitiesConfig {
+    tools?: {
+        /** Enable `dingtalk.docs.*` and `dingtalk-connector.docs.*` Gateway RPCs (default: true) */
+        docs?: boolean;
+        /** Enable proactive-send Gateway RPCs: `dingtalk-connector.sendToUser/sendToGroup/send` (default: true) */
+        proactiveSend?: boolean;
+    };
+    /** Optional doc-space allowlist; when set, docs RPCs only accept these `spaceId` values */
+    docs?: {
+        allowedSpaceIds?: string[];
+    };
+    /** Optional proactive-send target allowlist; entries must be `user:*` or `group:*` */
+    send?: {
+        allowedTargets?: string[];
+    };
+}
 /**
  * DingTalk channel configuration (extends base OpenClaw config)
  */
@@ -70,10 +95,23 @@ export interface DingTalkConfig extends OpenClawConfig {
      *  - answer: stream answer text
      *  - all: stream answer + reasoning text */
     cardStreamingMode?: CardStreamingMode;
+    /** Internal derived flag, not a user-facing config key: whether
+     *  `cardStreamingMode` came from an explicit user setting instead of the
+     *  runtime default. Written by config normalization only. */
+    cardStreamingModeConfigured?: boolean;
     /** @deprecated Use `cardStreamingMode` instead. */
     cardRealTimeStream?: boolean;
     /** Throttle interval in ms for card stream updates (default 1000) */
     cardStreamInterval?: number;
+    /** Live "task in progress" block on AI cards for long-running tasks.
+     *  `true` forces it on, `false` forces it off; when unset it is on unless
+     *  `cardStreamingMode` is explicitly `"off"`. */
+    cardTaskProgress?: boolean;
+    /** How stage/step changes reach the progress block. `heartbeat` (default)
+     *  keeps the documented "once on appearance, then once per 30s" budget;
+     *  `interval` pushes on every correlated tool event, throttled by
+     *  `cardStreamInterval`, trading card updates for a fresher stage label. */
+    cardTaskProgressRefresh?: CardTaskProgressRefresh;
     /** AICard degrade duration in milliseconds after trigger errors (default 30m) */
     aicardDegradeMs?: number;
     /** Enable local learning loop (events/reflections/session notes/global rules) */
@@ -95,6 +133,8 @@ export interface DingTalkConfig extends OpenClawConfig {
         tokens?: boolean;
         dapiUsage?: boolean;
     };
+    /** Gateway RPC capability gates and allowlists (docs RPCs + proactive-send RPCs). Named `gatewayCapabilities` because host `OpenClawConfig` already owns `gateway` and `tools`, and a bare `capabilities` key would collide with this plugin's channel capabilities metadata. */
+    gatewayCapabilities?: DingTalkGatewayCapabilitiesConfig;
 }
 /**
  * Multi-account DingTalk configuration wrapper
@@ -150,10 +190,23 @@ export interface DingTalkChannelConfig {
      *  - answer: stream answer text
      *  - all: stream answer + reasoning text */
     cardStreamingMode?: CardStreamingMode;
+    /** Internal derived flag, not a user-facing config key: whether
+     *  `cardStreamingMode` came from an explicit user setting instead of the
+     *  runtime default. Written by config normalization only. */
+    cardStreamingModeConfigured?: boolean;
     /** @deprecated Use `cardStreamingMode` instead. */
     cardRealTimeStream?: boolean;
     /** Throttle interval in ms for card stream updates (default 1000) */
     cardStreamInterval?: number;
+    /** Live "task in progress" block on AI cards for long-running tasks.
+     *  `true` forces it on, `false` forces it off; when unset it is on unless
+     *  `cardStreamingMode` is explicitly `"off"`. */
+    cardTaskProgress?: boolean;
+    /** How stage/step changes reach the progress block. `heartbeat` (default)
+     *  keeps the documented "once on appearance, then once per 30s" budget;
+     *  `interval` pushes on every correlated tool event, throttled by
+     *  `cardStreamInterval`, trading card updates for a fresher stage label. */
+    cardTaskProgressRefresh?: CardTaskProgressRefresh;
     /** AICard degrade duration in milliseconds after trigger errors (default 30m) */
     aicardDegradeMs?: number;
     /** Enable local learning loop (events/reflections/session notes/global rules) */
@@ -166,6 +219,8 @@ export interface DingTalkChannelConfig {
     convertMarkdownTables?: boolean;
     /** @mention the sender after card finalization in group chats; value is the message text */
     cardAtSender?: string;
+    /** Gateway RPC capability gates and allowlists (docs RPCs + proactive-send RPCs). Named `gatewayCapabilities` because host `OpenClawConfig` already owns `gateway` and `tools`, and a bare `capabilities` key would collide with this plugin's channel capabilities metadata. */
+    gatewayCapabilities?: DingTalkGatewayCapabilitiesConfig;
 }
 /**
  * DingTalk token info for caching
@@ -211,6 +266,16 @@ export interface DocInfo {
     creatorId?: string;
     updatedAt?: number | string;
 }
+/**
+ * Recursive element node of an interactiveCard `cardContent` payload.
+ * Real DingTalk quote callbacks carry card text as nested element trees
+ * (e.g. LIST -> RICHTEXT -> TEXT nodes) rather than a flat `text` field.
+ */
+export interface DingTalkCardContentNode {
+    elementType?: string;
+    value?: string;
+    children?: DingTalkCardContentNode[];
+}
 /**
  * DingTalk incoming message (Stream mode)
  */
@@ -236,9 +301,13 @@ export interface DingTalkInboundMessage {
             createdAt?: number;
             content?: {
                 text?: string;
+                /** Quoted text message body in real payloads (`msgType: "text"`). */
+                content?: string;
                 downloadCode?: string;
                 fileName?: string;
                 biz_custom_action_url?: string;
+                /** interactiveCard quoted content as nested element tree. */
+                cardContent?: DingTalkCardContentNode[];
                 richText?: Array<{
                     msgType?: string;
                     type?: string;
@@ -386,7 +455,11 @@ export interface SendMessageOptions {
     /** Force markdown/text delivery even when messageType is "card". Bypasses card
      *  creation while preserving journal writes and other side-effects. */
     forceMarkdown?: boolean;
-    /** Allowed local roots for sandbox/container media path resolution. */
+    /**
+     * Host-provided allowlist of local media roots. When set, caller-supplied
+     * host paths whose canonical location is outside these roots are resolved
+     * through the runtime media bridge instead of being read directly.
+     */
     mediaLocalRoots?: string[];
 }
 export interface DingTalkTrackingMetadata {

package/dist/src/{persistence-store.d.ts → shared/persistence-store.d.ts}

@@ -1,4 +1,4 @@
-import type { Logger } from "./types";
+import type { Logger } from "../platform/types";
 type NamespaceFormat = "json";
 export interface PersistenceScope {
     accountId?: string;

package/dist/src/{utils.d.ts → shared/utils.d.ts}

@@ -1,7 +1,7 @@
 import * as dns from "node:dns";
 import * as fs from "node:fs";
 import * as net from "node:net";
-import type { Logger, RetryOptions } from "./types";
+import type { Logger, RetryOptions } from "../platform/types";
 type PluginDebugLogParams = {
     accountId: string;
     storePath?: string;

package/dist/src/targeting/agent-name-matcher.d.ts

@@ -4,7 +4,7 @@
  * Matches @mentions to agent IDs based on name and id fields in agents.list config.
  */
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import type { AtMention, AgentNameMatch } from "../types";
+import type { AtMention, AgentNameMatch } from "../platform/types";
 interface AgentConfig {
     id: string;
     name?: string;

package/dist/src/targeting/agent-routing.d.ts

@@ -7,9 +7,9 @@
  * (channel + accountId + peer), not content-based dynamic routing.
  */
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { getDingTalkRuntime } from "../runtime";
-import type { AgentNameMatch, DingTalkConfig, DingTalkInboundMessage, HandleDingTalkMessageParams, Logger, MessageContent, ResolvedDingTalkRoute } from "../types";
-import type { ResolvedDingTalkSessionPeer } from "../session-routing";
+import { getDingTalkRuntime } from "../platform/runtime";
+import type { AgentNameMatch, DingTalkConfig, DingTalkInboundMessage, HandleDingTalkMessageParams, Logger, MessageContent, ResolvedDingTalkRoute } from "../platform/types";
+import type { ResolvedDingTalkSessionPeer } from "./session-routing";
 export declare class HostRoutingHelperUnavailableError extends Error {
     constructor(message?: string);
 }

package/dist/src/{session-routing.d.ts → targeting/session-routing.d.ts}

@@ -1,4 +1,4 @@
-import type { DingTalkConfig } from "./types";
+import type { DingTalkConfig } from "../platform/types";
 export interface ResolveDingTalkSessionPeerParams {
     isDirect: boolean;
     senderId: string;

package/index.ts

@@ -4,26 +4,106 @@ import {
   type OpenClawPluginDefinition,
 } from "openclaw/plugin-sdk/core";
 import { readStringParam } from "openclaw/plugin-sdk/param-readers";
-import { getAccessToken } from "./src/auth";
 import { registerDingTalkAskUserQuestionTool } from "./src/card/ask-user-question";
+import { accumulateUsage } from "./src/card/run-usage-store";
 import { dingtalkPlugin } from "./src/channel";
-import { getConfig, listDingTalkAccountIds, resolveDingTalkAccount } from "./src/config";
 import {
   appendToDoc,
   createDoc,
   DocCreateAppendError,
   listDocs,
   searchDocs,
-} from "./src/docs-service";
-import { accumulateUsage } from "./src/run-usage-store";
-import { setDingTalkRuntime } from "./src/runtime";
-import { sendMessage } from "./src/send-service";
+} from "./src/gateway/docs-service";
+import { sendMessage } from "./src/messaging/send-service";
+import { getAccessToken } from "./src/platform/auth";
+import {
+  checkDocsGatewayCapability,
+  checkProactiveSendGatewayCapability,
+  getConfig,
+  listDingTalkAccountIds,
+  PROACTIVE_SEND_GATE_DISABLED_REASON,
+  resolveDingTalkAccount,
+  resolveGatewayCapabilityConfig,
+} from "./src/platform/config";
+import { setDingTalkRuntime } from "./src/platform/runtime";
 
 type GatewayMethodContext = Pick<
   Parameters<Parameters<OpenClawPluginApi["registerGatewayMethod"]>[1]>[0],
   "context" | "params" | "respond"
 >;
 
+type GatewayMethodArgs = Parameters<Parameters<OpenClawPluginApi["registerGatewayMethod"]>[1]>[0];
+
+/**
+ * Respond with a capability denial for a Gateway RPC call.
+ * Logged under `[DingTalk][GatewayRPC][Denied]` for fast audit diagnosis.
+ */
+function denyGatewayCapability(
+  api: OpenClawPluginApi,
+  method: string,
+  reason: string,
+  respond: GatewayMethodContext["respond"],
+): ReturnType<GatewayMethodContext["respond"]> {
+  api.logger?.warn?.(`[DingTalk][GatewayRPC][Denied] ${method}: ${reason}`);
+  return respond(false, { error: reason });
+}
+
+/**
+ * Wrap a docs Gateway RPC handler with the `gatewayCapabilities.tools.docs` capability gate
+ * and the optional `gatewayCapabilities.docs.allowedSpaceIds` allowlist (Issue #608, 问题 3).
+ * `dingtalk.docs.*` and `dingtalk-connector.docs.*` aliases share handlers, so
+ * the gate automatically applies to both namespaces.
+ */
+function withDocsGatewayCapability(
+  api: OpenClawPluginApi,
+  method: string,
+  handler: (args: GatewayMethodArgs) => Promise<void>,
+): (args: GatewayMethodArgs) => Promise<void> {
+  return async (args: GatewayMethodArgs) => {
+    const { respond, params } = args;
+    const accountId = readStringParam(params, "accountId");
+    const caps = resolveGatewayCapabilityConfig(api.config, accountId ?? undefined);
+    // `checkDocsGatewayCapability` evaluates the capability switch first, so a
+    // disabled tool answers with a structured deny before any method params
+    // (all optional for docs RPCs) are inspected.
+    const spaceId = readStringParam(params, "spaceId") ?? undefined;
+    const denial = checkDocsGatewayCapability(caps, spaceId);
+    if (denial) {
+      return denyGatewayCapability(api, method, denial, respond);
+    }
+    return handler(args);
+  };
+}
+
+/**
+ * Wrap a proactive-send Gateway RPC handler with the `gatewayCapabilities.tools.proactiveSend`
+ * capability gate and the optional `gatewayCapabilities.send.allowedTargets` allowlist
+ * (Issue #608, 问题 3).
+ */
+function withProactiveSendGatewayCapability(
+  api: OpenClawPluginApi,
+  method: string,
+  resolveTarget: (params: Record<string, unknown>) => string | undefined,
+  handler: (args: GatewayMethodArgs, target: string) => Promise<void>,
+): (args: GatewayMethodArgs) => Promise<void> {
+  return async (args: GatewayMethodArgs) => {
+    const { respond, params } = args;
+    const accountId = readStringParam(params, "accountId");
+    const caps = resolveGatewayCapabilityConfig(api.config, accountId ?? undefined);
+    // Fast-path the capability switch before resolving required params so a
+    // disabled tool answers with a structured deny rather than a param error.
+    if (!caps.proactiveSendEnabled) {
+      return denyGatewayCapability(api, method, PROACTIVE_SEND_GATE_DISABLED_REASON, respond);
+    }
+    const target = resolveTarget(params) ?? "";
+    const denial = checkProactiveSendGatewayCapability(caps, target);
+    if (denial) {
+      return denyGatewayCapability(api, method, denial, respond);
+    }
+    return handler(args, target);
+  };
+}
+
 /**
  * Register the canonical OpenClaw DingTalk docs RPC namespace.
  *
@@ -93,14 +173,38 @@ function registerDingTalkDocsGatewayMethods(api: OpenClawPluginApi): void {
     return respond(true, { docs });
   };
 
-  api.registerGatewayMethod("dingtalk.docs.create", createHandler);
-  api.registerGatewayMethod("dingtalk.docs.append", appendHandler);
-  api.registerGatewayMethod("dingtalk.docs.search", searchHandler);
-  api.registerGatewayMethod("dingtalk.docs.list", listHandler);
-  api.registerGatewayMethod("dingtalk-connector.docs.create", createHandler);
-  api.registerGatewayMethod("dingtalk-connector.docs.append", appendHandler);
-  api.registerGatewayMethod("dingtalk-connector.docs.search", searchHandler);
-  api.registerGatewayMethod("dingtalk-connector.docs.list", listHandler);
+  api.registerGatewayMethod(
+    "dingtalk.docs.create",
+    withDocsGatewayCapability(api, "dingtalk.docs.create", createHandler),
+  );
+  api.registerGatewayMethod(
+    "dingtalk.docs.append",
+    withDocsGatewayCapability(api, "dingtalk.docs.append", appendHandler),
+  );
+  api.registerGatewayMethod(
+    "dingtalk.docs.search",
+    withDocsGatewayCapability(api, "dingtalk.docs.search", searchHandler),
+  );
+  api.registerGatewayMethod(
+    "dingtalk.docs.list",
+    withDocsGatewayCapability(api, "dingtalk.docs.list", listHandler),
+  );
+  api.registerGatewayMethod(
+    "dingtalk-connector.docs.create",
+    withDocsGatewayCapability(api, "dingtalk-connector.docs.create", createHandler),
+  );
+  api.registerGatewayMethod(
+    "dingtalk-connector.docs.append",
+    withDocsGatewayCapability(api, "dingtalk-connector.docs.append", appendHandler),
+  );
+  api.registerGatewayMethod(
+    "dingtalk-connector.docs.search",
+    withDocsGatewayCapability(api, "dingtalk-connector.docs.search", searchHandler),
+  );
+  api.registerGatewayMethod(
+    "dingtalk-connector.docs.list",
+    withDocsGatewayCapability(api, "dingtalk-connector.docs.list", listHandler),
+  );
 }
 
 function getContentParam(params: Record<string, unknown>): string | undefined {
@@ -176,68 +280,88 @@ async function sendGatewayMessage(params: {
 function registerDingTalkConnectorCompatibilityGatewayMethods(api: OpenClawPluginApi): void {
   api.registerGatewayMethod(
     "dingtalk-connector.sendToUser",
-    async ({ context, respond, params }: GatewayMethodContext) => {
-      const accountId = readStringParam(params, "accountId");
-      const userId = readStringParam(params, "userId", { required: true });
-      const content = getContentParam(params);
-      if (!content) {
-        return respond(false, { error: "content or message is required" });
-      }
-      return sendGatewayMessage({
-        api,
-        respond,
-        accountId: accountId ?? undefined,
-        target: `user:${userId}`,
-        content,
-        storePath: context?.cronStorePath,
-        useAICard: params.useAICard,
-      });
-    },
+    withProactiveSendGatewayCapability(
+      api,
+      "dingtalk-connector.sendToUser",
+      (params) => {
+        const userId = readStringParam(params, "userId", { required: true });
+        return userId ? `user:${userId}` : undefined;
+      },
+      async ({ context, respond, params }, target) => {
+        const accountId = readStringParam(params, "accountId");
+        const content = getContentParam(params);
+        if (!content) {
+          return respond(false, { error: "content or message is required" });
+        }
+        return sendGatewayMessage({
+          api,
+          respond,
+          accountId: accountId ?? undefined,
+          target,
+          content,
+          storePath: context?.cronStorePath,
+          useAICard: params.useAICard,
+        });
+      },
+    ),
   );
 
   api.registerGatewayMethod(
     "dingtalk-connector.sendToGroup",
-    async ({ context, respond, params }: GatewayMethodContext) => {
-      const accountId = readStringParam(params, "accountId");
-      const openConversationId = readStringParam(params, "openConversationId", { required: true });
-      const content = getContentParam(params);
-      if (!content) {
-        return respond(false, { error: "content or message is required" });
-      }
-      return sendGatewayMessage({
-        api,
-        respond,
-        accountId: accountId ?? undefined,
-        target: `group:${openConversationId}`,
-        content,
-        storePath: context?.cronStorePath,
-        useAICard: params.useAICard,
-      });
-    },
+    withProactiveSendGatewayCapability(
+      api,
+      "dingtalk-connector.sendToGroup",
+      (params) => {
+        const openConversationId = readStringParam(params, "openConversationId", {
+          required: true,
+        });
+        return openConversationId ? `group:${openConversationId}` : undefined;
+      },
+      async ({ context, respond, params }, target) => {
+        const accountId = readStringParam(params, "accountId");
+        const content = getContentParam(params);
+        if (!content) {
+          return respond(false, { error: "content or message is required" });
+        }
+        return sendGatewayMessage({
+          api,
+          respond,
+          accountId: accountId ?? undefined,
+          target,
+          content,
+          storePath: context?.cronStorePath,
+          useAICard: params.useAICard,
+        });
+      },
+    ),
   );
 
   api.registerGatewayMethod(
     "dingtalk-connector.send",
-    async ({ context, respond, params }: GatewayMethodContext) => {
-      const accountId = readStringParam(params, "accountId");
-      const target = readStringParam(params, "target", { required: true });
-      const content = getContentParam(params);
-      if (!content) {
-        return respond(false, { error: "content or message is required" });
-      }
-      if (!isConnectorSendTarget(target)) {
-        return respond(false, { error: "target must start with user: or group:" });
-      }
-      return sendGatewayMessage({
-        api,
-        respond,
-        accountId: accountId ?? undefined,
-        target,
-        content,
-        storePath: context?.cronStorePath,
-        useAICard: params.useAICard,
-      });
-    },
+    withProactiveSendGatewayCapability(
+      api,
+      "dingtalk-connector.send",
+      (params) => readStringParam(params, "target", { required: true }) ?? undefined,
+      async ({ context, respond, params }, target) => {
+        const accountId = readStringParam(params, "accountId");
+        const content = getContentParam(params);
+        if (!content) {
+          return respond(false, { error: "content or message is required" });
+        }
+        if (!isConnectorSendTarget(target)) {
+          return respond(false, { error: "target must start with user: or group:" });
+        }
+        return sendGatewayMessage({
+          api,
+          respond,
+          accountId: accountId ?? undefined,
+          target,
+          content,
+          storePath: context?.cronStorePath,
+          useAICard: params.useAICard,
+        });
+      },
+    ),
   );
 
   api.registerGatewayMethod(
@@ -282,7 +406,7 @@ function registerDingTalkConnectorCompatibilityGatewayMethods(api: OpenClawPlugi
 }
 
 export { dingtalkPlugin } from "./src/channel";
-export { setDingTalkRuntime } from "./src/runtime";
+export { setDingTalkRuntime } from "./src/platform/runtime";
 
 const dingtalkEntry = defineChannelPluginEntry({
   id: "dingtalk",