@next-open-ai/openclawx 0.8.8 → 0.8.16

package/dist/core/agent/proxy/adapters/coze-adapter.js

@@ -0,0 +1,399 @@
+const COZE_ENDPOINT_COM = "https://api.coze.com";
+const COZE_ENDPOINT_CN = "https://api.coze.cn";
+const REQUEST_TIMEOUT_MS = 120_000;
+function getCozeConfig(config) {
+    const coze = config.coze;
+    if (!coze?.botId?.trim() || !coze?.apiKey?.trim()) {
+        console.warn(`[Coze] getCozeConfig: missing coze config (hasCoze=${!!coze}, hasBotId=${!!coze?.botId?.trim()}, hasApiKey=${!!coze?.apiKey?.trim()})`);
+        return null;
+    }
+    const explicitEndpoint = coze.endpoint?.trim();
+    const region = coze.region === "cn" ? "cn" : "com";
+    const defaultBase = region === "cn" ? COZE_ENDPOINT_CN : COZE_ENDPOINT_COM;
+    const baseUrl = (explicitEndpoint || defaultBase).replace(/\/$/, "");
+    const apiKey = coze.apiKey.trim();
+    console.log(`[Coze] getCozeConfig: botId=${coze.botId.trim()}, region=${region}, baseUrl=${baseUrl}`);
+    return { botId: coze.botId.trim(), apiKey, baseUrl, region };
+}
+/** 国内站常见内部事件：不当作正文展示 */
+const COZE_INTERNAL_MSG_TYPES = new Set([
+    "empty result",
+    "generate_answer_finish",
+]);
+/** 若字符串明显是内部协议 JSON（不应展示给用户），返回 true */
+function looksLikeInternalJson(s) {
+    const t = s.trim();
+    if (t.startsWith("{")) {
+        if (t.includes('"msg_type"') || t.includes("from_module") || t.includes("generate_answer_finish"))
+            return true;
+    }
+    return false;
+}
+/** 从 Coze 流式 SSE 的 data 行 JSON 中解析出文本 delta（兼容国际站/国内站 v3） */
+function parseCozeStreamLine(data) {
+    const trimmed = data.trim();
+    if (!trimmed || trimmed === "[DONE]" || trimmed === "[done]")
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        const msgType = parsed.msg_type;
+        if (msgType != null && COZE_INTERNAL_MSG_TYPES.has(String(msgType).toLowerCase()))
+            return null;
+        const d = parsed.data;
+        if (d && typeof d.content === "string") {
+            if (!looksLikeInternalJson(d.content))
+                return d.content;
+            return null;
+        }
+        if (d && typeof d.delta === "string") {
+            const v = d.delta;
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        if (d && d.delta?.content != null) {
+            const v = String(d.delta.content);
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        const dataMsg = d?.message;
+        if (dataMsg && typeof dataMsg.content === "string") {
+            if (!looksLikeInternalJson(dataMsg.content))
+                return dataMsg.content;
+            return null;
+        }
+        const msg = parsed.message;
+        if (msg && typeof msg.content === "string") {
+            if (!looksLikeInternalJson(msg.content))
+                return msg.content;
+            return null;
+        }
+        if (typeof parsed.content === "string") {
+            const v = parsed.content;
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        if (typeof parsed.delta === "string") {
+            const v = parsed.delta;
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        if (parsed.delta?.content != null) {
+            const v = String(parsed.delta.content);
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        if (parsed.type === "answer" && typeof parsed.content === "string") {
+            const v = parsed.content;
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        if (typeof parsed.answer === "string") {
+            const v = parsed.answer;
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        if (typeof parsed.text === "string") {
+            const v = parsed.text;
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        if (d && typeof d.text === "string") {
+            const v = d.text;
+            if (!looksLikeInternalJson(v))
+                return v;
+            return null;
+        }
+        const parts = (msg ?? dataMsg)?.parts;
+        if (Array.isArray(parts) && parts.length > 0) {
+            const text = parts.map((p) => (p?.content != null ? String(p.content) : "")).join("");
+            if (text && !looksLikeInternalJson(text))
+                return text;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Coze 业务错误码：code !== 0 时抛出，提示用户检查配置（如 API Key） */
+function throwIfCozeError(data) {
+    const code = data.code;
+    if (code === undefined || code === 0)
+        return;
+    const msg = data.msg || "Unknown error";
+    if (code === 4101) {
+        throw new Error("Coze 返回 4101：当前填写的 API Key 被 Coze 拒绝（已传递，但认证失败）。请检查：1) 必须使用「个人访问令牌」Personal Access Token，在 Coze 开放平台「个人中心 - API 密钥」创建，不要用 Bot ID 或其它 token；2) 国际站 (api.coze.com) 与国内站 (api.coze.cn) 的 Key 不通用，Endpoint 需与 Key 所属站点一致；3) Key 可能已过期或被撤销，请重新生成并保存。参考：https://www.coze.com/docs/developer_guides/authentication");
+    }
+    throw new Error(`Coze API 错误 (code=${code}): ${msg}`);
+}
+/** 从 Coze 非流式 JSON 响应中解析出助手回复文本 */
+function parseCozeCollectResponse(data) {
+    const dataObj = data.data;
+    if (dataObj) {
+        const msg = dataObj.message;
+        if (msg && typeof msg.content === "string")
+            return msg.content.trim();
+        if (typeof dataObj.content === "string")
+            return dataObj.content.trim();
+        const messages = dataObj.messages;
+        if (Array.isArray(messages) && messages.length > 0) {
+            const last = messages[messages.length - 1];
+            if (last && typeof last.content === "string")
+                return last.content.trim();
+        }
+    }
+    const msg = data.message;
+    if (msg && typeof msg.content === "string")
+        return msg.content.trim();
+    if (typeof data.content === "string")
+        return data.content.trim();
+    return "";
+}
+export const cozeAdapter = {
+    type: "coze",
+    async runStream(options, config, callbacks) {
+        const cozeConfig = getCozeConfig(config);
+        if (!cozeConfig) {
+            throw new Error("Coze adapter: missing coze.botId or coze.apiKey in agent config");
+        }
+        const { sessionId, message } = options;
+        const url = `${cozeConfig.baseUrl}/v3/chat?bot_id=${encodeURIComponent(cozeConfig.botId)}`;
+        const body = {
+            conversation_id: sessionId,
+            bot_id: cozeConfig.botId,
+            user_id: `channel:${sessionId}`,
+            stream: true,
+            auto_save_history: true,
+            additional_messages: [{ role: "user", content: message, content_type: "text" }],
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            console.log(`[Coze] POST ${url} (stream=true)`);
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${cozeConfig.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            console.log(`[Coze] Response status=${res.status} content-type=${res.headers.get("content-type") ?? "(none)"}`);
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`Coze API error ${res.status}: ${text}`);
+            }
+            const contentType = (res.headers.get("content-type") || "").toLowerCase();
+            // Coze 在 token 错误等情况下仍返回 200 + application/json，需先按 JSON 解析并检查 code
+            if (contentType.includes("application/json")) {
+                const text = await res.text();
+                try {
+                    const data = JSON.parse(text);
+                    throwIfCozeError(data);
+                    const fullText = parseCozeCollectResponse(data);
+                    if (fullText)
+                        callbacks.onChunk(fullText);
+                }
+                catch (e) {
+                    if (e?.message?.startsWith("Coze API") || e?.message?.startsWith("Coze API Key"))
+                        throw e;
+                    throw new Error(`Coze 返回了 JSON 但解析失败: ${e?.message ?? e}`);
+                }
+                callbacks.onTurnEnd?.();
+                callbacks.onDone();
+                return;
+            }
+            const reader = res.body?.getReader();
+            if (!reader) {
+                console.log(`[Coze] No stream reader, reading body as text`);
+                const text = await res.text();
+                if (text)
+                    callbacks.onChunk(text);
+                callbacks.onTurnEnd?.();
+                callbacks.onDone();
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = "";
+            let hadAnyChunk = false;
+            const rawDataSamples = [];
+            let lastEvent = "";
+            let streamAccumulated = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.replace(/\r\n/g, "\n").split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    if (trimmedLine.startsWith("event:")) {
+                        lastEvent = trimmedLine.slice(6).trim();
+                        continue;
+                    }
+                    if (!trimmedLine.startsWith("data:"))
+                        continue;
+                    const raw = trimmedLine.slice(5).trim();
+                    if (!raw)
+                        continue;
+                    if (rawDataSamples.length < 5)
+                        rawDataSamples.push(lastEvent + " -> " + raw.slice(0, 150));
+                    const e = lastEvent.toLowerCase();
+                    const isMessageEvent = e.includes("message") || e.includes("delta") || e.includes("answer") || e.includes("chunk") || lastEvent === "";
+                    const content = isMessageEvent ? parseCozeStreamLine(raw) : null;
+                    if (content) {
+                        if (content === streamAccumulated)
+                            continue;
+                        if (streamAccumulated.length > 0 && streamAccumulated.startsWith(content))
+                            continue;
+                        if (streamAccumulated.length > 0 && content.length >= 10 && streamAccumulated.endsWith(content))
+                            continue;
+                        if (content.startsWith(streamAccumulated)) {
+                            const suffix = content.slice(streamAccumulated.length);
+                            if (suffix) {
+                                streamAccumulated = content;
+                                hadAnyChunk = true;
+                                callbacks.onChunk(suffix);
+                            }
+                            continue;
+                        }
+                        streamAccumulated += content;
+                        hadAnyChunk = true;
+                        callbacks.onChunk(content);
+                    }
+                }
+            }
+            // 若 SSE 流中没有任何可解析的 content，尝试：1) buffer 为 data: 行；2) buffer 为整段 JSON（非流式返回）
+            if (!hadAnyChunk && buffer.trim()) {
+                const dataPart = buffer.startsWith("data: ") ? buffer.slice(6) : buffer;
+                const content = parseCozeStreamLine(dataPart);
+                if (content) {
+                    callbacks.onChunk(content);
+                }
+                else {
+                    try {
+                        const asJson = JSON.parse(buffer.trim());
+                        const fullText = parseCozeCollectResponse(asJson);
+                        if (fullText)
+                            callbacks.onChunk(fullText);
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+            if (!hadAnyChunk) {
+                const sample = buffer.trim().slice(0, 300);
+                console.log(`[Coze] Stream ended with no parsed chunks. Buffer sample: ${sample || "(empty)"}`);
+                if (rawDataSamples.length > 0) {
+                    console.log(`[Coze] First SSE data lines sample: ${rawDataSamples.join(" | ")}`);
+                }
+                // 可能是 Coze 返回的 JSON 错误体（如 4101 token 无效），先检查再决定是否回退
+                try {
+                    const asJson = JSON.parse(buffer.trim());
+                    throwIfCozeError(asJson);
+                    const fullText = parseCozeCollectResponse(asJson);
+                    if (fullText)
+                        callbacks.onChunk(fullText);
+                }
+                catch (parseErr) {
+                    if (parseErr?.message?.startsWith("Coze API") || parseErr?.message?.startsWith("Coze API Key"))
+                        throw parseErr;
+                    // 流式未解析到内容，回退到非流式接口
+                    try {
+                        console.log(`[Coze] Stream had no parsed chunks, trying runCollect fallback`);
+                        const fallbackText = await this.runCollect(options, config);
+                        if (fallbackText) {
+                            callbacks.onChunk(fallbackText);
+                            console.log(`[Coze] Fallback runCollect returned ${fallbackText.length} chars`);
+                        }
+                    }
+                    catch (collectErr) {
+                        if (collectErr?.message?.startsWith("Coze API") || collectErr?.message?.startsWith("Coze API Key"))
+                            throw collectErr;
+                        console.warn(`[Coze] Fallback runCollect failed:`, collectErr?.message ?? collectErr);
+                    }
+                }
+            }
+            callbacks.onTurnEnd?.();
+            callbacks.onDone();
+            console.log(`[Coze] runStream finished`);
+        }
+        catch (err) {
+            console.error(`[Coze] runStream error:`, err?.message ?? err);
+            // 请求超时或网络错误时，尝试非流式接口兜底
+            try {
+                const fallbackText = await this.runCollect(options, config);
+                if (fallbackText) {
+                    callbacks.onChunk(fallbackText);
+                    callbacks.onTurnEnd?.();
+                    callbacks.onDone();
+                    console.log(`[Coze] runStream recovered via runCollect`);
+                    return;
+                }
+            }
+            catch (_) {
+                // ignore
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    },
+    async runCollect(options, config) {
+        const cozeConfig = getCozeConfig(config);
+        if (!cozeConfig) {
+            throw new Error("Coze adapter: missing coze.botId or coze.apiKey in agent config");
+        }
+        const { sessionId, message } = options;
+        const url = `${cozeConfig.baseUrl}/v3/chat?bot_id=${encodeURIComponent(cozeConfig.botId)}`;
+        const body = {
+            conversation_id: sessionId,
+            bot_id: cozeConfig.botId,
+            user_id: `channel:${sessionId}`,
+            stream: false,
+            auto_save_history: true,
+            additional_messages: [{ role: "user", content: message, content_type: "text" }],
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${cozeConfig.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const raw = await res.text();
+            if (!res.ok)
+                throw new Error(`Coze API error ${res.status}: ${raw}`);
+            let data;
+            try {
+                data = JSON.parse(raw);
+            }
+            catch {
+                return "(无文本回复)";
+            }
+            throwIfCozeError(data);
+            const content = parseCozeCollectResponse(data);
+            return content || "(无文本回复)";
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    },
+};

package/dist/core/agent/proxy/adapters/local-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { IAgentProxyAdapter } from "../types.js";
+export declare const localAdapter: IAgentProxyAdapter;

package/dist/core/agent/proxy/adapters/local-adapter.js

@@ -0,0 +1,100 @@
+/**
+ * Local AgentProxy 适配器：使用本机 AgentManager（pi-coding-agent）执行。
+ */
+import { agentManager } from "../../agent-manager.js";
+import { getDesktopConfig } from "../../../config/desktop-config.js";
+import { getExperienceContextForUserMessage } from "../../../memory/index.js";
+const CHANNEL_AGENT_TIMEOUT_MS = 120_000;
+export const localAdapter = {
+    type: "local",
+    async runStream(options, config, callbacks) {
+        const { sessionId, message, agentId } = options;
+        const workspace = config.workspace ?? agentId ?? "default";
+        const { maxAgentSessions } = getDesktopConfig();
+        const session = await agentManager.getOrCreateSession(sessionId, {
+            agentId,
+            workspace,
+            provider: config.provider,
+            modelId: config.model,
+            apiKey: config.apiKey,
+            maxSessions: maxAgentSessions,
+            targetAgentId: agentId,
+            mcpServers: config.mcpServers,
+            systemPrompt: config.systemPrompt,
+        });
+        let resolveDone;
+        const donePromise = new Promise((r) => {
+            resolveDone = r;
+        });
+        const unsubscribe = session.subscribe((event) => {
+            if (event.type === "message_update" && event.assistantMessageEvent?.type === "text_delta" && event.assistantMessageEvent?.delta) {
+                callbacks.onChunk(event.assistantMessageEvent.delta);
+            }
+            else if (event.type === "turn_end") {
+                callbacks.onTurnEnd?.();
+            }
+            else if (event.type === "agent_end") {
+                callbacks.onDone();
+                resolveDone();
+            }
+        });
+        try {
+            const experienceBlock = await getExperienceContextForUserMessage();
+            const userMessageToSend = experienceBlock.trim().length > 0
+                ? `${experienceBlock}\n\n用户问题：\n${message}`
+                : message;
+            await session.sendUserMessage(userMessageToSend, { deliverAs: "followUp" });
+            await Promise.race([
+                donePromise,
+                new Promise((_, rej) => setTimeout(() => rej(new Error("Channel agent reply timeout")), CHANNEL_AGENT_TIMEOUT_MS)),
+            ]);
+        }
+        finally {
+            unsubscribe();
+        }
+    },
+    async runCollect(options, config) {
+        const { sessionId, message, agentId } = options;
+        const workspace = config.workspace ?? agentId ?? "default";
+        const { maxAgentSessions } = getDesktopConfig();
+        const session = await agentManager.getOrCreateSession(sessionId, {
+            agentId,
+            workspace,
+            provider: config.provider,
+            modelId: config.model,
+            apiKey: config.apiKey,
+            maxSessions: maxAgentSessions,
+            targetAgentId: agentId,
+            mcpServers: config.mcpServers,
+            systemPrompt: config.systemPrompt,
+        });
+        const chunks = [];
+        let resolveDone;
+        const donePromise = new Promise((r) => {
+            resolveDone = r;
+        });
+        const unsubscribe = session.subscribe((event) => {
+            if (event.type === "message_update" && event.assistantMessageEvent?.type === "text_delta" && event.assistantMessageEvent?.delta) {
+                chunks.push(event.assistantMessageEvent.delta);
+            }
+            else if (event.type === "agent_end") {
+                resolveDone();
+            }
+        });
+        try {
+            const experienceBlock = await getExperienceContextForUserMessage();
+            const userMessageToSend = experienceBlock.trim().length > 0
+                ? `${experienceBlock}\n\n用户问题：\n${message}`
+                : message;
+            await session.sendUserMessage(userMessageToSend, { deliverAs: "followUp" });
+            await Promise.race([
+                donePromise,
+                new Promise((_, rej) => setTimeout(() => rej(new Error("Channel agent reply timeout")), CHANNEL_AGENT_TIMEOUT_MS)),
+            ]);
+        }
+        finally {
+            unsubscribe();
+        }
+        return chunks.join("").trim() || "(无文本回复)";
+    },
+};

package/dist/core/agent/proxy/adapters/openclawx-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { IAgentProxyAdapter } from "../types.js";
+export declare const openclawxAdapter: IAgentProxyAdapter;

package/dist/core/agent/proxy/adapters/openclawx-adapter.js

@@ -0,0 +1,108 @@
+const REQUEST_TIMEOUT_MS = 120_000;
+function getOpenClawXConfig(config) {
+    const ox = config.openclawx;
+    if (!ox?.baseUrl?.trim())
+        return null;
+    return {
+        baseUrl: ox.baseUrl.replace(/\/$/, ""),
+        apiKey: ox.apiKey?.trim(),
+    };
+}
+function buildHeaders(apiKey) {
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey)
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    return headers;
+}
+export const openclawxAdapter = {
+    type: "openclawx",
+    async runStream(options, config, callbacks) {
+        const oxConfig = getOpenClawXConfig(config);
+        if (!oxConfig) {
+            throw new Error("OpenClawX adapter: missing openclawx.baseUrl in agent config");
+        }
+        const url = `${oxConfig.baseUrl}/server-api/agents/proxy-chat/stream`;
+        const body = { sessionId: options.sessionId, message: options.message, agentId: options.agentId };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: buildHeaders(oxConfig.apiKey),
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`OpenClawX proxy stream error ${res.status}: ${text}`);
+            }
+            const reader = res.body?.getReader();
+            if (!reader) {
+                callbacks.onDone();
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.startsWith("data:")) {
+                        const data = line.slice(5).trim();
+                        if (!data)
+                            continue;
+                        try {
+                            const parsed = JSON.parse(data);
+                            if (parsed.done) {
+                                callbacks.onDone();
+                                return;
+                            }
+                            if (typeof parsed.delta === "string" && parsed.delta) {
+                                callbacks.onChunk(parsed.delta);
+                            }
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                }
+            }
+            callbacks.onDone();
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    },
+    async runCollect(options, config) {
+        const oxConfig = getOpenClawXConfig(config);
+        if (!oxConfig) {
+            throw new Error("OpenClawX adapter: missing openclawx.baseUrl in agent config");
+        }
+        const url = `${oxConfig.baseUrl}/server-api/agents/proxy-chat`;
+        const body = { sessionId: options.sessionId, message: options.message, agentId: options.agentId };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: buildHeaders(oxConfig.apiKey),
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`OpenClawX proxy error ${res.status}: ${text}`);
+            }
+            const data = (await res.json());
+            const text = data.text;
+            return typeof text === "string" ? text.trim() || "(无文本回复)" : "(无文本回复)";
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    },
+};

package/dist/core/agent/proxy/index.d.ts

@@ -0,0 +1,3 @@
+export { runForChannelStream, runForChannelCollect } from "./run-for-channel.js";
+export { registerAgentProxyAdapter, getAgentProxyAdapter, listAgentProxyAdapterTypes } from "./registry.js";
+export type { IAgentProxyAdapter, RunAgentForChannelOptions, RunAgentStreamCallbacks } from "./types.js";

package/dist/core/agent/proxy/index.js

@@ -0,0 +1,14 @@
+/**
+ * AgentProxy 模块：统一执行入口与适配器注册。
+ * 使用前需确保已通过 registerAgentProxyAdapter 注册各类型适配器；
+ * 本模块在加载时注册内置的 local、coze、openclawx 适配器。
+ */
+import { registerAgentProxyAdapter } from "./registry.js";
+import { localAdapter } from "./adapters/local-adapter.js";
+import { cozeAdapter } from "./adapters/coze-adapter.js";
+import { openclawxAdapter } from "./adapters/openclawx-adapter.js";
+registerAgentProxyAdapter(localAdapter);
+registerAgentProxyAdapter(cozeAdapter);
+registerAgentProxyAdapter(openclawxAdapter);
+export { runForChannelStream, runForChannelCollect } from "./run-for-channel.js";
+export { registerAgentProxyAdapter, getAgentProxyAdapter, listAgentProxyAdapterTypes } from "./registry.js";

package/dist/core/agent/proxy/registry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AgentProxy 注册表：按 runnerType 注册与获取适配器。
+ */
+import type { IAgentProxyAdapter } from "./types.js";
+export declare function registerAgentProxyAdapter(adapter: IAgentProxyAdapter): void;
+export declare function getAgentProxyAdapter(type: string): IAgentProxyAdapter | undefined;
+export declare function listAgentProxyAdapterTypes(): string[];

package/dist/core/agent/proxy/registry.js

@@ -0,0 +1,13 @@
+const adapters = new Map();
+export function registerAgentProxyAdapter(adapter) {
+    if (adapters.has(adapter.type)) {
+        console.warn(`[AgentProxyRegistry] overwriting adapter for type "${adapter.type}"`);
+    }
+    adapters.set(adapter.type, adapter);
+}
+export function getAgentProxyAdapter(type) {
+    return adapters.get(type);
+}
+export function listAgentProxyAdapterTypes() {
+    return Array.from(adapters.keys());
+}

package/dist/core/agent/proxy/run-for-channel.d.ts

@@ -0,0 +1,3 @@
+import type { RunAgentForChannelOptions, RunAgentStreamCallbacks } from "./types.js";
+export declare function runForChannelStream(options: RunAgentForChannelOptions, callbacks: RunAgentStreamCallbacks): Promise<void>;
+export declare function runForChannelCollect(options: RunAgentForChannelOptions): Promise<string>;