lightclawbot 1.1.2 → 1.2.0-beta.1

package/dist/src/streaming/stream-reply-sink.js

@@ -0,0 +1,387 @@
+/**
+ * LightClaw — 真流式回复分发 (StreamReplySink)
+ *
+ * 通过 `dispatchReplyFromConfig` 的回调实现逐 token 流式输出：
+ *   - onPartialReply    → 计算增量 → emit stream_chunk
+ *   - onToolStart       → emit tool_start（前端决定如何渲染）
+ *   - sendFinalReply    → 跨轮次去重后发送剩余增量（或丢弃）
+ *   - markComplete      → 发 typing_stop；NO_REPLY 场景兜底一条提示
+ *
+ * 关键状态：
+ *   streamedText     当前 assistant 轮已流式推送的文本
+ *   streamedHistory  历史轮次已推送的快照，用于跨轮次去重
+ *   counts / *Count  计数器，供 markComplete 推断 NO_REPLY 原因
+ */
+import { CHANNEL_KEY } from "../config.js";
+import { uploadFileToCos } from "../file-storage.js";
+import { mediaUrlsToFiles } from "../media.js";
+import { createDeltaTrackerState, toStreamDeltaText } from "./delta-tracker.js";
+import { emitSignal } from "../types.js";
+/** 派生/管理 subagent 的工具名；前端可据此特化渲染 tool_start。 */
+const SUBAGENT_TOOL_NAMES = new Set([
+    "sessions_spawn",
+    "sessions.spawn",
+    "subagents",
+]);
+/** 匹配 openclaw 原生 abort 回执（见 abort.ts:formatAbortReplyText）并汉化。 */
+const OPENCLAW_ABORT_REPLY_RE = /^⚙️ Agent was aborted\.(?: Stopped \d+ sub-agents?\.)?$/;
+const LOCALIZED_ABORT_REPLY = "已停止当前回复。";
+function localizeAbortReplyText(text) {
+    return OPENCLAW_ABORT_REPLY_RE.test(text.trim()) ? LOCALIZED_ABORT_REPLY : text;
+}
+export function createStreamReplyConfig(opts, prefixOptions, signalCtx) {
+    const { emitter, targetId, originalMsgId, log, effectiveApiKey, typingAlreadyStarted } = opts;
+    // ── 增量追踪 & 已推送文本 ──
+    let partialReplyState = createDeltaTrackerState();
+    let streamedText = "";
+    const streamedHistory = [];
+    // ── 是否已经给用户推送过任何可见内容 ──
+    //
+    // 在真正向用户发送 stream_chunk / sendReply / sendFiles 时置 true。
+    // 上层据此决定"是否需要 NO_REPLY 兜底"——业务决策放在 inbound，sink 只如实记录。
+    let emittedUserVisible = false;
+    // ── 计数器（仅用于 NO_REPLY 诊断） ──
+    const counts = { tool: 0, block: 0, final: 0 };
+    let toolStartCount = 0;
+    let assistantMessageCount = 0;
+    // ── thinking/reasoning 观测（不面向用户，仅为首字延迟归因） ──
+    let reasoningChars = 0;
+    let reasoningFirstAt = 0;
+    let reasoningLastAt = 0;
+    // ── typing / 完成态 ──
+    let typingStartSent = !!typingAlreadyStarted;
+    let typingStopSent = false;
+    let completed = false;
+    /** openclaw abort 检测：sendFinalReply 收到 abort 文案时置 true，markComplete 据此跳过 NO_REPLY。 */
+    let abortDetected = false;
+    // ── 串行化回调队列：保证 COS 上传等异步操作按顺序执行 ──
+    let queuePromise = Promise.resolve();
+    const enqueue = (fn) => {
+        if (completed)
+            return;
+        queuePromise = queuePromise.then(fn, fn).then(() => { }, () => { });
+    };
+    const ensureTypingStart = () => {
+        if (typingStartSent)
+            return;
+        typingStartSent = true;
+        emitSignal(signalCtx, "typing_start");
+    };
+    const sendTypingStop = () => {
+        if (typingStopSent)
+            return;
+        typingStopSent = true;
+        emitSignal(signalCtx, "typing_stop");
+    };
+    /**
+     * 处理 payload 中的 mediaUrls：COS 上传 → 拼 Markdown 链接 → emit sendReply/sendFiles。
+     * 仅在 mediaList 非空时调用。
+     */
+    const handleMediaFinal = async (replyText, mediaList) => {
+        const files = await mediaUrlsToFiles(mediaList, log);
+        const storageConfig = { apiKey: effectiveApiKey };
+        const publicUrls = [];
+        for (const mediaUrl of mediaList) {
+            try {
+                const localPath = mediaUrl.startsWith("file://") ? mediaUrl.slice(7) : mediaUrl;
+                if (localPath.startsWith("/") || localPath.match(/^[A-Za-z]:\\/)) {
+                    const { existsSync } = await import("node:fs");
+                    if (existsSync(localPath)) {
+                        const result = await uploadFileToCos(localPath, storageConfig);
+                        publicUrls.push(result.url || "");
+                        log?.info(`[${CHANNEL_KEY}] [stream] Uploaded to COS: ${localPath} → ${result.url}`);
+                    }
+                }
+            }
+            catch (uploadErr) {
+                log?.warn(`[${CHANNEL_KEY}] [stream] COS upload failed for ${mediaUrl}: ${uploadErr}`);
+            }
+        }
+        let enrichedText = replyText;
+        if (publicUrls.length > 0) {
+            const urlSection = publicUrls
+                .map((url, i) => {
+                const match = url.match(/filePath=([^&]+)/);
+                const filePath = match ? decodeURIComponent(match[1]) : "";
+                const fileName = filePath.split("/").pop() || `file${publicUrls.length > 1 ? ` (${i + 1})` : ""}`;
+                return `📎 [${fileName}](${url})`;
+            })
+                .join("\n");
+            enrichedText = enrichedText ? `${enrichedText}\n\n${urlSection}` : urlSection;
+        }
+        if (files.length > 0) {
+            emitter.sendFiles(targetId, enrichedText, files, originalMsgId);
+            emittedUserVisible = true;
+        }
+        else if (enrichedText.trim()) {
+            emitter.sendReply(targetId, enrichedText, originalMsgId);
+            emittedUserVisible = true;
+        }
+    };
+    // ────────────────────────────────────────
+    // dispatcher
+    // ────────────────────────────────────────
+    const dispatcher = {
+        /**
+         * 工具调用结束：openclaw runtime 在每个工具执行完（成功/失败）后调此回调。
+         *
+         * payload 里没有 toolName，但由于 LLM 的工具调用是串行的（等上一个返回才发下一个），
+         * 前端按"最近一次 tool_start"配对即可。透传 isError 让前端标示失败态。
+         */
+        sendToolResult: (payload) => {
+            if (completed)
+                return false;
+            counts.tool++;
+            const isError = !!payload.isError;
+            log?.info(`[${CHANNEL_KEY}] [stream] sendToolResult: textLen=${payload.text?.length ?? 0} isError=${isError}`);
+            emitSignal(signalCtx, "tool_end", "", { toolIsError: isError });
+            return true;
+        },
+        /** 块回复：文本已由 onPartialReply 推送，这里只处理媒体。 */
+        sendBlockReply: (payload) => {
+            if (completed)
+                return false;
+            counts.block++;
+            const mediaList = payload.mediaUrls?.length
+                ? payload.mediaUrls
+                : payload.mediaUrl ? [payload.mediaUrl] : [];
+            if (mediaList.length > 0) {
+                log?.info(`[${CHANNEL_KEY}] [stream] sendBlockReply: processing ${mediaList.length} media files`);
+                enqueue(() => handleMediaFinal(payload.text ?? "", mediaList).catch((err) => {
+                    log?.error(`[${CHANNEL_KEY}] [stream] sendBlockReply media error: ${err}`);
+                }));
+            }
+            return true;
+        },
+        /**
+         * 最终回复去重逻辑：
+         *   A. payload.text 命中 streamedHistory 任一轮次快照 → 已在历史轮推送过，丢弃
+         *   B. 当前轮已有 streamedText：
+         *      - 完全相同 → 跳过
+         *      - 以 streamedText 为前缀 → 只发尾部增量
+         *      - 其他 → 丢弃（已通过 onPartialReply 推送）
+         *   C. 当前轮未推送过 → 作为完整 chunk 发送
+         */
+        sendFinalReply: (payload) => {
+            if (completed)
+                return false;
+            counts.final++;
+            // abort fast-path 也走 sendFinalReply，这里汉化英文回执。
+            const rawText = payload.text ?? "";
+            const replyText = localizeAbortReplyText(rawText);
+            if (replyText !== rawText) {
+                abortDetected = true;
+            }
+            const mediaList = payload.mediaUrls?.length
+                ? payload.mediaUrls
+                : payload.mediaUrl ? [payload.mediaUrl] : [];
+            log?.info(`[${CHANNEL_KEY}] [stream] sendFinalReply: textLen=${replyText.length} mediaCount=${mediaList.length} streamedLen=${streamedText.length} historyRounds=${streamedHistory.length}`);
+            if (mediaList.length > 0) {
+                enqueue(() => handleMediaFinal(replyText, mediaList).catch((err) => {
+                    log?.error(`[${CHANNEL_KEY}] [stream] sendFinalReply media error: ${err}`);
+                }));
+            }
+            if (replyText.length === 0)
+                return true;
+            let delta;
+            const hitHistory = streamedHistory.some((prev) => prev === replyText || prev.startsWith(replyText));
+            if (hitHistory) {
+                log?.debug?.(`[${CHANNEL_KEY}] [stream] Final text hit history, suppressed`);
+            }
+            else if (streamedText) {
+                if (replyText === streamedText) {
+                    log?.debug?.(`[${CHANNEL_KEY}] [stream] Final text identical to streamed, skipping`);
+                }
+                else if (replyText.startsWith(streamedText)) {
+                    const remaining = replyText.slice(streamedText.length);
+                    if (remaining.length > 0) {
+                        delta = remaining;
+                        streamedText += remaining;
+                        partialReplyState.latest = replyText;
+                    }
+                }
+                else {
+                    log?.debug?.(`[${CHANNEL_KEY}] [stream] Final text mismatch with streamed, suppressed`);
+                }
+            }
+            else {
+                delta = replyText;
+                streamedText = replyText;
+                partialReplyState.latest = replyText;
+            }
+            if (delta) {
+                emitSignal(signalCtx, "stream_chunk", delta);
+                emittedUserVisible = true;
+                log?.debug?.(`[${CHANNEL_KEY}] [stream] Final delta: ${delta.length} chars`);
+            }
+            return true;
+        },
+        waitForIdle: async () => {
+            await queuePromise;
+        },
+        // 下面两个 getter 是 openclaw ReplyDispatcher 契约要求的，这里直接返回 counts 快照
+        getQueuedCounts: () => ({ ...counts }),
+        getFailedCounts: () => ({ tool: 0, block: 0, final: 0 }),
+        /**
+         * 标记本次 dispatch 完成 → 发 typing_stop。
+         *
+         * NO_REPLY 仅在"LLM 正常完成一次完整 run 但没产出可见文本"时才触发。
+         * 以下场景均不发：
+         *   - isAborted / abortDetected：/stop 或 abort 触发
+         *   - hadLLMActivity 但 hadDispatch=false：LLM 启动但被中途打断（abort 没来得及 sendFinalReply）
+         *   - !hadLLMActivity：followup 被 collect 合并 / plugin 拦截
+         */
+        markComplete: (markOpts) => {
+            completed = true;
+            const hadStreamedText = streamedText.length > 0 || streamedHistory.length > 0;
+            const hadDispatch = counts.tool > 0 || counts.block > 0 || counts.final > 0;
+            const hadLLMActivity = toolStartCount > 0 || assistantMessageCount > 0;
+            const isAborted = markOpts?.aborted === true || abortDetected;
+            if (isAborted) {
+                log?.info(`[${CHANNEL_KEY}] [stream] markComplete: aborted`);
+            }
+            else if (!hadLLMActivity) {
+                // 静默 dispatch（followup 被合并 / plugin 拦截）
+                log?.info(`[${CHANNEL_KEY}] [stream] markComplete: silent dispatch (likely followup merged by openclaw queue)`);
+            }
+            else if (!hadStreamedText && !hadDispatch) {
+                // LLM 启动但未完成 dispatch（被 abort 中断但本 sink 没收到 abort 文案）
+                log?.info(`[${CHANNEL_KEY}] [stream] markComplete: LLM interrupted before output ` +
+                    `(toolStart=${toolStartCount} assistantMsg=${assistantMessageCount})`);
+            }
+            else if (!hadStreamedText && hadDispatch) {
+                // LLM 完成了 dispatch 但没有可见文本输出 → 真正的 NO_REPLY
+                const cause = toolStartCount > 0
+                    ? "LLM invoked tool(s) but produced no visible text"
+                    : "LLM only produced thinking, no visible text";
+                log?.warn(`[${CHANNEL_KEY}] [stream] NO_REPLY: counts=${JSON.stringify(counts)} ` +
+                    `toolStart=${toolStartCount} assistantMsg=${assistantMessageCount}. Cause: ${cause}`);
+                emitter.sendReply(targetId, "NO_REPLY", originalMsgId);
+            }
+            else {
+                log?.info(`[${CHANNEL_KEY}] [stream] markComplete: counts=${JSON.stringify(counts)} ` +
+                    `toolStart=${toolStartCount} assistantMsg=${assistantMessageCount} ` +
+                    `streamedLen=${streamedText.length} historyRounds=${streamedHistory.length}`);
+            }
+            sendTypingStop();
+        },
+    };
+    // ────────────────────────────────────────
+    // replyOptions
+    // ────────────────────────────────────────
+    const replyOptions = {
+        ...prefixOptions,
+        /** AI 每产 token 回调，计算增量后 emit stream_chunk。 */
+        onPartialReply: (payload) => {
+            if (completed || !payload.text)
+                return;
+            ensureTypingStart();
+            const delta = toStreamDeltaText(partialReplyState, payload.text);
+            if (delta) {
+                streamedText += delta;
+                emitSignal(signalCtx, "stream_chunk", delta);
+                emittedUserVisible = true;
+            }
+        },
+        /**
+         * 工具调用开始：透传 toolName 给前端。
+         * 命中 SUBAGENT_TOOL_NAMES 时视为派生子任务，前端可据此显示"处理中"提示；
+         * 子任务完成后会由 openclaw announce 机制回灌，主 agent 下一轮 assistant 消息会输出结果。
+         */
+        onToolStart: (payload) => {
+            if (completed)
+                return;
+            toolStartCount++;
+            const toolName = payload.name ?? "unknown";
+            const toolPhase = payload.phase ?? "";
+            const isSubagentSpawn = SUBAGENT_TOOL_NAMES.has(toolName);
+            log?.info(`[${CHANNEL_KEY}] [stream] onToolStart: name=${toolName} phase=${toolPhase}` +
+                (isSubagentSpawn ? " (subagent-spawn)" : ""));
+            emitSignal(signalCtx, "tool_start", "\n\n", { toolName, toolPhase });
+        },
+        onReplyStart: () => {
+            if (completed)
+                return;
+            ensureTypingStart();
+        },
+        onAgentRunStart: (runId) => {
+            if (completed)
+                return;
+            log?.info(`[${CHANNEL_KEY}] [stream] Agent run started: runId=${runId}`);
+        },
+        /**
+         * 模型 thinking/reasoning 增量。仅用于观测首字延迟归因，不向用户 emit。
+         * - 第一次命中时记录 reasoningFirstAt（distance to onAgentRunStart = LLM prefill + 开始思考耗时）
+         * - 每次累加字符数
+         * 与 onPartialReply 互斥：reasoning 期间不会有 text delta。
+         */
+        onReasoningStream: (payload) => {
+            if (completed || !payload.text)
+                return;
+            const now = Date.now();
+            if (reasoningFirstAt === 0) {
+                reasoningFirstAt = now;
+                log?.info(`[${CHANNEL_KEY}] [stream] onReasoningStream:first len=${payload.text.length}`);
+            }
+            reasoningLastAt = now;
+            reasoningChars += payload.text.length;
+        },
+        /** thinking block 结束：首个可见 token 的出现 ≈ 此刻 + 模型从 reasoning 切到 content 的微小间隙 */
+        onReasoningEnd: () => {
+            if (completed)
+                return;
+            // 仅在有实际 reasoning 内容时打日志，避免噪音（如 GLM-4-7 在工具调用前无内容触发）
+            if (reasoningChars === 0)
+                return;
+            const duration = reasoningLastAt && reasoningFirstAt ? reasoningLastAt - reasoningFirstAt : 0;
+            log?.info(`[${CHANNEL_KEY}] [stream] onReasoningEnd: chars=${reasoningChars} durationMs=${duration}`);
+        },
+        /**
+         * 新一轮 assistant 消息开始（多轮 tool call 场景）。
+         * 先把当前轮已推文本存入 streamedHistory 供跨轮去重，再重置当前轮状态。
+         */
+        onAssistantMessageStart: () => {
+            if (completed)
+                return;
+            assistantMessageCount++;
+            if (streamedText)
+                streamedHistory.push(streamedText);
+            partialReplyState = createDeltaTrackerState();
+            streamedText = "";
+            log?.info(`[${CHANNEL_KEY}] [stream] onAssistantMessageStart: round=${assistantMessageCount}` +
+                (reasoningChars > 0 ? ` prevReasoningChars=${reasoningChars} prevReasoningMs=${reasoningLastAt && reasoningFirstAt ? reasoningLastAt - reasoningFirstAt : 0}` : ""));
+            // 复位本轮 reasoning 计数
+            reasoningChars = 0;
+            reasoningFirstAt = 0;
+            reasoningLastAt = 0;
+        },
+        /**
+         * work item 生命周期事件（纯日志观测）。
+         *
+         * openclaw 的 agent event 里 `stream === "item"` 的事件会命中这里，payload 字段较多
+         * （itemId / kind / name / phase / status / summary / progressText / approvalId / approvalSlug）。
+         *
+         * 目的：先跑一轮拿到线上真实 payload 分布（kind / status 的可能取值、触发时机），
+         * 再决定是否要用它替代/增强现有 tool_start / tool_end 事件。在此之前不向前端 emit，
+         * 避免协议面扩散。
+         */
+        onItemEvent: (payload) => {
+            if (completed)
+                return;
+            log?.info(`[${CHANNEL_KEY}] [stream] onItemEvent: ${JSON.stringify(payload)}`);
+        },
+        onTypingCleanup: () => {
+            log?.info(`[${CHANNEL_KEY}] [stream] onTypingCleanup: counts=${JSON.stringify(counts)} ` +
+                `toolStart=${toolStartCount} assistantMsg=${assistantMessageCount} ` +
+                `streamedLen=${streamedText.length} historyRounds=${streamedHistory.length}`);
+        },
+        // 禁用框架内部的 block streaming，避免与 onPartialReply 重复分发。
+        disableBlockStreaming: true,
+    };
+    return {
+        dispatcher,
+        replyOptions,
+        // 业务辅助：独立于 openclaw ReplyDispatcher 契约暴露，避免污染 dispatcher
+        hasEmittedContent: () => emittedUserVisible,
+    };
+}

package/dist/src/streaming/types.js

@@ -0,0 +1,4 @@
+/**
+ * LightClaw — 流式输出类型定义
+ */
+export {};

package/dist/src/tools.js

@@ -0,0 +1,13 @@
+/**
+ * LightClaw — 工具注册入口
+ *
+ * 在 defineChannelPluginEntry 的 registerFull 回调中注册所有 Agent Tools。
+ * 此模块仅在插件完全激活后加载，避免 setup-only 模式拉起不必要的依赖。
+ */
+import { registerUploadTool } from './upload-tool.js';
+// import { registerDownloadTool } from "./download-tool.js";
+export function registerLightclawTools(api) {
+    // 注册文件存储工具（飞书工厂函数模式：execute 时动态从 api.config 解析 apiKey）
+    registerUploadTool(api);
+    // registerDownloadTool(api);
+}

package/dist/src/types.js

@@ -5,6 +5,26 @@
  *   { msgId, from, to, content, files, timestamp }
  *
  * files 格式为 FileAttachment[]，每个文件包含 name, mimeType, bytes(data URL)。
+ *
+ * @format
+ */
+/**
+ * 统一的信号发送出口，收敛 typing / stream / tool 控制帧的构造逻辑。
+ *
+ * - typing_start 不带 replyToMsgId（协议要求）；其余帧都携带。
+ * - extra 用于透传 kind 相关字段（如 tool_start 的 toolName/toolPhase、tool_end 的 toolIsError）。
  */
-export {};
-//# sourceMappingURL=types.js.map
+export function emitSignal(ctx, kind, content = "", extra) {
+    const { emitter, targetId, replyMsgId, originalMsgId, agentId } = ctx;
+    return emitter.emit({
+        msgId: replyMsgId,
+        from: emitter.botClientId,
+        to: targetId,
+        content,
+        timestamp: Date.now(),
+        kind,
+        ...(kind !== "typing_start" ? { replyToMsgId: originalMsgId } : {}),
+        ...extra,
+        agentId,
+    });
+}

package/dist/src/upload-tool.js

@@ -142,4 +142,3 @@ export function registerUploadTool(api) {
         };
     }, { name: UPLOAD_TOOL_NAME });
 }
-//# sourceMappingURL=upload-tool.js.map

package/dist/src/utils/account.js

@@ -0,0 +1,73 @@
+import { CHANNEL_KEY, DEFAULT_ACCOUNT_ID } from '../config.js';
+/**
+ * 从全局配置中提取当前渠道（LightClaw）的配置对象。
+ *
+ * @param cfg - OpenClaw 全局配置
+ * @returns 当前渠道的配置对象；若未配置则返回空对象 `{}`
+ */
+export function getChannelConfig(cfg) {
+    // 通过 CHANNEL_KEY 定位渠道配置，未配置时降级为空对象，避免后续访问报错
+    return (cfg.channels?.[CHANNEL_KEY] ?? {});
+}
+/**
+ * 列出当前渠道配置中所有已注册的账户 ID。
+ *
+ * @param cfg - OpenClaw 全局配置
+ * @returns 账户 ID 数组；若未配置任何账户则返回空数组
+ */
+export function listAccountIds(cfg) {
+    const channelConfig = getChannelConfig(cfg);
+    // getChannelConfig 始终返回对象，此处防御性判断以应对极端情况
+    if (!channelConfig)
+        return [];
+    const ids = [];
+    // accounts 的结构为 Record<accountId, AssistantAccountConfig>
+    const accounts = channelConfig?.accounts;
+    if (accounts && typeof accounts === 'object') {
+        // 将所有账户 ID（即 accounts 的 key）收集到结果数组
+        ids.push(...Object.keys(accounts));
+    }
+    return ids;
+}
+/**
+ * 根据账户 ID 从配置中解析出完整的账户信息（含默认值填充）。
+ *
+ * 若指定的 accountId 在配置中不存在，则所有字段均使用默认值，
+ * 不会抛出异常，调用方可安全使用返回值。
+ *
+ * @param cfg       - OpenClaw 全局配置
+ * @param accountId - 目标账户 ID；为空或 null 时使用空字符串作为 key 查找
+ * @returns 解析后的完整账户对象 {@link ResolvedAssistantAccount}
+ */
+export function resolveAccount(cfg, accountId) {
+    const channelConfig = getChannelConfig(cfg);
+    // 去除首尾空白，null/undefined 统一转为空字符串
+    const id = accountId?.trim() || '';
+    // accounts 结构：{ [accountId]: AssistantAccountConfig }
+    const accounts = channelConfig.accounts;
+    // 若账户不存在则降级为空对象，后续字段均使用默认值
+    const raw = accounts?.[id] ?? {};
+    return {
+        accountId: id,
+        apiKey: raw.apiKey || '', // API 密钥，未配置时为空字符串
+        apiBaseUrl: raw.apiBaseUrl || '', // REST API 基础地址，未配置时为空字符串
+        enabled: raw.enabled ?? true, // 是否启用，默认开启
+        name: raw.name || '', // 账户显示名称，未配置时为空字符串
+        dmPolicy: raw.dmPolicy ?? 'open', // DM 策略，默认 open（所有人可发消息）
+        allowFrom: raw.allowFrom ?? ['*'], // 允许发消息的用户列表，默认不限制
+        systemPrompt: raw.systemPrompt || '', // 自定义系统提示词，未配置时为空字符串
+    };
+}
+/**
+ * 获取当前渠道的默认账户 ID。
+ *
+ * 默认账户 ID 由常量 {@link DEFAULT_ACCOUNT_ID} 定义，
+ * 与具体配置无关，可在未指定账户时作为 fallback 使用。
+ *
+ * @param _cfg - OpenClaw 全局配置（当前未使用，保留以统一函数签名）
+ * @returns 默认账户 ID 字符串
+ */
+export function defaultAccountId(cfg) {
+    const ids = listAccountIds(cfg);
+    return ids[0] || DEFAULT_ACCOUNT_ID;
+}

package/dist/src/utils/common.js

@@ -0,0 +1,48 @@
+import { X_PRODUCT } from '../config.js';
+/**
+ * 将长文本按指定长度拆分为多个文本块。
+ *
+ * 拆分策略（优先级从高到低）：
+ * 1. 优先在换行符（\n）处切割，保持段落完整性；
+ * 2. 若换行符位置过靠前（< limit 的 50%），则退而求其次在空格处切割；
+ * 3. 若仍找不到合适的空格，则强制在 limit 处硬切。
+ *
+ * @param text  - 待拆分的原始文本
+ * @param limit - 每个文本块的最大字符数
+ * @returns 拆分后的文本块数组
+ */
+export function chunkText(text, limit) {
+    // 文本长度未超限，直接返回原文本
+    if (text.length <= limit)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        // 剩余文本已在限制内，直接作为最后一块
+        if (remaining.length <= limit) {
+            chunks.push(remaining);
+            break;
+        }
+        // 策略 1：尝试在换行符处切割
+        let splitAt = remaining.lastIndexOf('\n', limit);
+        // 策略 2：换行符位置过靠前时，改为在空格处切割
+        if (splitAt <= 0 || splitAt < limit * 0.5) {
+            splitAt = remaining.lastIndexOf(' ', limit);
+        }
+        // 策略 3：仍找不到合适位置，强制硬切
+        if (splitAt <= 0 || splitAt < limit * 0.5) {
+            splitAt = limit;
+        }
+        chunks.push(remaining.slice(0, splitAt));
+        // trimStart 去除下一块开头的空白，避免段首多余空格
+        remaining = remaining.slice(splitAt).trimStart();
+    }
+    return chunks;
+}
+/** 构建通用认证 headers */
+export function buildAuthHeaders(apiKey) {
+    return {
+        authorization: `Bearer ${apiKey}`,
+        'x-product': X_PRODUCT,
+    };
+}

package/dist/src/utils/index.js

@@ -0,0 +1,2 @@
+export * from './common.js';
+export * from './account.js';

package/node_modules/ws/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const createWebSocketStream = require('./lib/stream');
+const extension = require('./lib/extension');
+const PerMessageDeflate = require('./lib/permessage-deflate');
+const Receiver = require('./lib/receiver');
+const Sender = require('./lib/sender');
+const subprotocol = require('./lib/subprotocol');
+const WebSocket = require('./lib/websocket');
+const WebSocketServer = require('./lib/websocket-server');
+
+WebSocket.createWebSocketStream = createWebSocketStream;
+WebSocket.extension = extension;
+WebSocket.PerMessageDeflate = PerMessageDeflate;
+WebSocket.Receiver = Receiver;
+WebSocket.Sender = Sender;
+WebSocket.Server = WebSocketServer;
+WebSocket.subprotocol = subprotocol;
+WebSocket.WebSocket = WebSocket;
+WebSocket.WebSocketServer = WebSocketServer;
+
+module.exports = WebSocket;

package/node_modules/{engine.io-client/node_modules/ws → ws}/lib/constants.js

@@ -7,6 +7,7 @@ if (hasBlob) BINARY_TYPES.push('blob');
 
 module.exports = {
   BINARY_TYPES,
+  CLOSE_TIMEOUT: 30000,
   EMPTY_BUFFER: Buffer.alloc(0),
   GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
   hasBlob,

package/node_modules/{engine.io-client/node_modules/ws → ws}/lib/permessage-deflate.js

@@ -37,6 +37,9 @@ class PerMessageDeflate {
    *     acknowledge disabling of client context takeover
    * @param {Number} [options.concurrencyLimit=10] The number of concurrent
    *     calls to zlib
+   * @param {Boolean} [options.isServer=false] Create the instance in either
+   *     server or client mode
+   * @param {Number} [options.maxPayload=0] The maximum allowed message length
    * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
    *     use of a custom server window size
    * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
@@ -47,16 +50,13 @@ class PerMessageDeflate {
    *     deflate
    * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
    *     inflate
-   * @param {Boolean} [isServer=false] Create the instance in either server or
-   *     client mode
-   * @param {Number} [maxPayload=0] The maximum allowed message length
    */
-  constructor(options, isServer, maxPayload) {
-    this._maxPayload = maxPayload | 0;
+  constructor(options) {
     this._options = options || {};
     this._threshold =
       this._options.threshold !== undefined ? this._options.threshold : 1024;
-    this._isServer = !!isServer;
+    this._maxPayload = this._options.maxPayload | 0;
+    this._isServer = !!this._options.isServer;
     this._deflate = null;
     this._inflate = null;