@next-open-ai/openclawx 0.8.36 → 0.8.48

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/methods/agent-chat.js

@@ -9,6 +9,23 @@ import { consumePendingAgentReload } from "../../core/config/agent-reload-pendin
 import { registerProxyRunAbort } from "../proxy-run-abort.js";
 import { getSessionOutlet, sendSessionMessage } from "../../core/session-outlet/index.js";
 const COMPOSITE_KEY_SEP = "::";
+/** 将 delta/text 规范为字符串，避免 SDK 或上游返回对象时前端显示 [object Object] 或触发 Unknown value type */
+function normalizeChunkText(v) {
+    if (v == null)
+        return "";
+    if (typeof v === "string")
+        return v;
+    if (typeof v.content === "string")
+        return v.content;
+    if (typeof v.text === "string")
+        return v.text;
+    try {
+        return String(JSON.stringify(v));
+    }
+    catch {
+        return String(v);
+    }
+}
 /** 当前每个 session 的流式订阅（用于在 cancel 或新 run 前移除旧订阅，避免重复广播） */
 const sessionSubscriptionBySessionId = new Map();
 /**
@@ -40,7 +57,7 @@ const SYSTEM_MSG_PREFIX = "[System Message] ";
 const SYSTEM_MSG_SUFFIX = "\n";
 /**
  * 创建 Web 端会话消息消费者：将统一出口的 SessionMessage 转为 Gateway 事件并 broadcast。
- * 系统消息以 agent.chunk 形式发送，正文带 [System Message] 前缀且结尾换行，与当轮回复分行。
+ * 系统消息以独立事件 system_message 下发，前端做中间展示、不进入 session 聊天记录；各通道通过统一出口收到原始 system 消息后自行处理。
  */
 function createWebSessionConsumer(_sessionId) {
     return {
@@ -48,9 +65,8 @@ function createWebSessionConsumer(_sessionId) {
             const sid = msg.sessionId;
             if (msg.type === "system" && msg.code === "command.result") {
                 const raw = msg.payload?.text ?? "";
-                const text = raw ? SYSTEM_MSG_PREFIX + raw + SYSTEM_MSG_SUFFIX : "";
-                if (text)
-                    broadcastToSession(sid, createEvent("agent.chunk", { text, sessionId: sid }));
+                if (raw)
+                    broadcastToSession(sid, createEvent("system_message", { text: raw, code: "command.result", sessionId: sid }));
                 broadcastToSession(sid, createEvent("turn_end", { sessionId: sid, content: "" }));
                 broadcastToSession(sid, createEvent("message_complete", { sessionId: sid, content: "" }));
                 broadcastToSession(sid, createEvent("agent_end", { sessionId: sid }));
@@ -59,10 +75,8 @@ function createWebSessionConsumer(_sessionId) {
             }
             if (msg.type === "system" && msg.code === "mcp.progress") {
                 const raw = msg.payload?.message ?? msg.payload?.phase ?? "";
-                if (raw) {
-                    const text = SYSTEM_MSG_PREFIX + raw + SYSTEM_MSG_SUFFIX;
-                    broadcastToSession(sid, createEvent("agent.chunk", { text, sessionId: sid }));
-                }
+                if (raw)
+                    broadcastToSession(sid, createEvent("system_message", { text: raw, code: "mcp.progress", sessionId: sid }));
                 return;
             }
             if (msg.type === "chat") {
@@ -145,7 +159,7 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                 apiKey = agentConfig.apiKey;
         }
         const runnerType = agentConfig?.runnerType ?? "local";
-        const isProxyAgent = runnerType === "coze" || runnerType === "openclawx" || runnerType === "opencode";
+        const isProxyAgent = runnerType === "coze" || runnerType === "openclawx" || runnerType === "opencode" || runnerType === "claude_code";
         if (isProxyAgent) {
             console.log(`[agent.chat] Using proxy agent (${runnerType}) for session=${targetSessionId}, agentId=${currentAgentId}`);
         }
@@ -159,37 +173,40 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                 sendSessionMessage(targetSessionId, { type: "chat", code: "agent_end", payload: {} });
                 sendSessionMessage(targetSessionId, { type: "chat", code: "conversation_end", payload: {} });
             };
-            try {
-                await runForChannelStream({
-                    sessionId: targetSessionId,
-                    message,
-                    agentId: currentAgentId,
-                    signal,
-                }, {
-                    onChunk(delta) {
-                        sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: delta } });
-                    },
-                    onTurnEnd() {
-                        sendSessionMessage(targetSessionId, { type: "chat", code: "turn_end", payload: {} });
-                        sendSessionMessage(targetSessionId, { type: "chat", code: "message_complete", payload: {} });
-                    },
-                    onDone() {
-                        finishAndUnregister();
-                    },
-                });
-                return { status: "completed", sessionId: targetSessionId };
-            }
-            catch (error) {
+            runForChannelStream({
+                sessionId: targetSessionId,
+                message,
+                agentId: currentAgentId,
+                signal,
+            }, {
+                onChunk(delta) {
+                    sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: delta } });
+                },
+                onTurnEnd() {
+                    sendSessionMessage(targetSessionId, { type: "chat", code: "turn_end", payload: {} });
+                    sendSessionMessage(targetSessionId, { type: "chat", code: "message_complete", payload: {} });
+                },
+                onDone() {
+                    finishAndUnregister();
+                },
+            }).catch((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);
+                    let errMsg = error?.message || String(error);
+                    const needNormalize = typeof errMsg === "object" || (typeof errMsg === "string" && errMsg.includes("[object Object]"));
+                    if (needNormalize) {
+                        errMsg = normalizeChunkText(errMsg);
+                        if (typeof errMsg === "string" && errMsg.includes("Unknown value type") && errMsg.includes("[object Object]")) {
+                            errMsg = "模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
+                        }
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: `请求失败：${errMsg}` } });
                 }
-                return { status: "completed", sessionId: targetSessionId };
-            }
+            });
+            return { status: "streaming", sessionId: targetSessionId };
         }
         const isEphemeralSession = sessionType === "system" || sessionType === "scheduled";
         if (isEphemeralSession) {
@@ -211,8 +228,10 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                 maxSessions: maxAgentSessions,
                 targetAgentId: effectiveTargetAgentId,
                 mcpServers: agentConfig?.mcpServers,
+                mcpMaxResultTokens: agentConfig?.mcpMaxResultTokens,
                 systemPrompt: agentConfig?.systemPrompt,
                 useLongMemory: agentConfig?.useLongMemory,
+                webSearch: agentConfig?.webSearch,
             });
         }
         catch (err) {
@@ -248,10 +267,10 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                 const update = event;
                 if (update.assistantMessageEvent && update.assistantMessageEvent.type === "text_delta") {
                     hasReceivedAnyChunk = true;
-                    wsPayload = { type: "chat", code: "agent.chunk", payload: { text: update.assistantMessageEvent.delta } };
+                    wsPayload = { type: "chat", code: "agent.chunk", payload: { text: normalizeChunkText(update.assistantMessageEvent.delta) } };
                 }
                 else if (update.assistantMessageEvent && update.assistantMessageEvent.type === "thinking_delta") {
-                    wsPayload = { type: "chat", code: "agent.chunk", payload: { text: update.assistantMessageEvent.delta, isThinking: true } };
+                    wsPayload = { type: "chat", code: "agent.chunk", payload: { text: normalizeChunkText(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);
@@ -276,9 +295,16 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                     hasReceivedAnyChunk = true;
                 }
                 if (msg?.errorMessage) {
-                    const errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
+                    // 调试：定位本地 LLM 流式报错来源（pi-ai 等 SDK 抛出的原始 errorMessage）
+                    console.error("[agent.chat] message_end errorMessage:", msg.errorMessage);
+                    if (typeof msg.errorStack === "string")
+                        console.error("[agent.chat] message_end errorStack:", msg.errorStack);
+                    let errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
                         ? "API 余额不足，请到「设置」检查并充值后重试。"
-                        : `请求失败：${msg.errorMessage}`;
+                        : `请求失败：${normalizeChunkText(msg.errorMessage)}`;
+                    if (errText.includes("Unknown value type") && errText.includes("[object Object]")) {
+                        errText = "请求失败：模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: errText } });
                 }
                 wsPayload = null;
@@ -296,9 +322,16 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                     }
                 }
                 if (msg?.errorMessage) {
-                    const errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
+                    // 调试：定位 turn_end 时 SDK 传入的原始错误
+                    console.error("[agent.chat] turn_end errorMessage:", msg.errorMessage);
+                    if (typeof msg.errorStack === "string")
+                        console.error("[agent.chat] turn_end errorStack:", msg.errorStack);
+                    let errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
                         ? "API 余额不足，请到「设置」检查并充值后重试。"
-                        : `请求失败：${msg.errorMessage}`;
+                        : `请求失败：${normalizeChunkText(msg.errorMessage)}`;
+                    if (errText.includes("Unknown value type") && errText.includes("[object Object]")) {
+                        errText = "请求失败：模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: errText } });
                     hasReceivedAnyChunk = true;
                 }
@@ -340,9 +373,8 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
         sessionSubscriptionBySessionId.set(targetSessionId, unsubscribe);
         try {
             await session.sendUserMessage(message, { deliverAs: "followUp" });
-            await agentDonePromise;
-            console.log(`Agent chat completed for session ${targetSessionId}`);
-            return { status: "completed", sessionId: targetSessionId };
+            // 流已启动，立即返回；前端以 agent_end 判断整轮结束，超时以「首包」计算更优
+            return { status: "streaming", sessionId: targetSessionId };
         }
         catch (error) {
             console.error(`Error in agent chat:`, error);

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

@@ -61,8 +61,10 @@ export async function handleRunScheduledTask(req, res) {
             modelId,
             apiKey,
             mcpServers: agentConfig?.mcpServers,
+            mcpMaxResultTokens: agentConfig?.mcpMaxResultTokens,
             systemPrompt: agentConfig?.systemPrompt,
             useLongMemory: agentConfig?.useLongMemory,
+            webSearch: agentConfig?.webSearch,
         });
         let assistantContent = "";
         let turnPromptTokens = 0;

package/dist/gateway/server.js

@@ -44,7 +44,9 @@ import multer from "multer";
 import { handleInstallSkillFromPath } from "./methods/install-skill-from-path.js";
 import { handleInstallSkillFromUpload } from "./methods/install-skill-from-upload.js";
 import { setBackendBaseUrl } from "./backend-url.js";
-import { ensureDesktopConfigInitialized, getChannelsConfigSync } from "../core/config/desktop-config.js";
+import { ensureDesktopConfigInitialized, getChannelsConfigSync, loadDesktopAgentConfig } from "../core/config/desktop-config.js";
+import { startLocalLlmServer } from "../core/local-llm-server/index.js";
+import { isModelFileInCache } from "../core/local-llm-server/model-resolve.js";
 import { createNestAppEmbedded } from "../server/bootstrap.js";
 import { registerChannel, startAllChannels, stopAllChannels } from "./channel/registry.js";
 import { createFeishuChannel } from "./channel/adapters/feishu.js";
@@ -79,6 +81,57 @@ export async function startGatewayServer(port = 38080) {
     process.env.PORT = String(port);
     await ensureDesktopConfigInitialized();
     console.log(`Starting gateway server on port ${port}...`);
+    // 若默认智能体或环境变量指定为 local provider，后台启动本地 LLM 子进程（不阻塞主服务启动）
+    // 仅读 env 时，桌面端选「本机」默认 agent 时可能未设 OPENBOT_PROVIDER，导致本地服务未启、出现 Connection error
+    const envProvider = process.env.OPENBOT_PROVIDER ?? "";
+    let shouldStartLocal = envProvider === "local";
+    let defaultLocalModel;
+    let defaultAgentContextSize;
+    try {
+        const defaultAgent = await loadDesktopAgentConfig("default");
+        if (defaultAgent) {
+            defaultAgentContextSize = defaultAgent.contextSize;
+            if (!shouldStartLocal) {
+                shouldStartLocal =
+                    defaultAgent.provider === "local" &&
+                        defaultAgent.runnerType !== "coze" &&
+                        defaultAgent.runnerType !== "openclawx" &&
+                        defaultAgent.runnerType !== "opencode" &&
+                        defaultAgent.runnerType !== "claude_code";
+            }
+            if (shouldStartLocal && defaultAgent.provider === "local" && defaultAgent.model?.trim()) {
+                defaultLocalModel = defaultAgent.model.trim();
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    if (shouldStartLocal) {
+        // 若缺省模型已指定但文件不在缓存中，不启动本地服务，标记不可用，由用户在设置中下载后手动启动
+        const llmFileExists = !defaultLocalModel || isModelFileInCache(defaultLocalModel);
+        if (!llmFileExists) {
+            process.env.LOCAL_LLM_START_FAILED = `缺省模型文件不存在: ${defaultLocalModel}，请先在「模型管理」中下载或选择已安装模型后点击「启动本地模型服务」`;
+            console.warn("[local-llm] 未启动:", process.env.LOCAL_LLM_START_FAILED);
+        }
+        else {
+            const opts = {
+                ...(defaultLocalModel ? { llmModelPath: defaultLocalModel } : {}),
+                contextSize: defaultAgentContextSize ?? 32768,
+            };
+            startLocalLlmServer(opts)
+                .then((handle) => {
+                process.env.LOCAL_LLM_BASE_URL = handle.baseUrl;
+                delete process.env.LOCAL_LLM_START_FAILED;
+                console.log("[local-llm] 已就绪:", handle.baseUrl);
+            })
+                .catch((e) => {
+                const msg = e instanceof Error ? e.message : String(e);
+                process.env.LOCAL_LLM_START_FAILED = msg;
+                console.warn("[local-llm] 启动失败:", msg);
+            });
+        }
+    }
     setBackendBaseUrl(`http://localhost:${port}`);
     const { app: nestApp, express: nestExpress } = await createNestAppEmbedded();
     try {

package/dist/server/agent-config/agent-config.controller.d.ts

@@ -25,7 +25,7 @@ export declare class AgentConfigController {
         success: boolean;
         data: AgentConfigItem;
     }>;
-    updateAgent(id: string, body: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers' | 'systemPrompt' | 'icon' | 'runnerType' | 'coze' | 'openclawx' | 'opencode'>>): Promise<{
+    updateAgent(id: string, body: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers' | 'mcpMaxResultTokens' | 'systemPrompt' | 'icon' | 'runnerType' | 'coze' | 'openclawx' | 'opencode' | 'claudeCode' | 'useLongMemory' | 'webSearch' | 'contextSize'>>): Promise<{
         success: boolean;
         data: AgentConfigItem;
     }>;

package/dist/server/agent-config/agent-config.service.d.ts

@@ -3,8 +3,8 @@ import { DatabaseService } from '../database/database.service.js';
 import { WorkspaceService } from '../workspace/workspace.service.js';
 /** 缺省智能体 ID / 工作空间名，不可删除；对应目录 ~/.openbot/workspace/default */
 export declare const DEFAULT_AGENT_ID = "default";
-/** 执行器类型：local=本机，coze/openclawx/opencode=远程代理 */
-export type AgentRunnerType = 'local' | 'coze' | 'openclawx' | 'opencode';
+/** 执行器类型：local=本机，coze/openclawx/opencode=远程代理，claude_code=本机 Claude Code CLI */
+export type AgentRunnerType = 'local' | 'coze' | 'openclawx' | 'opencode' | 'claude_code';
 /** Coze 站点：cn=国内 api.coze.cn，com=国际 api.coze.com，凭证不通用 */
 export type CozeRegion = 'cn' | 'com';
 /** 某站点的 Bot 凭证 */
@@ -60,6 +60,8 @@ export interface AgentConfigItem {
     isDefault?: boolean;
     /** MCP 配置：数组（含 transport）或标准 JSON 对象（key 为服务器名称），创建 Session 时归一化使用 */
     mcpServers?: McpServerConfig[] | McpServersStandardFormat;
+    /** MCP 单次返回最大 token；不配置则不限制 */
+    mcpMaxResultTokens?: number;
     /** 自定义系统提示词，会与技能等一起组成最终 systemPrompt */
     systemPrompt?: string;
     /** 智能体图标标识（前端预设图标 id，如 default、star、code 等） */
@@ -72,8 +74,20 @@ export interface AgentConfigItem {
     openclawx?: AgentOpenClawXConfig;
     /** OpenCode 代理配置（runnerType 为 opencode 时使用） */
     opencode?: AgentOpenCodeConfig;
+    /** Claude Code 代理配置（runnerType 为 claude_code 时使用）：工作目录等 */
+    claudeCode?: {
+        workingDirectory?: string;
+    };
     /** 是否使用经验（长记忆）：memory_recall / save_experience；默认 true */
     useLongMemory?: boolean;
+    /** 在线搜索：启用后该智能体拥有 web_search 工具；可选默认 provider、maxResultTokens（前端默认 64K） */
+    webSearch?: {
+        enabled?: boolean;
+        provider?: 'brave' | 'duck-duck-scrape';
+        maxResultTokens?: number;
+    };
+    /** 本地模型上下文长度（token 数），仅 runnerType 为 local 时生效；默认 32768（32K） */
+    contextSize?: number;
 }
 export interface DeleteAgentOptions {
     /** 是否同时删除该工作区在磁盘上的目录及文件；默认 false（仅删数据库中的工作区相关数据，保留目录） */
@@ -104,7 +118,7 @@ export declare class AgentConfigService {
         /** 智能体图标标识 */
         icon?: string;
     }): Promise<AgentConfigItem>;
-    updateAgent(id: string, updates: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers' | 'systemPrompt' | 'icon' | 'runnerType' | 'coze' | 'openclawx' | 'opencode' | 'useLongMemory'>>): Promise<AgentConfigItem>;
+    updateAgent(id: string, updates: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers' | 'mcpMaxResultTokens' | 'systemPrompt' | 'icon' | 'runnerType' | 'coze' | 'openclawx' | 'opencode' | 'claudeCode' | 'useLongMemory' | 'webSearch'>>): Promise<AgentConfigItem>;
     deleteAgent(id: string, options?: DeleteAgentOptions): Promise<void>;
     /** 仅删除数据库中与该工作区相关的数据（会话、定时任务、收藏等），不删磁盘目录 */
     private deleteWorkspaceDataFromDb;

package/dist/server/agent-config/agent-config.service.js

@@ -162,6 +162,8 @@ let AgentConfigService = class AgentConfigService {
             agent.modelItemCode = updates.modelItemCode;
         if (updates.mcpServers !== undefined)
             agent.mcpServers = updates.mcpServers;
+        if (updates.mcpMaxResultTokens !== undefined)
+            agent.mcpMaxResultTokens = updates.mcpMaxResultTokens;
         if (updates.systemPrompt !== undefined)
             agent.systemPrompt = updates.systemPrompt?.trim() || undefined;
         if (updates.icon !== undefined)
@@ -211,8 +213,29 @@ let AgentConfigService = class AgentConfigService {
             agent.openclawx = updates.openclawx;
         if (updates.opencode !== undefined)
             agent.opencode = updates.opencode;
+        if (updates.claudeCode !== undefined)
+            agent.claudeCode = updates.claudeCode;
         if (updates.useLongMemory !== undefined)
             agent.useLongMemory = updates.useLongMemory;
+        if ('contextSize' in updates) {
+            const v = updates.contextSize;
+            agent.contextSize =
+                typeof v === 'number' && Number.isInteger(v) && v > 0 ? v : undefined;
+        }
+        if (updates.webSearch !== undefined) {
+            agent.webSearch =
+                updates.webSearch && (updates.webSearch.enabled || updates.webSearch.provider)
+                    ? {
+                        enabled: !!updates.webSearch.enabled,
+                        provider: updates.webSearch.provider === 'brave' || updates.webSearch.provider === 'duck-duck-scrape'
+                            ? updates.webSearch.provider
+                            : 'duck-duck-scrape',
+                        maxResultTokens: updates.webSearch.maxResultTokens != null && typeof updates.webSearch.maxResultTokens === 'number' && updates.webSearch.maxResultTokens > 0
+                            ? updates.webSearch.maxResultTokens
+                            : undefined,
+                    }
+                    : undefined;
+        }
         await this.writeAgentsFile(file);
         await addPendingAgentReload(id).catch(() => { });
         return { ...agent, isDefault: agent.id === DEFAULT_AGENT_ID };