@next-open-ai/openclawx 0.8.32 → 0.8.40

package/dist/core/tools/web-search/providers/brave.js

@@ -0,0 +1,87 @@
+const PROVIDER_ID = "brave";
+const BRAVE_WEB_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search";
+const cache = new Map();
+function cacheKey(query, count) {
+    return `${PROVIDER_ID}:${query}:${count}`;
+}
+export const braveProvider = {
+    id: PROVIDER_ID,
+    isAvailable(options) {
+        return !!(options.apiKey && String(options.apiKey).trim());
+    },
+    async search(params) {
+        const query = (params.query ?? "").trim();
+        const count = Math.min(10, Math.max(1, params.count ?? 5));
+        const apiKey = params.apiKey?.trim();
+        if (!apiKey) {
+            return {
+                query,
+                provider: PROVIDER_ID,
+                results: [],
+                count: 0,
+                tookMs: 0,
+                cached: false,
+            };
+        }
+        const cacheTtlMinutes = typeof params.cacheTtlMinutes === "number" && params.cacheTtlMinutes >= 0 ? params.cacheTtlMinutes : 0;
+        const key = cacheKey(query, count);
+        if (cacheTtlMinutes > 0) {
+            const hit = cache.get(key);
+            if (hit && hit.expiresAt > Date.now()) {
+                return { ...hit.result, cached: true };
+            }
+        }
+        const timeoutMs = (params.timeoutSeconds ?? 15) * 1000;
+        const controller = new AbortController();
+        const t = setTimeout(() => controller.abort(), timeoutMs);
+        const start = Date.now();
+        try {
+            const url = new URL(BRAVE_WEB_SEARCH_URL);
+            url.searchParams.set("q", query);
+            url.searchParams.set("count", String(count));
+            if (params.country?.trim())
+                url.searchParams.set("country", params.country.trim());
+            if (params.freshness?.trim())
+                url.searchParams.set("freshness", params.freshness.trim());
+            const res = await fetch(url.toString(), {
+                method: "GET",
+                headers: {
+                    Accept: "application/json",
+                    "X-Subscription-Token": apiKey,
+                },
+                signal: controller.signal,
+            });
+            const tookMs = Date.now() - start;
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`Brave Search API error ${res.status}: ${text || res.statusText}`);
+            }
+            const data = (await res.json());
+            const rawResults = data.web?.results ?? [];
+            const results = rawResults.slice(0, count).map((r) => ({
+                title: r.title ?? "",
+                url: r.url ?? "",
+                description: r.description,
+                published: r.age,
+            }));
+            const result = {
+                query,
+                provider: PROVIDER_ID,
+                results,
+                count: results.length,
+                tookMs,
+                cached: false,
+            };
+            if (cacheTtlMinutes > 0) {
+                cache.set(key, {
+                    result,
+                    expiresAt: Date.now() + cacheTtlMinutes * 60 * 1000,
+                });
+            }
+            return result;
+        }
+        finally {
+            clearTimeout(t);
+        }
+    },
+};

package/dist/core/tools/web-search/providers/duck-duck-scrape.d.ts

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

package/dist/core/tools/web-search/providers/duck-duck-scrape.js

@@ -0,0 +1,47 @@
+import { search as ddgSearch } from "duck-duck-scrape";
+const PROVIDER_ID = "duck-duck-scrape";
+const cache = new Map();
+function cacheKey(query, count) {
+    return `${PROVIDER_ID}:${query}:${count}`;
+}
+export const duckDuckScrapeProvider = {
+    id: PROVIDER_ID,
+    isAvailable() {
+        return true;
+    },
+    async search(params) {
+        const query = (params.query ?? "").trim();
+        const count = Math.min(10, Math.max(1, params.count ?? 5));
+        const cacheTtlMinutes = typeof params.cacheTtlMinutes === "number" && params.cacheTtlMinutes >= 0 ? params.cacheTtlMinutes : 0;
+        const key = cacheKey(query, count);
+        if (cacheTtlMinutes > 0) {
+            const hit = cache.get(key);
+            if (hit && hit.expiresAt > Date.now()) {
+                return { ...hit.result, cached: true };
+            }
+        }
+        const start = Date.now();
+        const res = await ddgSearch(query, {});
+        const tookMs = Date.now() - start;
+        const results = (res.results ?? []).slice(0, count).map((r) => ({
+            title: r.title ?? "",
+            url: r.url ?? "",
+            description: r.description,
+        }));
+        const result = {
+            query,
+            provider: PROVIDER_ID,
+            results,
+            count: results.length,
+            tookMs,
+            cached: false,
+        };
+        if (cacheTtlMinutes > 0) {
+            cache.set(key, {
+                result,
+                expiresAt: Date.now() + cacheTtlMinutes * 60 * 1000,
+            });
+        }
+        return result;
+    },
+};

package/dist/core/tools/web-search/providers/index.d.ts

@@ -0,0 +1,5 @@
+import type { WebSearchProviderId, IWebSearchProvider } from "../types.js";
+import { duckDuckScrapeProvider } from "./duck-duck-scrape.js";
+import { braveProvider } from "./brave.js";
+export declare function getWebSearchProvider(id: WebSearchProviderId): IWebSearchProvider;
+export { duckDuckScrapeProvider, braveProvider };

package/dist/core/tools/web-search/providers/index.js

@@ -0,0 +1,13 @@
+import { duckDuckScrapeProvider } from "./duck-duck-scrape.js";
+import { braveProvider } from "./brave.js";
+const providers = {
+    "duck-duck-scrape": duckDuckScrapeProvider,
+    brave: braveProvider,
+};
+export function getWebSearchProvider(id) {
+    const p = providers[id];
+    if (!p)
+        throw new Error(`Unknown web search provider: ${id}`);
+    return p;
+}
+export { duckDuckScrapeProvider, braveProvider };

package/dist/core/tools/web-search/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 在线搜索 Provider 统一类型，供 web_search 工具与多 Provider 实现使用。
+ */
+export type WebSearchProviderId = "duck-duck-scrape" | "brave";
+export interface WebSearchResultItem {
+    title: string;
+    url: string;
+    description?: string;
+    published?: string;
+    siteName?: string;
+}
+export interface WebSearchProviderResult {
+    query: string;
+    provider: WebSearchProviderId;
+    results: WebSearchResultItem[];
+    count: number;
+    tookMs?: number;
+    cached?: boolean;
+}
+export interface WebSearchSearchParams {
+    query: string;
+    count?: number;
+    apiKey?: string;
+    timeoutSeconds?: number;
+    cacheTtlMinutes?: number;
+    country?: string;
+    freshness?: string;
+}
+export interface IWebSearchProvider {
+    id: WebSearchProviderId;
+    isAvailable(options: {
+        apiKey?: string;
+    }): boolean;
+    search(params: WebSearchSearchParams): Promise<WebSearchProviderResult>;
+}

package/dist/core/tools/web-search/types.js

@@ -0,0 +1,4 @@
+/**
+ * 在线搜索 Provider 统一类型，供 web_search 工具与多 Provider 实现使用。
+ */
+export {};

package/dist/gateway/channel/channel-core.d.ts

@@ -1,5 +1,6 @@
 /**
  * 通道核心：收 UnifiedMessage → 会话映射 → 调 Agent → 选 Outbound → 发 UnifiedReply。
+ * 系统消息（// 命令结果、MCP 进度）经统一出口推送，通道注册消费者后按 outbound 发送。
  */
 import type { UnifiedMessage, IChannel } from "./types.js";
 /**

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

@@ -2,6 +2,10 @@ 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}`;
@@ -70,87 +74,104 @@ export async function handleChannelMessage(channel, msg) {
         currentAgentId,
     });
     getSessionCurrentAgentUpdater()?.(sessionId, effectiveAgentId);
-    if (directResponse != null && directResponse !== "") {
+    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;
+        }
+        // 与 Web/Desktop 统一：通道会话入库并追加用户消息（用预处理后的 agentId 与消息）
         await persistChannelUserMessage(sessionId, {
             agentId: effectiveAgentId,
-            title: rawMessage.slice(0, 50) || undefined,
-            messageText: rawMessage,
+            title: messageText.slice(0, 50) || undefined,
+            messageText,
         });
-        persistChannelAssistantMessage(sessionId, directResponse);
-        const reply = { text: directResponse };
-        await outbound.send(threadId, reply);
-        await msg.ack?.(reply);
-        return;
-    }
-    // 与 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);
+        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: 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));
-                },
+            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: messageText,
-            agentId: effectiveAgentId,
-        });
+        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
  */