@soimy/dingtalk 3.5.1 → 3.5.3

package/src/channel.ts

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { DWClient, TOPIC_CARD, TOPIC_ROBOT } from "dingtalk-stream";
+import { jsonResult } from "openclaw/plugin-sdk/channel-actions";
 import type { ChannelMessageActionAdapter } from "openclaw/plugin-sdk/channel-contract";
 import { buildChannelConfigSchema, type OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { jsonResult } from "openclaw/plugin-sdk/telegram-core";
 import { readStringParam } from "openclaw/plugin-sdk/param-readers";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
 import { getAccessToken } from "./auth";
@@ -33,7 +33,7 @@ import {
   recordExplicitFeedbackLearning,
 } from "./feedback-learning-service";
 import { handleDingTalkMessage } from "./inbound-handler";
-import { getLogger } from "./logger-context";
+import { getLogger, setCurrentLogger } from "./logger-context";
 import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
 import { dingtalkSetupAdapter, dingtalkSetupWizard } from "./onboarding.js";
 import { resolveOriginalPeerId, preloadPeerIdsFromSessions } from "./peer-id-registry";
@@ -62,11 +62,14 @@ import type {
 } from "./types";
 import { ConnectionState } from "./types";
 import {
+  closePluginDebugLog,
   cleanupOrphanedTempFiles,
   createResolve4FallbackLookup,
   formatDingTalkConnectionErrorLog,
   formatDingTalkErrorPayloadLog,
   getCurrentTimestamp,
+  parseBooleanLike,
+  resolvePluginDebugLog,
 } from "./utils";
 
 type InstrumentedDWClient = {
@@ -186,29 +189,15 @@ function logInboundCounters(log: any, accountId: string, reason: string): void {
 }
 
 function readBooleanLikeParam(params: Record<string, unknown>, key: string): boolean | undefined {
-  const value = params[key];
-  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 parseBooleanLike(params[key]);
+}
+
+function readSharedAudioAsVoiceParam(params: Record<string, unknown>): boolean {
+  const sharedValue = readBooleanLikeParam(params, "audioAsVoice");
+  if (sharedValue !== undefined) {
+    return sharedValue;
   }
-  return undefined;
+  return readBooleanLikeParam(params, "asVoice") === true;
 }
 
 function describeDingTalkMessageTool(cfg: OpenClawConfig): {
@@ -259,7 +248,7 @@ const dingtalkMessageActions: ChannelMessageActionAdapter = {
       message = caption;
     }
 
-    const asVoice = readBooleanLikeParam(params, "asVoice") === true;
+    const asVoice = readSharedAudioAsVoiceParam(params);
     const requestedMediaType = readStringParam(params, "mediaType");
 
     const target = resolveOriginalPeerId(stripTargetPrefix(to).targetId);
@@ -460,14 +449,15 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
         agentId: accountId,
       });
+      const effectiveLog = getLogger(accountId) || log;
       try {
         const result = await sendMessage(config, to, text, {
-          log,
+          log: effectiveLog,
           accountId,
           storePath,
           conversationId: to,
         });
-        getLogger()?.debug?.(`[DingTalk] sendText: "${text}" result: ${JSON.stringify(result)}`);
+        effectiveLog?.debug?.(`[DingTalk] sendText: "${text}" result: ${JSON.stringify(result)}`);
         if (!result.ok) {
           throw new Error(result.error || "sendText failed");
         }
@@ -487,7 +477,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         };
       } catch (err: any) {
         if (err?.response?.data !== undefined) {
-          log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendText", err.response.data));
+          effectiveLog?.error?.(formatDingTalkErrorPayloadLog("outbound.sendText", err.response.data));
         }
         throw new Error(
           typeof err?.response?.data === "string"
@@ -504,6 +494,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       filePath,
       mediaUrl,
       mediaType: providedMediaType,
+      audioAsVoice,
       asVoice,
       accountId,
       mediaLocalRoots,
@@ -514,6 +505,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
         agentId: accountId,
       });
+      const effectiveLog = getLogger(accountId) || log;
       if (!config.clientId) {
         throw new Error("DingTalk not configured");
       }
@@ -521,7 +513,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       // Support mediaPath/filePath/mediaUrl aliases for better CLI compatibility.
       const rawMediaPath = mediaPath || filePath || mediaUrl;
 
-      getLogger()?.debug?.(
+      effectiveLog?.debug?.(
         `[DingTalk] sendMedia called: to=${to}, mediaPath=${mediaPath}, filePath=${filePath}, mediaUrl=${mediaUrl}, rawMediaPath=${rawMediaPath}`,
       );
 
@@ -539,10 +531,10 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       let preparedMedia;
       try {
         try {
-          preparedMedia = await prepareMediaInput(rawMediaPath, log, config.mediaUrlAllowlist);
+          preparedMedia = await prepareMediaInput(rawMediaPath, effectiveLog, config.mediaUrlAllowlist);
         } catch (err: any) {
           if (err?.response?.data !== undefined) {
-            log?.error?.(
+            effectiveLog?.error?.(
               formatDingTalkErrorPayloadLog("outbound.sendMedia.prepare", err.response.data),
             );
           }
@@ -559,19 +551,19 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           ? preparedMedia.path
           : resolveRelativePath(preparedMedia.path);
 
-        getLogger()?.debug?.(
+        effectiveLog?.debug?.(
           `[DingTalk] sendMedia resolved path: rawMediaPath=${rawMediaPath}, actualMediaPath=${actualMediaPath}`,
         );
 
         const mediaType = resolveOutboundMediaType({
           mediaType: typeof providedMediaType === "string" ? providedMediaType : undefined,
           mediaPath: actualMediaPath,
-          asVoice: asVoice === true,
+          asVoice: readSharedAudioAsVoiceParam({ audioAsVoice, asVoice }),
         });
         let result;
         try {
           result = await sendProactiveMedia(config, to, actualMediaPath, mediaType, {
-            log,
+            log: effectiveLog,
             accountId,
             storePath,
             conversationId: to,
@@ -579,7 +571,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           });
         } catch (err: any) {
           if (err?.response?.data !== undefined) {
-            log?.error?.(
+            effectiveLog?.error?.(
               formatDingTalkErrorPayloadLog("outbound.sendMedia.send", err.response.data),
             );
           }
@@ -587,7 +579,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             cause: err,
           });
         }
-        getLogger()?.debug?.(
+        effectiveLog?.debug?.(
           `[DingTalk] sendMedia: ${mediaType} file=${actualMediaPath} result: ${JSON.stringify(result)}`,
         );
 
@@ -609,7 +601,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         );
       } catch (err: any) {
         if (err?.response?.data !== undefined) {
-          log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia", err.response.data));
+          effectiveLog?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia", err.response.data));
         }
         throw new Error(
           typeof err?.response?.data === "string"
@@ -639,34 +631,48 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         accountStorePath = undefined;
       }
 
-      ctx.log?.info?.(`[${account.accountId}] Initializing DingTalk Stream client...`);
+      const pluginLog = resolvePluginDebugLog({
+        accountId: account.accountId,
+        storePath: accountStorePath,
+        debug: config.debug,
+        baseLog: ctx.log,
+      });
+      setCurrentLogger(pluginLog, account.accountId);
+
+      pluginLog?.info?.(`[${account.accountId}] Initializing DingTalk Stream client...`);
 
       // Preload known peer IDs from sessions so outbound delivery (e.g. cron
       // jobs that fire immediately after startup) can resolve the original
       // case-sensitive conversationId before any inbound message has arrived.
       preloadPeerIdsFromSessions();
-      ctx.log?.debug?.(`[${account.accountId}] Peer ID registry preloaded from sessions`);
+      pluginLog?.debug?.(`[${account.accountId}] Peer ID registry preloaded from sessions`);
 
-      cleanupOrphanedTempFiles(ctx.log);
+      cleanupOrphanedTempFiles(pluginLog);
       try {
         const recovered = await recoverPendingCardsForAccount(
           config,
           account.accountId,
           accountStorePath,
-          ctx.log,
+          pluginLog,
         );
         if (recovered > 0) {
-          ctx.log?.info?.(
+          pluginLog?.info?.(
             `[${account.accountId}] Recovered and finalized ${recovered} unfinished card(s) from previous runtime`,
           );
         }
       } catch (err: any) {
-        ctx.log?.warn?.(
+        pluginLog?.warn?.(
           `[${account.accountId}] Failed to recover unfinished cards: ${err.message}`,
         );
       }
 
       const useConnectionManager = config.useConnectionManager ?? true;
+      const applyStatusPatch = (patch: Record<string, unknown>) => {
+        ctx.setStatus({
+          ...ctx.getStatus(),
+          ...patch,
+        });
+      };
 
       // Factory that creates a fresh DWClient with the TOPIC_ROBOT callback
       // already registered. Each client captures its own reference for
@@ -683,7 +689,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         });
         (c as any).sslopts = {
           ...(c as any).sslopts,
-          lookup: createResolve4FallbackLookup(ctx.log, account.accountId),
+          lookup: createResolve4FallbackLookup(pluginLog, account.accountId),
         };
 
         instrumentConnectionStages(c);
@@ -702,13 +708,21 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
               c.socketCallBackResponse(messageId, { success: true });
               stats.acked += 1;
             } catch (ackError: any) {
-              ctx.log?.warn?.(
+              pluginLog?.warn?.(
                 `[${account.accountId}] Failed to acknowledge callback ${messageId}: ${ackError.message}`,
               );
             }
           };
           try {
             const data = JSON.parse(res.data) as DingTalkInboundMessage;
+            // Record the latest inbound callback arrival for status/UI projection.
+            // This intentionally tracks "message reached the plugin callback" rather
+            // than "message passed dedup and completed processing".
+            applyStatusPatch({
+              connected: true,
+              lastInboundAt: getCurrentTimestamp(),
+              lastEventAt: getCurrentTimestamp(),
+            });
 
             const robotKey = resolveRobotCode(config) || account.accountId;
             const msgId = data.msgId || messageId;
@@ -723,38 +737,38 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                 accountId: account.accountId,
                 data,
                 sessionWebhook: data.sessionWebhook,
-                log: ctx.log,
+                log: pluginLog,
                 dingtalkConfig: config,
               });
               stats.processed += 1;
               if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
-                logInboundCounters(ctx.log, account.accountId, "periodic");
+                logInboundCounters(pluginLog, account.accountId, "periodic");
               }
               return;
             }
 
             if (isMessageProcessed(dedupKey)) {
-              ctx.log?.debug?.(`[${account.accountId}] Skipping duplicate message: ${dedupKey}`);
+              pluginLog?.debug?.(`[${account.accountId}] Skipping duplicate message: ${dedupKey}`);
               stats.dedupSkipped += 1;
               acknowledge();
-              logInboundCounters(ctx.log, account.accountId, "dedup-skipped");
+              logInboundCounters(pluginLog, account.accountId, "dedup-skipped");
               return;
             }
 
             const inflightSince = processingDedupKeys.get(dedupKey);
             if (inflightSince !== undefined) {
               if (Date.now() - inflightSince > INFLIGHT_TTL_MS) {
-                ctx.log?.warn?.(
+                pluginLog?.warn?.(
                   `[${account.accountId}] Releasing stale in-flight lock for ${dedupKey} (held ${Date.now() - inflightSince}ms > TTL ${INFLIGHT_TTL_MS}ms)`,
                 );
                 processingDedupKeys.delete(dedupKey);
               } else {
-                ctx.log?.debug?.(
+                pluginLog?.debug?.(
                   `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`,
                 );
                 stats.inflightSkipped += 1;
                 acknowledge();
-                logInboundCounters(ctx.log, account.accountId, "inflight-skipped");
+                logInboundCounters(pluginLog, account.accountId, "inflight-skipped");
                 return;
               }
             }
@@ -767,21 +781,21 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                 accountId: account.accountId,
                 data,
                 sessionWebhook: data.sessionWebhook,
-                log: ctx.log,
+                log: pluginLog,
                 dingtalkConfig: config,
               });
               stats.processed += 1;
               markMessageProcessed(dedupKey);
               if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
-                logInboundCounters(ctx.log, account.accountId, "periodic");
+                logInboundCounters(pluginLog, account.accountId, "periodic");
               }
             } finally {
               processingDedupKeys.delete(dedupKey);
             }
           } catch (error: any) {
             stats.failed += 1;
-            logInboundCounters(ctx.log, account.accountId, "failed");
-            ctx.log?.error?.(`[${account.accountId}] Error processing message: ${error.message}`);
+            logInboundCounters(pluginLog, account.accountId, "failed");
+            pluginLog?.error?.(`[${account.accountId}] Error processing message: ${error.message}`);
           }
         });
 
@@ -794,7 +808,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             try {
               c.socketCallBackResponse(messageId, { success: true });
             } catch (ackError: any) {
-              ctx.log?.warn?.(
+              pluginLog?.warn?.(
                 `[${account.accountId}] Failed to acknowledge card callback ${messageId}: ${ackError.message}`,
               );
             }
@@ -803,7 +817,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           try {
             const payload = JSON.parse(res.data);
             const analysis = analyzeCardCallback(payload);
-            ctx.log?.info?.(
+            pluginLog?.info?.(
               `[${account.accountId}] [DingTalk][CardCallback] action=${analysis.summary} raw=${JSON.stringify(payload)}`,
             );
 
@@ -826,14 +840,14 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                   analysis.feedbackAckText,
                   {
                     accountId: account.accountId,
-                    log: ctx.log,
+                    log: pluginLog,
                   },
                 );
-                ctx.log?.info?.(
+                pluginLog?.info?.(
                   `[${account.accountId}] [DingTalk][CardCallback] feedback ack sent to ${analysis.feedbackTarget}`,
                 );
               } catch (sendErr: any) {
-                ctx.log?.warn?.(
+                pluginLog?.warn?.(
                   `[${account.accountId}] [DingTalk][CardCallback] Failed to send feedback ack: ${sendErr?.message || String(sendErr)}`,
                 );
               }
@@ -843,15 +857,15 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
               cfg,
               accountId: account.accountId,
               config,
-              log: ctx.log,
+              log: pluginLog,
             });
             if (!actionResult.handled && analysis.actionId && analysis.actionId !== "feedback_up" && analysis.actionId !== "feedback_down") {
-              ctx.log?.debug?.(
+              pluginLog?.debug?.(
                 `[${account.accountId}] [DingTalk][CardCallback] Unhandled actionId=${analysis.actionId}`,
               );
             }
           } catch (error: any) {
-            ctx.log?.error?.(
+            pluginLog?.error?.(
               `[${account.accountId}] [DingTalk][CardCallback] Failed to parse callback: ${error.message}`,
             );
           } finally {
@@ -877,15 +891,15 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           return;
         }
         stopped = true;
-        ctx.log?.info?.(`[${account.accountId}] Stopping DingTalk Stream client...`);
+        pluginLog?.info?.(`[${account.accountId}] Stopping DingTalk Stream client...`);
         void finalizeActiveCardsForAccount(
           config,
           account.accountId,
           "⚠️ 服务正在重启，当前回复已中断。请重新发送你的问题。",
           accountStorePath,
-          ctx.log,
+          pluginLog,
         ).catch((err: any) => {
-          ctx.log?.debug?.(
+          pluginLog?.debug?.(
             `[${account.accountId}] Failed to finalize active cards during stop: ${err.message}`,
           );
         });
@@ -895,29 +909,35 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           try {
             client.disconnect();
           } catch (err: any) {
-            ctx.log?.warn?.(`[${account.accountId}] Error during disconnect: ${err.message}`);
+            pluginLog?.warn?.(`[${account.accountId}] Error during disconnect: ${err.message}`);
           }
           nativeStopResolve?.();
         }
 
-        ctx.setStatus({
-          ...ctx.getStatus(),
+        applyStatusPatch({
           running: false,
+          connected: false,
+          lastEventAt: getCurrentTimestamp(),
           lastStopAt: getCurrentTimestamp(),
         });
 
-        ctx.log?.info?.(`[${account.accountId}] DingTalk Stream client stopped`);
+        pluginLog?.info?.(`[${account.accountId}] DingTalk Stream client stopped`);
+        closePluginDebugLog({
+          accountId: account.accountId,
+          storePath: accountStorePath,
+        });
       };
 
       if (abortSignal) {
         if (abortSignal.aborted) {
-          ctx.log?.warn?.(
+          pluginLog?.warn?.(
             `[${account.accountId}] Abort signal already active, skipping connection`,
           );
 
-          ctx.setStatus({
-            ...ctx.getStatus(),
+          applyStatusPatch({
             running: false,
+            connected: false,
+            lastEventAt: getCurrentTimestamp(),
             lastStopAt: getCurrentTimestamp(),
             lastError: "Connection aborted before start",
           });
@@ -929,7 +949,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           if (stopped) {
             return;
           }
-          ctx.log?.info?.(
+          pluginLog?.info?.(
             `[${account.accountId}] Abort signal received, stopping DingTalk Stream client...`,
           );
           stopClient();
@@ -940,17 +960,19 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         try {
           await client.connect();
           if (!stopped) {
-            ctx.setStatus({
-              ...ctx.getStatus(),
+            applyStatusPatch({
               running: true,
+              connected: true,
+              lastConnectedAt: getCurrentTimestamp(),
+              lastEventAt: getCurrentTimestamp(),
               lastStartAt: getCurrentTimestamp(),
               lastError: null,
             });
-            ctx.log?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
+            pluginLog?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
             await nativeStopPromise;
           }
         } catch (err: any) {
-          ctx.log?.error?.(
+          pluginLog?.error?.(
             formatDingTalkConnectionErrorLog(
               // Use connect.open as base scope; instrumentation can override to connect.websocket
               "connect.open",
@@ -958,9 +980,10 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
               `[${account.accountId}] Failed to establish connection: ${err.message}`,
             ) ?? `[${account.accountId}] Failed to establish connection: ${err.message}`,
           );
-          ctx.setStatus({
-            ...ctx.getStatus(),
+          applyStatusPatch({
             running: false,
+            connected: false,
+            lastEventAt: getCurrentTimestamp(),
             lastError: err.message || "Connection failed",
           });
           throw err;
@@ -984,13 +1007,15 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           if (stopped) {
             return;
           }
-          ctx.log?.debug?.(
+          pluginLog?.debug?.(
             `[${account.accountId}] Connection state changed to: ${state}${error ? ` (${error})` : ""}`,
           );
           if (state === ConnectionState.CONNECTED) {
-            ctx.setStatus({
-              ...ctx.getStatus(),
+            applyStatusPatch({
               running: true,
+              connected: true,
+              lastConnectedAt: getCurrentTimestamp(),
+              lastEventAt: getCurrentTimestamp(),
               lastStartAt: getCurrentTimestamp(),
               lastError: null,
             });
@@ -1007,20 +1032,21 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
               }
             }
             if (cleared > 0) {
-              ctx.log?.info?.(
+              pluginLog?.info?.(
                 `[${account.accountId}] Cleared ${cleared} stale in-flight lock(s) on disconnect`,
               );
             }
-            ctx.setStatus({
-              ...ctx.getStatus(),
+            applyStatusPatch({
               running: false,
+              connected: false,
+              lastEventAt: getCurrentTimestamp(),
               lastError: error || `Connection ${state.toLowerCase()}`,
             });
           }
         },
       };
 
-      ctx.log?.debug?.(
+      pluginLog?.debug?.(
         `[${account.accountId}] Connection config: maxAttempts=${connectionConfig.maxAttempts}, ` +
           `initialDelay=${connectionConfig.initialDelay}ms, maxDelay=${connectionConfig.maxDelay}ms, ` +
           `jitter=${connectionConfig.jitter}`,
@@ -1030,7 +1056,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         client,
         account.accountId,
         connectionConfig,
-        ctx.log,
+        pluginLog,
         createStreamClient,
       );
 
@@ -1038,23 +1064,25 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         await connectionManager.connect();
 
         if (!stopped && connectionManager.isConnected()) {
-          ctx.setStatus({
-            ...ctx.getStatus(),
+          applyStatusPatch({
             running: true,
+            connected: true,
+            lastConnectedAt: getCurrentTimestamp(),
+            lastEventAt: getCurrentTimestamp(),
             lastStartAt: getCurrentTimestamp(),
             lastError: null,
           });
-          ctx.log?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
+          pluginLog?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
 
           await connectionManager.waitForStop();
         } else {
-          ctx.log?.info?.(
+          pluginLog?.info?.(
             `[${account.accountId}] DingTalk Stream client connect() completed but channel is ` +
               `not running (stopped=${stopped}, connected=${connectionManager.isConnected()})`,
           );
         }
       } catch (err: any) {
-        ctx.log?.error?.(
+        pluginLog?.error?.(
           formatDingTalkConnectionErrorLog(
             // Use connect.open as base scope; instrumentation can override to connect.websocket
             "connect.open",
@@ -1063,9 +1091,10 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           ) ?? `[${account.accountId}] Failed to establish connection: ${err.message}`,
         );
 
-        ctx.setStatus({
-          ...ctx.getStatus(),
+        applyStatusPatch({
           running: false,
+          connected: false,
+          lastEventAt: getCurrentTimestamp(),
           lastError: err.message || "Connection failed",
         });
         throw err;
@@ -1082,7 +1111,10 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
     defaultRuntime: {
       accountId: "default",
       running: false,
+      connected: false,
       lastEventAt: null,
+      lastConnectedAt: null,
+      lastInboundAt: null,
       lastStartAt: null,
       lastStopAt: null,
       lastError: null,
@@ -1139,7 +1171,10 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         configured: account.configured,
         clientId: account.config?.clientId ?? null,
         running,
+        connected: runtime?.connected ?? snapshot?.connected ?? null,
         lastEventAt: running ? getCurrentTimestamp() : persistedLastEventAt,
+        lastConnectedAt: runtime?.lastConnectedAt ?? snapshot?.lastConnectedAt ?? null,
+        lastInboundAt: runtime?.lastInboundAt ?? snapshot?.lastInboundAt ?? null,
         lastStartAt: runtime?.lastStartAt ?? snapshot?.lastStartAt ?? null,
         lastStopAt: runtime?.lastStopAt ?? snapshot?.lastStopAt ?? null,
         lastError: runtime?.lastError ?? snapshot?.lastError ?? null,

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

@@ -1,26 +1,8 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { resolveNativeCommandSessionTargets } from "openclaw/plugin-sdk/command-auth";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { getDingTalkRuntime } from "../runtime";
 import type { Logger } from "../types";
 
-/**
- * Local implementation of the same logic as
- * `resolveNativeCommandSessionTargets` from `openclaw/plugin-sdk/command-auth`.
- *
- * Inlined because the CI openclaw package does not yet export that sub-path.
- * Replace with a direct import once the upstream package is updated.
- */
-function resolveNativeCommandSessionTargets(params: {
-  agentId: string;
-  sessionPrefix: string;
-  userId: string;
-  targetSessionKey: string;
-}): { sessionKey: string; commandTargetSessionKey: string } {
-  return {
-    sessionKey: `agent:${params.agentId}:${params.sessionPrefix}:${params.userId}`,
-    commandTargetSessionKey: params.targetSessionKey,
-  };
-}
-
 /**
  * Dispatch a native targeted `/stop` command through the OpenClaw SDK,
  * replacing the previous self-built Gateway WebSocket `chat.abort` approach.
@@ -35,8 +17,8 @@ function resolveNativeCommandSessionTargets(params: {
  * and executes `abortEmbeddedPiRun` + `clearSessionQueues`.
  *
  * Accesses SDK functions via `getDingTalkRuntime().channel.reply` — the same
- * pattern used by `inbound-handler.ts` — to avoid direct sub-path imports
- * that may not be available in the CI openclaw package version.
+ * pattern used by `inbound-handler.ts` — while reusing the upstream native
+ * command session-target helper exported by the plugin SDK.
  */
 export async function dispatchDingTalkCardStopCommand(params: {
   cfg: OpenClawConfig;