listpage-next-ai 0.0.256 → 0.0.259

package/dist/cjs/index.d.ts

@@ -1,32 +1,115 @@
-import { AgentExecutorInput } from '@langchain/classic/agents';
-import { IterableReadableStream } from '@langchain/core/utils/stream';
-import { StreamEvent } from '@langchain/core/tracers/log_stream';
+import { AnyAnnotationRoot } from 'langchain';
+import { BaseMessage } from 'langchain';
+import { BaseMessageChunk } from 'langchain';
+import { ChatOpenAICallOptions } from '@langchain/openai';
+import { ChatOpenAICompletions } from '@langchain/openai';
+import { LanguageModelLike } from '@langchain/core/language_models/base';
+import { MessageStructure } from '@langchain/core/messages';
+import { MessageType } from '@langchain/core/messages';
+import { OpenAIClient } from '@langchain/openai';
+import { ReactAgent } from 'langchain';
+import { ResponseFormatUndefined } from 'langchain';
 
-export declare class Agent {
+export declare interface AgentOptions {
+    features: {
+        database?: boolean;
+        knowledge?: boolean;
+        word?: boolean;
+        websearch?: boolean;
+    };
+    databaseOptions?: DatabaseAgentOptions;
+    knowledgeOptions?: KnowledgeAgentOptions;
+    wordOptions?: WordToolOptions;
+    websearchOptions?: {};
+    model: LanguageModelLike;
     system_prompt: string;
+    tools?: any[];
+    middleware?: any[];
+    name?: string;
+    inject_current_time?: boolean;
+    max_iterations?: number;
+}
+
+export declare class ChatVolcengine extends ChatOpenAICompletions<ChatOpenAICallOptions> {
+    static lc_name(): string;
+    _llmType(): string;
+    constructor(fields?: Partial<ChatVolcengineInput>);
+    protected _convertCompletionsDeltaToBaseMessageChunk(delta: Record<string, any>, rawResponse: OpenAIClient.ChatCompletionChunk, defaultRole?: 'function' | 'user' | 'system' | 'developer' | 'assistant' | 'tool'): BaseMessageChunk<MessageStructure, MessageType>;
+    protected _convertCompletionsMessageToBaseMessage(message: OpenAIClient.ChatCompletionMessage, rawResponse: OpenAIClient.ChatCompletion): BaseMessage<MessageStructure, MessageType>;
+}
+
+declare type ChatVolcengineInput = {
+    apiKey: string;
     model: string;
-    model_config: Record<string, any>;
-    tools: AgentExecutorInput['tools'];
-    api_key: string;
-    constructor(options: AgentOptions);
-    stream(sessionId: string, input: string, chat_history: MessageData[]): Promise<IterableReadableStream<StreamEvent>>;
-    private createRunnable;
-    private createExecutor;
-    private createPrompt;
-    private createModel;
-}
-
-declare interface AgentOptions {
-    system_prompt: string;
-    tools: AgentExecutorInput['tools'];
-    model: string;
-    api_key: string;
-    model_config?: Record<string, any>;
+    temperature?: number;
+    streaming?: boolean;
+    configuration?: any;
+    timeout?: number;
+};
+
+declare interface Column {
+    name: string;
+    description: string;
+    type: string;
+    enums?: {
+        key: string;
+        value: string;
+    }[] | null;
+}
+
+export declare function createReactAgent(options: AgentOptions): ReactAgent<ResponseFormatUndefined, undefined, AnyAnnotationRoot, any[]>;
+
+declare interface DatabaseAgentOptions extends DatabaseToolOptions {
+}
+
+declare interface DatabaseToolOptions {
+    datasource: {
+        host: string;
+        port: number;
+        username: string;
+        password: string;
+        database: string;
+    };
+    datasets: {
+        name: string;
+        description: string;
+        columns: Column[];
+    }[];
+    onGenerateChart?: (options: {
+        sql: string;
+        title: string;
+        chartConfig: {
+            type: 'BAR_CHART' | 'LINE_CHART' | 'PIE_CHART';
+            dimension: string;
+            metric: {
+                name: string;
+                alias: string;
+                aggregate: string;
+            }[];
+        };
+    }) => Promise<string>;
+}
+
+declare interface KnowledgeAgentOptions extends KnowledgeToolOptions {
+}
+
+declare interface KnowledgeToolOptions {
+    knowledges: string[];
+    onRetrieveFragments: (index: string, query: string) => Promise<string>;
+    onRetrieveFullDocs: (index: string, title: string) => Promise<string>;
 }
 
-declare interface MessageData {
-    role: 'user' | 'assistant';
-    content: string;
+declare interface WordToolOptions {
+    glossry: {
+        name: string;
+        description: string;
+        words: {
+            name: string;
+            description: string;
+        }[];
+    }[];
+    min_score?: number;
+    top_n?: number;
 }
 
 export { }

package/dist/cjs/index.js

@@ -24,10 +24,417 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    Agent: ()=>Agent
+    createReactAgent: ()=>createReactAgent,
+    ChatVolcengine: ()=>ChatVolcengine,
+    AgentOptions: ()=>types_namespaceObject.AgentOptions
 });
-const agents_namespaceObject = require("@langchain/classic/agents");
-const prompts_namespaceObject = require("@langchain/core/prompts");
+var types_namespaceObject = {};
+__webpack_require__.r(types_namespaceObject);
+const external_langchain_namespaceObject = require("langchain");
+const promise_namespaceObject = require("mysql2/promise");
+const external_lodash_namespaceObject = require("lodash");
+function getTableSchema(table) {
+    return `## Table: ${table.name} (${table.description})
+${table.columns.map((c)=>`- ${c.name} (${c.type} : ${c.description})`).join('\n')}
+
+## Column Value Mappings:
+${table.columns.filter((c)=>!(0, external_lodash_namespaceObject.isEmpty)(c.enums)).map((c)=>`- Column: \`${c.name}\`
+${c.enums.map(({ key, value })=>`- ${key}: ${value}`).join('\n')}`).join('\n\n')}
+`;
+}
+function createDatabaseTools(options) {
+    const { datasource, datasets, onGenerateChart } = options;
+    return [
+        (0, external_langchain_namespaceObject.tool)(async ({ query })=>{
+            const tablesMd = datasets.map((t)=>`${t.name}: ${t.description}`).join('\n');
+            return `\n==========\n${tablesMd}\n==========\n`;
+        }, {
+            name: 'list_table',
+            description: '在需要访问的数据库信息的时候调用该工具，用于列出所有与 `query` 相关的数据表，如果列出全部数据表，返回的结果包含数据表的名称以及描述。',
+            schema: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: '根据 query 语义检索数据表'
+                    }
+                }
+            }
+        }),
+        (0, external_langchain_namespaceObject.tool)(async ({ name })=>{
+            const table = datasets.find((t)=>t.name === name);
+            if (!table) return `表名 ${name} 不存在`;
+            const data = {
+                name: table.name,
+                description: table.description,
+                columns: table.columns.map((c)=>({
+                        name: c.name,
+                        description: c.description,
+                        type: c.type,
+                        enums: c.enums
+                    }))
+            };
+            return getTableSchema(data);
+        }, {
+            name: 'describe_table',
+            description: '在需要生成SQL时使用该工具，用于获取数据表的详细字段信息，并且包含字段的枚举值。',
+            schema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: '表名, 必须是 list_table 中返回的表名'
+                    }
+                }
+            }
+        }),
+        (0, external_langchain_namespaceObject.tool)(async ({ sql })=>{
+            let connection;
+            try {
+                connection = await promise_namespaceObject.createConnection({
+                    host: datasource.host,
+                    port: datasource.port,
+                    user: datasource.username,
+                    password: datasource.password,
+                    database: datasource.database
+                });
+                console.log(sql);
+                await connection.connect();
+                const [rows] = await connection.query(sql);
+                return JSON.stringify(rows);
+            } catch (error) {
+                return error.message;
+            } finally{
+                await connection.end();
+            }
+        }, {
+            name: 'execute_sql',
+            description: '在需要执行SQL查询获取数据时调用该工具，用于执行 SQL 语句，仅支持查询语句，基于 MySQL 8.0的语法。',
+            schema: {
+                type: 'object',
+                properties: {
+                    sql: {
+                        type: 'string',
+                        description: 'SQL 语句'
+                    }
+                }
+            }
+        }),
+        onGenerateChart && (0, external_langchain_namespaceObject.tool)(async ({ sql, chartConfig, title })=>{
+            try {
+                const id = await onGenerateChart({
+                    sql,
+                    title,
+                    chartConfig
+                });
+                return `<chart-view id="${id}"></chart-view>`;
+            } catch (error) {
+                return `工具目前不可用：${error.message}`;
+            }
+        }, {
+            name: 'generate_chart',
+            description: '在需要可视化展示数据或者生成图表时调用该工具，用于生成图表，工具返回的结果可以直接被嵌入到 Markdown 中。',
+            schema: {
+                type: 'object',
+                properties: {
+                    title: {
+                        type: 'string',
+                        description: '图表标题'
+                    },
+                    sql: {
+                        type: 'string',
+                        description: 'SQL 查询语句'
+                    },
+                    chartConfig: {
+                        type: 'object',
+                        description: '图表的配置，可为空，如果为空表示只展示二维表的查询结果',
+                        properties: {
+                            type: {
+                                type: 'string',
+                                description: '图表的类型，可选值有：BAR_CHART、PIE_CHART、LINE_CHART'
+                            },
+                            metric: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        name: {
+                                            type: 'string',
+                                            description: '指标的名称，对应SQL执行出来的数据里面的字段名'
+                                        },
+                                        alias: {
+                                            type: 'string',
+                                            description: '指标的别名，例如“数量”、“金额”、“比例”等'
+                                        },
+                                        aggregate: {
+                                            type: 'string',
+                                            description: '指标的聚合函数，这里指的是对SQL执行的结果进行进一步聚合，如果不指定，则默认不聚合，可选值有 SUM、COUNT、AVG'
+                                        }
+                                    }
+                                }
+                            },
+                            dimension: {
+                                type: 'string',
+                                description: '图表的维度，例如时间、地点、指标等，最多只能有一个维度'
+                            }
+                        }
+                    }
+                }
+            }
+        })
+    ];
+}
+function createKnowledgeTools(options) {
+    const { knowledges, onRetrieveFullDocs, onRetrieveFragments } = options;
+    return [
+        (0, external_langchain_namespaceObject.tool)(async ({ index, query })=>{
+            if (!knowledges.includes(index)) return `错误，你没有权限访问【${index}】知识库`;
+            return await onRetrieveFragments(index, query);
+        }, {
+            name: 'retrieve_fragments',
+            description: '在需要查询专业词库获取专业且详细的信息的时候调用该工具，根据 query 进行检索，返回与之相关的分片内容',
+            schema: {
+                type: 'object',
+                properties: {
+                    index: {
+                        type: 'string',
+                        description: `知识库名称, 可以选择的库有\n ${knowledges.map((k)=>`- ${k}`).join('\n')}\n库名称必须为以上库中的一个`
+                    },
+                    query: {
+                        type: 'string',
+                        description: '根据 query 进行检索'
+                    }
+                }
+            }
+        }),
+        (0, external_langchain_namespaceObject.tool)(async ({ title, index })=>{
+            if (!knowledges.includes(index)) return `错误，你没有权限访问【${index}】知识库`;
+            return await onRetrieveFullDocs(index, title);
+        }, {
+            name: 'retrieve_full_docs',
+            description: '在需要从知识库中检索文档全文的时候调用该工具，根据 title 检索文档标题（全匹配）',
+            schema: {
+                type: 'object',
+                properties: {
+                    index: {
+                        type: 'string',
+                        description: `知识库名称, 可以选择的库有\n ${knowledges.map((k)=>`- ${k}`).join('\n')}\n库名称必须为以上库中的一个`
+                    },
+                    title: {
+                        type: 'string',
+                        description: '根据 title 进行检索'
+                    }
+                }
+            }
+        })
+    ];
+}
+function currentTimeMiddleware() {
+    return (0, external_langchain_namespaceObject.createMiddleware)({
+        name: 'currentTimeMiddleware',
+        wrapModelCall: (request, handler)=>{
+            const now = new Date();
+            const timeString = new Intl.DateTimeFormat('zh-CN', {
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit',
+                weekday: 'long',
+                timeZone: 'Asia/Shanghai',
+                hour12: false
+            }).format(now);
+            return handler({
+                ...request,
+                systemMessage: request.systemMessage.concat('\n\n当前时间: ' + timeString)
+            });
+        }
+    });
+}
+const langgraph_namespaceObject = require("@langchain/langgraph");
+const external_zod_namespaceObject = require("zod");
+const messages_namespaceObject = require("@langchain/core/messages");
+const maxIterationsMiddleware = ({ maxIterations })=>(0, external_langchain_namespaceObject.createMiddleware)({
+        name: 'max_iterations',
+        stateSchema: external_zod_namespaceObject.z.object({
+            iterations: external_zod_namespaceObject.z.number().default(0)
+        }),
+        beforeAgent: async (state)=>{
+            const currentIterations = state.iterations || 0;
+            const newIterations = currentIterations + 1;
+            if (newIterations > maxIterations) return {
+                iterations: newIterations,
+                messages: [
+                    new messages_namespaceObject.AIMessage({
+                        content: '由于达到了最大迭代次数限制，且无法直接生成回答，我必须停止当前的思考过程。'
+                    })
+                ],
+                jumpTo: langgraph_namespaceObject.END
+            };
+            if (newIterations === maxIterations) return {
+                iterations: newIterations,
+                messages: [
+                    new messages_namespaceObject.SystemMessage('system_directive: 你已经达到了最大迭代次数限制。请停止使用工具，并根据目前已有的信息，直接回答用户的问题。')
+                ]
+            };
+            return {
+                iterations: newIterations
+            };
+        }
+    });
+function createPatchToolCallsMiddleware() {
+    return (0, external_langchain_namespaceObject.createMiddleware)({
+        name: 'patchToolCallsMiddleware',
+        beforeAgent: async (state)=>{
+            const messages = state.messages;
+            if (!messages || 0 === messages.length) return;
+            const patchedMessages = [];
+            for(let i = 0; i < messages.length; i++){
+                const msg = messages[i];
+                patchedMessages.push(msg);
+                if (external_langchain_namespaceObject.AIMessage.isInstance(msg) && null != msg.tool_calls) for (const toolCall of msg.tool_calls){
+                    const correspondingToolMsg = messages.slice(i).find((m)=>external_langchain_namespaceObject.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id);
+                    if (!correspondingToolMsg) {
+                        const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
+                        patchedMessages.push(new external_langchain_namespaceObject.ToolMessage({
+                            content: toolMsg,
+                            name: toolCall.name,
+                            tool_call_id: toolCall.id
+                        }));
+                    }
+                }
+            }
+            return {
+                messages: [
+                    new messages_namespaceObject.RemoveMessage({
+                        id: langgraph_namespaceObject.REMOVE_ALL_MESSAGES
+                    }),
+                    ...patchedMessages
+                ]
+            };
+        }
+    });
+}
+const jieba_namespaceObject = require("@node-rs/jieba");
+const dict_namespaceObject = require("@node-rs/jieba/dict");
+class BM25 {
+    constructor(documents, k1 = 1.5, b = 0.75){
+        this.documents = documents;
+        this.k1 = k1;
+        this.b = b;
+        this.docFreqs = new Map();
+        this.idf = new Map();
+        this.avgdl = 0;
+        this.initialize();
+    }
+    initialize() {
+        let totalLength = 0;
+        this.documents.forEach((doc)=>{
+            totalLength += doc.length;
+            const uniqueTerms = new Set(doc);
+            uniqueTerms.forEach((term)=>{
+                this.docFreqs.set(term, (this.docFreqs.get(term) || 0) + 1);
+            });
+        });
+        this.avgdl = totalLength / this.documents.length || 1;
+        const N = this.documents.length;
+        this.docFreqs.forEach((count, term)=>{
+            const idf = Math.log((N - count + 0.5) / (count + 0.5) + 1);
+            this.idf.set(term, Math.max(idf, 0));
+        });
+    }
+    getScore(query, index) {
+        let score = 0;
+        const doc = this.documents[index];
+        const docLen = doc.length;
+        query.forEach((term)=>{
+            if (!this.idf.has(term)) return;
+            const tf = doc.filter((t)=>t === term).length;
+            const idf = this.idf.get(term);
+            const numerator = tf * (this.k1 + 1);
+            const denominator = tf + this.k1 * (1 - this.b + this.b * (docLen / this.avgdl));
+            score += numerator / denominator * idf;
+        });
+        return score;
+    }
+}
+const jieba = jieba_namespaceObject.Jieba.withDict(dict_namespaceObject.dict);
+function createWordTools(options) {
+    const { glossry, min_score = 0, top_n = 5 } = options;
+    const enableGlossry = (options.glossry ?? []).map((g)=>`- ${g.name}: ${g.description}`).join('\n');
+    return [
+        (0, external_langchain_namespaceObject.tool)(async (options)=>{
+            const { name, query } = options;
+            const { words } = glossry.find((g)=>g.name === name) ?? {};
+            if (!words) return `获取错误，你没有权限查看【${name}】词条库`;
+            const documents = words.map((f)=>{
+                const content = `${f.name} ${f.description}`;
+                return jieba.cut(content, false);
+            });
+            const bm25 = new BM25(documents);
+            const queryTokens = jieba.cut(query, false);
+            const scoredFiles = words.map((f, index)=>{
+                const score = bm25.getScore(queryTokens, index);
+                return {
+                    file: f,
+                    score
+                };
+            });
+            const result = scoredFiles.filter((item)=>item.score > min_score).sort((a, b)=>b.score - a.score).slice(0, top_n).map((item)=>`${item.file.name}: ${item.file.description}`).join('\n');
+            if (!result) return '没有找到该词条对应的数据';
+        }, {
+            name: 'query_professional_thesaurus',
+            description: '查询专业词库中特定术语的定义、用法及相关领域解释',
+            schema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: `词库名, 可以选择的库有\n ${enableGlossry}\n库名称必须为以上库中的一个`
+                    },
+                    query: {
+                        type: 'string',
+                        description: '根据 query 语义检索词条'
+                    }
+                }
+            }
+        })
+    ];
+}
+function createReactAgent(options) {
+    const { name, model, system_prompt, tools, middleware, features, databaseOptions, knowledgeOptions, wordOptions, inject_current_time, max_iterations = 0 } = options;
+    const agent = (0, external_langchain_namespaceObject.createAgent)({
+        name,
+        model,
+        systemPrompt: system_prompt,
+        tools: [
+            ...features.database ? createDatabaseTools(databaseOptions) : [],
+            ...features.knowledge ? createKnowledgeTools(knowledgeOptions) : [],
+            ...features.word ? createWordTools(wordOptions) : [],
+            ...tools
+        ],
+        middleware: [
+            inject_current_time && currentTimeMiddleware(),
+            max_iterations > 0 && maxIterationsMiddleware({
+                maxIterations: max_iterations
+            }),
+            (0, external_langchain_namespaceObject.todoListMiddleware)(),
+            (0, external_langchain_namespaceObject.summarizationMiddleware)({
+                model: model,
+                trigger: {
+                    tokens: 170000
+                },
+                keep: {
+                    messages: 6
+                }
+            }),
+            createPatchToolCallsMiddleware(),
+            ...middleware
+        ].filter(Boolean)
+    });
+    return agent;
+}
 const openai_namespaceObject = require("@langchain/openai");
 class ChatVolcengine extends openai_namespaceObject.ChatOpenAICompletions {
     static lc_name() {
@@ -42,7 +449,8 @@ class ChatVolcengine extends openai_namespaceObject.ChatOpenAICompletions {
             configuration: {
                 baseURL: 'https://ark.cn-beijing.volces.com/api/v3',
                 ...fields?.configuration
-            }
+            },
+            timeout: fields?.timeout
         });
     }
     _convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole) {
@@ -56,85 +464,13 @@ class ChatVolcengine extends openai_namespaceObject.ChatOpenAICompletions {
         return langChainMessage;
     }
 }
-const runnables_namespaceObject = require("@langchain/core/runnables");
-const chat_history_namespaceObject = require("@langchain/core/chat_history");
-class Agent {
-    constructor(options){
-        this.system_prompt = options.system_prompt;
-        this.model = options.model;
-        this.tools = options.tools;
-        this.api_key = options.api_key;
-        this.model_config = options.model_config || {};
-    }
-    async stream(sessionId, input, chat_history) {
-        const runnable = await this.createRunnable(chat_history);
-        return runnable.streamEvents({
-            input
-        }, {
-            version: 'v2',
-            configurable: {
-                sessionId
-            }
-        });
-    }
-    async createRunnable(messages) {
-        const executor = this.createExecutor();
-        const runnable = new runnables_namespaceObject.RunnableWithMessageHistory({
-            getMessageHistory: async ()=>{
-                const msg = new chat_history_namespaceObject.InMemoryChatMessageHistory();
-                messages.forEach((m)=>{
-                    if ('user' === m.role) msg.addUserMessage(m.content);
-                    else if ('assistant' === m.role) msg.addAIMessage(m.content);
-                });
-                return msg;
-            },
-            runnable: executor,
-            inputMessagesKey: 'input',
-            historyMessagesKey: 'chat_history'
-        });
-        return runnable;
-    }
-    createExecutor() {
-        const llm = this.createModel();
-        const prompt = this.createPrompt();
-        const agent = (0, agents_namespaceObject.createToolCallingAgent)({
-            llm: llm,
-            tools: this.tools,
-            prompt,
-            streamRunnable: true
-        });
-        return new agents_namespaceObject.AgentExecutor({
-            agent,
-            tools: this.tools
-        });
-    }
-    createPrompt() {
-        return prompts_namespaceObject.ChatPromptTemplate.fromMessages([
-            [
-                'system',
-                this.system_prompt
-            ],
-            new prompts_namespaceObject.MessagesPlaceholder('chat_history'),
-            [
-                'human',
-                '{input}'
-            ],
-            new prompts_namespaceObject.MessagesPlaceholder('agent_scratchpad')
-        ]);
-    }
-    createModel() {
-        return new ChatVolcengine({
-            apiKey: this.api_key,
-            model: this.model,
-            temperature: 0,
-            streaming: true,
-            ...this.model_config
-        });
-    }
-}
-exports.Agent = __webpack_exports__.Agent;
+exports.AgentOptions = __webpack_exports__.AgentOptions;
+exports.ChatVolcengine = __webpack_exports__.ChatVolcengine;
+exports.createReactAgent = __webpack_exports__.createReactAgent;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "Agent"
+    "AgentOptions",
+    "ChatVolcengine",
+    "createReactAgent"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "listpage-next-ai",
-  "version": "0.0.256",
+  "version": "0.0.259",
   "description": "A React component library for creating filter forms with Ant Design",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -23,26 +23,34 @@
     "build": "rslib build",
     "format": "prettier --write .",
     "prepublishOnly": "npm run build",
-    "test": "npx ts-node ./src/test.ts"
+    "test": "npx tsx ./src/test.ts"
   },
   "devDependencies": {
+    "@microsoft/api-extractor": "~7.53.3",
     "@rsbuild/core": "^1.5.7",
     "@rsbuild/plugin-react": "^1.4.0",
     "@rslib/core": "^0.13.3",
+    "@types/lodash": "~4.17.20",
     "prettier": "^3.6.2",
-    "typescript": "^5.9.2",
     "ts-node": "~10.9.2",
-    "@types/lodash": "~4.17.20",
-    "@microsoft/api-extractor": "~7.53.3"
+    "tsx": "^4.19.0",
+    "typescript": "^5.9.2"
   },
   "dependencies": {
-    "uuid": "9.0.1",
-    "lodash": "~4.17.21",
-    "@langchain/core": "1.0.5",
+    "@langchain/classic": "~1.0.3",
     "@langchain/community": "~1.0.3",
+    "@langchain/core": "^1.1.5",
+    "@langchain/langgraph": "^1.0.0",
     "@langchain/openai": "~1.1.1",
-    "@langchain/classic": "~1.0.3",
+    "@langchain/tavily": "~1.0.1",
+    "deepagents": "~1.3.1",
+    "fast-glob": "^3.3.3",
+    "langchain": "^1.2.0",
+    "lodash": "~4.17.21",
     "rxjs": "~7.8.2",
-    "zod": "^3.23.8"
+    "uuid": "9.0.1",
+    "zod": "^3.23.8",
+    "mysql2": "~3.15.3",
+    "@node-rs/jieba": "~2.0.1"
   }
 }