@soimy/dingtalk 3.6.11 → 3.7.0

package/dist/src/{ack-reaction-service.d.ts → ack-reaction/ack-reaction-service.d.ts}

@@ -1,4 +1,4 @@
-import type { DingTalkConfig } from "./types";
+import type { DingTalkConfig } from "../platform/types";
 type AckReactionLogger = {
     debug?: (msg: string) => void;
     info?: (msg: string) => void;

package/dist/src/ack-reaction/dynamic-ack-reaction-controller.d.ts

@@ -1,5 +1,5 @@
-import type { DingTalkConfig } from "../types";
-import { type DynamicAckReactionLogger, type RuntimeEventsSurface } from "./dynamic-ack-reaction-events";
+import { type RuntimeEventsLogger, type RuntimeEventsSurface } from "../platform/runtime-events";
+import type { DingTalkConfig } from "../platform/types";
 type DynamicAckReactionControllerParams = {
     enabled: boolean;
     initialReaction: string;
@@ -9,7 +9,7 @@ type DynamicAckReactionControllerParams = {
     msgId: string;
     conversationId: string;
     sessionKey: string;
-    log?: DynamicAckReactionLogger;
+    log?: RuntimeEventsLogger;
     runtimeEvents?: RuntimeEventsSurface;
     onReactionDisposed?: () => void;
 };

package/dist/src/card/ask-user-question-context.d.ts

@@ -1,4 +1,4 @@
-import type { DingTalkConfig, DingTalkInboundMessage, HandleDingTalkMessageParams, Logger, ResolvedDingTalkRoute, SubAgentOptions } from "../types";
+import type { DingTalkConfig, DingTalkInboundMessage, HandleDingTalkMessageParams, Logger, ResolvedDingTalkRoute, SubAgentOptions } from "../platform/types";
 export type DingTalkQuestionContext = {
     cfg: HandleDingTalkMessageParams["cfg"];
     accountId: string;

package/dist/src/card/ask-user-question-store.d.ts

@@ -1,4 +1,4 @@
-import type { Logger } from "../types";
+import type { Logger } from "../platform/types";
 export type AskUserActiveState = "reserved" | "pending" | "dispatching";
 export type AskUserTerminalReason = "delivery_failed" | "superseded_by_question" | "superseded_by_message" | "expired" | "cancelled" | "empty" | "submitted" | "pause_failed" | "restart_invalidated" | "restart_during_dispatch" | "dispatch_failed";
 export interface AskUserLifecycleRecord {

package/dist/src/card/ask-user-question.d.ts

@@ -1,5 +1,5 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import type { DingTalkConfig, Logger } from "../types";
+import type { DingTalkConfig, Logger } from "../platform/types";
 import { type DingTalkQuestionContext } from "./ask-user-question-context";
 import { type AskUserLifecycleRecord } from "./ask-user-question-store";
 type AskUserOption = {

package/dist/src/card/card-action-handler.d.ts

@@ -1,6 +1,6 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import type { CardCallbackAnalysis } from "../card-callback-service";
-import type { DingTalkConfig, Logger } from "../types";
+import type { DingTalkConfig, Logger } from "../platform/types";
+import type { CardCallbackAnalysis } from "./card-callback-service";
 export interface CardActionResult {
     handled: boolean;
 }

package/dist/src/{card-draft-controller.d.ts → card/card-draft-controller.d.ts}

@@ -9,8 +9,12 @@
  * It delegates throttling and single-flight transport guarantees to
  * {@link createDraftStreamLoop}.
  */
-import type { AICardInstance, Logger } from "./types";
+import type { AICardInstance, Logger } from "../platform/types";
 export interface CardDraftController {
+    updateProgress: (text: string) => Promise<void>;
+    clearProgress: (options?: {
+        clearRemoteWhenEmpty?: boolean;
+    }) => Promise<void>;
     updateAnswer: (text: string, options?: {
         stream?: boolean;
         renderBlocks?: boolean;

package/dist/src/card/card-run-registry.d.ts

@@ -1,3 +1,4 @@
+import type { AICardInstance } from "../platform/types";
 /**
  * In-process card run registry for tracking active AI card runs.
  *
@@ -7,8 +8,7 @@
  * the stop button to silently fail. Ensure single-process deployment or sticky
  * routing per card callback when using the stop button feature.
  */
-import type { CardDraftController } from "../card-draft-controller";
-import type { AICardInstance } from "../types";
+import type { CardDraftController } from "./card-draft-controller";
 export interface CardRunRecord {
     outTrackId: string;
     accountId: string;

package/dist/src/{card-service.d.ts → card/card-service.d.ts}

@@ -1,4 +1,4 @@
-import type { AICardInstance, DingTalkConfig, DingTalkTrackingMetadata, Logger, QuotedRef } from "./types";
+import type { AICardInstance, DingTalkConfig, DingTalkTrackingMetadata, Logger, QuotedRef } from "../platform/types";
 export declare function hideCardStopButton(outTrackId: string, token: string, config?: {
     bypassProxyForSend?: boolean;
 }, retries?: number): Promise<void>;

package/dist/src/card/card-stop-handler.d.ts

@@ -1,5 +1,5 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import type { DingTalkConfig, Logger } from "../types";
+import type { DingTalkConfig, Logger } from "../platform/types";
 export interface StopCardRunResult {
     ok: boolean;
     status: string;

package/dist/src/card/card-streaming-mode.d.ts

@@ -1,4 +1,4 @@
-import type { DingTalkConfig } from "../types";
+import type { DingTalkConfig } from "../platform/types";
 export type CardStreamingMode = "off" | "answer" | "all";
 export declare function resolveCardStreamingMode(config: Pick<DingTalkConfig, "cardStreamingMode" | "cardRealTimeStream">): {
     mode: CardStreamingMode;

package/dist/src/card/card-task-progress.d.ts

@@ -0,0 +1,60 @@
+import { type RuntimeEventsLogger, type RuntimeEventsSurface } from "../platform/runtime-events";
+import type { CardTaskProgressRefresh, DingTalkConfig } from "../platform/types";
+/**
+ * Decide whether the live task-progress block is allowed for this card.
+ *
+ * `cardTaskProgress` is tri-state on purpose: explicit `true`/`false` always
+ * wins. When unset the block is on by default, except for an explicit
+ * `cardStreamingMode: "off"` — that is a deliberate "keep card traffic
+ * minimal" request, so progress stays quiet until the user opts back in.
+ *
+ * The runtime normalizes an omitted `cardStreamingMode` to `"off"` before the
+ * config reaches this point, so the effective value alone cannot tell "omitted"
+ * apart from "explicitly off". `cardStreamingModeConfigured` carries that
+ * distinction; configs that never went through normalization (hand-built test
+ * or embedded configs) fall back to "was a mode present at all".
+ */
+export declare function resolveCardTaskProgressEnabled(config: Pick<DingTalkConfig, "cardTaskProgress" | "cardStreamingMode" | "cardStreamingModeConfigured">): boolean;
+export interface CardTaskProgressController {
+    /** Wait for queued card updates to settle (test/observability helper). */
+    awaitDrain(): Promise<void>;
+    /**
+     * Release timers and the runtime-event subscription, then remove the
+     * progress block. Idempotent, and safe to call when nothing was rendered.
+     *
+     * `clearRemoteWhenEmpty` is for teardown paths that will never commit the
+     * card (for example ask-user question-card takeover): when the progress block
+     * was the only visible block, the local removal must also clear the remote
+     * card, otherwise the reader keeps seeing a live-looking "任务处理中" card.
+     */
+    dispose(options?: {
+        clearRemoteWhenEmpty?: boolean;
+    }): Promise<void>;
+}
+export interface ClearProgressOptions {
+    /** Clear the remote card when removing progress leaves no visible block. */
+    clearRemoteWhenEmpty?: boolean;
+}
+/**
+ * Keep one replaceable "task in progress" block on an AI card.
+ *
+ * Returns a no-op controller when progress is disabled by config or when the
+ * session key is unknown: without a session key the correlator could only rely
+ * on its optimistic window, which surfaces as an intermittently missing block.
+ */
+export declare function createCardTaskProgressController(params: {
+    sessionKey: string;
+    enabled?: boolean;
+    /**
+     * `heartbeat` (default) coalesces stage/step changes into the 30s refresh;
+     * `interval` pushes them on every correlated tool event, throttled further
+     * down by the card draft loop's `cardStreamInterval`.
+     */
+    refresh?: CardTaskProgressRefresh;
+    runtimeEvents?: RuntimeEventsSurface;
+    updateProgress: (text: string) => Promise<void>;
+    clearProgress: (options?: ClearProgressOptions) => Promise<void>;
+    startDelayMs?: number;
+    heartbeatIntervalMs?: number;
+    log?: RuntimeEventsLogger;
+}): CardTaskProgressController;

package/dist/src/channel.d.ts

@@ -1,9 +1,9 @@
 import { CHANNEL_INFLIGHT_NAMESPACE_POLICY } from "./gateway/channel-gateway";
-import type { DingTalkChannelPlugin } from "./types";
+import type { DingTalkChannelPlugin } from "./platform/types";
 export declare const dingtalkPlugin: DingTalkChannelPlugin;
 export { CHANNEL_INFLIGHT_NAMESPACE_POLICY };
-export { getAccessToken } from "./auth";
-export { createAICard, finishAICard, streamAICard } from "./card-service";
-export { detectMediaTypeFromExtension } from "./media-utils";
-export { getLogger } from "./logger-context";
-export { sendBySession, sendMessage, sendProactiveMedia, uploadMedia, } from "./send-service";
+export { getAccessToken } from "./platform/auth";
+export { createAICard, finishAICard, streamAICard } from "./card/card-service";
+export { detectMediaTypeFromExtension } from "./messaging/media-utils";
+export { getLogger } from "./platform/logger-context";
+export { sendBySession, sendMessage, sendProactiveMedia, uploadMedia, } from "./messaging/send-service";

package/dist/src/command/card-stop-command.d.ts

@@ -1,5 +1,5 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import type { Logger } from "../types";
+import type { Logger } from "../platform/types";
 /**
  * Dispatch a native targeted `/stop` command through the OpenClaw SDK,
  * replacing the previous self-built Gateway WebSocket `chat.abort` approach.

package/dist/src/{feedback-learning-service.d.ts → command/feedback-learning-service.d.ts}

@@ -1,5 +1,5 @@
+import type { DingTalkConfig, MessageContent } from "../platform/types";
 import { ScopedLearnedRuleRecord, TargetSetRecord } from "./feedback-learning-store";
-import type { DingTalkConfig, MessageContent } from "./types";
 export declare function isLearningEnabled(config: DingTalkConfig | undefined): boolean;
 export declare function isLearningAutoApplyEnabled(config: DingTalkConfig | undefined): boolean;
 export declare function recordOutboundReplyForLearning(params: {

package/dist/src/command/inbound-command-dispatch-service.d.ts

@@ -1,5 +1,5 @@
-import type { SessionPeerSourceKind } from "../session-peer-store";
-import type { DingTalkConfig, HandleDingTalkMessageParams, MessageContent } from "../types";
+import type { DingTalkConfig, HandleDingTalkMessageParams, MessageContent } from "../platform/types";
+import type { SessionPeerSourceKind } from "../targeting/session-peer-store";
 type InboundCommandDispatchParams = {
     cfg: HandleDingTalkMessageParams["cfg"];
     accountId: string;

package/dist/src/{learning-command-service.d.ts → command/learning-command-service.d.ts}

@@ -1,4 +1,4 @@
-import type { DingTalkConfig } from "./types";
+import type { DingTalkConfig } from "../platform/types";
 export interface ParsedLearnCommand {
     scope: "help" | "global" | "session" | "here" | "target" | "targets" | "list" | "disable" | "delete" | "whoami" | "whereami" | "owner-status" | "target-set-create" | "target-set-apply" | "unknown";
     instruction?: string;

package/dist/src/gateway/channel-gateway.d.ts

@@ -1,3 +1,3 @@
-import type { DingTalkChannelPlugin } from "../types";
+import type { DingTalkChannelPlugin } from "../platform/types";
 export declare const CHANNEL_INFLIGHT_NAMESPACE_POLICY: "memory-only";
 export declare function createDingTalkGateway(): NonNullable<DingTalkChannelPlugin["gateway"]>;

package/dist/src/{connection-manager.d.ts → gateway/connection-manager.d.ts}

@@ -9,7 +9,7 @@
  * - Structured logging for all connection events
  */
 import type { DWClient } from "dingtalk-stream";
-import type { ConnectionState, ConnectionManagerConfig, Logger, StreamClientFactory } from "./types";
+import type { ConnectionState, ConnectionManagerConfig, Logger, StreamClientFactory } from "../platform/types";
 /**
  * Thrown when a runtime reconnection cycle exceeds the configured deadline.
  * Identified via instanceof in reconnect() to skip cycle counting.

package/dist/src/{docs-service.d.ts → gateway/docs-service.d.ts}

@@ -1,4 +1,4 @@
-import type { DingTalkConfig, DocInfo } from "./types";
+import type { DingTalkConfig, DocInfo } from "../platform/types";
 export declare class DocCreateAppendError extends Error {
     readonly doc: DocInfo;
     constructor(doc: DocInfo, cause?: unknown);

package/dist/src/{inbound-handler.d.ts → gateway/inbound-handler.d.ts}

@@ -1,4 +1,4 @@
-import type { DingTalkConfig, HandleDingTalkMessageParams, MediaFile } from "./types";
+import type { DingTalkConfig, HandleDingTalkMessageParams, MediaFile } from "../platform/types";
 export declare function resetProactivePermissionHintStateForTest(): void;
 /**
  * Download DingTalk media file via runtime media service (sandbox-compatible).

package/dist/src/gateway/inbound-session-queue-dispatcher.d.ts

@@ -1,4 +1,4 @@
-import type { AICardInstance, DingTalkConfig, DingTalkInboundMessage, Logger } from "../types";
+import type { AICardInstance, DingTalkConfig, DingTalkInboundMessage, Logger } from "../platform/types";
 export interface InboundQueueDispatchInput {
     accountId: string;
     data: DingTalkInboundMessage;

package/dist/src/messaging/attachment-text-extractor.d.ts

@@ -1,4 +1,4 @@
-import type { AttachmentTextSource } from "../types";
+import type { AttachmentTextSource } from "../platform/types";
 export interface AttachmentTextExtractionInput {
     path: string;
     mimeType?: string;

package/dist/src/messaging/btw-deliver.d.ts

@@ -1,4 +1,4 @@
-import type { DingTalkConfig, Logger } from "../types";
+import type { DingTalkConfig, Logger } from "../platform/types";
 /**
  * Strip leading `@mention` tokens from inbound text. Used by both the abort and
  * BTW bypass branches in `inbound-handler.ts` so that command detection works

package/dist/src/messaging/channel-outbound.d.ts

@@ -1,2 +1,2 @@
-import type { DingTalkChannelPlugin } from "../types";
+import type { DingTalkChannelPlugin } from "../platform/types";
 export declare function createDingTalkOutbound(): NonNullable<DingTalkChannelPlugin["outbound"]>;

package/dist/src/{media-utils.d.ts → messaging/media-utils.d.ts}

@@ -1,4 +1,4 @@
-import type { DingTalkConfig, Logger } from "./types";
+import type { DingTalkConfig, Logger } from "../platform/types";
 /**
  * Calculate MP3 duration in seconds by parsing MPEG frame headers
  * Supports CBR and VBR MP3 files

package/dist/src/{message-context-store.d.ts → messaging/message-context-store.d.ts}

@@ -1,4 +1,4 @@
-import type { AttachmentTextSource, Logger, QuotedRef } from "./types";
+import type { AttachmentTextSource, Logger, QuotedRef } from "../platform/types";
 export declare const DEFAULT_MESSAGE_CONTEXT_TTL_DAYS = 7;
 export declare const DEFAULT_CARD_CONTENT_TTL_MS: number;
 export declare const DEFAULT_MEDIA_CONTEXT_TTL_MS: number;
@@ -30,7 +30,10 @@ export interface MessageRecord {
     quotedRef?: QuotedRef;
     senderId?: string;
     senderName?: string;
+    /** Display names parsed from mentions; not positionally aligned with mentionUserIds. */
     mentions?: string[];
+    /** Raw DingTalk user IDs from structured @mention payloads (atUsers / richText atUserId). Not positionally aligned with mentions. */
+    mentionUserIds?: string[];
     chatType?: "direct" | "group";
     /** Flat quoted target for summary/history lookups; quotedRef remains the authoritative structured link. */
     quotedMessageId?: string;
@@ -66,7 +69,10 @@ interface BaseUpsertParams {
     quotedRef?: QuotedRef;
     senderId?: string;
     senderName?: string;
+    /** Display names parsed from mentions; not positionally aligned with mentionUserIds. */
     mentions?: string[];
+    /** Raw DingTalk user IDs from structured @mention payloads (atUsers / richText atUserId). Not positionally aligned with mentions. */
+    mentionUserIds?: string[];
     chatType?: "direct" | "group";
     quotedMessageId?: string;
     media?: {

package/dist/src/{message-utils.d.ts → messaging/message-utils.d.ts}

@@ -1,4 +1,4 @@
-import type { DingTalkInboundMessage, MessageContent, SendMessageOptions } from "./types";
+import type { DingTalkInboundMessage, MessageContent, SendMessageOptions } from "../platform/types";
 /**
  * Auto-detect markdown usage and derive message title.
  * Title extraction follows DingTalk markdown card title constraints.

package/dist/src/messaging/quoted-context.d.ts

@@ -1,5 +1,5 @@
-import type { MessageRecord } from "../message-context-store";
-import type { Logger, QuotedRef } from "../types";
+import type { Logger, QuotedRef } from "../platform/types";
+import type { MessageRecord } from "./message-context-store";
 export interface QuotedChainEntry {
     depth: number;
     direction: MessageRecord["direction"];

package/dist/src/messaging/quoted-file-service.d.ts

@@ -1,4 +1,4 @@
-import type { DingTalkConfig, Logger, MediaFile } from "../types";
+import type { DingTalkConfig, Logger, MediaFile } from "../platform/types";
 export declare function parseDingTalkFileTime(timeStr: string): number;
 export declare function getUnionIdByStaffId(config: DingTalkConfig, staffId: string, log?: Logger): Promise<string>;
 export declare function getGroupFileSpaceId(config: DingTalkConfig, openConversationId: string, unionId: string, log?: Logger): Promise<string>;

package/dist/src/messaging/quoted-ref.d.ts

@@ -1,5 +1,5 @@
-import { type MessageRecord } from "../message-context-store";
-import type { DingTalkInboundMessage, Logger, MessageContent, QuotedRef } from "../types";
+import type { DingTalkInboundMessage, Logger, MessageContent, QuotedRef } from "../platform/types";
+import { type MessageRecord } from "./message-context-store";
 export declare function buildInboundQuotedRef(data: DingTalkInboundMessage, content: MessageContent): QuotedRef | undefined;
 export declare function createReplyQuotedRef(msgId: string | undefined): QuotedRef | undefined;
 export declare function resolveQuotedRecord(params: {

package/dist/src/{reply-strategy-card.d.ts → messaging/reply-strategy-card.d.ts}

@@ -5,8 +5,8 @@
  * (final / tool / block), finalization, and failure fallback so that
  * inbound-handler only coordinates — it no longer owns card state.
  */
+import type { AICardInstance } from "../platform/types";
 import type { ReplyStrategy, ReplyStrategyContext } from "./reply-strategy-types";
-import type { AICardInstance } from "./types";
 export declare function createCardReplyStrategy(ctx: ReplyStrategyContext & {
     card: AICardInstance;
     isStopRequested?: () => boolean;

package/dist/src/{reply-strategy-types.d.ts → messaging/reply-strategy-types.d.ts}

@@ -6,7 +6,8 @@
  * can share these interfaces without circular imports.
  */
 import type { GetReplyOptions } from "openclaw/plugin-sdk/reply-runtime";
-import type { DingTalkConfig, Logger, QuotedRef } from "./types";
+import type { RuntimeEventsSurface } from "../platform/runtime-events";
+import type { DingTalkConfig, Logger, QuotedRef } from "../platform/types";
 export type InternalReplyStrategyConfig = DingTalkConfig & {
     /** @deprecated Internal compatibility only. Removed from public config surface. */
     cardStreamReasoning?: boolean;
@@ -47,6 +48,13 @@ export interface ReplyStrategy {
     finalize(): Promise<void>;
     /** Called when dispatch throws an error. */
     abort(error: Error): Promise<void>;
+    /**
+     * Release strategy-owned resources (timers, event subscriptions) without
+     * touching the delivery surface. Idempotent, and safe to call after
+     * `finalize()`/`abort()`. Callers must invoke this even on early-return
+     * paths so a strategy that never finalized cannot leak.
+     */
+    dispose(): Promise<void>;
     /** Last known final text (for external consumers such as logging). */
     getFinalText(): string | undefined;
 }
@@ -84,4 +92,5 @@ export interface ReplyStrategyContext {
     isStopRequested?: () => boolean;
     inboundText?: string;
     taskMeta?: TaskMeta;
+    runtimeEvents?: RuntimeEventsSurface;
 }

package/dist/src/{reply-strategy-with-reaction.d.ts → messaging/reply-strategy-with-reaction.d.ts}

@@ -23,8 +23,8 @@
  * cross-session reaction contamination when multiple messages are processed
  * concurrently. The `sessionFilter` parameter is required for this reason.
  */
+import type { DingTalkConfig, Logger } from "../platform/types";
 import type { ReplyStrategy } from "./reply-strategy-types";
-import type { DingTalkConfig, Logger } from "./types";
 export interface DynamicReactionParams {
     config: DingTalkConfig;
     msgId: string;

package/dist/src/{reply-strategy.d.ts → messaging/reply-strategy.d.ts}

@@ -4,7 +4,7 @@
  * Delegates the "how to deliver a reply" concern to card or markdown
  * strategy implementations. Type definitions live in reply-strategy-types.ts.
  */
-import type { AICardInstance } from "./types";
+import type { AICardInstance } from "../platform/types";
 import type { ReplyStrategy, ReplyStrategyContext } from "./reply-strategy-types";
 export type { DeliverPayload, ReplyOptions, ReplyStrategy, ReplyStrategyContext, TaskMeta, } from "./reply-strategy-types";
 export declare function createReplyStrategy(params: ReplyStrategyContext & {

package/dist/src/{send-service.d.ts → messaging/send-service.d.ts}

@@ -1,5 +1,5 @@
+import type { AICardInstance, AxiosResponse, DingTalkConfig, DingTalkTrackingMetadata, Logger, SendMessageOptions } from "../platform/types";
 import type { UploadMediaResult } from "./media-utils";
-import type { AICardInstance, AxiosResponse, DingTalkConfig, DingTalkTrackingMetadata, Logger, SendMessageOptions } from "./types";
 export { detectMediaTypeFromExtension } from "./media-utils";
 type ProactiveTextSendResult = AxiosResponse | {
     tracking: DingTalkTrackingMetadata;

package/dist/src/platform/channel-status.d.ts

@@ -1,2 +1,2 @@
-import type { DingTalkChannelPlugin } from "../types";
+import type { DingTalkChannelPlugin } from "./types";
 export declare function createDingTalkStatus(): NonNullable<DingTalkChannelPlugin["status"]>;

package/dist/src/platform/config.d.ts

@@ -0,0 +1,110 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import type { DingTalkConfig, DingTalkGatewayCapabilitiesConfig } from "./types";
+export { resolveRelativePath, resolveUserPath } from "../shared/path-utils";
+export type RuntimeDingTalkConfig = Omit<DingTalkConfig, "clientSecret"> & {
+    clientSecret: string;
+};
+/**
+ * Merge channel-level and account-level `gatewayCapabilities` gates by sub-key.
+ *
+ * `mergeAccountWithDefaults` is a shallow merge, so without this helper an
+ * account-level object would replace the whole channel-level `gatewayCapabilities` and
+ * silently drop a channel-level allowlist (fail-open). Merging `tools` /
+ * `docs` / `send` separately keeps channel-level restrictions in force unless
+ * the account explicitly overrides that exact sub-key.
+ */
+export declare function mergeGatewayCapabilitiesConfig(channelLevel: DingTalkGatewayCapabilitiesConfig | undefined, accountLevel: DingTalkGatewayCapabilitiesConfig | undefined): DingTalkGatewayCapabilitiesConfig | undefined;
+/**
+ * Merge channel-level defaults into an account-specific config.
+ * Account-level values take precedence; `accounts` key is excluded to avoid recursion.
+ */
+export declare function mergeAccountWithDefaults(channelCfg: DingTalkConfig, accountCfg: DingTalkConfig): DingTalkConfig;
+/**
+ * Resolve DingTalk config for an account.
+ * Named accounts inherit channel-level defaults with account-level overrides.
+ * Falls back to top-level config for single-account setups.
+ */
+export declare function getConfig(cfg: OpenClawConfig, accountId?: string): DingTalkConfig;
+export declare function isConfigured(cfg: OpenClawConfig, accountId?: string): boolean;
+/**
+ * Resolved Gateway RPC capability settings (Issue #608, 问题 3).
+ * All capabilities default to enabled; allowlists default to unrestricted.
+ */
+export interface ResolvedGatewayCapabilities {
+    /** `dingtalk.docs.*` / `dingtalk-connector.docs.*` RPCs enabled (default: true) */
+    docsEnabled: boolean;
+    /** `dingtalk-connector.sendToUser/sendToGroup/send` RPCs enabled (default: true) */
+    proactiveSendEnabled: boolean;
+    /** When set, docs RPCs only accept these spaceId values */
+    allowedSpaceIds?: string[];
+    /** When set, proactive-send RPCs only accept these `user:*` / `group:*` targets */
+    allowedTargets?: string[];
+}
+/** Denial reason returned when `gatewayCapabilities.tools.docs` is explicitly false. */
+export declare const DOCS_GATE_DISABLED_REASON = "dingtalk docs Gateway RPC is disabled by config (gatewayCapabilities.tools.docs = false)";
+/** Denial reason returned when `gatewayCapabilities.tools.proactiveSend` is explicitly false. */
+export declare const PROACTIVE_SEND_GATE_DISABLED_REASON = "dingtalk proactive-send Gateway RPC is disabled by config (gatewayCapabilities.tools.proactiveSend = false)";
+/**
+ * Resolve Gateway RPC capability configuration for an account.
+ * Account-level `gatewayCapabilities` is merged with channel-level defaults by sub-key
+ * (see `mergeGatewayCapabilitiesConfig`); both default to all capabilities enabled.
+ */
+export declare function resolveGatewayCapabilityConfig(cfg: OpenClawConfig, accountId?: string): ResolvedGatewayCapabilities;
+/**
+ * Check a docs RPC request against the configured capability gates.
+ * Returns null when allowed, or a human-readable denial reason.
+ *
+ * A configured allowlist is fail-closed: an empty list (possible only when
+ * config validation was bypassed) denies every docs RPC, and a request without
+ * a spaceId is denied as well because its doc space cannot be verified.
+ */
+export declare function checkDocsGatewayCapability(caps: ResolvedGatewayCapabilities, spaceId: string | undefined): string | null;
+/**
+ * Check a proactive-send RPC request against the configured capability gates.
+ * Returns null when allowed, or a human-readable denial reason.
+ *
+ * A configured allowlist is fail-closed: an empty list (possible only when
+ * config validation was bypassed) denies every proactive-send RPC.
+ */
+export declare function checkProactiveSendGatewayCapability(caps: ResolvedGatewayCapabilities, target: string): string | null;
+export declare function resolveRuntimeConfig(config: DingTalkConfig, log?: {
+    warn?: (message: string, data?: unknown) => void;
+}): Promise<RuntimeDingTalkConfig>;
+/**
+ * Resolve the robot code used by DingTalk APIs.
+ * DingTalk robotCode is always equal to clientId; this helper trims whitespace.
+ */
+export declare function resolveRobotCode(config: Pick<DingTalkConfig, "clientId">): string;
+export declare function resolveGroupConfig(cfg: DingTalkConfig, groupId: string): {
+    systemPrompt?: string;
+    requireMention?: boolean;
+    groupAllowFrom?: string[];
+} | undefined;
+export declare function resolveAckReactionSetting(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    agentId?: string | null;
+}): string | undefined;
+/**
+ * Strip group/user prefixes used by CLI targeting.
+ * Returns raw DingTalk target ID and whether caller explicitly requested a user target.
+ */
+export declare function stripTargetPrefix(target: string): {
+    targetId: string;
+    isExplicitUser: boolean;
+};
+/**
+ * List all DingTalk account IDs from config
+ */
+export declare function listDingTalkAccountIds(cfg: OpenClawConfig): string[];
+/**
+ * Resolved DingTalk account with configuration status
+ */
+export interface ResolvedDingTalkAccount extends DingTalkConfig {
+    accountId: string;
+    configured: boolean;
+}
+/**
+ * Resolve a specific DingTalk account configuration
+ */
+export declare function resolveDingTalkAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedDingTalkAccount;

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;