@next-open-ai/openclawx 0.8.28 → 0.8.36

package/dist/gateway/channel/channel-core.js

@@ -1,5 +1,11 @@
 import { runAgentAndCollectReply, runAgentAndStreamReply } from "./run-agent.js";
 import { getChannelSessionPersistence, persistChannelUserMessage, persistChannelAssistantMessage } from "./session-persistence.js";
+import { preprocessInboundMessage } from "../../core/inbound-message-preprocess.js";
+import { getSessionCurrentAgentUpdater } from "../../core/session-current-agent.js";
+import { getSessionOutlet, sendSessionMessage } from "../../core/session-outlet/index.js";
+/** 系统消息前缀，与正常回复同路下发，仅用此前缀区分，各端无需额外逻辑；结尾换行便于与正文分行 */
+const SYSTEM_MSG_PREFIX = "[System Message] ";
+const SYSTEM_MSG_SUFFIX = "\n";
 const STREAM_THROTTLE_MS = 280;
 function toSessionId(channelId, threadId) {
     return `channel:${channelId}:${threadId}`;
@@ -61,75 +67,111 @@ export async function handleChannelMessage(channel, msg) {
         console.warn("[ChannelCore] invalid threadId, skip reply");
         return;
     }
-    // 与 Web/Desktop 统一：通道会话入库并追加用户消息（用 currentAgentId）
-    await persistChannelUserMessage(sessionId, {
-        agentId: currentAgentId,
-        title: msg.messageText?.trim().slice(0, 50) || undefined,
-        messageText: msg.messageText?.trim() || "",
+    const rawMessage = msg.messageText?.trim() ?? "";
+    const { message: messageText, agentId: effectiveAgentId, directResponse } = await preprocessInboundMessage({
+        sessionId,
+        message: rawMessage,
+        currentAgentId,
     });
-    const useStream = typeof outbound.sendStream === "function";
-    if (useStream) {
-        let sink;
-        try {
-            sink = await outbound.sendStream(threadId);
+    getSessionCurrentAgentUpdater()?.(sessionId, effectiveAgentId);
+    const outlet = getSessionOutlet();
+    const channelConsumer = {
+        send(m) {
+            if (m.type !== "system")
+                return;
+            const raw = m.payload?.text ?? m.payload?.message ?? m.payload?.phase ?? "";
+            if (raw) {
+                const text = SYSTEM_MSG_PREFIX + raw + SYSTEM_MSG_SUFFIX;
+                outbound.send(threadId, { text }).catch((e) => console.warn("[ChannelCore] outlet send failed:", e));
+            }
+        },
+    };
+    const unregisterConsumer = outlet ? outlet.registerConsumer(sessionId, channelConsumer) : () => { };
+    try {
+        if (directResponse != null && directResponse !== "") {
+            await persistChannelUserMessage(sessionId, {
+                agentId: effectiveAgentId,
+                title: rawMessage.slice(0, 50) || undefined,
+                messageText: rawMessage,
+            });
+            persistChannelAssistantMessage(sessionId, directResponse);
+            sendSessionMessage(sessionId, { type: "system", code: "command.result", payload: { text: directResponse } });
+            await msg.ack?.({ text: directResponse });
+            return;
         }
-        catch (err) {
-            console.error("[ChannelCore] sendStream init failed:", err);
-            const reply = { text: "发信失败，请稍后再试。" };
-            await outbound.send(threadId, reply);
+        // 与 Web/Desktop 统一：通道会话入库并追加用户消息（用预处理后的 agentId 与消息）
+        await persistChannelUserMessage(sessionId, {
+            agentId: effectiveAgentId,
+            title: messageText.slice(0, 50) || undefined,
+            messageText,
+        });
+        const useStream = typeof outbound.sendStream === "function";
+        if (useStream) {
+            let sink;
+            try {
+                sink = await outbound.sendStream(threadId);
+            }
+            catch (err) {
+                console.error("[ChannelCore] sendStream init failed:", err);
+                const reply = { text: "发信失败，请稍后再试。" };
+                await outbound.send(threadId, reply);
+                return;
+            }
+            let accumulated = "";
+            let donePromise = null;
+            const throttled = throttle(() => {
+                if (sink.onChunk)
+                    void Promise.resolve(sink.onChunk(accumulated)).catch((e) => console.error("[ChannelCore] stream onChunk error:", e));
+            }, STREAM_THROTTLE_MS);
+            try {
+                await runAgentAndStreamReply({ sessionId, message: messageText, agentId: effectiveAgentId }, {
+                    onChunk(delta) {
+                        accumulated += delta;
+                        throttled.run();
+                    },
+                    onTurnEnd() {
+                        throttled.flush();
+                        if (sink.onTurnEnd)
+                            void Promise.resolve(sink.onTurnEnd(accumulated)).catch((e) => console.error("[ChannelCore] stream onTurnEnd error:", e));
+                    },
+                    onDone() {
+                        throttled.cancel();
+                        const final = accumulated.trim() || "(无文本回复)";
+                        persistChannelAssistantMessage(sessionId, final);
+                        donePromise = Promise.resolve(sink.onDone(final)).catch((e) => console.error("[ChannelCore] stream onDone error:", e));
+                    },
+                });
+                if (donePromise)
+                    await donePromise;
+                await msg.ack?.(undefined);
+            }
+            catch (err) {
+                console.error("[ChannelCore] runAgent failed:", err);
+                throttled.cancel();
+                const fallback = accumulated.trim() || "处理时出错，请稍后再试。";
+                await Promise.resolve(sink.onDone(fallback)).catch(() => { });
+                await msg.ack?.(undefined);
+            }
             return;
         }
-        let accumulated = "";
-        let donePromise = null;
-        const throttled = throttle(() => {
-            if (sink.onChunk)
-                void Promise.resolve(sink.onChunk(accumulated)).catch((e) => console.error("[ChannelCore] stream onChunk error:", e));
-        }, STREAM_THROTTLE_MS);
+        let replyText;
         try {
-            await runAgentAndStreamReply({ sessionId, message: msg.messageText, agentId: currentAgentId }, {
-                onChunk(delta) {
-                    accumulated += delta;
-                    throttled.run();
-                },
-                onTurnEnd() {
-                    throttled.flush();
-                    if (sink.onTurnEnd)
-                        void Promise.resolve(sink.onTurnEnd(accumulated)).catch((e) => console.error("[ChannelCore] stream onTurnEnd error:", e));
-                },
-                onDone() {
-                    throttled.cancel();
-                    const final = accumulated.trim() || "(无文本回复)";
-                    persistChannelAssistantMessage(sessionId, final);
-                    donePromise = Promise.resolve(sink.onDone(final)).catch((e) => console.error("[ChannelCore] stream onDone error:", e));
-                },
+            replyText = await runAgentAndCollectReply({
+                sessionId,
+                message: messageText,
+                agentId: effectiveAgentId,
             });
-            if (donePromise)
-                await donePromise;
-            await msg.ack?.(undefined);
         }
         catch (err) {
             console.error("[ChannelCore] runAgent failed:", err);
-            throttled.cancel();
-            const fallback = accumulated.trim() || "处理时出错，请稍后再试。";
-            await Promise.resolve(sink.onDone(fallback)).catch(() => { });
-            await msg.ack?.(undefined);
+            replyText = "处理时出错，请稍后再试。";
         }
-        return;
-    }
-    let replyText;
-    try {
-        replyText = await runAgentAndCollectReply({
-            sessionId,
-            message: msg.messageText,
-            agentId: currentAgentId,
-        });
+        persistChannelAssistantMessage(sessionId, replyText);
+        const reply = { text: replyText };
+        const sendResult = await outbound.send(threadId, reply);
+        await msg.ack?.(sendResult);
     }
-    catch (err) {
-        console.error("[ChannelCore] runAgent failed:", err);
-        replyText = "处理时出错，请稍后再试。";
+    finally {
+        unregisterConsumer();
     }
-    persistChannelAssistantMessage(sessionId, replyText);
-    const reply = { text: replyText };
-    const sendResult = await outbound.send(threadId, reply);
-    await msg.ack?.(sendResult);
 }

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

@@ -1,5 +1,6 @@
 import { agentManager } from "../../core/agent/agent-manager.js";
 import { abortProxyRun } from "../proxy-run-abort.js";
+import { clearSessionStreamSubscription } from "./agent-chat.js";
 const COMPOSITE_KEY_SEP = "::";
 /**
  * Handle agent.cancel: abort the current turn for the given session.
@@ -13,8 +14,10 @@ export async function handleAgentCancel(client, params) {
     }
     const agentId = params?.agentId ?? client.agentId ?? "default";
     if (abortProxyRun(sessionId, agentId)) {
+        clearSessionStreamSubscription(sessionId);
         return { status: "aborted" };
     }
+    clearSessionStreamSubscription(sessionId);
     const compositeKey = sessionId + COMPOSITE_KEY_SEP + agentId;
     let session = agentManager.getSession(compositeKey);
     if (!session) {

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

@@ -1,4 +1,8 @@
 import type { GatewayClient, AgentChatParams } from "../types.js";
+/**
+ * 移除某 session 的流式订阅（cancel 或新消息开始时调用，避免同一事件被多个回调处理导致界面重复）
+ */
+export declare function clearSessionStreamSubscription(sessionId: string): void;
 /**
  * Handle agent chat request with streaming support
  */