@saber2pr/ai-agent 0.0.40 → 0.0.42

package/lib/cli-graph.js

@@ -5,5 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const agent_graph_1 = __importDefault(require("./core/agent-graph"));
-const agent = new agent_graph_1.default();
+const agent = new agent_graph_1.default({
+    stream: true,
+});
 agent.start();

package/lib/core/agent-graph.d.ts

@@ -1,7 +1,6 @@
-import { BaseMessage } from '@langchain/core/messages';
+import { AIMessage, BaseMessage } from '@langchain/core/messages';
 import { GraphAgentOptions } from '../types/type';
 import { AgentGraphModel } from '../model/AgentGraphModel';
-export declare const CONFIG_FILE: string;
 interface TokenUsage {
     total: number;
 }
@@ -28,7 +27,18 @@ export default class McpGraphAgent<T extends AgentGraphModel = any> {
     private maxTargetCount;
     private maxTokens;
     private mcpClients;
+    private streamEnabled;
+    private streamOutputCallback;
     constructor(options?: GraphAgentOptions<T>);
+    /**
+     * 设置外部流式输出回调（如 VS Code Webview）。
+     * 设置后，callModel 的流式输出将通过回调发送而非写入 stdout。
+     */
+    setStreamOutput(callback: (chunk: string, type: 'think' | 'text') => void): void;
+    /**
+     * 清除外部流式输出回调，恢复默认的 stdout 输出。
+     */
+    clearStreamOutput(): void;
     private printLoadedTools;
     private loadMcpConfigs;
     private initMcpTools;
@@ -41,10 +51,15 @@ export default class McpGraphAgent<T extends AgentGraphModel = any> {
     getModel(): Promise<T>;
     private askForConfig;
     chat(query?: string): Promise<void>;
+    /**
+     * 流式执行单次查询（编程式 API）。
+     * 无论 options.stream 是否开启，此方法始终以流式方式输出。
+     */
+    stream(query?: string): Promise<void>;
     start(): Promise<void>;
     private renderOutput;
     callModel(state: typeof AgentState.State): Promise<{
-        messages: import("@langchain/core/messages").AIMessageChunk[];
+        messages: AIMessage[];
         tokenUsage: {
             total: number;
         };

package/lib/core/agent-graph.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIG_FILE = void 0;
 const events_1 = require("events");
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
@@ -20,7 +19,7 @@ const builtin_1 = require("../tools/builtin");
 const convertToLangChainTool_1 = require("../utils/convertToLangChainTool");
 const jsonSchemaToZod_1 = require("../utils/jsonSchemaToZod");
 const formatSchema_1 = require("../utils/formatSchema");
-exports.CONFIG_FILE = path_1.default.join(os_1.default.homedir(), ".saber2pr-agent.json");
+const config_1 = require("../config/config");
 // ✅ 全局设置：修复 AbortSignal 监听器数量警告
 // LangChain 的 HTTP 客户端会创建多个 AbortSignal，需要增加默认限制
 events_1.EventEmitter.defaultMaxListeners = 100;
@@ -40,7 +39,7 @@ const AgentState = langgraph_1.Annotation.Root({
     }),
     mode: (0, langgraph_1.Annotation)({
         reducer: (x, y) => y !== null && y !== void 0 ? y : x,
-        default: () => "chat",
+        default: () => 'chat',
     }),
     // ✅ Token 累加器
     tokenUsage: (0, langgraph_1.Annotation)({
@@ -61,6 +60,7 @@ class McpGraphAgent {
         this.langchainTools = [];
         this.stopLoadingFunc = null;
         this.mcpClients = [];
+        this.streamOutputCallback = null;
         this.options = options;
         this.verbose = options.verbose || false;
         this.alwaysSystem = options.alwaysSystem || true;
@@ -69,6 +69,7 @@ class McpGraphAgent {
         this.apiConfig = options.apiConfig;
         this.maxTargetCount = options.maxTargetCount || 4;
         this.maxTokens = options.maxTokens || 8000;
+        this.streamEnabled = options.stream || false;
         process.setMaxListeners(100);
         // ✅ 修复 AbortSignal 监听器数量警告
         // LangChain 的 HTTP 客户端会创建多个 AbortSignal，需要增加默认限制
@@ -80,16 +81,29 @@ class McpGraphAgent {
             process.stdout.write('\u001B[?25h');
             process.exit(0);
         };
-        process.on("SIGINT", cleanup);
-        process.on("SIGTERM", cleanup);
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+    }
+    /**
+     * 设置外部流式输出回调（如 VS Code Webview）。
+     * 设置后，callModel 的流式输出将通过回调发送而非写入 stdout。
+     */
+    setStreamOutput(callback) {
+        this.streamOutputCallback = callback;
+    }
+    /**
+     * 清除外部流式输出回调，恢复默认的 stdout 输出。
+     */
+    clearStreamOutput() {
+        this.streamOutputCallback = null;
     }
     printLoadedTools() {
-        console.log("\n🛠️  [Graph] 正在加载工具节点...");
+        console.log('\n🛠️  [Graph] 正在加载工具节点...');
         this.langchainTools.forEach((tool) => {
             // 工具名称
             console.log(`\n🧰 工具名: ${tool.name}`);
             // 提取参数结构 (LangChain Tool 的 schema 是 Zod 对象)
-            const schema = tool.schema;
+            const { schema } = tool;
             if (schema && schema.shape) {
                 // 如果是 ZodObject，打印其内部 key
                 console.log(`   参数结构:\n${(0, formatSchema_1.formatSchema)(schema)}`);
@@ -108,12 +122,12 @@ class McpGraphAgent {
     loadMcpConfigs() {
         const combined = { mcpServers: {} };
         const paths = [
-            path_1.default.join(os_1.default.homedir(), ".cursor", "mcp.json"),
-            path_1.default.join(os_1.default.homedir(), ".vscode", "mcp.json"),
+            path_1.default.join(os_1.default.homedir(), '.cursor', 'mcp.json'),
+            path_1.default.join(os_1.default.homedir(), '.vscode', 'mcp.json'),
         ];
-        paths.forEach((p) => {
+        paths.forEach(p => {
             if (fs_1.default.existsSync(p)) {
-                const content = JSON.parse(fs_1.default.readFileSync(p, "utf-8"));
+                const content = JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
                 Object.assign(combined.mcpServers, content.mcpServers);
             }
         });
@@ -130,13 +144,13 @@ class McpGraphAgent {
                     args: config.args,
                     env: { ...process.env, ...(config.env || {}) },
                 });
-                const client = new index_js_1.Client({ name: "mcp-graph-client", version: "1.0.0" }, { capabilities: {} });
+                const client = new index_js_1.Client({ name: 'mcp-graph-client', version: '1.0.0' }, { capabilities: {} });
                 await client.connect(transport);
                 this.mcpClients.push(client);
                 const { tools } = await client.listTools();
-                tools.forEach((tool) => {
+                tools.forEach(tool => {
                     mcpToolInfos.push({
-                        type: "function",
+                        type: 'function',
                         function: {
                             name: tool.name,
                             description: tool.description,
@@ -163,12 +177,8 @@ class McpGraphAgent {
         const builtinToolInfos = (0, builtin_1.createDefaultBuiltinTools)({ options: this.options });
         const mcpToolInfos = await this.initMcpTools();
         // 合并内置、手动传入和 MCP 工具
-        const allToolInfos = [
-            ...builtinToolInfos,
-            ...(this.options.tools || []),
-            ...mcpToolInfos
-        ];
-        this.langchainTools = allToolInfos.map((t) => (0, convertToLangChainTool_1.convertToLangChainTool)(t));
+        const allToolInfos = [...builtinToolInfos, ...(this.options.tools || []), ...mcpToolInfos];
+        this.langchainTools = allToolInfos.map(t => (0, convertToLangChainTool_1.convertToLangChainTool)(t));
         this.toolNode = new prebuilt_1.ToolNode(this.langchainTools);
     }
     // ✅ 修改：初始化逻辑
@@ -228,6 +238,7 @@ class McpGraphAgent {
                 modelName: config.model,
                 temperature: 0,
                 maxTokens: this.maxTokens,
+                streaming: this.streamEnabled,
             });
         }
         this.model = modelInstance.bindTools(this.langchainTools);
@@ -237,40 +248,75 @@ class McpGraphAgent {
         if (this.apiConfig)
             return this.apiConfig;
         let config = {};
-        if (fs_1.default.existsSync(exports.CONFIG_FILE)) {
+        if (fs_1.default.existsSync(config_1.CONFIG_FILE)) {
             try {
-                config = JSON.parse(fs_1.default.readFileSync(exports.CONFIG_FILE, "utf-8"));
+                config = JSON.parse(fs_1.default.readFileSync(config_1.CONFIG_FILE, 'utf-8'));
             }
             catch (e) { }
         }
         if (!config.baseURL || !config.apiKey) {
             const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
-            const question = (q) => new Promise((res) => rl.question(q, res));
-            config.baseURL = config.baseURL || await question(`? API Base URL: `);
-            config.apiKey = config.apiKey || await question(`? API Key: `);
-            config.model = config.model || await question(`? Model Name: `) || "gpt-4o";
-            fs_1.default.writeFileSync(exports.CONFIG_FILE, JSON.stringify(config, null, 2));
+            const question = (q) => new Promise(res => rl.question(q, res));
+            config.baseURL = config.baseURL || (await question(`? API Base URL: `));
+            config.apiKey = config.apiKey || (await question(`? API Key: `));
+            config.model = config.model || (await question(`? Model Name: `)) || 'gpt-4o';
+            fs_1.default.writeFileSync(config_1.CONFIG_FILE, JSON.stringify(config, null, 2));
             rl.close();
         }
         return config;
     }
-    async chat(query = "开始代码审计") {
+    async chat(query = '开始代码审计') {
+        try {
+            await this.ensureInitialized();
+            await this.getModel();
+            const app = await this.createGraph();
+            const graphStream = await app.stream({
+                messages: [new messages_1.HumanMessage(query)],
+                mode: 'auto',
+                targetCount: this.maxTargetCount,
+            }, {
+                configurable: { thread_id: 'auto_worker' },
+                recursionLimit: this.recursionLimit,
+                debug: this.verbose,
+            });
+            for await (const output of graphStream)
+                this.renderOutput(output, this.streamEnabled);
+        }
+        catch (error) {
+            console.error('\n❌ Chat 过程中发生错误:', error);
+        }
+        finally {
+            await this.closeMcpClients();
+        }
+    }
+    /**
+     * 流式执行单次查询（编程式 API）。
+     * 无论 options.stream 是否开启，此方法始终以流式方式输出。
+     */
+    async stream(query = '开始代码审计') {
+        const prevStream = this.streamEnabled;
+        this.streamEnabled = true;
         try {
             await this.ensureInitialized();
             await this.getModel();
             const app = await this.createGraph();
-            const stream = await app.stream({
+            const graphStream = await app.stream({
                 messages: [new messages_1.HumanMessage(query)],
-                mode: "auto",
+                mode: 'auto',
                 targetCount: this.maxTargetCount,
-            }, { configurable: { thread_id: "auto_worker" }, recursionLimit: this.recursionLimit, debug: this.verbose, });
-            for await (const output of stream)
-                this.renderOutput(output);
+            }, {
+                configurable: { thread_id: 'stream_worker' },
+                recursionLimit: this.recursionLimit,
+                debug: this.verbose,
+            });
+            for await (const output of graphStream)
+                this.renderOutput(output, true);
         }
         catch (error) {
-            console.error("\n❌ Chat 过程中发生错误:", error);
+            console.error('\n❌ Stream 过程中发生错误:', error);
         }
         finally {
+            this.streamEnabled = prevStream;
             await this.closeMcpClients();
         }
     }
@@ -279,27 +325,31 @@ class McpGraphAgent {
         await this.getModel();
         const app = await this.createGraph();
         const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
-        rl.on("SIGINT", () => {
+        rl.on('SIGINT', () => {
             this.stopLoading();
             rl.close();
             process.stdout.write('\u001B[?25h');
             process.exit(0);
         });
         const ask = () => {
-            rl.question("> ", async (input) => {
-                if (input.toLowerCase() === "exit") {
+            rl.question('> ', async (input) => {
+                if (input.toLowerCase() === 'exit') {
                     rl.close();
                     return;
                 }
-                const stream = await app.stream({ messages: [new messages_1.HumanMessage(input)], mode: "chat" }, { configurable: { thread_id: "session" }, recursionLimit: this.recursionLimit, debug: this.verbose, });
-                for await (const output of stream)
-                    this.renderOutput(output);
+                const graphStream = await app.stream({ messages: [new messages_1.HumanMessage(input)], mode: 'chat' }, {
+                    configurable: { thread_id: 'session' },
+                    recursionLimit: this.recursionLimit,
+                    debug: this.verbose,
+                });
+                for await (const output of graphStream)
+                    this.renderOutput(output, this.streamEnabled);
                 ask();
             });
         };
         ask();
     }
-    renderOutput(output) {
+    renderOutput(output, isStreaming = false) {
         var _a, _b, _c;
         this.stopLoading(); // 停止加载动画
         const agentNode = output.agent;
@@ -321,13 +371,9 @@ class McpGraphAgent {
                 const toolCallId = msg.tool_call_id || msg.id;
                 if (toolCallId) {
                     const toolName = toolCallMap.get(toolCallId) || msg.name || 'unknown';
-                    const content = typeof msg.content === 'string'
-                        ? msg.content
-                        : JSON.stringify(msg.content);
+                    const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
                     // 如果内容太长，截断显示
-                    const displayContent = content.length > 500
-                        ? content.substring(0, 500) + '...'
-                        : content;
+                    const displayContent = content.length > 500 ? content.substring(0, 500) + '...' : content;
                     console.log(`✅ [工具结果] ${toolName}: ${displayContent}`);
                 }
             });
@@ -335,12 +381,13 @@ class McpGraphAgent {
         if (agentNode) {
             const msg = agentNode.messages[agentNode.messages.length - 1];
             // 1. 打印思考过程（如果有）
+            // 流式模式下思考内容可能已经随流输出，此处仅在非流式模式或有独立 reasoning 字段时打印
             const reasoning = (_b = msg.additional_kwargs) === null || _b === void 0 ? void 0 : _b.reasoning;
-            if (reasoning) {
+            if (reasoning && !isStreaming) {
                 console.log(`\n🧠 [思考]: ${reasoning}`);
             }
-            // 2. 打印 AI 回复内容
-            if (msg.content) {
+            // 2. 打印 AI 回复内容（流式模式下已在 callModel 中逐字输出，跳过）
+            if (msg.content && !isStreaming) {
                 console.log(`🤖 [AI]: ${msg.content}`);
             }
             // ✅ 3. 实时打印当次统计信息
@@ -353,20 +400,20 @@ class McpGraphAgent {
             }
             // 4. 打印工具调用情况
             if ((_c = msg.tool_calls) === null || _c === void 0 ? void 0 : _c.length) {
-                msg.tool_calls.forEach((call) => {
+                msg.tool_calls.forEach(call => {
                     console.log(`🛠️ [调用工具]: ${call.name} 📦 参数: ${JSON.stringify(call.args)}`);
                 });
             }
         }
     }
     async callModel(state) {
-        const auditedListStr = state.auditedFiles.length > 0
-            ? state.auditedFiles.map(f => `\n  - ${f}`).join("")
-            : "暂无";
+        const auditedListStr = state.auditedFiles.length > 0 ? state.auditedFiles.map(f => `\n  - ${f}`).join('') : '暂无';
         const recentToolCalls = this.getRecentToolCalls(state.messages);
         const recentToolCallsStr = recentToolCalls.length > 0
-            ? `\n\n⚠️ 最近调用的工具（避免重复调用相同工具和参数）：\n${recentToolCalls.map(tc => `  - ${tc.name}(${JSON.stringify(tc.args)})`).join("\n")}`
-            : "";
+            ? `\n\n⚠️ 最近调用的工具（避免重复调用相同工具和参数）：\n${recentToolCalls
+                .map(tc => `  - ${tc.name}(${JSON.stringify(tc.args)})`)
+                .join('\n')}`
+            : '';
         // 1. 构建当前的系统提示词模板
         const systemPromptTemplate = `你是一个代码专家。工作目录：${this.targetDir}。
 当前模式：{mode}
@@ -391,28 +438,142 @@ class McpGraphAgent {
         // ✅ 检查 options 中的 alwaysSystem 参数 (默认为 true 或根据你的需求设置)
         // 如果不希望每次都携带（即只在首轮携带），则过滤掉历史消息里的 SystemMessage
         if (this.options.alwaysSystem === false) {
-            inputMessages = state.messages.filter(msg => msg._getType() !== "system");
+            inputMessages = state.messages.filter(msg => msg._getType() !== 'system');
         }
         else {
             // 默认模式：保持干净，由 PromptTemplate 重新生成最新的 System 状态
-            inputMessages = state.messages.filter(msg => msg._getType() !== "system");
+            inputMessages = state.messages.filter(msg => msg._getType() !== 'system');
         }
         const prompt = prompts_1.ChatPromptTemplate.fromMessages([
-            ["system", systemPromptTemplate],
-            new prompts_1.MessagesPlaceholder("messages"),
+            ['system', systemPromptTemplate],
+            new prompts_1.MessagesPlaceholder('messages'),
         ]);
-        this.startLoading("AI 正在分析并思考中");
+        this.startLoading('AI 正在分析并思考中');
         try {
-            const chain = prompt.pipe(this.model);
-            const response = await chain.invoke({
-                messages: inputMessages, // ✅ 使用处理后的消息列表
+            const promptParams = {
+                messages: inputMessages,
                 mode: state.mode,
                 targetCount: state.targetCount,
                 doneCount: state.auditedFiles.length,
                 auditedList: auditedListStr,
                 recentToolCalls: recentToolCallsStr,
-                extraPrompt: this.options.extraSystemPrompt || "",
-            });
+                extraPrompt: this.options.extraSystemPrompt || '',
+            };
+            if (this.streamEnabled) {
+                // ✅ 流式模式：通过 AgentGraphModel.streamGenerate 进行流式输出
+                const formattedMessages = await prompt.formatMessages(promptParams);
+                this.stopLoading();
+                // --- 流式 <think> 标签实时过滤 + 流式打印思考内容 ---
+                const THINK_OPEN = '<think>';
+                const THINK_CLOSE = '</think>';
+                let inThink = false;
+                let textBuffer = '';
+                let aiHeaderPrinted = false;
+                let thinkHeaderPrinted = false;
+                const hasExternalHandler = !!this.streamOutputCallback;
+                const flushText = (text) => {
+                    if (!text)
+                        return;
+                    if (hasExternalHandler) {
+                        this.streamOutputCallback(text, 'text');
+                    }
+                    else {
+                        if (!aiHeaderPrinted) {
+                            process.stdout.write('🤖 [AI]: ');
+                            aiHeaderPrinted = true;
+                        }
+                        process.stdout.write(text);
+                    }
+                };
+                const flushThink = (text) => {
+                    if (!text)
+                        return;
+                    if (hasExternalHandler) {
+                        this.streamOutputCallback(text, 'think');
+                    }
+                    else {
+                        if (!thinkHeaderPrinted) {
+                            process.stdout.write('\x1b[2m🧠 [思考]: ');
+                            thinkHeaderPrinted = true;
+                        }
+                        process.stdout.write(text);
+                    }
+                };
+                const onChunk = (chunk) => {
+                    textBuffer += chunk;
+                    let processing = true;
+                    while (processing) {
+                        if (inThink) {
+                            // 在 <think> 块内，寻找 </think>
+                            const closeIdx = textBuffer.indexOf(THINK_CLOSE);
+                            if (closeIdx !== -1) {
+                                // 流式打印 </think> 之前的思考内容
+                                flushThink(textBuffer.slice(0, closeIdx));
+                                textBuffer = textBuffer.slice(closeIdx + THINK_CLOSE.length);
+                                inThink = false;
+                                // 思考块结束：stdout 模式下换行 + 重置样式
+                                if (!hasExternalHandler && thinkHeaderPrinted) {
+                                    process.stdout.write('\x1b[0m\n');
+                                    thinkHeaderPrinted = false;
+                                }
+                            }
+                            else {
+                                // 未找到闭合标签，安全输出可确认部分（防止 </think> 跨 chunk 截断）
+                                const safeLen = Math.max(0, textBuffer.length - (THINK_CLOSE.length - 1));
+                                flushThink(textBuffer.slice(0, safeLen));
+                                textBuffer = textBuffer.slice(safeLen);
+                                processing = false;
+                            }
+                        }
+                        else {
+                            // 不在 <think> 块内，寻找 <think>
+                            const openIdx = textBuffer.indexOf(THINK_OPEN);
+                            if (openIdx !== -1) {
+                                flushText(textBuffer.slice(0, openIdx));
+                                textBuffer = textBuffer.slice(openIdx + THINK_OPEN.length);
+                                inThink = true;
+                            }
+                            else {
+                                // 未找到开启标签，安全输出可确认部分（防止 <think> 跨 chunk 截断）
+                                const safeLen = Math.max(0, textBuffer.length - (THINK_OPEN.length - 1));
+                                flushText(textBuffer.slice(0, safeLen));
+                                textBuffer = textBuffer.slice(safeLen);
+                                processing = false;
+                            }
+                        }
+                    }
+                };
+                const result = await this.model.streamGenerate(formattedMessages, onChunk);
+                // 刷新残留缓冲
+                if (textBuffer) {
+                    if (inThink) {
+                        flushThink(textBuffer);
+                    }
+                    else {
+                        flushText(textBuffer);
+                    }
+                }
+                // 收尾：stdout 模式下关闭样式和换行
+                if (!hasExternalHandler) {
+                    if (thinkHeaderPrinted) {
+                        process.stdout.write('\x1b[0m\n');
+                    }
+                    if (aiHeaderPrinted)
+                        process.stdout.write('\n');
+                }
+                const aiMsg = result.generations[0].message;
+                const meta = aiMsg.response_metadata || {};
+                const currentToken = Number(meta.token) || 0;
+                const currentDuration = Number(meta.duration) || 0;
+                return {
+                    messages: [aiMsg],
+                    tokenUsage: { total: currentToken },
+                    totalDuration: currentDuration,
+                };
+            }
+            // 非流式模式（原有逻辑）
+            const chain = prompt.pipe(this.model);
+            const response = await chain.invoke(promptParams);
             this.stopLoading();
             const meta = response.response_metadata || {};
             const currentToken = Number(meta.token) || 0;
@@ -420,7 +581,7 @@ class McpGraphAgent {
             return {
                 messages: [response],
                 tokenUsage: { total: currentToken },
-                totalDuration: currentDuration
+                totalDuration: currentDuration,
             };
         }
         catch (error) {
@@ -464,51 +625,51 @@ class McpGraphAgent {
         const totalTokens = ((_a = state.tokenUsage) === null || _a === void 0 ? void 0 : _a.total) || 0;
         const totalMs = state.totalDuration || 0;
         if (totalTokens > 0 || totalMs > 0) {
-            console.log("\n" + "═".repeat(50));
+            console.log('\n' + '═'.repeat(50));
             console.log(`🏁 \x1b[32;1m[审计任务全量结算]\x1b[0m`);
             console.log(`   - 累计消耗总额: \x1b[33m${totalTokens}\x1b[0m Tokens`);
             console.log(`   - 累计执行耗时: \x1b[36m${(totalMs / 1000).toFixed(2)}\x1b[0m s`);
             console.log(`   - 审计文件总数: ${state.auditedFiles.length} 个`);
-            console.log("═".repeat(50) + "\n");
+            console.log('═'.repeat(50) + '\n');
         }
     }
     async createGraph() {
         const workflow = new langgraph_1.StateGraph(AgentState)
-            .addNode("agent", (state) => this.callModel(state))
-            .addNode("tools", this.toolNode)
-            .addNode("progress", (state) => this.trackProgress(state))
-            .addEdge(langgraph_1.START, "agent")
-            .addConditionalEdges("agent", (state) => {
-            const messages = state.messages;
+            .addNode('agent', state => this.callModel(state))
+            .addNode('tools', this.toolNode)
+            .addNode('progress', state => this.trackProgress(state))
+            .addEdge(langgraph_1.START, 'agent')
+            .addConditionalEdges('agent', state => {
+            const { messages } = state;
             const lastMsg = messages[messages.length - 1];
-            const content = lastMsg.content || "";
+            const content = lastMsg.content || '';
             // 🛑 新增：全局 Token 熔断保护
             // 如果已消耗 Token 超过了 options 中设置的 maxTokens (假设是总限额)
             if (this.options.maxTokens && state.tokenUsage.total >= this.options.maxTokens) {
-                console.warn("⚠️ [警告] 已达到最大 Token 限制，强制结束任务。");
+                console.warn('⚠️ [警告] 已达到最大 Token 限制，强制结束任务。');
                 this.printFinalSummary(state);
                 return langgraph_1.END;
             }
             // 1. 如果 AI 想要调用工具，去 tools 节点
             if (lastMsg.tool_calls && lastMsg.tool_calls.length > 0) {
-                return "tools";
+                return 'tools';
             }
             // 2. 判定结束的条件：
             // - 模式是 auto 且审计完成
             // - 或者 AI 明确输出了结束语
             // - 或者 AI 输出了普通内容且没有工具调用（针对问答模式）
-            const isAutoFinished = state.mode === "auto" && state.auditedFiles.length > state.targetCount;
-            const isFinalAnswer = content.includes("Final Answer");
+            const isAutoFinished = state.mode === 'auto' && state.auditedFiles.length > state.targetCount;
+            const isFinalAnswer = content.includes('Final Answer');
             // ✅ 修复核心：如果 AI 只是在聊天（没有工具调用），直接结束，不要跳回 agent
-            if (isAutoFinished || isFinalAnswer || state.mode === "chat") {
+            if (isAutoFinished || isFinalAnswer || state.mode === 'chat') {
                 this.printFinalSummary(state);
                 return langgraph_1.END;
             }
             // 兜底：如果是在 auto 模式且还没干完活，才跳回 agent（通常不会走到这里）
             return langgraph_1.END;
         })
-            .addEdge("tools", "progress")
-            .addEdge("progress", "agent");
+            .addEdge('tools', 'progress')
+            .addEdge('progress', 'agent');
         return workflow.compile({ checkpointer: this.checkpointer });
     }
 }

package/lib/model/AgentGraphModel.d.ts

@@ -7,13 +7,29 @@ export interface AgentGraphLLMResponse {
     token?: number;
     duration?: number;
 }
+/** 流式输出的回调类型 */
+export type StreamChunkCallback = (chunk: string) => void;
 export declare abstract class AgentGraphModel extends BaseChatModel {
     protected boundTools?: any[];
     constructor(fields?: BaseChatModelParams);
     bindTools(tools: any[]): any;
     abstract callApi(prompt: string): Promise<AgentGraphLLMResponse>;
+    /**
+     * 流式调用 API，子类可覆盖以实现真正的 SSE 流式传输。
+     * 默认回退到 callApi 非流式调用。
+     * @param prompt 序列化后的提示词
+     * @param onChunk 每收到一段文本时的回调
+     * @returns 完整的响应结果
+     */
+    callApiStream(prompt: string, onChunk: StreamChunkCallback): Promise<AgentGraphLLMResponse>;
     _generate(messages: BaseMessage[]): Promise<ChatResult>;
     private parseToolCalls;
-    private serializeMessages;
+    /**
+     * 流式生成：调用 callApiStream 进行流式输出，完成后构建完整的 ChatResult。
+     * @param messages LangChain 消息列表
+     * @param onChunk 每收到一段文本时的回调
+     */
+    streamGenerate(messages: BaseMessage[], onChunk: StreamChunkCallback): Promise<ChatResult>;
+    serializeMessages(messages: BaseMessage[]): string;
     _llmType(): string;
 }

package/lib/model/AgentGraphModel.js

@@ -13,6 +13,18 @@ class AgentGraphModel extends chat_models_1.BaseChatModel {
         this.boundTools = tools.map(t => (0, function_calling_1.convertToOpenAITool)(t));
         return this;
     }
+    /**
+     * 流式调用 API，子类可覆盖以实现真正的 SSE 流式传输。
+     * 默认回退到 callApi 非流式调用。
+     * @param prompt 序列化后的提示词
+     * @param onChunk 每收到一段文本时的回调
+     * @returns 完整的响应结果
+     */
+    async callApiStream(prompt, onChunk) {
+        const result = await this.callApi(prompt);
+        onChunk(result.text);
+        return result;
+    }
     async _generate(messages) {
         const fullPrompt = this.serializeMessages(messages);
         const response = await this.callApi(fullPrompt);
@@ -92,6 +104,47 @@ class AgentGraphModel extends chat_models_1.BaseChatModel {
             },
         ];
     }
+    /**
+     * 流式生成：调用 callApiStream 进行流式输出，完成后构建完整的 ChatResult。
+     * @param messages LangChain 消息列表
+     * @param onChunk 每收到一段文本时的回调
+     */
+    async streamGenerate(messages, onChunk) {
+        const fullPrompt = this.serializeMessages(messages);
+        const response = await this.callApiStream(fullPrompt, onChunk);
+        let { text, reasoning } = response;
+        // 1. 处理思考内容
+        if (!reasoning && text.includes('<think>')) {
+            const match = text.match(/<think>([\s\S]*?)<\/think>/);
+            if (match) {
+                reasoning = match[1].trim();
+                text = text.replace(/<think>[\s\S]*?<\/think>/, '').trim();
+            }
+        }
+        // 2. 解析工具调用
+        const toolCalls = this.parseToolCalls(text);
+        return {
+            generations: [
+                {
+                    text,
+                    message: new messages_1.AIMessage({
+                        content: text,
+                        tool_calls: toolCalls,
+                        additional_kwargs: {
+                            reasoning: reasoning || '',
+                            token: response.token,
+                            duration: response.duration,
+                        },
+                        response_metadata: {
+                            reasoning: reasoning || '',
+                            token: response.token,
+                            duration: response.duration,
+                        },
+                    }),
+                },
+            ],
+        };
+    }
     serializeMessages(messages) {
         const systemMsg = messages.find(m => m._getType() === 'system');
         const lastMsg = messages[messages.length - 1];

package/lib/types/type.d.ts

@@ -39,4 +39,6 @@ export interface GraphAgentOptions<T extends AgentGraphModel = any> extends Agen
     alwaysSystem?: boolean;
     recursionLimit?: number;
     maxTargetCount?: number;
+    /** 是否启用流式输出，默认 false */
+    stream?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber2pr/ai-agent",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "AI Assistant CLI.",
   "author": "saber2pr",
   "license": "ISC",
@@ -30,7 +30,6 @@
     "@saber2pr/ts-context-mcp": "^0.0.9",
     "diff": "^8.0.3",
     "glob": "^10.5.0",
-    "js-tiktoken": "^1.0.21",
     "minimatch": "^10.0.1",
     "openai": "^6.16.0",
     "typescript": "^5.9.3",