mozi-bot 1.0.0

package/dist/agents/agent.js

@@ -0,0 +1,686 @@
+/**
+ * Agent - 消息处理核心 (增强版)
+ * 支持 OpenAI 原生 function calling 和 tool 消息格式
+ */
+import { getProvider, findProviderForModel } from "../providers/index.js";
+import { getChildLogger } from "../utils/logger.js";
+import { generateId } from "../utils/index.js";
+import { registerTools, getAllTools, filterToolsByPolicy, executeToolCalls, createBuiltinTools, } from "../tools/index.js";
+import { estimateMessagesTokens, summarizeInStages, limitHistoryTurns, pruneHistoryForContextShare, } from "./compaction.js";
+import { runWithModelFallback } from "./model-fallback.js";
+import { buildSystemPrompt } from "./system-prompt.js";
+import { createSessionStore } from "./session-store.js";
+const logger = getChildLogger("agent");
+// ============== Agent 类 ==============
+/** Agent 类 */
+export class Agent {
+    options;
+    tools = [];
+    openaiTools = [];
+    constructor(options) {
+        this.options = {
+            model: options.model,
+            provider: options.provider ?? "deepseek",
+            systemPrompt: options.systemPrompt ?? "",
+            temperature: options.temperature ?? 0.7,
+            maxTokens: options.maxTokens ?? 4096,
+            maxHistoryMessages: options.maxHistoryMessages ?? 50,
+            maxHistoryTurns: options.maxHistoryTurns ?? 20,
+            contextWindow: options.contextWindow ?? 32000,
+            enableTools: options.enableTools ?? true,
+            toolPolicy: options.toolPolicy ?? {},
+            enableCompaction: options.enableCompaction ?? true,
+            compactionThreshold: options.compactionThreshold ?? 64000,
+            fallbacks: options.fallbacks ?? [],
+            maxToolRounds: options.maxToolRounds ?? 10,
+            workingDirectory: options.workingDirectory ?? process.cwd(),
+            enableFunctionCalling: options.enableFunctionCalling ?? true,
+            sessionStore: options.sessionStore ?? createSessionStore(),
+        };
+        // 初始化工具
+        if (this.options.enableTools) {
+            this.initializeTools();
+        }
+    }
+    /** 初始化工具 */
+    initializeTools() {
+        const builtinTools = createBuiltinTools({
+            filesystem: { allowedPaths: [this.options.workingDirectory] },
+            bash: { allowedPaths: [this.options.workingDirectory] },
+            enableBrowser: true,
+        });
+        registerTools(builtinTools);
+        this.tools = filterToolsByPolicy(getAllTools(), this.options.toolPolicy);
+        // 转换为 OpenAI 格式
+        this.openaiTools = this.tools.map((tool) => ({
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            },
+        }));
+        logger.info({ toolCount: this.tools.length }, "Tools initialized");
+    }
+    /** 注册自定义工具 */
+    registerTool(tool) {
+        registerTools([tool]);
+        this.tools = filterToolsByPolicy(getAllTools(), this.options.toolPolicy);
+        this.openaiTools = this.tools.map((t) => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+    /** 处理消息 */
+    async processMessage(context) {
+        const sessionKey = this.getSessionKey(context);
+        logger.debug({ sessionKey, content: context.content.slice(0, 100) }, "Processing message");
+        // 获取会话历史
+        const history = this.getSessionHistory(sessionKey);
+        // 添加用户消息
+        history.messages.push({
+            role: "user",
+            content: context.content,
+        });
+        // 检查是否需要压缩
+        if (this.options.enableCompaction) {
+            await this.maybeCompactHistory(history);
+        }
+        // 构建请求消息
+        const messages = this.buildMessages(history);
+        // 执行对话 (可能包含多轮工具调用)
+        const response = await this.executeWithTools(messages, history);
+        // 添加助手回复到历史
+        history.messages.push({
+            role: "assistant",
+            content: response.content,
+        });
+        // 更新会话
+        history.lastUpdate = Date.now();
+        history.totalTokensUsed += response.usage?.totalTokens ?? 0;
+        this.trimHistory(history);
+        this.options.sessionStore.set(sessionKey, history);
+        logger.debug({ sessionKey, usage: response.usage }, "Message processed");
+        return response;
+    }
+    /** 执行对话 (包含原生 function calling) */
+    async executeWithTools(messages, history) {
+        let currentMessages = [...messages];
+        const allToolCalls = [];
+        let totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        let fallbackAttempts;
+        for (let round = 0; round < this.options.maxToolRounds; round++) {
+            // 调用模型
+            const result = await runWithModelFallback({
+                provider: this.options.provider,
+                model: this.options.model,
+                fallbacks: this.options.fallbacks,
+                run: async (provider, model) => {
+                    const p = getProvider(provider);
+                    if (!p)
+                        throw new Error(`Provider not found: ${provider}`);
+                    const request = {
+                        model,
+                        messages: currentMessages,
+                        temperature: this.options.temperature,
+                        maxTokens: this.options.maxTokens,
+                    };
+                    // 添加工具定义 (如果启用原生 function calling)
+                    if (this.options.enableFunctionCalling && this.openaiTools.length > 0) {
+                        request.tools = this.openaiTools;
+                        request.tool_choice = "auto";
+                    }
+                    return p.chat(request);
+                },
+                onError: (attempt) => {
+                    logger.warn({ ...attempt }, "Model call failed");
+                },
+            });
+            fallbackAttempts = result.attempts.length > 0 ? result.attempts : undefined;
+            // 累计 token 使用
+            if (result.result.usage) {
+                totalUsage.promptTokens += result.result.usage.promptTokens;
+                totalUsage.completionTokens += result.result.usage.completionTokens;
+                totalUsage.totalTokens += result.result.usage.totalTokens;
+            }
+            // 检查是否有工具调用
+            const toolCalls = result.result.toolCalls;
+            if (!toolCalls || toolCalls.length === 0) {
+                // 没有工具调用，返回结果
+                return {
+                    content: result.result.content,
+                    toolCalls: allToolCalls.length > 0 ? allToolCalls : undefined,
+                    usage: totalUsage,
+                    provider: result.provider,
+                    model: result.model,
+                    fallbackAttempts,
+                };
+            }
+            // 添加 assistant 消息 (包含 tool_calls)
+            const assistantMessage = {
+                role: "assistant",
+                content: result.result.content || null,
+                tool_calls: toolCalls,
+            };
+            currentMessages.push(assistantMessage);
+            history.messages.push(assistantMessage);
+            // 执行工具调用
+            logger.debug({ toolCount: toolCalls.length, round }, "Executing tool calls");
+            const toolCallInputs = toolCalls.map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                arguments: this.parseToolArguments(tc.function.arguments),
+            }));
+            const toolResults = await executeToolCalls(toolCallInputs);
+            allToolCalls.push(...toolResults);
+            // 添加 tool 消息 (每个工具调用一个)
+            for (const tr of toolResults) {
+                const toolMessage = {
+                    role: "tool",
+                    content: this.formatToolResult(tr),
+                    tool_call_id: tr.toolCallId,
+                    name: tr.name,
+                };
+                currentMessages.push(toolMessage);
+                history.messages.push(toolMessage);
+            }
+        }
+        throw new Error("Max tool rounds exceeded");
+    }
+    /** 解析工具参数 */
+    parseToolArguments(argsStr) {
+        // 处理空字符串或只有空白的情况 - 返回空对象
+        if (!argsStr || argsStr.trim() === "" || argsStr.trim() === "{}") {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(argsStr);
+            if (typeof parsed !== "object" || parsed === null) {
+                logger.warn({ argsStr }, "Tool arguments is not an object");
+                return {};
+            }
+            return parsed;
+        }
+        catch (error) {
+            // 尝试修复常见的 JSON 格式问题
+            logger.warn({ argsStr, error }, "Failed to parse tool arguments, attempting repair");
+            // 尝试修复常见问题：
+            // 1. 尾部多余逗号
+            // 2. 单引号替换为双引号
+            // 3. 未转义的换行符
+            // 4. 多个 JSON 对象拼接在一起 (claude-code-router bug workaround)
+            let repaired = argsStr
+                .replace(/,\s*}/g, "}")
+                .replace(/,\s*]/g, "]")
+                .replace(/'/g, '"')
+                .replace(/\n/g, "\\n")
+                .replace(/\r/g, "\\r")
+                .replace(/\t/g, "\\t");
+            try {
+                return JSON.parse(repaired);
+            }
+            catch {
+                // 检测是否是多个 JSON 对象拼接在一起（如 {...}{...}）
+                // 这是 claude-code-router 的一个 bug，它会把多个工具调用的参数发送到同一个 content block
+                const multiJsonMatch = repaired.match(/^(\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\})/);
+                if (multiJsonMatch && multiJsonMatch[1]) {
+                    const firstJson = multiJsonMatch[1];
+                    try {
+                        logger.warn({ original: argsStr, extracted: firstJson }, "Detected concatenated JSON objects (claude-code-router bug), using first object");
+                        return JSON.parse(firstJson);
+                    }
+                    catch {
+                        // 继续尝试其他方法
+                    }
+                }
+                // 尝试提取第一个完整的 JSON 对象（简单的括号匹配）
+                let depth = 0;
+                let firstJsonEnd = -1;
+                for (let i = 0; i < repaired.length; i++) {
+                    if (repaired[i] === "{")
+                        depth++;
+                    else if (repaired[i] === "}") {
+                        depth--;
+                        if (depth === 0) {
+                            firstJsonEnd = i;
+                            break;
+                        }
+                    }
+                }
+                if (firstJsonEnd > 0) {
+                    const firstJson = repaired.slice(0, firstJsonEnd + 1);
+                    try {
+                        const parsed = JSON.parse(firstJson);
+                        logger.warn({ original: argsStr, extracted: firstJson }, "Extracted first JSON object from concatenated string");
+                        return parsed;
+                    }
+                    catch {
+                        // 仍然失败
+                    }
+                }
+                logger.error({ argsStr, repaired }, "Failed to parse tool arguments after repair");
+                return {};
+            }
+        }
+    }
+    /** 格式化工具结果为字符串 */
+    formatToolResult(result) {
+        const content = result.result.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text)
+            .join("\n");
+        if (result.isError) {
+            return `Error: ${content}`;
+        }
+        return content;
+    }
+    /** 获取工具参数预览 (Claude Code 风格) */
+    getToolArgsPreview(args) {
+        if (!args || Object.keys(args).length === 0)
+            return "";
+        // 常见工具的主参数提取
+        const mainArg = args.path ?? args.directory ?? args.command ?? args.query ?? args.pattern ?? args.content;
+        if (typeof mainArg === "string") {
+            const preview = mainArg.replace(/\n/g, " ").trim();
+            return preview.length > 40 ? preview.slice(0, 40) + "…" : preview;
+        }
+        // 其他情况显示简化的参数
+        const firstKey = Object.keys(args)[0];
+        if (firstKey) {
+            const firstVal = args[firstKey];
+            if (typeof firstVal === "string") {
+                const preview = firstVal.replace(/\n/g, " ").trim();
+                return preview.length > 30 ? preview.slice(0, 30) + "…" : preview;
+            }
+        }
+        return "";
+    }
+    /** 获取错误信息预览 */
+    getErrorPreview(result) {
+        const content = result.result.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text)
+            .join(" ");
+        // 提取第一行错误信息
+        const firstLine = content.split("\n")[0]?.trim() ?? "Unknown error";
+        return firstLine.length > 50 ? firstLine.slice(0, 50) + "…" : firstLine;
+    }
+    /** 流式处理消息 (支持原生 function calling) */
+    async *processMessageStream(context) {
+        const sessionKey = this.getSessionKey(context);
+        logger.debug({ sessionKey, content: context.content.slice(0, 100) }, "Processing message (stream)");
+        // 获取会话历史
+        const history = this.getSessionHistory(sessionKey);
+        // 添加用户消息
+        history.messages.push({
+            role: "user",
+            content: context.content,
+        });
+        // 检查是否需要压缩
+        if (this.options.enableCompaction) {
+            await this.maybeCompactHistory(history);
+        }
+        // 构建请求消息
+        let currentMessages = this.buildMessages(history);
+        // 获取提供商 (先按 provider ID 查找，再按 model ID 查找)
+        const provider = (this.options.provider
+            ? getProvider(this.options.provider)
+            : undefined) ?? findProviderForModel(this.options.model);
+        if (!provider) {
+            throw new Error(`No provider found for model: ${this.options.model}`);
+        }
+        let fullContent = "";
+        let totalTokens = 0;
+        const allToolCalls = [];
+        // 工具调用循环
+        for (let round = 0; round < this.options.maxToolRounds; round++) {
+            let roundContent = "";
+            const pendingToolCalls = new Map();
+            // 构建请求
+            const request = {
+                model: this.options.model,
+                messages: currentMessages,
+                temperature: this.options.temperature,
+                maxTokens: this.options.maxTokens,
+            };
+            if (this.options.enableFunctionCalling && this.openaiTools.length > 0) {
+                request.tools = this.openaiTools;
+                request.tool_choice = "auto";
+            }
+            // 流式调用
+            for await (const chunk of provider.chatStream(request)) {
+                // 处理文本内容
+                if (chunk.delta) {
+                    roundContent += chunk.delta;
+                    yield chunk.delta;
+                }
+                // 处理工具调用增量
+                if (chunk.toolCallDeltas) {
+                    for (const delta of chunk.toolCallDeltas) {
+                        // 使用 id 作为 key (优先)，fallback 到 index
+                        const key = delta.id ?? `idx_${delta.index}`;
+                        let tc = pendingToolCalls.get(key);
+                        if (!tc) {
+                            tc = {
+                                id: delta.id ?? generateId("tc"),
+                                type: "function",
+                                function: { name: "", arguments: "" },
+                            };
+                            pendingToolCalls.set(key, tc);
+                        }
+                        if (delta.id && tc.id !== delta.id)
+                            tc.id = delta.id;
+                        // 只在名称为空时设置，避免重复累加
+                        if (delta.function?.name && !tc.function.name)
+                            tc.function.name = delta.function.name;
+                        if (delta.function?.arguments)
+                            tc.function.arguments += delta.function.arguments;
+                    }
+                }
+            }
+            fullContent += roundContent;
+            // 检查是否有完整的工具调用
+            const completedToolCalls = Array.from(pendingToolCalls.values()).filter((tc) => tc.function.name // 只要有函数名就认为有效，arguments 可以为空
+            );
+            // 调试日志
+            if (pendingToolCalls.size > 0) {
+                logger.debug({
+                    pendingCount: pendingToolCalls.size,
+                    completedCount: completedToolCalls.length,
+                    toolCalls: completedToolCalls.map((tc) => ({
+                        name: tc.function.name,
+                        argsLength: tc.function.arguments.length,
+                        argsPreview: tc.function.arguments.slice(0, 100),
+                    })),
+                }, "Tool calls accumulated");
+            }
+            if (completedToolCalls.length === 0) {
+                // 没有工具调用，结束循环
+                break;
+            }
+            // 添加 assistant 消息
+            const assistantMessage = {
+                role: "assistant",
+                content: roundContent || null,
+                tool_calls: completedToolCalls,
+            };
+            currentMessages.push(assistantMessage);
+            history.messages.push(assistantMessage);
+            // 执行工具调用
+            const toolCallInputs = completedToolCalls.map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                arguments: this.parseToolArguments(tc.function.arguments),
+            }));
+            const toolResults = await executeToolCalls(toolCallInputs);
+            allToolCalls.push(...toolResults);
+            // 添加 tool 消息并输出结果摘要 (Claude Code 风格)
+            for (const tr of toolResults) {
+                const toolMessage = {
+                    role: "tool",
+                    content: this.formatToolResult(tr),
+                    tool_call_id: tr.toolCallId,
+                    name: tr.name,
+                };
+                currentMessages.push(toolMessage);
+                history.messages.push(toolMessage);
+                // 简洁的工具输出格式
+                const argsPreview = this.getToolArgsPreview(toolCallInputs.find(t => t.id === tr.toolCallId)?.arguments);
+                if (tr.isError) {
+                    const errorMsg = this.getErrorPreview(tr);
+                    yield `\n⏺ ${tr.name}(${argsPreview}) ✗ ${errorMsg}`;
+                }
+                else {
+                    yield `\n⏺ ${tr.name}(${argsPreview}) ✓`;
+                }
+            }
+            yield `\n\n`;
+        }
+        // 估算 token
+        totalTokens = estimateMessagesTokens(currentMessages) + estimateMessagesTokens([
+            { role: "assistant", content: fullContent }
+        ]);
+        // 添加完整回复到历史
+        if (!history.messages.some(m => m.role === "assistant" && m.content === fullContent)) {
+            history.messages.push({
+                role: "assistant",
+                content: fullContent,
+            });
+        }
+        // 更新会话
+        history.lastUpdate = Date.now();
+        history.totalTokensUsed += totalTokens;
+        this.trimHistory(history);
+        this.options.sessionStore.set(sessionKey, history);
+        return {
+            content: fullContent,
+            toolCalls: allToolCalls.length > 0 ? allToolCalls : undefined,
+            usage: {
+                promptTokens: estimateMessagesTokens(currentMessages),
+                completionTokens: estimateMessagesTokens([{ role: "assistant", content: fullContent }]),
+                totalTokens,
+            },
+            provider: provider.id,
+            model: this.options.model,
+        };
+    }
+    /** 获取会话键 */
+    getSessionKey(context) {
+        if (context.chatType === "group") {
+            return `${context.channelId}:${context.chatId}`;
+        }
+        return `${context.channelId}:${context.senderId}`;
+    }
+    /** 获取会话历史 */
+    getSessionHistory(sessionKey) {
+        const cached = this.options.sessionStore.get(sessionKey);
+        if (cached) {
+            return cached;
+        }
+        return {
+            messages: [],
+            lastUpdate: Date.now(),
+            totalTokensUsed: 0,
+        };
+    }
+    /** 构建消息列表 */
+    buildMessages(history) {
+        const messages = [];
+        // 构建系统提示
+        const systemContent = buildSystemPrompt({
+            basePrompt: this.options.systemPrompt,
+            workingDirectory: this.options.workingDirectory,
+            includeEnvironment: true,
+            includeDateTime: true,
+            includeToolRules: !this.options.enableFunctionCalling, // 使用原生 FC 时不需要文本规则
+            tools: this.options.enableFunctionCalling ? undefined : this.tools,
+            additionalContext: history.summary,
+        });
+        messages.push({ role: "system", content: systemContent });
+        // 验证并清理历史消息，确保 tool_calls 和 tool 消息配对
+        const validatedMessages = this.validateToolCallPairs(history.messages);
+        // 添加历史消息
+        messages.push(...validatedMessages);
+        return messages;
+    }
+    /** 验证 tool_calls 和 tool 消息配对，清理不完整的工具调用 */
+    validateToolCallPairs(messages) {
+        // 第一遍：收集所有有效的 tool_call_id
+        const validToolCallIds = new Set();
+        for (const msg of messages) {
+            if (msg.role === "assistant" && msg.tool_calls) {
+                for (const tc of msg.tool_calls) {
+                    validToolCallIds.add(tc.id);
+                }
+            }
+        }
+        const result = [];
+        let i = 0;
+        while (i < messages.length) {
+            const msg = messages[i];
+            // 如果是 tool 消息，检查是否有对应的 tool_call
+            if (msg.role === "tool") {
+                if (msg.tool_call_id && validToolCallIds.has(msg.tool_call_id)) {
+                    result.push(msg);
+                }
+                else {
+                    // 孤立的 tool_result，跳过
+                    logger.warn({ orphanToolCallId: msg.tool_call_id, messageIndex: i }, "Skipping orphan tool_result message");
+                }
+                i++;
+                continue;
+            }
+            // 如果是包含 tool_calls 的 assistant 消息
+            if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+                const toolCallIds = new Set(msg.tool_calls.map(tc => tc.id));
+                const toolResults = [];
+                // 查找后续的 tool 消息
+                let j = i + 1;
+                while (j < messages.length && messages[j]?.role === "tool") {
+                    const toolMsg = messages[j];
+                    if (toolMsg.tool_call_id && toolCallIds.has(toolMsg.tool_call_id)) {
+                        toolResults.push(toolMsg);
+                        toolCallIds.delete(toolMsg.tool_call_id);
+                    }
+                    j++;
+                }
+                // 检查是否所有 tool_calls 都有对应的 tool 结果
+                if (toolCallIds.size === 0) {
+                    // 完整配对，添加 assistant 和所有 tool 消息
+                    result.push(msg);
+                    result.push(...toolResults);
+                }
+                else {
+                    // 不完整的工具调用，跳过整个 assistant 消息和相关 tool 消息
+                    logger.warn({ missingToolResults: Array.from(toolCallIds), messageIndex: i }, "Skipping incomplete tool call sequence");
+                    // 如果 assistant 消息有文本内容，保留文本内容但移除 tool_calls
+                    if (msg.content) {
+                        result.push({
+                            role: "assistant",
+                            content: msg.content,
+                        });
+                    }
+                }
+                // 跳到 tool 消息之后
+                i = j;
+            }
+            else {
+                // 普通消息直接添加
+                result.push(msg);
+                i++;
+            }
+        }
+        return result;
+    }
+    /** 裁剪历史消息 */
+    trimHistory(history) {
+        // 按轮次限制
+        history.messages = limitHistoryTurns({
+            messages: history.messages,
+            maxTurns: this.options.maxHistoryTurns,
+            preserveSystemMessage: false, // 系统消息在 buildMessages 中单独处理
+        });
+        // 按消息数限制
+        if (history.messages.length > this.options.maxHistoryMessages) {
+            history.messages = history.messages.slice(-this.options.maxHistoryMessages);
+        }
+    }
+    /** 检查并执行上下文压缩 */
+    async maybeCompactHistory(history) {
+        const tokens = estimateMessagesTokens(history.messages);
+        if (tokens <= this.options.compactionThreshold) {
+            return;
+        }
+        logger.info({ tokens, threshold: this.options.compactionThreshold }, "Compacting history");
+        try {
+            // 分离要保留的最近消息和要压缩的旧消息
+            const keepRecent = Math.min(10, Math.floor(history.messages.length / 2));
+            const toCompact = history.messages.slice(0, -keepRecent);
+            const toKeep = history.messages.slice(-keepRecent);
+            if (toCompact.length === 0) {
+                return;
+            }
+            // 生成摘要
+            const summary = await summarizeInStages(toCompact, {
+                provider: this.options.provider,
+                model: this.options.model,
+                previousSummary: history.summary,
+                maxChunkTokens: 4000,
+                contextWindow: this.options.contextWindow,
+            });
+            // 更新历史
+            history.summary = summary;
+            history.messages = toKeep;
+            logger.info({ compacted: toCompact.length, kept: toKeep.length, summaryLength: summary.length }, "History compacted");
+        }
+        catch (error) {
+            logger.error({ error }, "Failed to compact history");
+            // 压缩失败，回退到简单裁剪
+            const pruned = pruneHistoryForContextShare({
+                messages: history.messages,
+                maxContextTokens: this.options.contextWindow,
+                maxHistoryShare: 0.5,
+            });
+            history.messages = pruned.messages;
+        }
+    }
+    /** 清除会话 */
+    clearSession(context) {
+        const sessionKey = this.getSessionKey(context);
+        this.options.sessionStore.delete(sessionKey);
+        logger.debug({ sessionKey }, "Session cleared");
+    }
+    /** 获取会话信息 */
+    getSessionInfo(context) {
+        const sessionKey = this.getSessionKey(context);
+        const history = this.options.sessionStore.get(sessionKey);
+        if (!history)
+            return null;
+        return {
+            messageCount: history.messages.length,
+            estimatedTokens: estimateMessagesTokens(history.messages),
+            hasSummary: !!history.summary,
+            lastUpdate: new Date(history.lastUpdate),
+        };
+    }
+    /** 恢复会话历史（从 transcript 消息重建 Agent 上下文） */
+    restoreSessionFromTranscript(sessionKey, messages) {
+        // 检查是否已有会话（如果服务没有重启，可能还在内存中）
+        const existing = this.options.sessionStore.get(sessionKey);
+        if (existing && existing.messages.length > 0) {
+            logger.debug({ sessionKey, messageCount: existing.messages.length }, "Session already exists, skipping restore");
+            return;
+        }
+        // 将 transcript 消息转换为 ChatMessage 格式
+        const chatMessages = messages.map((msg) => ({
+            role: msg.role,
+            content: msg.content,
+        }));
+        // 保存到 sessionStore
+        const sessionData = {
+            messages: chatMessages,
+            lastUpdate: Date.now(),
+            totalTokensUsed: 0,
+        };
+        this.options.sessionStore.set(sessionKey, sessionData);
+        logger.debug({ sessionKey, messageCount: chatMessages.length }, "Session restored from transcript");
+    }
+}
+/** 创建 Agent */
+export function createAgent(config) {
+    return new Agent({
+        model: config.agent.defaultModel,
+        provider: config.agent.defaultProvider,
+        systemPrompt: config.agent.systemPrompt ?? "",
+        temperature: config.agent.temperature,
+        maxTokens: config.agent.maxTokens,
+        workingDirectory: config.agent.workingDirectory ?? process.cwd(),
+        enableFunctionCalling: config.agent.enableFunctionCalling ?? true,
+        sessionStore: createSessionStore(config.sessions),
+    });
+}
+//# sourceMappingURL=agent.js.map