@next-open-ai/openclawx 0.8.16 → 0.8.22

package/dist/gateway/channel/adapters/wechat.js

@@ -0,0 +1,205 @@
+import { dispatchMessage } from "../registry.js";
+let currentQrCodeBase64 = null;
+let currentLoginStatus = "logged_out";
+let currentUserName = null;
+/** 供 Gateway API 查询当前二维码（base64 Data URL 或 null） */
+export function getWechatQrCode() {
+    return currentQrCodeBase64;
+}
+/** 供 Gateway API 查询登录状态 */
+export function getWechatStatus() {
+    return { status: currentLoginStatus, userName: currentUserName };
+}
+/** 重启 Wechaty 以刷新二维码（二维码过期后调用） */
+export async function refreshWechatQrCode() {
+    if (currentLoginStatus === "logged_in")
+        return; // 已登录无需刷新
+    if (!wechatyBot)
+        return; // bot 不存在
+    console.log("[WeChat] Refreshing QR code by restarting bot...");
+    currentQrCodeBase64 = null;
+    currentLoginStatus = "logged_out";
+    currentUserName = null;
+    try {
+        await wechatyBot.stop();
+        await wechatyBot.start();
+        console.log("[WeChat] Bot restarted for QR refresh");
+    }
+    catch (e) {
+        console.error("[WeChat] Refresh failed:", e);
+    }
+}
+/* ---------- Wechaty 实例引用 ---------- */
+let wechatyBot = null;
+/* ---------- Inbound ---------- */
+class WechatInbound {
+    config;
+    messageHandler = null;
+    stopped = false;
+    constructor(config) {
+        this.config = config;
+    }
+    setMessageHandler(handler) {
+        this.messageHandler = handler;
+    }
+    async start() {
+        this.stopped = false;
+        currentLoginStatus = "logged_out";
+        currentQrCodeBase64 = null;
+        currentUserName = null;
+        try {
+            // 动态导入 wechaty 和 qrcode（ESM）
+            const { WechatyBuilder } = await import("wechaty");
+            const QRCode = await import("qrcode");
+            const opts = { name: "openclawx-wechat" };
+            if (this.config.puppet) {
+                opts.puppet = this.config.puppet;
+            }
+            const builder = WechatyBuilder.build(opts);
+            wechatyBot = builder;
+            builder.on("scan", async (qrcode, status) => {
+                if (this.stopped)
+                    return;
+                console.log(`[WeChat] Scan event, status=${status}, qrcode=${qrcode ? 'present(' + qrcode.length + ' chars)' : 'empty'}`);
+                // Status: 0=Unknown, 2=WaitingForScan, 3=WaitingForConfirm, 4=Cancelled, 5=Expired
+                if (status === 4 || status === 5) {
+                    // QR code expired or cancelled
+                    currentQrCodeBase64 = null;
+                    currentLoginStatus = "logged_out";
+                    console.log("[WeChat] QR code expired or cancelled");
+                    return;
+                }
+                if (qrcode) {
+                    try {
+                        currentQrCodeBase64 = await QRCode.toDataURL(qrcode, { width: 256 });
+                        currentLoginStatus = "scanning";
+                        console.log("[WeChat] QR code generated successfully, waiting for scan...");
+                    }
+                    catch (e) {
+                        console.error("[WeChat] QR code generation failed:", e);
+                    }
+                }
+                else {
+                    console.log("[WeChat] Scan event without qrcode data, status:", status);
+                }
+            });
+            builder.on("login", (user) => {
+                currentLoginStatus = "logged_in";
+                currentQrCodeBase64 = null;
+                currentUserName = user?.name?.() || user?.payload?.name || String(user);
+                console.log(`[WeChat] Logged in as: ${currentUserName}`);
+            });
+            builder.on("logout", (user) => {
+                currentLoginStatus = "logged_out";
+                currentQrCodeBase64 = null;
+                currentUserName = null;
+                console.log("[WeChat] Logged out:", user?.name?.() || user);
+            });
+            builder.on("message", async (message) => {
+                if (this.stopped)
+                    return;
+                try {
+                    const isSelf = await message.self?.();
+                    if (isSelf)
+                        return;
+                    const text = (await message.text?.())?.trim?.() || message.text?.trim?.() || '';
+                    if (!text)
+                        return;
+                    console.log(`[WeChat] Received: "${text.substring(0, 80)}${text.length > 80 ? '...' : ''}"`);
+                    const talker = message.talker?.() ?? message.from?.();
+                    const room = await message.room?.();
+                    const talkerId = talker?.id || "unknown";
+                    const talkerName = (await talker?.name?.()) || talker?.name || undefined;
+                    const roomId = room?.id;
+                    const threadId = room ? (roomId || String(await room.topic?.())) : talkerId;
+                    const unified = {
+                        channelId: "wechat",
+                        threadId: String(threadId),
+                        userId: String(talkerId),
+                        userName: typeof talkerName === 'string' ? talkerName : undefined,
+                        messageText: text,
+                        replyTarget: String(threadId),
+                        raw: { roomId, talkerId },
+                    };
+                    if (this.messageHandler) {
+                        await this.messageHandler(unified);
+                    }
+                    else {
+                        await dispatchMessage(unified);
+                    }
+                    console.log("[WeChat] message dispatched");
+                }
+                catch (e) {
+                    console.error("[WeChat] message handler error:", e);
+                }
+            });
+            builder.on("error", (e) => {
+                console.error("[WeChat] bot error:", e?.message || e);
+            });
+            await builder.start();
+            console.log("[WeChat] Wechaty bot started, waiting for scan...");
+        }
+        catch (e) {
+            console.error("[WeChat] Failed to start Wechaty bot:", e);
+            currentLoginStatus = "logged_out";
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        currentLoginStatus = "logged_out";
+        currentQrCodeBase64 = null;
+        currentUserName = null;
+        if (wechatyBot) {
+            try {
+                await wechatyBot.stop();
+            }
+            catch (e) {
+                console.warn("[WeChat] stop error:", e);
+            }
+            wechatyBot = null;
+        }
+    }
+}
+/* ---------- Outbound ---------- */
+class WechatOutbound {
+    async send(targetId, reply) {
+        if (!wechatyBot) {
+            console.warn("[WeChat] bot not started, cannot send");
+            return;
+        }
+        const text = reply.text?.trim() || "(无内容)";
+        try {
+            // 先尝试作为 Room（群聊）发送
+            const room = await wechatyBot.Room?.find?.({ id: targetId });
+            if (room) {
+                await room.say(text);
+                return { sent: true, type: "room", id: targetId };
+            }
+            // 否则作为 Contact（私聊）发送
+            const contact = await wechatyBot.Contact?.find?.({ id: targetId });
+            if (contact) {
+                await contact.say(text);
+                return { sent: true, type: "contact", id: targetId };
+            }
+            console.warn("[WeChat] cannot find room or contact for targetId:", targetId);
+            return { sent: false, reason: "target not found" };
+        }
+        catch (e) {
+            console.error("[WeChat] send failed:", e);
+            throw e;
+        }
+    }
+}
+/* ---------- Channel 工厂 ---------- */
+export function createWechatChannel(config) {
+    const inbound = new WechatInbound(config);
+    const outbound = new WechatOutbound();
+    inbound.setMessageHandler((msg) => dispatchMessage(msg));
+    return {
+        id: "wechat",
+        name: "WeChat",
+        defaultAgentId: config.defaultAgentId ?? "default",
+        getInbounds: () => [inbound],
+        getOutbounds: () => [outbound],
+    };
+}

package/dist/gateway/methods/agent-cancel.d.ts

@@ -1,10 +1,12 @@
 import type { GatewayClient } from "../types.js";
 /**
  * Handle agent.cancel: abort the current turn for the given session.
- * Uses pi-coding-agent's session.abort() to stop the running agent and wait until idle.
+ * - Proxy agents: abort in-flight run via registered AbortController.
+ * - Local agent: uses pi-coding-agent's session.abort().
  */
 export declare function handleAgentCancel(client: GatewayClient, params: {
     sessionId?: string;
+    agentId?: string;
 }): Promise<{
     status: string;
 }>;

package/dist/gateway/methods/agent-cancel.js

@@ -1,14 +1,25 @@
 import { agentManager } from "../../core/agent/agent-manager.js";
+import { abortProxyRun } from "../proxy-run-abort.js";
+const COMPOSITE_KEY_SEP = "::";
 /**
  * Handle agent.cancel: abort the current turn for the given session.
- * Uses pi-coding-agent's session.abort() to stop the running agent and wait until idle.
+ * - Proxy agents: abort in-flight run via registered AbortController.
+ * - Local agent: uses pi-coding-agent's session.abort().
  */
 export async function handleAgentCancel(client, params) {
     const sessionId = params?.sessionId ?? client.sessionId;
     if (!sessionId) {
         throw new Error("No session ID available");
     }
-    const session = agentManager.getSession(sessionId);
+    const agentId = params?.agentId ?? client.agentId ?? "default";
+    if (abortProxyRun(sessionId, agentId)) {
+        return { status: "aborted" };
+    }
+    const compositeKey = sessionId + COMPOSITE_KEY_SEP + agentId;
+    let session = agentManager.getSession(compositeKey);
+    if (!session) {
+        session = agentManager.getSessionBySessionId(sessionId);
+    }
     if (!session) {
         return { status: "no_session" };
     }

package/dist/gateway/methods/agent-chat.js

@@ -1,10 +1,10 @@
 import { agentManager } from "../../core/agent/agent-manager.js";
 import { runForChannelStream } from "../../core/agent/proxy/index.js";
 import { getSessionCurrentAgentResolver, getSessionCurrentAgentUpdater } from "../../core/session-current-agent.js";
-import { getExperienceContextForUserMessage } from "../../core/memory/index.js";
 import { send, createEvent } from "../utils.js";
 import { connectedClients } from "../clients.js";
 import { getDesktopConfig, loadDesktopAgentConfig } from "../../core/config/desktop-config.js";
+import { registerProxyRunAbort } from "../proxy-run-abort.js";
 const COMPOSITE_KEY_SEP = "::";
 /**
  * Broadcast message to all clients subscribed to a session
@@ -59,40 +59,55 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
             apiKey = agentConfig.apiKey;
     }
     const runnerType = agentConfig?.runnerType ?? "local";
-    const isProxyAgent = runnerType === "coze" || runnerType === "openclawx";
+    const isProxyAgent = runnerType === "coze" || runnerType === "openclawx" || runnerType === "opencode";
     if (isProxyAgent) {
         console.log(`[agent.chat] Using proxy agent (${runnerType}) for session=${targetSessionId}, agentId=${currentAgentId}`);
     }
-    // 代理智能体（Coze / OpenClawX）：走 AgentProxy 统一入口，流式结果通过 WebSocket 推给客户端
+    // 代理智能体（Coze / OpenClawX / OpenCode）：走 AgentProxy 统一入口，流式结果通过 WebSocket 推给客户端
     if (isProxyAgent) {
+        const { signal, unregister } = registerProxyRunAbort(targetSessionId, currentAgentId);
+        const finishAndUnregister = () => {
+            unregister();
+            broadcastToSession(targetSessionId, createEvent("turn_end", { sessionId: targetSessionId, content: "" }));
+            broadcastToSession(targetSessionId, createEvent("message_complete", { sessionId: targetSessionId, content: "" }));
+            broadcastToSession(targetSessionId, createEvent("agent_end", { sessionId: targetSessionId }));
+            broadcastToSession(targetSessionId, createEvent("conversation_end", { sessionId: targetSessionId }));
+        };
         try {
             await runForChannelStream({
                 sessionId: targetSessionId,
                 message,
                 agentId: currentAgentId,
+                signal,
             }, {
                 onChunk(delta) {
-                    broadcastToSession(targetSessionId, createEvent("agent.chunk", { text: delta }));
+                    broadcastToSession(targetSessionId, createEvent("agent.chunk", { text: delta, sessionId: targetSessionId }));
                 },
                 onTurnEnd() {
                     broadcastToSession(targetSessionId, createEvent("turn_end", { sessionId: targetSessionId, content: "" }));
                     broadcastToSession(targetSessionId, createEvent("message_complete", { sessionId: targetSessionId, content: "" }));
                 },
                 onDone() {
-                    broadcastToSession(targetSessionId, createEvent("agent_end", { sessionId: targetSessionId }));
-                    broadcastToSession(targetSessionId, createEvent("conversation_end", { sessionId: targetSessionId }));
+                    finishAndUnregister();
                 },
             });
             return { status: "completed", sessionId: targetSessionId };
         }
         catch (error) {
-            console.error(`Error in agent chat (proxy ${runnerType}):`, error);
-            throw error;
+            const isAbort = error?.name === "AbortError" || (typeof error?.message === "string" && error.message.includes("abort"));
+            if (!isAbort)
+                console.error(`Error in agent chat (proxy ${runnerType}):`, error);
+            finishAndUnregister();
+            if (!isAbort) {
+                const errMsg = error?.message || String(error);
+                broadcastToSession(targetSessionId, createEvent("agent.chunk", { text: `请求失败：${errMsg}`, sessionId: targetSessionId }));
+            }
+            return { status: "completed", sessionId: targetSessionId };
         }
     }
     const isEphemeralSession = sessionType === "system" || sessionType === "scheduled";
     if (isEphemeralSession) {
-        agentManager.deleteSession(targetSessionId + COMPOSITE_KEY_SEP + currentAgentId);
+        await agentManager.deleteSession(targetSessionId + COMPOSITE_KEY_SEP + currentAgentId);
     }
     const effectiveTargetAgentId = sessionType === "system" ? targetAgentId : currentAgentId;
     const { maxAgentSessions } = getDesktopConfig();
@@ -108,6 +123,7 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
             targetAgentId: effectiveTargetAgentId,
             mcpServers: agentConfig?.mcpServers,
             systemPrompt: agentConfig?.systemPrompt,
+            useLongMemory: agentConfig?.useLongMemory,
         });
     }
     catch (err) {
@@ -119,17 +135,37 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
         throw err;
     }
     // 向各通道广播：turn_end（本小轮结束）、agent_end（整轮对话结束），并保留 message_complete / conversation_end 兼容。各端按需处理。
-    const unsubscribe = session.subscribe((event) => {
-        // console.log(`Agent event received: ${event.type}`); // Reduce noise
+    // 必须等 agent_end 后再 resolve 并 unsubscribe，否则 sendUserMessage 一 return 就 unsubscribe，流式 text_delta 会收不到，前端看不到回复。
+    let resolveAgentDone;
+    const agentDonePromise = new Promise((resolve) => {
+        resolveAgentDone = resolve;
+    });
+    let didUnsubscribe = false;
+    let unsubscribe;
+    const doUnsubscribe = () => {
+        if (didUnsubscribe)
+            return;
+        didUnsubscribe = true;
+        unsubscribe();
+    };
+    let hasReceivedAnyChunk = false;
+    unsubscribe = session.subscribe((event) => {
+        if (event.type !== "message_update") {
+            console.log(`[agent.chat] event: ${event.type}`);
+        }
         let wsMessage = null;
         if (event.type === "message_update") {
             const update = event;
             if (update.assistantMessageEvent && update.assistantMessageEvent.type === "text_delta") {
+                hasReceivedAnyChunk = true;
                 wsMessage = createEvent("agent.chunk", { text: update.assistantMessageEvent.delta });
             }
             else if (update.assistantMessageEvent && update.assistantMessageEvent.type === "thinking_delta") {
                 wsMessage = createEvent("agent.chunk", { text: update.assistantMessageEvent.delta, isThinking: true });
             }
+            else if (update.assistantMessageEvent?.type === "error" && update.assistantMessageEvent?.error?.errorMessage) {
+                console.warn("[agent.chat] model error:", update.assistantMessageEvent.error.errorMessage);
+            }
         }
         else if (event.type === "tool_execution_start") {
             wsMessage = createEvent("agent.tool", {
@@ -148,8 +184,48 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                 isError: event.isError
             });
         }
+        else if (event.type === "message_end") {
+            const msg = event.message;
+            if (msg?.role === "assistant" && msg?.content && Array.isArray(msg.content)) {
+                const text = msg.content
+                    .filter((c) => c?.type === "text" && typeof c.text === "string")
+                    .map((c) => c.text)
+                    .join("");
+                if (text) {
+                    hasReceivedAnyChunk = true;
+                    broadcastToSession(targetSessionId, createEvent("agent.chunk", { text }));
+                }
+            }
+            if (msg?.errorMessage) {
+                console.warn("[agent.chat] message_end error:", msg.errorMessage);
+                const errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
+                    ? "API 余额不足，请到「设置」检查并充值后重试。"
+                    : `请求失败：${msg.errorMessage}`;
+                broadcastToSession(targetSessionId, createEvent("agent.chunk", { text: errText }));
+            }
+            wsMessage = null;
+        }
         else if (event.type === "turn_end") {
-            const usage = event.message?.usage;
+            const msg = event.message;
+            if (!hasReceivedAnyChunk && msg?.content && Array.isArray(msg.content)) {
+                const fullText = msg.content
+                    .filter((c) => c?.type === "text" && typeof c.text === "string")
+                    .map((c) => c.text)
+                    .join("");
+                if (fullText) {
+                    broadcastToSession(targetSessionId, createEvent("agent.chunk", { text: fullText }));
+                    hasReceivedAnyChunk = true;
+                }
+            }
+            if (msg?.errorMessage) {
+                console.warn("[agent.chat] turn message error:", msg.errorMessage);
+                const errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
+                    ? "API 余额不足，请到「设置」检查并充值后重试。"
+                    : `请求失败：${msg.errorMessage}`;
+                broadcastToSession(targetSessionId, createEvent("agent.chunk", { text: errText }));
+                hasReceivedAnyChunk = true;
+            }
+            const usage = msg?.usage;
             const promptTokens = Number(usage?.input ?? usage?.input_tokens ?? 0) || 0;
             const completionTokens = Number(usage?.output ?? usage?.output_tokens ?? 0) || 0;
             const usagePayload = promptTokens > 0 || completionTokens > 0
@@ -165,25 +241,36 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
             wsMessage = null;
         }
         else if (event.type === "agent_end") {
+            if (!hasReceivedAnyChunk && Array.isArray(event.messages)) {
+                const messages = event.messages;
+                const lastAssistant = [...messages].reverse().find((m) => m?.role === "assistant" && m?.content);
+                if (lastAssistant?.content) {
+                    const text = lastAssistant.content
+                        .filter((c) => c?.type === "text" && typeof c.text === "string")
+                        .map((c) => c.text)
+                        .join("");
+                    if (text)
+                        broadcastToSession(targetSessionId, createEvent("agent.chunk", { text }));
+                }
+            }
             const agentPayload = { sessionId: targetSessionId };
             broadcastToSession(targetSessionId, createEvent("agent_end", agentPayload));
             broadcastToSession(targetSessionId, createEvent("conversation_end", agentPayload));
             wsMessage = null;
+            resolveAgentDone();
+            doUnsubscribe();
+            if (isEphemeralSession) {
+                void agentManager.deleteSession(targetSessionId + COMPOSITE_KEY_SEP + currentAgentId).catch(() => { });
+            }
         }
         if (wsMessage) {
             broadcastToSession(targetSessionId, wsMessage);
         }
-        if (event.type === "agent_end" && isEphemeralSession) {
-            agentManager.deleteSession(targetSessionId + COMPOSITE_KEY_SEP + currentAgentId);
-        }
     });
     try {
-        const experienceBlock = await getExperienceContextForUserMessage();
-        const userMessageToSend = experienceBlock.trim().length > 0
-            ? `${experienceBlock}\n\n用户问题：\n${message}`
-            : message;
         // 若 agent 正在流式输出，deliverAs: 'followUp' 将本条消息排队，避免抛出 "Agent is already processing"
-        await session.sendUserMessage(userMessageToSend, { deliverAs: "followUp" });
+        await session.sendUserMessage(message, { deliverAs: "followUp" });
+        await agentDonePromise;
         console.log(`Agent chat completed for session ${targetSessionId}`);
         return {
             status: "completed",
@@ -192,9 +279,8 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
     }
     catch (error) {
         console.error(`Error in agent chat:`, error);
+        resolveAgentDone();
+        doUnsubscribe();
         throw error;
     }
-    finally {
-        unsubscribe();
-    }
 }

package/dist/gateway/methods/run-scheduled-task.js

@@ -1,5 +1,4 @@
 import { agentManager } from "../../core/agent/agent-manager.js";
-import { getExperienceContextForUserMessage } from "../../core/memory/index.js";
 import { loadDesktopAgentConfig } from "../../core/config/desktop-config.js";
 async function readBody(req) {
     return new Promise((resolve, reject) => {
@@ -59,6 +58,7 @@ export async function handleRunScheduledTask(req, res) {
             apiKey,
             mcpServers: agentConfig?.mcpServers,
             systemPrompt: agentConfig?.systemPrompt,
+            useLongMemory: agentConfig?.useLongMemory,
         });
         let assistantContent = "";
         let turnPromptTokens = 0;
@@ -78,10 +78,6 @@ export async function handleRunScheduledTask(req, res) {
                 }
             }
         });
-        const experienceBlock = await getExperienceContextForUserMessage();
-        const userMessageToSend = experienceBlock.trim().length > 0
-            ? `${experienceBlock}\n\n用户问题：\n${message}`
-            : message;
         // 定时任务复用同一 session：若上次执行未结束会报 "Agent is already processing"。先等待空闲再发，避免并发。
         const idleTimeoutMs = 10 * 60 * 1000;
         const pollMs = 2000;
@@ -93,7 +89,7 @@ export async function handleRunScheduledTask(req, res) {
         if (session.isStreaming) {
             throw new Error("Session still busy after waiting; try again later.");
         }
-        await session.sendUserMessage(userMessageToSend);
+        await session.sendUserMessage(message);
         unsubscribe();
         if (backendBaseUrl && assistantContent !== undefined) {
             const url = `${backendBaseUrl.replace(/\/$/, "")}/server-api/agents/sessions/${encodeURIComponent(sessionId)}/messages`;
@@ -124,6 +120,6 @@ export async function handleRunScheduledTask(req, res) {
         res.end(JSON.stringify({ success: false, error: friendlyError }));
     }
     finally {
-        agentManager.deleteSession(sessionId + COMPOSITE_KEY_SEP + sessionAgentId);
+        await agentManager.deleteSession(sessionId + COMPOSITE_KEY_SEP + sessionAgentId);
     }
 }

package/dist/gateway/proxy-run-abort.d.ts

@@ -0,0 +1,6 @@
+export declare function registerProxyRunAbort(sessionId: string, agentId: string): {
+    signal: AbortSignal;
+    unregister: () => void;
+};
+/** Abort the proxy run for this session+agent if any; returns true if aborted. */
+export declare function abortProxyRun(sessionId: string, agentId: string): boolean;

package/dist/gateway/proxy-run-abort.js

@@ -0,0 +1,39 @@
+/**
+ * Registry of AbortControllers for in-flight proxy runs (Coze/OpenClawX/OpenCode).
+ * agent.cancel looks up by sessionId+agentId and aborts the controller so the run stops.
+ */
+const SEP = "::";
+function key(sessionId, agentId) {
+    return sessionId + SEP + agentId;
+}
+const controllers = new Map();
+export function registerProxyRunAbort(sessionId, agentId) {
+    const k = key(sessionId, agentId);
+    const existing = controllers.get(k);
+    if (existing) {
+        existing.abort();
+        controllers.delete(k);
+    }
+    const controller = new AbortController();
+    controllers.set(k, controller);
+    return {
+        signal: controller.signal,
+        unregister: () => {
+            controllers.delete(k);
+        },
+    };
+}
+/** Abort the proxy run for this session+agent if any; returns true if aborted. */
+export function abortProxyRun(sessionId, agentId) {
+    const k = key(sessionId, agentId);
+    const c = controllers.get(k);
+    if (!c)
+        return false;
+    try {
+        c.abort();
+    }
+    finally {
+        controllers.delete(k);
+    }
+    return true;
+}