@youdu/openclaw-youdu 2026.6.26 → 2026.8.20

package/dist/src/channel.d.ts

@@ -1,3 +1,9 @@
 import { type ChannelPlugin } from "openclaw/plugin-sdk/core";
 import { type ResolvedYouDuAccount } from './utils.js';
-export declare const youduPlugin: ChannelPlugin<ResolvedYouDuAccount>;
+import type { WsConnectionSnapshot } from "./sdk/types.js";
+export type YouDuProbeResult = WsConnectionSnapshot & {
+    ok: boolean;
+    status: number;
+    error?: string;
+};
+export declare const youduPlugin: ChannelPlugin<ResolvedYouDuAccount, YouDuProbeResult>;

package/dist/src/channel.js

@@ -1,10 +1,11 @@
-import { monitorYouDuProvider } from './monitor.js';
+import { monitorYouDuProvider, YOUDU_CONFIGURATION_ERROR_HEALTH_STATE } from './monitor.js';
 import { resolveYouDuAccount } from './utils.js';
 import { TEXT_CHUNK_LIMIT, CHANNEL_ID, DEFAULT_DM_POLICY } from './const.js';
 import { youduSetupAdapter, youduSetupWizard } from './onboarding.js';
 import { DEFAULT_ACCOUNT_ID, formatPairingApproveHint } from './openclaw-compat.js';
 import { getYouDuRuntime } from './runtime.js';
 import { sendYouDuMediaMessage, sendYouDuTextMessage } from './message-sender.js';
+import { getYouDuWebSocket } from './state-manager.js';
 
 /*
 * Licensed under the MIT License.
@@ -19,6 +20,50 @@ const meta = {
     blurb: '有度机器人接入插件',
     systemImage: 'message.fill',
 };
+function toProbeResult(snapshot) {
+    const ok = snapshot.state === "authenticated" && snapshot.authenticated;
+    return {
+        ok,
+        status: ok ? 200 : 503,
+        ...snapshot,
+        ...(ok
+            ? {}
+            : { error: snapshot.lastError ?? `WebSocket is ${snapshot.state}` }),
+    };
+}
+function connectionStatusFields(value) {
+    const source = value && typeof value === "object" ? value : {};
+    const state = source.state ?? "stopped";
+    const authenticated = state === "authenticated" && source.authenticated === true;
+    return {
+        state,
+        authenticated,
+        connected: authenticated,
+        healthState: state,
+        reconnectAttempts: source.reconnectAttempts ?? 0,
+        reconnectPhase: source.reconnectPhase ?? "fast",
+        nextRetryAt: source.nextRetryAt ?? null,
+        lastConnectedAt: source.lastConnectedAt ?? null,
+        lastAuthenticatedAt: source.lastAuthenticatedAt ?? null,
+        lastDisconnectedAt: source.lastDisconnectedAt ?? null,
+        lastError: source.lastError ?? null,
+    };
+}
+function probeFromSnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== "object")
+        return undefined;
+    return snapshot.probe;
+}
+function hasAuthenticationConfigurationError(...values) {
+    return values.some((value) => {
+        if (!value || typeof value !== "object")
+            return false;
+        const record = value;
+        if (record.healthState === YOUDU_CONFIGURATION_ERROR_HEALTH_STATE)
+            return true;
+        return [record.lastError, record.error].some((message) => typeof message === "string" && /\b1101\b/.test(message));
+    });
+}
 const youduPlugin = {
     id: CHANNEL_ID,
     meta: {
@@ -198,20 +243,45 @@ const youduPlugin = {
                 return issues;
             });
         },
-        buildChannelSummary: ({ snapshot }) => ({
-            configured: snapshot.configured ?? false,
-            running: snapshot.running ?? false,
-            lastStartAt: snapshot.lastStartAt ?? null,
-            lastStopAt: snapshot.lastStopAt ?? null,
-            lastError: snapshot.lastError ?? null,
-        }),
-        probeAccount: async () => {
-            return { ok: true, status: 200 };
+        buildChannelSummary: ({ snapshot }) => {
+            const probe = probeFromSnapshot(snapshot);
+            const configurationError = hasAuthenticationConfigurationError(snapshot, probe);
+            return {
+                configured: configurationError ? false : snapshot.configured ?? false,
+                running: snapshot.running ?? false,
+                lastStartAt: snapshot.lastStartAt ?? null,
+                lastStopAt: snapshot.lastStopAt ?? null,
+                ...connectionStatusFields(probe ?? snapshot),
+                ...(configurationError
+                    ? { healthState: YOUDU_CONFIGURATION_ERROR_HEALTH_STATE }
+                    : {}),
+            };
+        },
+        probeAccount: async ({ account }) => {
+            const wsClient = getYouDuWebSocket(account.accountId);
+            if (!wsClient) {
+                return toProbeResult({
+                    state: "stopped",
+                    authenticated: false,
+                    reconnectAttempts: 0,
+                    reconnectPhase: "fast",
+                    nextRetryAt: null,
+                    lastConnectedAt: null,
+                    lastAuthenticatedAt: null,
+                    lastDisconnectedAt: null,
+                    lastError: "WebSocket client is not running",
+                });
+            }
+            return toProbeResult(wsClient.getConnectionSnapshot());
         },
-        buildAccountSnapshot: ({ account, runtime }) => {
-            const configured = Boolean(account.botId?.trim() &&
+        buildAccountSnapshot: ({ account, runtime, probe }) => {
+            const configurationError = hasAuthenticationConfigurationError(runtime, probe);
+            const configuredByCredentials = Boolean(account.botId?.trim() &&
                 account.secret?.trim() &&
                 account.url?.trim());
+            const configured = configurationError || runtime?.configured === false
+                ? false
+                : configuredByCredentials;
             return {
                 accountId: account.accountId,
                 name: account.name,
@@ -220,7 +290,10 @@ const youduPlugin = {
                 running: runtime?.running ?? false,
                 lastStartAt: runtime?.lastStartAt ?? null,
                 lastStopAt: runtime?.lastStopAt ?? null,
-                lastError: runtime?.lastError ?? null,
+                ...connectionStatusFields(probe ?? probeFromSnapshot(runtime) ?? runtime),
+                ...(configurationError
+                    ? { healthState: YOUDU_CONFIGURATION_ERROR_HEALTH_STATE }
+                    : {}),
             };
         },
     },
@@ -232,6 +305,8 @@ const youduPlugin = {
                 config: ctx.cfg,
                 runtime: ctx.runtime,
                 abortSignal: ctx.abortSignal,
+                getStatus: ctx.getStatus,
+                setStatus: ctx.setStatus,
             });
         },
         logoutAccount: async ({ cfg }) => {

package/dist/src/const.d.ts

@@ -11,18 +11,12 @@ export declare const UPLOAD_MEDIA_URL = "/cgi/bot/file/upload";
 export declare const TEXT_CHUNK_LIMIT = 4000;
 /** WebSocket 心跳间隔（毫秒） */
 export declare const WS_HEARTBEAT_INTERVAL_MS = 30000;
-/** WebSocket 最大重连次数 */
+/** WebSocket 快速重连阶段次数；超过后转入低频持续恢复。 */
 export declare const WS_MAX_RECONNECT_ATTEMPTS = 10;
-/** 消息处理总超时时间（毫秒，被两级超时机制取代，保留兼容） */
-export declare const MESSAGE_PROCESS_TIMEOUT_MS: number;
-/** 第一级超时：警告阈值（毫秒）- 10 分钟，发送提示后任务继续 */
-export declare const WARNING_TIMEOUT_MS: number;
-/** 第二级超时：中止阈值（毫秒）- 20 分钟，发送提示后强制中断 */
-export declare const ABORT_TIMEOUT_MS: number;
-/** 超时警告提示 */
-export declare const WARNING_MESSAGE = "\u5904\u7406\u65F6\u95F4\u8F83\u957F\uFF0C\u8BF7\u7A0D\u7B49\uFF0C\u6B63\u5728\u751F\u6210\u6700\u7EC8\u7ED3\u679C...";
-/** 超时中止提示 */
-export declare const ABORT_MESSAGE = "\u5904\u7406\u65F6\u95F4\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+/** 循环提醒间隔（毫秒）- 每 10 分钟发送一次进度提醒，任务永不中断 */
+export declare const REMINDER_INTERVAL_MS: number;
+/** 生成提醒消息，包含已过时间 */
+export declare function getReminderMessage(elapsedMinutes: number): string;
 /** "思考中"流式消息占位内容 */
 export declare const THINKING_MESSAGE = "<think></think>";
 /** 消息状态清理间隔（毫秒） */

package/dist/src/const.js

@@ -14,16 +14,14 @@ const UPLOAD_MEDIA_URL = "/cgi/bot/file/upload";
 const TEXT_CHUNK_LIMIT = 4000;
 /** WebSocket 心跳间隔（毫秒） */
 const WS_HEARTBEAT_INTERVAL_MS = 30000;
-/** WebSocket 最大重连次数 */
+/** WebSocket 快速重连阶段次数；超过后转入低频持续恢复。 */
 const WS_MAX_RECONNECT_ATTEMPTS = 10;
-/** 第一级超时：警告阈值（毫秒）- 10 分钟，发送提示后任务继续 */
-const WARNING_TIMEOUT_MS = 10 * 60 * 1000;
-/** 第二级超时：中止阈值（毫秒）- 20 分钟，发送提示后强制中断 */
-const ABORT_TIMEOUT_MS = 20 * 60 * 1000;
-/** 超时警告提示 */
-const WARNING_MESSAGE = '处理时间较长，请稍等，正在生成最终结果...';
-/** 超时中止提示 */
-const ABORT_MESSAGE = '处理时间超时，请稍后重试';
+/** 循环提醒间隔（毫秒）- 每 10 分钟发送一次进度提醒，任务永不中断 */
+const REMINDER_INTERVAL_MS = 10 * 60 * 1000;
+/** 生成提醒消息，包含已过时间 */
+function getReminderMessage(elapsedMinutes) {
+    return `处理时间较长，已处理${elapsedMinutes}分钟，请稍等，正在生成最终结果.`;
+}
 /** "思考中"流式消息占位内容 */
 const THINKING_MESSAGE = '<think></think>';
 /** 消息状态清理间隔（毫秒） */
@@ -35,4 +33,4 @@ const MEDIA_DOCUMENT_PLACEHOLDER = "<media:document>";
 /** 最大的媒体传输大小 */
 const DEFAULT_MEDIA_MAX_SIZE = 12 * 1024 * 1024; // 12MB
 
-export { ABORT_MESSAGE, ABORT_TIMEOUT_MS, CHANNEL_ID, DEFAULT_DM_POLICY, DEFAULT_MEDIA_MAX_SIZE, DOWNLOAD_MEDIA_URL, HTTP_SCHEME, MEDIA_DOCUMENT_PLACEHOLDER, MEDIA_IMAGE_PLACEHOLDER, MESSAGE_STATE_CLEANUP_INTERVAL_MS, PORT, TEXT_CHUNK_LIMIT, THINKING_MESSAGE, UPLOAD_MEDIA_URL, WARNING_MESSAGE, WARNING_TIMEOUT_MS, WEBSOCKET_SCHEME, WS_HEARTBEAT_INTERVAL_MS, WS_MAX_RECONNECT_ATTEMPTS, WS_URL };
+export { CHANNEL_ID, DEFAULT_DM_POLICY, DEFAULT_MEDIA_MAX_SIZE, DOWNLOAD_MEDIA_URL, HTTP_SCHEME, MEDIA_DOCUMENT_PLACEHOLDER, MEDIA_IMAGE_PLACEHOLDER, MESSAGE_STATE_CLEANUP_INTERVAL_MS, PORT, REMINDER_INTERVAL_MS, TEXT_CHUNK_LIMIT, THINKING_MESSAGE, UPLOAD_MEDIA_URL, WEBSOCKET_SCHEME, WS_HEARTBEAT_INTERVAL_MS, WS_MAX_RECONNECT_ATTEMPTS, WS_URL, getReminderMessage };

package/dist/src/monitor.d.ts

@@ -1,5 +1,6 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
+import { WSClient } from './sdk/ws-client.js';
 import { ResolvedYouDuAccount } from './utils.js';
 import { type Youdu } from './media.js';
 import { type YouduDecodedBody } from './message-prepare.js';
@@ -42,7 +43,13 @@ export interface YouDuMonitorOptions {
     config: OpenClawConfig;
     runtime: RuntimeEnv;
     abortSignal?: AbortSignal;
+    /** OpenClaw channel runtime status sink. It observes the manager; it never schedules recovery. */
+    getStatus?: () => any;
+    setStatus?: (next: any) => void;
+    /** Test/runtime seam for supplying a client without changing reconnect ownership. */
+    createClient?: (options: any) => WSClient;
 }
+export declare const YOUDU_CONFIGURATION_ERROR_HEALTH_STATE = "configuration-error";
 /**
  * 监听 YouDu WebSocket 连接（主函数）
  */

package/dist/src/monitor.js

@@ -1,7 +1,7 @@
 import { WSClient } from './sdk/ws-client.js';
 import { getYouDuRuntime } from './runtime.js';
 import { resolveYouDuAccount } from './utils.js';
-import { WS_MAX_RECONNECT_ATTEMPTS, WS_HEARTBEAT_INTERVAL_MS, PORT, THINKING_MESSAGE, ABORT_TIMEOUT_MS, ABORT_MESSAGE, WARNING_TIMEOUT_MS, WARNING_MESSAGE, CHANNEL_ID, MEDIA_IMAGE_PLACEHOLDER, MEDIA_DOCUMENT_PLACEHOLDER } from './const.js';
+import { WS_MAX_RECONNECT_ATTEMPTS, WS_HEARTBEAT_INTERVAL_MS, PORT, THINKING_MESSAGE, getReminderMessage, REMINDER_INTERVAL_MS, CHANNEL_ID, MEDIA_IMAGE_PLACEHOLDER, MEDIA_DOCUMENT_PLACEHOLDER } from './const.js';
 import { buildYouDuTlsConnectOptions } from './tls.js';
 import { cleanupAccount, startMessageStateCleanup, setYouDuWebSocket, stopMessageStateCleanup, rememberDirectChatTarget, setMessageState, deleteMessageState } from './state-manager.js';
 import { checkDmPolicy } from './dm-policy.js';
@@ -14,6 +14,7 @@ import { prepareMessageBody } from './message-prepare.js';
 /*
 * Licensed under the MIT License.
 */
+const YOUDU_CONFIGURATION_ERROR_HEALTH_STATE = 'configuration-error';
 function buildMessageContext(frame, account, config, text, mediaList) {
     const core = getYouDuRuntime();
     const body = frame.body;
@@ -165,40 +166,30 @@ async function processYouDuMessage(params) {
             runtime,
             onCleanup: cleanupState,
         }), {
-            warningMs: WARNING_TIMEOUT_MS,
-            abortMs: ABORT_TIMEOUT_MS,
-            onWarning: async () => {
-                runtime.log?.(`[youdu] Task running for ${WARNING_TIMEOUT_MS / 1000 / 60} min, sending warning`);
-                await sendYouDuReply({ wsClient, frame, text: WARNING_MESSAGE, runtime });
-            },
-            onAbort: async () => {
-                runtime.log?.(`[youdu] Task running for ${ABORT_TIMEOUT_MS / 1000 / 60} min, aborting`);
-                state.timedOut = true;
-                await sendYouDuReply({ wsClient, frame, text: ABORT_MESSAGE, runtime });
+            intervalMs: REMINDER_INTERVAL_MS,
+            onReminder: async (elapsedMs) => {
+                const minutes = Math.round(elapsedMs / 60000);
+                const msg = getReminderMessage(minutes);
+                runtime.log?.(`[youdu] Task running for ${minutes} min, sending reminder`);
+                await sendYouDuReply({ wsClient, frame, text: msg, runtime });
             },
         });
     }
     catch (err) {
-        // 超时中止错误已在 onAbort 中发送提示，不再重复发送
-        if (state.timedOut) {
-            runtime.error?.(`[youdu][plugin] Message processing timed out after ${ABORT_TIMEOUT_MS / 1000 / 60} min`);
-        }
-        else {
-            runtime.error?.(`[youdu][plugin] Message processing failed: ${String(err)}`);
-            try {
-                if (shouldSendThinking) {
-                    await sendYouDuReply({
-                        wsClient,
-                        frame,
-                        text: '处理消息时出现异常，请稍后重试。',
-                        runtime,
-                    });
-                }
-            }
-            catch (finishErr) {
-                runtime.error?.(`[youdu] Failed to finish thinking stream on error: ${String(finishErr)}`);
+        runtime.error?.(`[youdu][plugin] Message processing failed: ${String(err)}`);
+        try {
+            if (shouldSendThinking) {
+                await sendYouDuReply({
+                    wsClient,
+                    frame,
+                    text: '处理消息时出现异常，请稍后重试。',
+                    runtime,
+                });
             }
         }
+        catch (finishErr) {
+            runtime.error?.(`[youdu] Failed to finish thinking stream on error: ${String(finishErr)}`);
+        }
         cleanupState();
     }
 }
@@ -222,9 +213,6 @@ async function routeAndDispatchMessage(params) {
             cfg: config,
             dispatcherOptions: {
                 deliver: async (payload, info) => {
-                    // 超时中止后不再处理后续交付
-                    if (state.timedOut)
-                        return;
                     state.deliverCalled = true;
                     // 累积文本
                     if (payload.text) {
@@ -297,9 +285,6 @@ function buildMediaErrorSummary(mediaUrl, errMsg) {
 }
 async function finishThinkingStream(ctx) {
     const { wsClient, frame, state, runtime } = ctx;
-    // 超时中止后不再发送最终回复
-    if (state.timedOut)
-        return;
     let finishText = state.accumulatedText;
     if (finishText) {
         await sendYouDuReply({ wsClient, frame, text: finishText, runtime });
@@ -332,50 +317,37 @@ async function finishThinkingStream(ctx) {
     }
 }
 /**
- * 两级超时保护
+ * 循环提醒保护
  *
- * 第一级（warningMs）：发送提示消息，任务继续执行
- * 第二级（abortMs）：发送中止消息，强制中断任务
+ * 每隔 intervalMs 发送一次进度提醒，任务永不中断。
+ * 任务完成后自动停止提醒。
  */
 async function processWithTimeoutGuard(task, options) {
     return new Promise((resolve, reject) => {
         let finished = false;
-        const warningTimer = setTimeout(async () => {
-            if (finished)
-                return;
-            try {
-                await options.onWarning();
-            }
-            catch {
-                // 警告发送失败不影响主流程
-            }
-        }, options.warningMs);
-        const abortTimer = setTimeout(async () => {
+        const startTime = Date.now();
+        const reminderTimer = setInterval(async () => {
             if (finished)
                 return;
-            finished = true;
-            clearTimeout(warningTimer);
+            const elapsed = Date.now() - startTime;
             try {
-                await options.onAbort();
+                await options.onReminder(elapsed);
             }
             catch {
-                // 中止消息发送失败仍要 reject
+                // 提醒发送失败不影响主流程
             }
-            reject(new Error('Task aborted after timeout'));
-        }, options.abortMs);
+        }, options.intervalMs);
         task().then((result) => {
             if (finished)
                 return;
             finished = true;
-            clearTimeout(warningTimer);
-            clearTimeout(abortTimer);
+            clearInterval(reminderTimer);
             resolve(result);
         }, (error) => {
             if (finished)
                 return;
             finished = true;
-            clearTimeout(warningTimer);
-            clearTimeout(abortTimer);
+            clearInterval(reminderTimer);
             reject(error);
         });
     });
@@ -406,18 +378,18 @@ async function getExtendedMediaLocalRoots(config) {
  * 监听 YouDu WebSocket 连接（主函数）
  */
 async function monitorYouDuProvider(options) {
-    const { account, config, runtime, abortSignal } = options;
+    const { account, config, runtime, abortSignal, getStatus, setStatus, createClient } = options;
     runtime.log?.(`[youdu][${account.accountId}] ========== monitorYouDuProvider STARTED ==========`);
     runtime.log?.(`[youdu][${account.accountId}] Initializing WSClient...`);
     runtime.log?.(`[youdu][${account.accountId}] Config: botId=${account.botId}, websocketUrl=${account.url || '(default)'}`);
     // 启动消息状态定期清理
     await cleanupAccount(account.accountId);
     startMessageStateCleanup();
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
         const logger = createSdkLogger(runtime, account.accountId);
         runtime.log?.(`[youdu][${account.accountId}] Creating WSClient instance...`);
         const tlsOptions = buildYouDuTlsConnectOptions(account);
-        const wsClient = new WSClient({
+        const wsClient = (createClient ?? ((clientOptions) => new WSClient(clientOptions)))({
             botId: account.botId,
             secret: account.secret,
             wsUrl: `${account.url}:${PORT}`,
@@ -426,37 +398,94 @@ async function monitorYouDuProvider(options) {
             heartbeatInterval: WS_HEARTBEAT_INTERVAL_MS,
             maxReconnectAttempts: WS_MAX_RECONNECT_ATTEMPTS,
         });
+        const syncStatus = (mode = 'active') => {
+            if (!setStatus)
+                return;
+            const snapshot = wsClient.getConnectionSnapshot();
+            const healthy = snapshot.state === 'authenticated' && snapshot.authenticated;
+            const sdkOwnsRecovery = snapshot.state === 'connecting' ||
+                snapshot.state === 'reconnecting' ||
+                snapshot.state === 'offline';
+            const configurationError = mode === 'configuration-error';
+            const current = getStatus?.() ?? { accountId: account.accountId };
+            setStatus({
+                ...current,
+                accountId: account.accountId,
+                configured: configurationError ? false : current.configured,
+                // OpenClaw treats connected=false as permission to restart the channel.
+                // Leave it undecided while this manager owns recovery; probe/status still
+                // expose the actual unauthenticated state and retry metadata.
+                running: mode === 'stopped' ? false : true,
+                connected: healthy
+                    ? true
+                    : configurationError || sdkOwnsRecovery
+                        ? undefined
+                        : false,
+                healthState: configurationError
+                    ? YOUDU_CONFIGURATION_ERROR_HEALTH_STATE
+                    : snapshot.state,
+                state: snapshot.state,
+                authenticated: snapshot.authenticated,
+                reconnectAttempts: snapshot.reconnectAttempts,
+                reconnectPhase: snapshot.reconnectPhase,
+                nextRetryAt: snapshot.nextRetryAt,
+                lastConnectedAt: snapshot.lastConnectedAt,
+                lastAuthenticatedAt: snapshot.lastAuthenticatedAt,
+                lastDisconnectedAt: snapshot.lastDisconnectedAt,
+                lastError: snapshot.lastError,
+            });
+        };
         runtime.log?.(`[youdu][${account.accountId}] WSClient created, setting up event listeners...`);
         setYouDuWebSocket(account.accountId, wsClient);
-        const cleanup = async () => {
+        const cleanup = async (removeClient = true) => {
             stopMessageStateCleanup();
-            await cleanupAccount(account.accountId, wsClient);
+            if (removeClient) {
+                await cleanupAccount(account.accountId, wsClient);
+            }
+            else {
+                wsClient.disconnect();
+            }
         };
+        let authenticationFailureHandled = false;
         if (abortSignal) {
             abortSignal.addEventListener('abort', async () => {
                 runtime.log?.(`[${account.accountId}] Connection aborted`);
                 await cleanup();
+                syncStatus('stopped');
                 resolve();
             });
         }
         wsClient.on('connected', () => {
+            syncStatus();
             // runtime.log?.(`[youdu][${account.accountId}] >>> WebSocket CONNECTED event received`);
         });
         wsClient.on('authenticated', () => {
             runtime.log?.(`[youdu][${account.accountId}] >>> Authentication SUCCESSFUL`);
             setYouDuWebSocket(account.accountId, wsClient);
+            syncStatus();
         });
         wsClient.on('disconnected', (reason) => {
             runtime.log?.(`[youdu][${account.accountId}] <<< WebSocket DISCONNECTED: ${reason}`);
+            syncStatus();
         });
         wsClient.on('reconnecting', (attempt) => {
             runtime.log?.(`[youdu][${account.accountId}] ↻ Reconnecting attempt #${attempt}...`);
+            syncStatus();
         });
         wsClient.on('error', (error) => {
             runtime.error?.(`[youdu][${account.accountId}] !!! WebSocket ERROR: ${error.message}`);
             if (error.message.includes('Authentication failed')) {
-                runtime.error?.(`[youdu][${account.accountId}] Authentication failed, rejecting promise`);
-                cleanup().finally(() => reject(error));
+                if (authenticationFailureHandled)
+                    return;
+                authenticationFailureHandled = true;
+                // 1101 is a configuration fault. Keep this monitor alive so OpenClaw's
+                // account supervisor does not turn it into an automatic restart loop.
+                runtime.error?.(`[youdu][${account.accountId}] Authentication failed; waiting for configuration reload`);
+                syncStatus('configuration-error');
+                void cleanup(false).then(() => syncStatus('configuration-error'));
+            }
+            else {
+                syncStatus();
             }
         });
         runtime.log?.(`[youdu][${account.accountId}] Event listeners registered, calling wsClient.connect()...`);
@@ -477,7 +506,8 @@ async function monitorYouDuProvider(options) {
         });
         // 建立连接
         wsClient.connect();
+        syncStatus();
     });
 }
 
-export { monitorYouDuProvider };
+export { YOUDU_CONFIGURATION_ERROR_HEALTH_STATE, monitorYouDuProvider };

package/dist/src/sdk/types.d.ts

@@ -1,4 +1,5 @@
 import type { YouDuTlsConnectOptions } from "../tls.js";
+import type WebSocket from "ws";
 /**
  * 日志接口
  */
@@ -8,6 +9,29 @@ export interface Logger {
     warn(message: string, ...args: any[]): void;
     error(message: string, ...args: any[]): void;
 }
+export type WsConnectionState = "connecting" | "authenticated" | "reconnecting" | "offline" | "stopped";
+export type WsReconnectPhase = "fast" | "slow";
+export interface WsConnectionSnapshot {
+    readonly state: WsConnectionState;
+    readonly authenticated: boolean;
+    readonly reconnectAttempts: number;
+    readonly reconnectPhase: WsReconnectPhase;
+    readonly nextRetryAt: number | null;
+    readonly lastConnectedAt: number | null;
+    readonly lastAuthenticatedAt: number | null;
+    readonly lastDisconnectedAt: number | null;
+    readonly lastError: string | null;
+}
+export interface WsConnectionManagerHooks {
+    readonly now?: () => number;
+    readonly random?: () => number;
+    readonly setTimeout?: (callback: () => void, delay: number) => ReturnType<typeof setTimeout>;
+    readonly clearTimeout?: (timer: ReturnType<typeof setTimeout>) => void;
+    /** 可测试的 socket 创建入口；生产默认使用 ws.WebSocket。 */
+    readonly createWebSocket?: (url: string, options?: ConstructorParameters<typeof WebSocket>[1]) => WebSocket;
+    readonly connectTimeoutMs?: number;
+    readonly authTimeoutMs?: number;
+}
 /**
  * WebSocket 帧结构
  */

package/dist/src/sdk/ws-client.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from "events";
 import { WsCmd, WsErrCode, DefaultLogger } from "./ws-utils";
-import type { WsFrame, WSClientOptions } from "./types";
+import type { WsConnectionSnapshot, WsFrame, WSClientOptions } from "./types";
 /**
  * YouDu WebSocket 客户端
  */
@@ -16,6 +16,7 @@ export declare class WSClient extends EventEmitter {
     reply(frame: WsFrame, body: any, cmd?: string): Promise<WsFrame>;
     sendMessage(chatId: string, body: any): Promise<WsFrame>;
     getToken(): string;
+    getConnectionSnapshot(): WsConnectionSnapshot;
 }
-export type { Logger, WsFrame, WSClientOptions, WSClientEventMap, } from "./types";
+export type { Logger, WsFrame, WSClientOptions, WSClientEventMap, WsConnectionSnapshot, WsConnectionState, WsReconnectPhase, } from "./types";
 export { DefaultLogger, WsCmd, WsErrCode };

package/dist/src/sdk/ws-client.js

@@ -79,6 +79,9 @@ class WSClient extends EventEmitter {
     getToken() {
         return this.wsManager.getToken();
     }
+    getConnectionSnapshot() {
+        return this.wsManager.getConnectionSnapshot();
+    }
 }
 
 export { DefaultLogger, WSClient, WsCmd };

package/dist/src/sdk/ws-manager.d.ts

@@ -1,6 +1,11 @@
 import { EventEmitter } from "events";
-import type { Logger, WsFrame } from "./types";
+import type { Logger, WsConnectionManagerHooks, WsConnectionSnapshot, WsFrame, WsReconnectPhase } from "./types";
 import type { YouDuTlsConnectOptions } from "../tls.js";
+export interface ReconnectDelay {
+    readonly delay: number;
+    readonly phase: WsReconnectPhase;
+}
+export declare function calculateReconnectDelay(reconnectAttempt: number, maxFastAttempts?: number, reconnectBaseDelay?: number, reconnectMaxDelay?: number, random?: () => number): ReconnectDelay;
 /**
  * WebSocket 长连接管理器
  */
@@ -13,12 +18,33 @@ export declare class WsConnectionManager extends EventEmitter {
     private heartbeatTimer;
     private maxReconnectAttempts;
     private reconnectAttempts;
+    private reconnectTimer;
+    private connectWatchdogTimer;
+    private authWatchdogTimer;
+    private reconnectPhase;
     private isManualClose;
+    private state;
+    private authenticated;
+    private nextRetryAt;
+    private lastConnectedAt;
+    private lastAuthenticatedAt;
+    private lastDisconnectedAt;
+    private lastError;
+    /** 保留本次连接尝试中更具体的 socket/auth 错误，避免 close(1006) 覆盖根因。 */
+    private lastErrorIsSpecific;
+    private readonly now;
+    private readonly random;
+    private readonly scheduleTimeout;
+    private readonly cancelTimeout;
+    private readonly createWebSocket;
+    private readonly connectTimeoutMs;
+    private readonly authTimeoutMs;
     /** 认证凭证 */
     private botId;
     private botSecret;
     private token;
     private hasAuthenticated;
+    private isReauthenticating;
     /** 连续未收到心跳响应的次数 */
     private missedPongCount;
     private readonly maxMissedPong;
@@ -29,9 +55,10 @@ export declare class WsConnectionManager extends EventEmitter {
     private pendingAcks;
     private readonly replyAckTimeout;
     private readonly maxReplyQueueSize;
-    constructor(logger: Logger, heartbeatInterval?: number, reconnectBaseDelay?: number, maxReconnectAttempts?: number, wsUrl?: string, tlsOptions?: YouDuTlsConnectOptions);
+    constructor(logger: Logger, heartbeatInterval?: number, reconnectBaseDelay?: number, maxReconnectAttempts?: number, wsUrl?: string, tlsOptions?: YouDuTlsConnectOptions, hooks?: WsConnectionManagerHooks);
     setCredentials(botId: string, botSecret: string): void;
     getToken(): string;
+    getConnectionSnapshot(): WsConnectionSnapshot;
     connect(): void;
     private setupEventHandlers;
     private sendAuth;
@@ -41,6 +68,12 @@ export declare class WsConnectionManager extends EventEmitter {
     private reconnectWithFreshAuth;
     private sendHeartbeat;
     private scheduleReconnect;
+    private clearReconnectTimer;
+    private startConnectWatchdog;
+    private startAuthWatchdog;
+    private clearConnectWatchdog;
+    private clearAuthWatchdog;
+    private clearWatchdogs;
     send(frame: WsFrame): void;
     sendReply(reqId: string, body: any, cmd?: string): Promise<WsFrame>;
     private processReplyQueue;

package/dist/src/sdk/ws-manager.js

@@ -6,21 +6,57 @@ import { WsCmd, generateReqId, WsErrCode } from './ws-utils.js';
 /*
 * Licensed under the MIT License.
 */
+const SLOW_RECONNECT_DELAY_MS = 5 * 60 * 1000;
+const SLOW_RECONNECT_JITTER_RATIO = 0.2;
+const DEFAULT_CONNECT_TIMEOUT_MS = 30000;
+const DEFAULT_AUTH_TIMEOUT_MS = 30000;
+function calculateReconnectDelay(reconnectAttempt, maxFastAttempts = 10, reconnectBaseDelay = 1000, reconnectMaxDelay = 30000, random = Math.random) {
+    const attempt = Math.max(1, Math.floor(reconnectAttempt));
+    const fastAttemptLimit = maxFastAttempts > 0 ? Math.floor(maxFastAttempts) : 10;
+    // Fast recovery: the configured window (10 attempts in production) caps at 30 seconds.
+    if (attempt <= fastAttemptLimit) {
+        return {
+            delay: Math.min(reconnectBaseDelay * Math.pow(2, attempt - 1), reconnectMaxDelay),
+            phase: "fast",
+        };
+    }
+    // Slow persistent recovery: retry forever every five minutes with +/-20% jitter.
+    const randomValue = Math.min(1, Math.max(0, random()));
+    const jitterMultiplier = 1 - SLOW_RECONNECT_JITTER_RATIO + randomValue * SLOW_RECONNECT_JITTER_RATIO * 2;
+    return {
+        delay: Math.round(SLOW_RECONNECT_DELAY_MS * jitterMultiplier),
+        phase: "slow",
+    };
+}
 /**
  * WebSocket 长连接管理器
  */
 class WsConnectionManager extends EventEmitter {
-    constructor(logger, heartbeatInterval = 30000, reconnectBaseDelay = 1000, maxReconnectAttempts = 10, wsUrl, tlsOptions) {
+    constructor(logger, heartbeatInterval = 30000, reconnectBaseDelay = 1000, maxReconnectAttempts = 10, wsUrl, tlsOptions, hooks = {}) {
         super();
         this.ws = null;
         this.heartbeatTimer = null;
         this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.connectWatchdogTimer = null;
+        this.authWatchdogTimer = null;
+        this.reconnectPhase = "fast";
         this.isManualClose = false;
+        this.state = "stopped";
+        this.authenticated = false;
+        this.nextRetryAt = null;
+        this.lastConnectedAt = null;
+        this.lastAuthenticatedAt = null;
+        this.lastDisconnectedAt = null;
+        this.lastError = null;
+        /** 保留本次连接尝试中更具体的 socket/auth 错误，避免 close(1006) 覆盖根因。 */
+        this.lastErrorIsSpecific = false;
         /** 认证凭证 */
         this.botId = "";
         this.botSecret = "";
         this.token = "";
         this.hasAuthenticated = false; // 是否曾经成功认证过
+        this.isReauthenticating = false;
         /** 连续未收到心跳响应的次数 */
         this.missedPongCount = 0;
         this.maxMissedPong = 2;
@@ -36,6 +72,13 @@ class WsConnectionManager extends EventEmitter {
         this.reconnectBaseDelay = reconnectBaseDelay;
         this.maxReconnectAttempts = maxReconnectAttempts;
         this.tlsOptions = tlsOptions;
+        this.now = hooks.now ?? Date.now;
+        this.random = hooks.random ?? Math.random;
+        this.scheduleTimeout = hooks.setTimeout ?? setTimeout;
+        this.cancelTimeout = hooks.clearTimeout ?? clearTimeout;
+        this.createWebSocket = hooks.createWebSocket ?? ((url, options) => new WebSocket(url, options));
+        this.connectTimeoutMs = hooks.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+        this.authTimeoutMs = hooks.authTimeoutMs ?? DEFAULT_AUTH_TIMEOUT_MS;
         if (wsUrl && wsUrl.trim()) {
             this.wsUrl = `${WEBSOCKET_SCHEME}${wsUrl.trim()}${WS_URL}`;
         }
@@ -44,14 +87,42 @@ class WsConnectionManager extends EventEmitter {
         }
     }
     setCredentials(botId, botSecret) {
+        const changed = this.botId !== botId || this.botSecret !== botSecret;
         this.botId = botId;
         this.botSecret = botSecret;
+        if (changed) {
+            // 配置更新后允许重新认证，即使上一次 1101 曾主动停止了管理器。
+            this.isManualClose = false;
+            this.clearReconnectTimer();
+            this.clearAuth();
+            this.state = "stopped";
+            this.lastError = null;
+            this.lastErrorIsSpecific = false;
+        }
     }
     getToken() {
         return this.token;
     }
+    getConnectionSnapshot() {
+        return {
+            state: this.state,
+            authenticated: this.authenticated,
+            reconnectAttempts: this.reconnectAttempts,
+            reconnectPhase: this.reconnectPhase,
+            nextRetryAt: this.nextRetryAt,
+            lastConnectedAt: this.lastConnectedAt,
+            lastAuthenticatedAt: this.lastAuthenticatedAt,
+            lastDisconnectedAt: this.lastDisconnectedAt,
+            lastError: this.lastError,
+        };
+    }
     connect() {
+        this.clearReconnectTimer();
+        this.clearWatchdogs();
         this.isManualClose = false;
+        this.lastErrorIsSpecific = false;
+        this.authenticated = false;
+        this.state = "connecting";
         if (this.ws) {
             this.logger.info("[WS] Closing existing connection before reconnect...");
             this.ws.removeAllListeners();
@@ -70,11 +141,15 @@ class WsConnectionManager extends EventEmitter {
             else {
                 this.logger.info("[WS] Using WS protocol, no TLS config required");
             }
-            this.ws = new WebSocket(this.wsUrl, options);
+            this.ws = this.createWebSocket(this.wsUrl, options);
             this.logger.info(`[WS] WebSocket instance created, readyState=${this.ws.readyState}`);
             this.setupEventHandlers();
+            this.startConnectWatchdog(this.ws);
         }
         catch (error) {
+            this.state = "offline";
+            this.lastError = error.message;
+            this.lastErrorIsSpecific = true;
             this.logger.error(`[WS] !!! Failed to create WebSocket connection: ${error.message}`);
             this.logger.error(`[WS] Error stack: ${error.stack}`);
             this.emit("error", error);
@@ -84,22 +159,25 @@ class WsConnectionManager extends EventEmitter {
     setupEventHandlers() {
         if (!this.ws)
             return;
-        this.logger.info(`[WS] Setting up event handlers for WebSocket (readyState=${this.ws.readyState})`);
-        this.ws.on("open", () => {
+        const socket = this.ws;
+        this.logger.info(`[WS] Setting up event handlers for WebSocket (readyState=${socket.readyState})`);
+        socket.on("open", () => {
+            if (this.ws !== socket || this.isManualClose)
+                return;
+            this.clearConnectWatchdog();
             this.missedPongCount = 0;
+            this.lastConnectedAt = this.now();
             const authMethod = (this.hasAuthenticated && this.token) ? "reconnect (with token)" : "subscribe (with bot_id + secret)";
             this.logger.info(`[WS] WebSocket opened, will use ${authMethod} for authentication`);
             this.sendAuth();
             this.emit("connected");
         });
-        this.ws.on("message", (data) => {
+        socket.on("message", (data) => {
             const raw = data.toString();
             let frame;
             try {
                 frame = JSON.parse(raw);
-                if (!frame.headers?.reqId.startsWith("ping")) {
-                    this.logger.info(`[WS] <<< Received message (${raw.length} chars): ${raw}`);
-                }
+                this.logger.info(`[WS] <<< Received message (${raw.length} chars): ${raw}`);
             }
             catch {
                 frame = {
@@ -117,25 +195,54 @@ class WsConnectionManager extends EventEmitter {
             }
             this.handleFrame(frame);
         });
-        this.ws.on("close", (code, reason) => {
+        socket.on("close", (code, reason) => {
             const reasonStr = reason.toString() || `code: ${code}`;
             const logMsg = `[WS] WebSocket DISCONNECTED: ${reasonStr}`;
             this.logger.warn(logMsg);
             this.logger.warn(`[WS] isManualClose=${this.isManualClose}`);
+            if (this.ws !== socket)
+                return;
             this.stopHeartbeat();
+            this.clearWatchdogs();
             this.clearPendingMessages(`WebSocket connection closed (${reasonStr})`);
+            if (this.ws === socket) {
+                this.ws = null;
+            }
+            this.authenticated = false;
+            if (this.state !== "stopped") {
+                this.state = "offline";
+            }
+            this.lastDisconnectedAt = this.now();
+            if (!this.isManualClose && !this.lastErrorIsSpecific) {
+                this.lastError = reasonStr;
+            }
             this.emit("disconnected", reasonStr);
             if (!this.isManualClose) {
                 this.scheduleReconnect();
             }
         });
-        this.ws.on("error", (error) => {
+        socket.on("error", (error) => {
             const errMsg = `[WS] !!! WebSocket ERROR: ${error.message}`;
+            if (this.ws !== socket)
+                return;
+            this.clearWatchdogs();
+            this.authenticated = false;
+            if (!this.isManualClose || !this.lastErrorIsSpecific) {
+                this.state = this.isManualClose ? "stopped" : "offline";
+                this.lastError = error.message;
+                this.lastErrorIsSpecific = true;
+            }
             this.logger.error(errMsg);
             this.emit("error", error);
+            if (!this.isManualClose) {
+                this.scheduleReconnect();
+            }
+        });
+        socket.on("ping", () => {
+            socket.pong();
         });
-        this.ws.on("ping", () => {
-            this.ws?.pong();
+        socket.on("pong", () => {
+            this.missedPongCount = 0;
         });
         this.logger.info("[WS] Event handlers registered");
     }
@@ -166,6 +273,8 @@ class WsConnectionManager extends EventEmitter {
                 this.logger.info("[WS] Sending subscribe frame with bot_id + secret");
             }
             this.send(frame);
+            if (this.ws)
+                this.startAuthWatchdog(this.ws);
             this.logger.info("[WS] Auth frame sent successfully");
         }
         catch (error) {
@@ -186,24 +295,31 @@ class WsConnectionManager extends EventEmitter {
             return;
         }
         if (actualReqId.startsWith(WsCmd.SUBSCRIBE) || actualReqId.startsWith(WsCmd.RECONNECT)) {
+            this.clearAuthWatchdog();
             const isReconnect = actualReqId.startsWith(WsCmd.RECONNECT);
             const authType = isReconnect ? "Reconnect" : "Subscribe";
             if (frame.errCode !== WsErrCode.SUCCESS) {
-                this.logger.error(`${authType} failed: errcode=${frame.errCode}, errmsg=${frame.errMsg}`);
+                const authError = `${authType} failed: errcode=${frame.errCode}, errmsg=${frame.errMsg}`;
+                this.authenticated = false;
+                this.state = "offline";
+                this.lastError = authError;
+                this.lastErrorIsSpecific = true;
+                this.logger.error(authError);
+                if (frame.errCode === WsErrCode.AUTH_FAILED) {
+                    this.isManualClose = true;
+                    this.clearReconnectTimer();
+                    this.stopHeartbeat();
+                    this.ws?.close(1000, "Authentication failed");
+                    this.emit("error", new Error(`Authentication failed: ${frame.errMsg} (code: ${frame.errCode})`));
+                    return;
+                }
                 // Token rejection means the current session is no longer trusted.
                 if (isReconnect) {
                     this.reconnectWithFreshAuth("[WS] Token invalid, will reconnect to re-authenticate");
                 }
                 else {
-                    if (frame.errCode === WsErrCode.AUTH_FAILED) {
-                        this.isManualClose = true;
-                        this.ws?.close(1000, "Authentication failed");
-                        this.emit("error", new Error(`${authType} failed: ${frame.errMsg} (code: ${frame.errCode})`));
-                    }
-                    else {
-                        this.logger.warn(`[WS] Subscribe failed with temporary error, reconnect will retry: errcode=${frame.errCode}`);
-                        this.ws?.terminate();
-                    }
+                    this.logger.warn(`[WS] Subscribe failed with temporary error, reconnect will retry: errcode=${frame.errCode}`);
+                    this.ws?.terminate();
                 }
                 return;
             }
@@ -214,7 +330,16 @@ class WsConnectionManager extends EventEmitter {
                 this.logger.info("token already stored");
             }
             this.logger.info("Authentication successful");
+            this.clearReconnectTimer();
+            this.authenticated = true;
+            this.state = "authenticated";
+            this.isReauthenticating = false;
             this.reconnectAttempts = 0;
+            this.reconnectPhase = "fast";
+            this.nextRetryAt = null;
+            this.lastAuthenticatedAt = this.now();
+            this.lastError = null;
+            this.lastErrorIsSpecific = false;
             this.startHeartbeat();
             this.emit("authenticated");
             return;
@@ -230,6 +355,11 @@ class WsConnectionManager extends EventEmitter {
             this.missedPongCount = 0;
             return;
         }
+        // A business ACK can arrive after its local timeout removed pendingAcks.
+        // Token invalidation still applies to the connection even though its promise is gone.
+        if (frame.errCode === WsErrCode.TOKEN_INVALID) {
+            this.reconnectWithFreshAuth("[WS] Token invalid in late reply, will reconnect to re-authenticate");
+        }
     }
     startHeartbeat() {
         this.stopHeartbeat();
@@ -246,47 +376,131 @@ class WsConnectionManager extends EventEmitter {
         }
     }
     reconnectWithFreshAuth(reason) {
+        if (this.isReauthenticating) {
+            return;
+        }
+        this.isReauthenticating = true;
         this.logger.warn(reason);
+        this.clearWatchdogs();
         this.stopHeartbeat();
         this.token = "";
         this.hasAuthenticated = false;
+        this.authenticated = false;
+        this.state = "offline";
+        this.lastError = reason;
+        this.lastErrorIsSpecific = true;
         this.missedPongCount = 0;
+        this.clearPendingMessages("Authentication expired; message was not retried");
         this.ws?.terminate();
     }
     sendHeartbeat() {
         if (this.missedPongCount >= this.maxMissedPong) {
-            this.logger.warn(`No heartbeat ack received for ${this.missedPongCount} consecutive pings`);
+            this.logger.warn(`No heartbeat pong received for ${this.missedPongCount} consecutive pings`);
             this.stopHeartbeat();
             this.ws?.terminate();
             return;
         }
         this.missedPongCount++;
         try {
-            this.send({
-                cmd: WsCmd.HEARTBEAT,
-                headers: { reqId: generateReqId(WsCmd.HEARTBEAT), token: this.token },
-            });
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.ping();
+            }
         }
         catch (error) {
             this.logger.error("Failed to send heartbeat:", error.message);
         }
     }
     scheduleReconnect() {
-        if (this.maxReconnectAttempts !== -1 && this.reconnectAttempts >= this.maxReconnectAttempts) {
-            this.logger.error(`Max reconnect attempts reached (${this.maxReconnectAttempts}), giving up`);
-            this.emit("error", new Error("Max reconnect attempts exceeded"));
+        if (this.isManualClose) {
             return;
         }
-        this.reconnectAttempts++;
-        const delay = Math.min(this.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts - 1), this.reconnectMaxDelay);
-        this.logger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+        if (this.reconnectTimer !== null) {
+            this.state = "reconnecting";
+            return;
+        }
+        const nextAttempt = this.reconnectAttempts + 1;
+        const { delay, phase } = calculateReconnectDelay(nextAttempt, this.maxReconnectAttempts, this.reconnectBaseDelay, this.reconnectMaxDelay, this.random);
+        this.reconnectAttempts = nextAttempt;
+        this.reconnectPhase = phase;
+        this.authenticated = false;
+        this.state = "reconnecting";
+        this.nextRetryAt = this.now() + delay;
+        this.logger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}, phase ${phase})...`);
         this.emit("reconnecting", this.reconnectAttempts);
-        setTimeout(() => {
-            if (this.isManualClose)
+        this.reconnectTimer = this.scheduleTimeout(() => {
+            this.reconnectTimer = null;
+            this.nextRetryAt = null;
+            if (this.isManualClose) {
+                this.state = "stopped";
                 return;
+            }
             this.connect();
         }, delay);
     }
+    clearReconnectTimer() {
+        if (this.reconnectTimer !== null) {
+            this.cancelTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.nextRetryAt = null;
+    }
+    startConnectWatchdog(socket) {
+        this.clearConnectWatchdog();
+        let timer;
+        timer = this.scheduleTimeout(() => {
+            if (this.connectWatchdogTimer !== timer)
+                return;
+            this.connectWatchdogTimer = null;
+            if (this.isManualClose || this.ws !== socket)
+                return;
+            const error = new Error(`WebSocket connection timed out after ${this.connectTimeoutMs}ms`);
+            this.state = "offline";
+            this.lastError = error.message;
+            this.lastErrorIsSpecific = true;
+            this.logger.error(`[WS] !!! ${error.message}`);
+            this.emit("error", error);
+            socket.terminate();
+            this.scheduleReconnect();
+        }, this.connectTimeoutMs);
+        this.connectWatchdogTimer = timer;
+    }
+    startAuthWatchdog(socket) {
+        this.clearAuthWatchdog();
+        let timer;
+        timer = this.scheduleTimeout(() => {
+            if (this.authWatchdogTimer !== timer)
+                return;
+            this.authWatchdogTimer = null;
+            if (this.isManualClose || this.ws !== socket)
+                return;
+            const error = new Error(`Authentication ACK timed out after ${this.authTimeoutMs}ms`);
+            this.authenticated = false;
+            this.state = "offline";
+            this.lastError = error.message;
+            this.lastErrorIsSpecific = true;
+            this.logger.error(`[WS] !!! ${error.message}`);
+            this.emit("error", error);
+            socket.terminate();
+            this.scheduleReconnect();
+        }, this.authTimeoutMs);
+        this.authWatchdogTimer = timer;
+    }
+    clearConnectWatchdog() {
+        if (this.connectWatchdogTimer !== null) {
+            this.cancelTimeout(this.connectWatchdogTimer);
+            this.connectWatchdogTimer = null;
+        }
+    }
+    clearAuthWatchdog() {
+        if (this.authWatchdogTimer !== null) {
+            this.cancelTimeout(this.authWatchdogTimer);
+            this.authWatchdogTimer = null;
+        }
+    }
+    clearWatchdogs() {
+        this.clearConnectWatchdog();
+        this.clearAuthWatchdog();
+    }
     send(frame) {
         if (this.ws && this.ws.readyState === WebSocket.OPEN) {
             const data = JSON.stringify(frame);
@@ -297,8 +511,11 @@ class WsConnectionManager extends EventEmitter {
         }
     }
     sendReply(reqId, body, cmd = WsCmd.RESPONSE) {
+        if (!this.hasAuthenticated || this.isReauthenticating || !this.token) {
+            return Promise.reject(new Error("WebSocket authentication is not ready; message was not sent"));
+        }
         return new Promise((resolve, reject) => {
-            const frame = { cmd, headers: { reqId: reqId, token: this.token }, body };
+            const frame = { cmd, headers: { reqId: reqId }, body };
             const item = { frame, resolve, reject };
             if (!this.replyQueues.has(reqId)) {
                 this.replyQueues.set(reqId, []);
@@ -322,6 +539,13 @@ class WsConnectionManager extends EventEmitter {
             return;
         }
         const item = queue[0];
+        if (!this.hasAuthenticated || this.isReauthenticating || !this.token) {
+            queue.shift();
+            item.reject(new Error("WebSocket authentication is not ready; message was not sent"));
+            this.processReplyQueue(reqId);
+            return;
+        }
+        item.frame.headers.token = this.token;
         try {
             this.send(item.frame);
         }
@@ -351,6 +575,10 @@ class WsConnectionManager extends EventEmitter {
             this.logger.error(`Reply ack error: reqId=${reqId}, errcode=${frame.errCode}`);
             queue?.shift();
             pending.reject(frame);
+            if (frame.errCode === WsErrCode.TOKEN_INVALID) {
+                this.reconnectWithFreshAuth("[WS] Token invalid in reply, will reconnect to re-authenticate");
+                return;
+            }
         }
         else {
             queue?.shift();
@@ -386,8 +614,13 @@ class WsConnectionManager extends EventEmitter {
      */
     disconnect() {
         this.isManualClose = true;
+        this.clearReconnectTimer();
+        this.clearWatchdogs();
         this.stopHeartbeat();
         this.clearPendingMessages("Connection manually closed");
+        this.authenticated = false;
+        this.state = "stopped";
+        this.lastDisconnectedAt = this.now();
         // 主动断开时清除 token，下次连接使用 subscribe + bot_id + secret
         // 被动断线不会调用此方法，会保留 token 并使用 reconnect
         this.clearAuth();
@@ -399,10 +632,13 @@ class WsConnectionManager extends EventEmitter {
     }
     /** 清除认证状态，强制下次连接使用 bot_id + secret 重新认证 */
     clearAuth() {
+        this.clearWatchdogs();
         this.token = "";
         this.hasAuthenticated = false;
+        this.authenticated = false;
+        this.isReauthenticating = false;
         this.logger.info("[WS] Auth state cleared, will use bot_id + secret for next authentication");
     }
 }
 
-export { WsConnectionManager };
+export { WsConnectionManager, calculateReconnectDelay };

package/dist/src/state-manager.d.ts

@@ -13,8 +13,6 @@ export interface MessageState {
     hasMediaFailed?: boolean;
     deliverCalled?: boolean;
     mediaErrorSummary?: string;
-    /** 标记是否已超时中止，true 时不再发送流式更新和最终回复 */
-    timedOut?: boolean;
 }
 /**
  * 设置账户的 WebSocket 客户端

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdu/openclaw-youdu",
-  "version": "2026.6.26",
+  "version": "2026.8.20",
   "type": "module",
   "main": "dist/index.esm.js",
   "module": "dist/index.esm.js",
@@ -13,6 +13,7 @@
     "skills"
   ],
   "scripts": {
+    "test": "rollup -c rollup.test.config.mjs && node --test .test-dist/network-reconnect.test.mjs .test-dist/ws-manager.test.mjs",
     "build": "rollup -c",
     "dev": "rollup -c -w",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
@@ -25,10 +26,6 @@
   ],
   "author": "",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/youdu/openclaw-youdu.git"
-  },
   "openclaw": {
     "extensions": [
       "./dist/index.esm.js"