@workclaw/openclaw-workclaw 1.0.20 → 1.0.25

package/dist/src/gateway/message-dispatcher.js

@@ -1,572 +0,0 @@
-/**
- * Message Dispatcher - handles all WorkClaw WebSocket message types
- */
-import { parseWorkClawMessage } from "./message-context.js";
-import { buildInboundContext } from "./message-context.js";
-import { handleAgentCreated, handleAgentUpdated, handleAgentDeleted } from "./agent-handlers.js";
-import { saveOpenConversationId, initWorkclawAgent } from "./config-writer.js";
-import { getWorkclawWsConnection } from "../runtime.js";
-import { getWorkclawRuntime } from "../runtime.js";
-import { sendMessageWorkclaw } from "../outbound/index.js";
-import { resolveAccountByUserIdAndAgentId, resolveWorkclawAccountWithCache } from "../accounts.js";
-import { getWorkclawAccessToken, getWorkclawModelConfigByAppKey } from "../connection/workclaw-client.js";
-import { setToolContext } from "../runtime.js";
-import { handleSkillsEvent } from "./skills-handler.js";
-import { handleToolsListEvent as doHandleToolsListEvent } from "./tools-list-handler.js";
-import { request } from "undici";
-import { resolveNativeCommandSessionTargets, maybeResolveTextAlias } from "openclaw/plugin-sdk/command-auth";
-/** Log an error safely */
-function logError(log, context, err) {
-    const errAny = err;
-    const stack = typeof errAny?.stack === "string" ? `\nStack: ${errAny.stack}` : "";
-    log?.error?.(`Dispatcher ${context}: ${String(err)}${stack}`);
-}
-// ---------------------------------------------------------------------------
-// Individual message handlers
-// ---------------------------------------------------------------------------
-async function handlePing(ctx, result) {
-    const { accountId, log } = ctx;
-    const ws = getWorkclawWsConnection(accountId);
-    if (!ws)
-        return;
-    try {
-        const pongResponse = {
-            code: 200,
-            message: "pong",
-            metadata: { contentType: "application/json" },
-            data: JSON.stringify(result.pongData),
-        };
-        ws.send(JSON.stringify(pongResponse));
-        log?.debug?.(`pong`);
-    }
-    catch (err) {
-        logError(log, "Failed to send pong", err);
-    }
-}
-async function handleDisconnect(ctx) {
-    const { accountId, log, scheduleReconnect } = ctx;
-    const ws = getWorkclawWsConnection(accountId);
-    if (ws) {
-        try {
-            ws.close();
-            log?.info?.(`Closed WebSocket due to disconnect command`);
-        }
-        catch (err) {
-            logError(log, "Failed to close WebSocket", err);
-        }
-    }
-    else {
-        log?.info?.(`WebSocket already cleared, triggering reconnect...`);
-        scheduleReconnect();
-    }
-}
-async function handleAgentEvent(ctx, result) {
-    const { cfg, log, baseConfig, accountId } = ctx;
-    const eventData = result.eventData;
-    if (!eventData) {
-        log?.warn?.(`Received ${result.type} event but no data`);
-        return;
-    }
-    const agentId = String(eventData.id || "");
-    const userId = String(eventData.futureId || "");
-    if (!agentId) {
-        log?.warn?.(`Received ${result.type} event but missing agent id`);
-        return;
-    }
-    log?.info?.(`Processing ${result.type} event for agent ${agentId}, userId: ${userId}`);
-    const accountData = {
-        agentId,
-        userId,
-        nickName: eventData.nickName,
-        phone: eventData.phone,
-        status: eventData.status,
-        introduction: eventData.introduction,
-        name: eventData.name,
-        tip: eventData.tip,
-        characterSettings: eventData.characterSettings,
-        personFeatures: eventData.personFeatures,
-        workFeatures: eventData.workFeatures,
-        learningFeatures: eventData.learningFeatures,
-        socializeFeatures: eventData.socializeFeatures,
-        job: eventData.job,
-        city: eventData.city,
-    };
-    switch (result.type) {
-        case "agent_created":
-            await handleAgentCreated(accountData, cfg, log);
-            handleAgentCreatedMessage(baseConfig, agentId, accountId, log);
-            break;
-        case "agent_updated":
-            await handleAgentUpdated(accountData, cfg, log);
-            break;
-        case "agent_deleted":
-            await handleAgentDeleted(accountData, cfg, log);
-            break;
-    }
-}
-async function handleSkillsProcessingEvent(ctx, result) {
-    const { accountId, baseConfig, log } = ctx;
-    if (!result.eventData)
-        return;
-    try {
-        const connConfig = {
-            baseUrl: baseConfig.baseUrl || "",
-            websocketUrl: baseConfig.websocketUrl,
-            appKey: baseConfig.appKey,
-            appSecret: baseConfig.appSecret,
-            localIp: baseConfig.localIp,
-            allowInsecureTls: baseConfig.allowInsecureTls,
-            requestTimeout: baseConfig.requestTimeout,
-        };
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
-        await handleSkillsEvent(result.eventData, token, connConfig.baseUrl, connConfig.appKey || accountId, log);
-    }
-    catch (err) {
-        logError(log, "handleSkillsEvent failed", err);
-    }
-}
-async function handleToolsListEvent(ctx, result) {
-    const { accountId, baseConfig, log } = ctx;
-    if (!result.eventData)
-        return;
-    try {
-        const connConfig = {
-            baseUrl: baseConfig.baseUrl || "",
-            websocketUrl: baseConfig.websocketUrl,
-            appKey: baseConfig.appKey,
-            appSecret: baseConfig.appSecret,
-            localIp: baseConfig.localIp,
-            allowInsecureTls: baseConfig.allowInsecureTls,
-            requestTimeout: baseConfig.requestTimeout,
-        };
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
-        await doHandleToolsListEvent(result.eventData, connConfig.baseUrl, token, log);
-    }
-    catch (err) {
-        logError(log, "handleToolsListEvent failed", err);
-    }
-}
-async function handleSkillsListEvent(ctx, result) {
-    const { accountId, baseConfig, log } = ctx;
-    if (!result.eventData)
-        return;
-    try {
-        const { handleSkillsListEvent } = await import('./skills-handler.js');
-        const connConfig = {
-            baseUrl: baseConfig.baseUrl || '',
-            websocketUrl: baseConfig.websocketUrl,
-            appKey: baseConfig.appKey,
-            appSecret: baseConfig.appSecret,
-            localIp: baseConfig.localIp,
-            allowInsecureTls: baseConfig.allowInsecureTls,
-            requestTimeout: baseConfig.requestTimeout,
-        };
-    }
-    finally {
-    }
-    async function handleInitAgentEvent(ctx, result) {
-        const { accountId, cfg, baseConfig, log } = ctx;
-        const initStartedAt = Date.now();
-        const eventData = result.eventData;
-        if (!eventData) {
-            log?.warn?.(`init_agent received but no data`);
-            return;
-        }
-        log?.info?.(`init_agent accountId=${accountId} eventDataType=${typeof eventData} preview=${JSON.stringify(eventData).slice(0, 200)}`);
-        const connConfig = {
-            baseUrl: baseConfig.baseUrl || "",
-            websocketUrl: baseConfig.websocketUrl,
-            appKey: baseConfig.appKey,
-            appSecret: baseConfig.appSecret,
-            localIp: baseConfig.localIp,
-            allowInsecureTls: baseConfig.allowInsecureTls,
-            requestTimeout: baseConfig.requestTimeout,
-        };
-        // Fetch apiKey and init agent config in one write
-        try {
-            const tokenCacheKey = baseConfig.appKey || accountId;
-            const { baseUrl: modelBaseUrl, apiKey } = await getWorkclawModelConfigByAppKey(tokenCacheKey, connConfig);
-            const maskedKey = apiKey ? `${String(apiKey).slice(0, 6)}...(${String(apiKey).length})` : "missing";
-            log?.info?.(`init_agent model fetched baseUrl=${modelBaseUrl} apiKey=${maskedKey}`);
-            const agentId = String(eventData?.id || eventData?.agentId || "");
-            const userId = String(eventData?.futureId || eventData?.userId || "");
-            await initWorkclawAgent({ apiKey, agentId, userId, accountId: "default" }, cfg, log);
-            log?.info?.(`init_agent config saved elapsedMs=${Date.now() - initStartedAt}`);
-        }
-        catch (err) {
-            logError(log, "init_agent failed", err);
-        }
-        log?.info?.(`init_agent handled elapsedMs=${Date.now() - initStartedAt}`);
-    }
-    async function handleCronTaskEvent(ctx, result) {
-        const { accountId, baseConfig, log } = ctx;
-        if (!result.cronTaskEvent)
-            return;
-        try {
-            const { handleCronTaskEvent } = await import('./cron-tasks-handler.js');
-            const connConfig = {
-                baseUrl: baseConfig.baseUrl || '',
-                websocketUrl: baseConfig.websocketUrl,
-                appKey: baseConfig.appKey,
-                appSecret: baseConfig.appSecret,
-                localIp: baseConfig.localIp,
-                allowInsecureTls: baseConfig.allowInsecureTls,
-                requestTimeout: baseConfig.requestTimeout,
-            };
-            const tokenCacheKey = baseConfig.appKey || accountId;
-            const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
-            await handleCronTaskEvent(result.cronTaskEvent, token, connConfig.baseUrl, connConfig.appKey || accountId, log);
-        }
-        catch (err) {
-            logError(log, 'handleCronTaskEvent failed', err);
-        }
-    }
-    async function handleAgentMessage(ctx, data, result) {
-        const { accountId, account, cfg, accountConfig, log } = ctx;
-        const { message } = result;
-        if (!message)
-            return;
-        // 这里的msgAgentId是云平台的agentId
-        const { text, userId, openConversationId, messageId: parsedMessageId, agentId: msgAgentId } = message;
-        // Resolve account from message
-        let messageAccountId = accountId;
-        let messageAccount = account;
-        if (userId && msgAgentId) {
-            const resolvedAccountId = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(msgAgentId));
-            if (resolvedAccountId) {
-                const resolved = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
-                messageAccountId = resolvedAccountId;
-                messageAccount = resolved;
-                log?.info?.(`Resolved account ${resolvedAccountId} from message (userId=${userId}, agentId=${msgAgentId})`);
-            }
-            else if (String(msgAgentId) !== String(accountConfig.agentId)) {
-                log?.warn?.(`Account not found for userId=${userId}, agentId=${msgAgentId}, ignoring`);
-                return;
-            }
-        }
-        const resolvedAccountConfig = messageAccount.config;
-        const msgAgentIdResolved = msgAgentId ?? accountConfig.agentId;
-        // Save openConversationId if new
-        if (openConversationId && openConversationId !== resolvedAccountConfig.openConversationId) {
-            try {
-                await saveOpenConversationId(messageAccountId, userId, openConversationId, cfg, log);
-                log?.info?.(`Saved openConversationId ${openConversationId} to account ${messageAccountId}`);
-            }
-            catch (err) {
-                logError(log, "saveOpenConversationId failed", err);
-            }
-        }
-        const resolvedOpenConversationId = openConversationId || resolvedAccountConfig.openConversationId || "";
-        const to = userId;
-        const bodyText = text || data;
-        if (!bodyText) {
-            log?.warn?.(`Empty body, ignoring`);
-            return;
-        }
-        // Route via bindings
-        const bindings = cfg?.bindings ?? [];
-        let targetAgentId = "default";
-        const matchedBinding = bindings.find((binding) => {
-            const match = binding?.match;
-            if (!match || match.channel !== "openclaw-workclaw")
-                return false;
-            return match.accountId === messageAccountId || match.accountId === "*";
-        });
-        if (matchedBinding) {
-            targetAgentId = matchedBinding.agentId;
-            log?.info?.(`Routing to agent ${targetAgentId} via binding (account: ${messageAccountId})`);
-        }
-        if (!targetAgentId) {
-            log?.warn?.(`Missing target, ignoring`);
-            return;
-        }
-        // 构建用于解析 sessionKey 的消息对象
-        // to = agentId (智能体/机器人), from = userId (用户)
-        const attachments = message.attachments;
-        const inboundMessage = {
-            text: bodyText,
-            to: to,
-            from: userId,
-            chatType: "dm",
-            messageId: parsedMessageId,
-            rawPayload: data,
-            timestamp: Date.now(),
-            attachments: attachments,
-        };
-        log?.info?.(`handleAgentMessage: text=${bodyText?.substring(0, 50)}, attachments=${attachments?.length || 0}, rawPayload=${data.substring(0, 300)}`);
-        const pluginRuntime = getWorkclawRuntime();
-        // 检测是否是框架命令（如 /new）
-        const textForCommandCheck = bodyText?.replace(/^\[引用[^\]]*\]\s*/, "").trim() || "";
-        const resolvedCommand = maybeResolveTextAlias(textForCommandCheck, messageAccount.config);
-        const isFrameworkCommand = resolvedCommand !== null;
-        if (isFrameworkCommand) {
-            log?.info?.(`[DELIVER] Framework command detected: ${bodyText}, will set CommandSource=native`);
-        }
-        // 使用扩展后的 buildInboundContext，它会处理完整的 session 流程
-        const finalized = await buildInboundContext(inboundMessage, messageAccountId, messageAccount.config, targetAgentId, pluginRuntime, true, log);
-        // 如果是框架命令，设置 CommandSource 等字段，让 OpenClaw 框架识别为原生命令
-        if (isFrameworkCommand) {
-            const targetSessionKey = finalized.SessionKey;
-            const { sessionKey: commandSessionKey, commandTargetSessionKey } = resolveNativeCommandSessionTargets({
-                agentId: targetAgentId,
-                sessionPrefix: "openclaw-workclaw:new",
-                userId: String(userId ?? ""),
-                targetSessionKey,
-            });
-            finalized.SessionKey = commandSessionKey;
-            finalized.CommandTargetSessionKey = commandTargetSessionKey;
-            finalized.CommandSource = "native";
-            finalized.CommandAuthorized = true;
-            log?.info?.(`[DELIVER] Set CommandSource=native, commandSessionKey=${commandSessionKey}, targetSessionKey=${targetSessionKey}`);
-        }
-        // 维护当前工具名称状态
-        let currentToolName = null;
-        // 追踪 final 是否已投递（框架在流式输出时会 drop final，需要手动补发 last: true）
-        let finalDelivered = false;
-        // 追踪是否有文本被 deliver 过
-        let textDelivered = false;
-        // 发送工具消息的辅助函数
-        const sendToolMessage = async (text, isStart = false) => {
-            try {
-                await sendMessageWorkclaw({
-                    cfg,
-                    to: to,
-                    text,
-                    accountId: messageAccountId,
-                    openConversationId: resolvedOpenConversationId,
-                    agentId: msgAgentIdResolved,
-                    replyToMessageId: parsedMessageId,
-                    last: false,
-                });
-            }
-            catch (err) {
-                logError(log, isStart ? "Tool start message send failed" : "Tool result message send failed", err);
-            }
-        };
-        await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-            ctx: finalized,
-            cfg,
-            replyOptions: {
-                onAgentRunStart(runId) {
-                    // 保存 runId 和 ctx 的关联，供 hook 使用
-                    setToolContext(runId, {
-                        target: targetAgentId,
-                        replyToMessageId: parsedMessageId,
-                        openConversationId: resolvedOpenConversationId,
-                        accountId: messageAccountId,
-                        agentId: String(msgAgentIdResolved),
-                        sessionKey: finalized.SessionKey || "",
-                    });
-                    log?.info?.(`[AGENT] onAgentRunStart: runId=${runId} target=${targetAgentId}`);
-                },
-                /*onToolStart(payload) {
-                    log?.info?.(`[AGENT] onToolStart: ${JSON.stringify(payload)}`);
-                    if (payload.phase === "start") {
-                        currentToolName = payload.name ?? null;
-                        const hint = getToolStartHint(currentToolName);
-                        log?.info?.(`[TOOL] Starting tool: ${currentToolName}, sending hint: ${hint}`);
-                        sendToolMessage(hint, true).catch((err) => {
-                            logError(log, "Tool start hint send failed", err);
-                        });
-                    }
-                }*/
-            },
-            dispatcherOptions: {
-                deliver: async (payload, info) => {
-                    // 记录每次 deliver 调用，帮助调试 info.kind 问题
-                    log?.info?.(`[DELIVER] deliver called: info.kind=${info?.kind}, payload.text=${String(payload?.text ?? "").substring(0, 100)}`);
-                    const resolvedReplyToId = payload?.replyToId || parsedMessageId;
-                    let textOut = String(payload.text ?? payload.body ?? "");
-                    const target = to || String(payload.to ?? "");
-                    if (!target) {
-                        log?.warn?.(`Skipping reply: no target`);
-                        return;
-                    }
-                    if (!textOut.trim()) {
-                        log?.warn?.(`Empty reply text, skipping`);
-                        return;
-                    }
-                    if (info?.kind === "tool")
-                        return;
-                    // 处理工具类型的 deliver
-                    /*if (info?.kind === "tool") {
-                        // log?.info?.(`[DELIVER] tool reply: ${JSON.stringify(payload)}`);
-                        const toolText = payload.text ?? "";
-                        if (toolText.trim()) {
-                            // 使用 formattedToolOutput 格式发送
-                            try {
-                                await sendMessageWorkclaw({
-                                    cfg,
-                                    to: targetAgentId,
-                                    text: JSON.stringify({
-                                        name: currentToolName || "Unknown",
-                                        content: toolText,
-                                        state: "result",
-                                    }),
-                                    msgType: "26",
-                                    accountId: messageAccountId,
-                                    openConversationId: resolvedOpenConversationId,
-                                    agentId: msgAgentIdResolved,
-                                    replyToMessageId: parsedMessageId,
-                                });
-                            } catch (err) {
-                                logError(log, "Tool result send failed", err);
-                            }
-                        }
-                        return;
-                    }*/
-                    // final 时清空工具状态
-                    if (info?.kind === "final") {
-                        currentToolName = null;
-                        finalDelivered = true;
-                        log?.info?.(`[DELIVER] final received, cleared currentToolName`);
-                    }
-                    // 明确设置 last：final 时为 true，否则为 false（显式转换，避免 undefined）
-                    const isFinal = info?.kind === "final";
-                    const isLast = isFinal ? true : false;
-                    log?.info?.(`[DELIVER] is last: ${isLast} (info.kind=${info?.kind})`);
-                    try {
-                        const result = await sendMessageWorkclaw({
-                            cfg, to: target, text: textOut,
-                            accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
-                            agentId: msgAgentIdResolved, replyToMessageId: resolvedReplyToId,
-                            last: isLast,
-                        });
-                        textDelivered = true;
-                        log?.info?.(`Reply sent messageId=${result.messageId}`);
-                    }
-                    catch (err) {
-                        logError(log, "Reply send failed", err);
-                        throw err;
-                    }
-                },
-            },
-        });
-        // 原始消息是命令但 AI 没有回复文本时，发送"命令已执行"确认
-        if (!textDelivered && bodyText?.startsWith('/')) {
-            log?.info?.(`[DELIVER] command ${bodyText} executed with no text reply, sending confirmation`);
-            try {
-                await sendMessageWorkclaw({
-                    cfg, to: to || String(userId || ""),
-                    text: `${bodyText} 已执行`,
-                    accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
-                    agentId: msgAgentIdResolved, replyToMessageId: parsedMessageId,
-                    last: false,
-                });
-            }
-            catch (err) {
-                logError(log, "Command confirmation send failed", err);
-            }
-        }
-        // 框架在流式输出时会 drop final payload，检测到时应手动补发 last: true
-        if (!finalDelivered) {
-            log?.warn?.(`[DELIVER] final was dropped by framework, sending last: true`);
-            try {
-                // 发送一个空格作为占位内容，确保 last: true 能被服务端接受
-                await sendMessageWorkclaw({
-                    cfg, to: to || String(userId || ""),
-                    text: "",
-                    accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
-                    agentId: msgAgentIdResolved, replyToMessageId: parsedMessageId,
-                    last: true,
-                });
-            }
-            catch (err) {
-                // 服务端可能拒绝空内容的 last 信号，忽略即可
-                const errStr = String(err);
-                if (errStr.includes("content can't be empty")) {
-                    log?.info?.(`[DELIVER] last signal skipped (empty content not supported)`);
-                }
-                else {
-                    logError(log, "Final/last signal send failed", err);
-                }
-            }
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Main dispatcher
-    // ---------------------------------------------------------------------------
-    export async function dispatchWorkclawMessage(data, ctx) {
-        const { log } = ctx;
-        const rawHasAuthToken = data.includes("authToken") ||
-            data.toLowerCase().includes("authorization") ||
-            data.toLowerCase().includes("bearer ");
-        const rawPreview = data.length > 300 ? `${data.slice(0, 300)}...` : data;
-        /*log?.info?.(
-            `Raw message bytes=${data.length} hasAuthToken=${rawHasAuthToken} preview=${rawPreview}`,
-        );*/
-        const result = parseWorkClawMessage(data, log);
-        if (!result) {
-            log?.warn?.(`Failed to parse message`);
-            return;
-        }
-        log?.info?.(`Message type=${result.type}`);
-        switch (result.type) {
-            case 'ping':
-                await handlePing(ctx, result);
-                return;
-            case 'disconnect':
-                await handleDisconnect(ctx);
-                return;
-            case 'agent_created':
-            case 'agent_updated':
-            case 'agent_deleted':
-                await handleAgentEvent(ctx, result);
-                return;
-            case 'skills_event':
-                await handleSkillsProcessingEvent(ctx, result);
-                return;
-            case 'tools_list':
-                await handleToolsListEvent(ctx, result);
-                return;
-            case 'skills_list':
-                await handleSkillsListEvent(ctx, result);
-                return;
-            case 'init_agent':
-                await handleInitAgentEvent(ctx, result);
-                return;
-            case 'cron_task_event':
-                await handleCronTaskEvent(ctx, result);
-                return;
-            case 'ignored':
-                log?.info?.(`Ignoring message type=${result.type}`);
-                return;
-            case 'agent_message':
-                await handleAgentMessage(ctx, data, result);
-                return;
-            default:
-                log?.info?.(`Unknown message type: ${result.type}, ignoring`);
-        }
-    }
-    // 创建成功回调
-    async function handleAgentCreatedMessage(baseConfig, agentId, accountId, log) {
-        // 通知
-        try {
-            const base = baseConfig.baseUrl.replace(/\/$/, ""); // 去掉末尾多余的 /
-            const callbackUrl = `${base}/open-apis/instance/agent-created/status`;
-            const tokenCacheKey = baseConfig.appKey || accountId;
-            const callbackData = {
-                "agentId": agentId,
-                "success": true
-            };
-            log?.info?.(`[AgentCreated] Calling callback API: ${callbackUrl}`);
-            const token = await getWorkclawAccessToken(tokenCacheKey, baseConfig);
-            const response = await request(callbackUrl, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "Authorization": `Bearer ${token}`,
-                },
-                body: JSON.stringify(callbackData),
-            });
-            const responseBody = await response.body.text();
-            log?.info?.(`[AgentCreated] Callback API response: status=${response.statusCode}, body=${responseBody}`);
-        }
-        catch (callbackErr) {
-            // 接口调用失败不影响主流程，只记录错误
-            log?.error?.(`[AgentCreated] Callback API failed: ${String(callbackErr)}`);
-        }
-    }
-}

package/dist/src/gateway/reconnect.d.ts

@@ -1,27 +0,0 @@
-/**
- * Reconnect Scheduler - manages WebSocket reconnection with exponential backoff
- */
-import { WebSocket } from "undici";
-import type { WorkClawBaseConfig } from "../types.js";
-export interface ReconnectSchedulerOptions {
-    /** Key for WebSocket storage (appKey) */
-    key: string;
-    config: WorkClawBaseConfig;
-    log?: {
-        info?: (msg: string) => void;
-        warn?: (msg: string) => void;
-        error?: (msg: string) => void;
-        debug?: (msg: string) => void;
-    };
-    onMessage: (data: string) => void;
-    onReconnectSuccess?: () => void;
-    /** Called when connection closes (after initial connect), to trigger reconnect */
-    onClose?: () => void;
-    /** Called after WebSocket is registered (before onopen), useful for lock release */
-    onConnectingStarted?: (ws: WebSocket) => void;
-}
-export declare function createReconnectScheduler(options: ReconnectSchedulerOptions): {
-    connect: () => Promise<void>;
-    scheduleReconnect: () => void;
-    stopReconnect: () => void;
-};