ningzhi-agent-cli 0.0.1

package/dist/agent/db.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DB_PATH = void 0;
+exports.searchMemories = searchMemories;
+exports.threadIdExists = threadIdExists;
+exports.initDb = initDb;
+exports.listRecentSessions = listRecentSessions;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const utils_1 = require("./utils");
+exports.DB_PATH = (0, node_path_1.join)((0, node_os_1.homedir)(), ".ningzhiAgentCli", ".dbData", "checkpointer.db");
+// recursive 多层路径创建，且目录已存在不报错，幂等性
+(0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(exports.DB_PATH), { recursive: true });
+// 搜索记忆
+function searchMemories(query, limit = 10) {
+    const trimmedQueries = query.map((q) => q.trim()).filter((q) => q.length > 0);
+    if (trimmedQueries.length === 0) {
+        return [];
+    }
+    const queryStr = trimmedQueries.join(" OR ").replace(/-/g, " ");
+    const db = new better_sqlite3_1.default(exports.DB_PATH);
+    try {
+        const rows = db
+            .prepare(`
+      WITH ranked AS (
+        SELECT
+          m.*,
+          -bm25(memory_fts, 10.0, 5.0) AS relevance_score,
+          (m.importance * 0.3) AS importance_score,
+          (
+            1.0 / (
+              1.0 +
+              ((strftime('%s','now') - strftime('%s', m.updated_at)) / 86400.0)
+            )
+          ) AS time_score
+        FROM memory_fts
+        JOIN memory m ON m.id = memory_fts.rowid
+        WHERE memory_fts MATCH ?
+      )
+      SELECT *,
+        (
+          relevance_score * 0.6 +
+          importance_score * 0.3 +
+          time_score * 0.1
+        ) AS final_score
+      FROM ranked
+      ORDER BY final_score DESC
+      LIMIT ?
+    `)
+            .all(queryStr, limit);
+        return rows.map((r) => ({
+            id: r.id,
+            type: r.type,
+            content: r.content,
+            keywords: r.keywords,
+            importance: r.importance,
+            session_id: r.session_id,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+            final_score: r.final_score,
+        }));
+    }
+    finally {
+        db.close();
+    }
+}
+// 检查会话id是否存在
+function threadIdExists(threadId) {
+    const db = new better_sqlite3_1.default(exports.DB_PATH);
+    try {
+        const row = db
+            .prepare(`
+      SELECT 1 FROM checkpoints WHERE thread_id = ? LIMIT 1
+    `)
+            .get(threadId);
+        return !!row;
+    }
+    finally {
+        db.close();
+    }
+}
+// 初始化数据库
+function initDb() {
+    const db = new better_sqlite3_1.default(exports.DB_PATH);
+    try {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS memory (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        keywords TEXT, 
+        importance INTEGER DEFAULT 3,
+        session_id TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        // SQLite 的 FTS（Full-Text Search）模块是一种虚拟表模块，支持高效的全文搜索功能。
+        // FTS5 是 SQLite 最新的全文搜索引擎，提供了强大的功能和灵活性。
+        db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+        content,
+        keywords,
+        content='memory', content_rowid='id'
+      )
+    `);
+        db.exec(`
+      CREATE TRIGGER IF NOT EXISTS memory_fts_insert AFTER INSERT ON memory BEGIN
+        INSERT INTO memory_fts(rowid, content, keywords)
+        VALUES (new.id, new.content, new.keywords);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memory_fts_delete AFTER DELETE ON memory BEGIN
+        INSERT INTO memory_fts(memory_fts, rowid, content, keywords)
+        VALUES ('delete', old.id, old.content, old.keywords);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memory_fts_update AFTER UPDATE ON memory BEGIN
+        INSERT INTO memory_fts(memory_fts, rowid, content, keywords)
+        VALUES ('delete', old.id, old.content, old.keywords);
+        INSERT INTO memory_fts(rowid, content, keywords)
+        VALUES (new.id, new.content, new.keywords);
+      END;
+    `);
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * 列出最近 10 个会话（线程）
+ * @returns 会话列表
+ */
+function listRecentSessions() {
+    const db = new better_sqlite3_1.default(exports.DB_PATH);
+    try {
+        // 查询最近 10 个会话（线程）：取每个线程的最后活跃时间，以及最近一条用户提问
+        const rows = db
+            .prepare(`
+      -- CTE：取每个线程最新的 checkpoint 及其 ts
+      WITH thread_last AS (
+        SELECT
+          thread_id,
+          MAX(json_extract(CAST(checkpoint AS TEXT), '$.ts')) AS last_ts,
+          (SELECT CAST(c2.checkpoint AS TEXT)
+           FROM checkpoints c2
+           WHERE c2.thread_id = c.thread_id
+           ORDER BY json_extract(CAST(c2.checkpoint AS TEXT), '$.ts') DESC
+           LIMIT 1) AS last_checkpoint
+        FROM checkpoints c
+        GROUP BY thread_id
+      )
+      SELECT
+        t.thread_id,
+        -- 从最新 checkpoint 的 messages 数组中，取最后一条用户消息的内容
+        (SELECT COALESCE(
+                  json_extract(j.value, '$.kwargs.content'),
+                  json_extract(j.value, '$.content')
+                )
+         FROM json_each(json_extract(t.last_checkpoint, '$.channel_values.messages')) j
+         WHERE json_extract(j.value, '$.id[2]') = 'HumanMessage'
+            OR json_extract(j.value, '$.type') = 'human'
+         ORDER BY CAST(j.key AS INTEGER) DESC
+         LIMIT 1) AS last_question,
+        t.last_ts
+      FROM thread_last t
+      ORDER BY t.last_ts DESC  -- 按最后活跃时间倒序（最新的在前）
+      LIMIT 10                 -- 只取最近 10 个会话
+    `)
+            .all();
+        return rows.map((r) => ({
+            thread_id: r.thread_id,
+            last_question: (0, utils_1.truncate)(r.last_question, 50),
+            last_ts: (0, utils_1.formatRelativeTime)(r.last_ts),
+        }));
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/agent/hooks/engine.d.ts

@@ -0,0 +1,27 @@
+import { type HookConfig, type HooksConfig } from "../config";
+export type { HookConfig, HooksConfig };
+export type HookResult = {
+    action: "continue";
+} | {
+    action: "block";
+    reason: string;
+} | {
+    action: "inject";
+    message: string;
+};
+export declare function loadHooksConfig(): HooksConfig;
+export declare function clearHooksCache(): void;
+export declare function matchHooks(hooks: HookConfig[] | undefined, toolName: string): HookConfig[];
+export declare function runHook(hook: HookConfig, env: Record<string, string>, timeout?: number): Promise<HookResult>;
+export interface ToolHookContext {
+    toolName: string;
+    toolArgs: any;
+    toolCallId: string;
+    threadId: string;
+}
+export declare function runPreToolUseHooks(context: ToolHookContext): Promise<HookResult>;
+export interface PostToolHookContext extends ToolHookContext {
+    toolOutput: string;
+}
+export declare function runPostToolUseHooks(context: PostToolHookContext): Promise<HookResult>;
+export declare function runSessionStartHooks(threadId: string): Promise<void>;

package/dist/agent/hooks/engine.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHooksConfig = loadHooksConfig;
+exports.clearHooksCache = clearHooksCache;
+exports.matchHooks = matchHooks;
+exports.runHook = runHook;
+exports.runPreToolUseHooks = runPreToolUseHooks;
+exports.runPostToolUseHooks = runPostToolUseHooks;
+exports.runSessionStartHooks = runSessionStartHooks;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+// 配置目录，hook 命令中的相对路径（如 ./hooks/xxx）相对于此目录解析
+const CONFIG_DIR = node_path_1.default.join(node_os_1.default.homedir(), ".ningzhiAgentCli");
+const config_1 = require("../config");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+function loadHooksConfig() {
+    return (0, config_1.getHooksConfig)();
+}
+function clearHooksCache() {
+    (0, config_1.clearConfigCache)();
+}
+function matchHooks(hooks, toolName) {
+    if (!hooks)
+        return [];
+    return hooks.filter((h) => h.matcher === "*" || toolName.includes(h.matcher));
+}
+async function runHook(hook, env, timeout = 30000) {
+    const hookType = env.NINGZHI_HOOK_TYPE || "hook";
+    console.log(`[Hook ${hookType}] ${hook.command}`);
+    try {
+        await execAsync(hook.command, {
+            cwd: CONFIG_DIR,
+            env: { ...process.env, ...env },
+            timeout,
+        });
+        return { action: "continue" };
+    }
+    catch (error) {
+        const code = error.code;
+        const stderr = error.stderr || "";
+        if (code === 1) {
+            return { action: "block", reason: stderr }; // 工具不执行，stderr 作为错误返回   ===>   通用未知错误
+        }
+        else if (code === 2) {
+            return { action: "inject", message: stderr }; // stderr 注入对话，工具仍执行  ===>  非法参数 / 命令语法错误
+        }
+        return {
+            action: "block",
+            reason: stderr || `Hook exited with code ${code}`,
+        };
+    }
+}
+async function runPreToolUseHooks(context) {
+    const config = loadHooksConfig();
+    const hooks = matchHooks(config.hooks.PreToolUse, context.toolName);
+    const injectMessages = [];
+    for (const hook of hooks) {
+        const result = await runHook(hook, {
+            NINGZHI_HOOK_TYPE: "PreToolUse",
+            NINGZHI_TOOL_NAME: context.toolName,
+            NINGZHI_TOOL_ARGS: JSON.stringify(context.toolArgs),
+            NINGZHI_TOOL_CALL_ID: context.toolCallId,
+            NINGZHI_THREAD_ID: context.threadId,
+        });
+        if (result.action === "block") {
+            return result;
+        }
+        if (result.action === "inject") {
+            injectMessages.push(result.message);
+        }
+    }
+    if (injectMessages.length > 0) {
+        return { action: "inject", message: injectMessages.join("\n") };
+    }
+    return { action: "continue" };
+}
+async function runPostToolUseHooks(context) {
+    const config = loadHooksConfig();
+    const hooks = matchHooks(config.hooks.PostToolUse, context.toolName);
+    const injectMessages = [];
+    for (const hook of hooks) {
+        const result = await runHook(hook, {
+            NINGZHI_HOOK_TYPE: "PostToolUse",
+            NINGZHI_TOOL_NAME: context.toolName,
+            NINGZHI_TOOL_ARGS: JSON.stringify(context.toolArgs),
+            NINGZHI_TOOL_OUTPUT: context.toolOutput,
+            NINGZHI_TOOL_CALL_ID: context.toolCallId,
+            NINGZHI_THREAD_ID: context.threadId,
+        });
+        if (result.action === "block") {
+            return result;
+        }
+        if (result.action === "inject") {
+            injectMessages.push(result.message);
+        }
+    }
+    if (injectMessages.length > 0) {
+        return { action: "inject", message: injectMessages.join("\n") };
+    }
+    return { action: "continue" };
+}
+async function runSessionStartHooks(threadId) {
+    const config = loadHooksConfig();
+    const hooks = config.hooks.SessionStart || [];
+    for (const hook of hooks) {
+        const result = await runHook(hook, {
+            NINGZHI_HOOK_TYPE: "SessionStart",
+            NINGZHI_THREAD_ID: threadId,
+        });
+        if (result.action === "block") {
+            console.error(`[SessionStart hook blocked] ${result.reason}`);
+        }
+        else if (result.action === "inject") {
+            console.log(result.message);
+        }
+    }
+}

package/dist/agent/hooks/index.d.ts

@@ -0,0 +1 @@
+export { loadHooksConfig, clearHooksCache, matchHooks, runHook, runPreToolUseHooks, runPostToolUseHooks, runSessionStartHooks, type HookConfig, type HooksConfig, type HookResult, type ToolHookContext, type PostToolHookContext, } from "./engine";

package/dist/agent/hooks/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSessionStartHooks = exports.runPostToolUseHooks = exports.runPreToolUseHooks = exports.runHook = exports.matchHooks = exports.clearHooksCache = exports.loadHooksConfig = void 0;
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "loadHooksConfig", { enumerable: true, get: function () { return engine_1.loadHooksConfig; } });
+Object.defineProperty(exports, "clearHooksCache", { enumerable: true, get: function () { return engine_1.clearHooksCache; } });
+Object.defineProperty(exports, "matchHooks", { enumerable: true, get: function () { return engine_1.matchHooks; } });
+Object.defineProperty(exports, "runHook", { enumerable: true, get: function () { return engine_1.runHook; } });
+Object.defineProperty(exports, "runPreToolUseHooks", { enumerable: true, get: function () { return engine_1.runPreToolUseHooks; } });
+Object.defineProperty(exports, "runPostToolUseHooks", { enumerable: true, get: function () { return engine_1.runPostToolUseHooks; } });
+Object.defineProperty(exports, "runSessionStartHooks", { enumerable: true, get: function () { return engine_1.runSessionStartHooks; } });

package/dist/agent/mcp/client.d.ts

@@ -0,0 +1,31 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+export interface McpServerConfig {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+}
+export interface McpToolInfo {
+    name: string;
+    description?: string;
+    inputSchema: object;
+}
+export interface McpServerConnection {
+    name: string;
+    client: Client;
+    transport: Transport;
+    tools: McpToolInfo[];
+}
+export declare function loadMcpConfig(): Record<string, McpServerConfig>;
+export declare function connectMcpServer(name: string, config: McpServerConfig): Promise<McpServerConnection>;
+export declare function initializeMcpClients(): Promise<McpServerConnection[]>;
+/**
+ * 调用指定 MCP 服务器上的工具，返回工具输出的文本内容。
+ * @param client 已连接的 MCP 客户端
+ * @param name   工具名称
+ * @param args   传给工具的参数
+ */
+export declare function callMcpTool(client: Client, name: string, args: Record<string, unknown>): Promise<string>;
+export declare function disconnectAllMcpClients(connections: McpServerConnection[]): Promise<void>;

package/dist/agent/mcp/client.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMcpConfig = loadMcpConfig;
+exports.connectMcpServer = connectMcpServer;
+exports.initializeMcpClients = initializeMcpClients;
+exports.callMcpTool = callMcpTool;
+exports.disconnectAllMcpClients = disconnectAllMcpClients;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const colors_1 = require("../colors");
+const config_1 = require("../config");
+const CONNECT_TIMEOUT_MS = 60000;
+function loadMcpConfig() {
+    return (0, config_1.getMCPServerConfig)();
+}
+async function withTimeout(promise, ms, label) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms)),
+    ]);
+}
+// 根据配置创建 MCP 服务器的传输层，根据配置是使用 HTTP 还是 Stdio 连接。
+// @param config - MCP 服务器的配置对象，包含连接信息和工具列表。
+// @returns - 创建的 MCP 服务器传输层实例
+function createMcpTransport(config) {
+    if (config.url) {
+        const url = new URL(config.url);
+        // `RequestInit` 是 Fetch API 中描述`fetch()` 请求配置项的接口类型，
+        // 包含`method` 、`headers` 、`body` 、`credentials` 等字段
+        // `@types/node` 已经把它声明为全局类型，所以不用导入 ==》 tsconfig.json 中的  compilerOptions 的"types": ["node", "jest"],
+        const requestInit = config.headers
+            ? { headers: config.headers }
+            : undefined;
+        return new streamableHttp_js_1.StreamableHTTPClientTransport(url, { requestInit });
+    }
+    // 如果配置了`command`，则使用`StdioClientTransport`
+    if (config.command) {
+        return new stdio_js_1.StdioClientTransport({
+            command: config.command,
+            args: config.args,
+            env: config.env,
+        });
+    }
+    throw new Error('Invalid MCP server config: must have either "command" or "url"');
+}
+async function connectMcpServer(name, config) {
+    const transport = createMcpTransport(config);
+    const client = new index_js_1.Client({ name: "ningzhi", version: "0.0.1" }, { capabilities: {} });
+    await withTimeout(client.connect(transport), // 通过传输层连接到 MCP 服务器
+    CONNECT_TIMEOUT_MS, `MCP server "${name}" connect`);
+    const toolsResult = await withTimeout(client.listTools(), CONNECT_TIMEOUT_MS, `MCP server "${name}" listTools`);
+    const tools = (toolsResult.tools || []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+    }));
+    return { name, client, transport, tools };
+}
+// 初始化 MCP 客户端连接，根据配置文件中的服务器列表连接到所有 MCP 服务器。
+// @returns 已连接的 MCP 服务器连接列表。
+async function initializeMcpClients() {
+    const config = loadMcpConfig();
+    const entries = Object.entries(config); // [ [ "playwright", {...} ], [ "key", {...} ] ]
+    if (entries.length === 0) {
+        return [];
+    }
+    console.log(colors_1.color.info(`[MCP] Connecting to ${entries.length} server(s)...`));
+    // allSettled 它会 等待所有传入的 Promise 都完成 （无论成功还是失败），然后返回一个结果数组。
+    const results = await Promise.allSettled(entries.map(([name, cfg]) => connectMcpServer(name, cfg).catch((err) => {
+        const msg = err.message || "";
+        const hint = msg.includes("timed out")
+            ? " (Hint: if using npx, the first run may need to download the package. Consider pre-installing with `npm install -g <package>` or increasing timeout.)"
+            : "";
+        console.error(colors_1.color.error(`[MCP] Failed to connect "${name}": ${msg}${hint}`));
+        throw err;
+    })));
+    const connections = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === "fulfilled") {
+            const conn = result.value;
+            console.log(colors_1.color.good(`[MCP] Connected "${conn.name}" with ${conn.tools.length} tool(s)`));
+            connections.push(conn);
+        }
+        else {
+            console.error(colors_1.color.error(`[MCP] Skipped "${entries[i][0]}" due to connection error`));
+        }
+    }
+    return connections;
+}
+/**
+ * 调用指定 MCP 服务器上的工具，返回工具输出的文本内容。
+ * @param client 已连接的 MCP 客户端
+ * @param name   工具名称
+ * @param args   传给工具的参数
+ */
+async function callMcpTool(client, name, args) {
+    // 向 MCP 服务器发起 tool call 请求
+    const result = await client.callTool({ name, arguments: args });
+    // MCP 协议中 isError 为 true 表示工具执行失败，需抛出错误让上层处理
+    if (result.isError) {
+        const text = extractTextFromResult(result);
+        throw new Error(text || `MCP tool "${name}" returned an error`);
+    }
+    // 成功时，从返回结果中提取文本内容（可能有多段 text，用换行拼接）
+    return extractTextFromResult(result);
+}
+// 从 MCP 服务器返回的工具调用结果中提取文本内容（可能有多段 text，用换行拼接）
+function extractTextFromResult(result) {
+    //   如果结果中没有 content 字段，返回原始结果
+    if (!result.content || !Array.isArray(result.content)) {
+        return JSON.stringify(result);
+    }
+    //   从结果中提取所有 text 类型的项，将它们的文本内容用换行拼接起来
+    const texts = [];
+    for (const item of result.content) {
+        if (item.type === "text" && typeof item.text === "string") {
+            texts.push(item.text);
+        }
+    }
+    //   如果结果中没有 text 类型的项，返回原始结果
+    if (texts.length === 0) {
+        return JSON.stringify(result);
+    }
+    //   否则，返回所有 text 类型项的文本内容，用换行拼接
+    return texts.join("\n");
+}
+async function disconnectAllMcpClients(connections) {
+    await Promise.allSettled(connections.map(async (conn) => {
+        try {
+            await conn.transport.close();
+        }
+        catch {
+            // ignore
+        }
+    }));
+}

package/dist/agent/mcp/index.d.ts

@@ -0,0 +1,4 @@
+import type { NingzhiTool } from "../tools";
+export declare function initMcpTools(): Promise<NingzhiTool[]>;
+export declare function getMcpTools(): NingzhiTool[];
+export declare function shutdownMcp(): Promise<void>;

package/dist/agent/mcp/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initMcpTools = initMcpTools;
+exports.getMcpTools = getMcpTools;
+exports.shutdownMcp = shutdownMcp;
+const client_1 = require("./client");
+const wrapper_1 = require("./wrapper");
+let mcpConnections = [];
+let mcpTools = [];
+async function initMcpTools() {
+    mcpConnections = await (0, client_1.initializeMcpClients)();
+    mcpTools = [];
+    for (const conn of mcpConnections) {
+        for (const mcpTool of conn.tools) {
+            mcpTools.push((0, wrapper_1.wrapMcpTool)(conn, mcpTool));
+        }
+    }
+    return mcpTools;
+}
+function getMcpTools() {
+    return mcpTools;
+}
+async function shutdownMcp() {
+    await (0, client_1.disconnectAllMcpClients)(mcpConnections);
+    mcpConnections = [];
+    mcpTools = [];
+}

package/dist/agent/mcp/wrapper.d.ts

@@ -0,0 +1,7 @@
+import { type McpServerConnection } from "./client";
+import type { NingzhiTool } from "../tools";
+export declare function wrapMcpTool(connection: McpServerConnection, mcpTool: {
+    name: string;
+    description?: string;
+    inputSchema: object;
+}): NingzhiTool;

package/dist/agent/mcp/wrapper.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapMcpTool = wrapMcpTool;
+const tools_1 = require("@langchain/core/tools");
+const client_1 = require("./client");
+const MCP_TOOL_PERMISSION_LEVEL = "mcp";
+function wrapMcpTool(connection, mcpTool) {
+    const prefixedName = `${connection.name}_${mcpTool.name}`;
+    // 描述信息：前缀标记来源服务器 + 原始描述
+    const description = `[MCP:${connection.name}] ${mcpTool.description || "No description"}`;
+    // 直接把 MCP 工具的 inputSchema（JSON Schema）传给 LangChain 作为参数 schema。
+    // 这样 LLM 能看到完整的参数定义（如 url 字段），而不是空 schema。
+    // LangChain 支持 JSON Schema，会用 @cfworker/json-schema 做参数校验。
+    const schema = mcpTool.inputSchema;
+    const impl = async (args) => {
+        const result = await (0, client_1.callMcpTool)(connection.client, mcpTool.name, args);
+        return result;
+    };
+    const t = (0, tools_1.tool)(impl, {
+        name: prefixedName,
+        description,
+        schema,
+    });
+    t.permission_level = MCP_TOOL_PERMISSION_LEVEL;
+    return t;
+}

package/dist/agent/model.d.ts

@@ -0,0 +1,5 @@
+import { ChatOpenAI } from "@langchain/openai";
+export declare function createModel(options?: {
+    streaming?: boolean;
+}): ChatOpenAI;
+export declare function checkModel(): Promise<boolean>;

package/dist/agent/model.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModel = createModel;
+exports.checkModel = checkModel;
+const openai_1 = require("@langchain/openai");
+const config_1 = require("./config");
+const modelConfig = (0, config_1.getModelConfig)();
+// 只要能支持 openai 的接口格式，都可以用。
+function createModel(options) {
+    return new openai_1.ChatOpenAI({
+        model: modelConfig.model,
+        apiKey: modelConfig.apiKey,
+        configuration: {
+            baseURL: modelConfig.baseURL,
+        },
+        streaming: options?.streaming ?? true,
+        // 透传给模型 API 的额外参数：关闭模型的深度思考（thinking）模式
+        modelKwargs: {
+            thinking: { type: "disabled" },
+        },
+    });
+}
+async function checkModel() {
+    if (modelConfig.apiKey.length < 20) {
+        try {
+            const model = createModel({ streaming: false });
+            await model.invoke([{ role: "user", content: "hi" }]);
+        }
+        catch {
+            console.log(`\n⚠️ API Key 验证失败，请检查配置是否正确\n\n请参考 https://chat.ningzhi2.site/getStart 修改配置\n`);
+            return false;
+        }
+    }
+    return true;
+}