@next-open-ai/openbot 0.2.8 → 0.6.6

package/dist/core/mcp/config.js

@@ -0,0 +1,69 @@
+/**
+ * MCP 配置解析与校验。
+ * 从 getOrCreateSession 的 options.mcpServers 中取出并规范化，支持 stdio 与 sse。
+ */
+/**
+ * 从会话选项里解析出本会话启用的 MCP 服务器配置列表。
+ * 支持 stdio（本地进程）与 sse（远程 HTTP）。
+ */
+export function resolveMcpServersForSession(mcpServers) {
+    if (!Array.isArray(mcpServers) || mcpServers.length === 0) {
+        return [];
+    }
+    const result = [];
+    for (const s of mcpServers) {
+        if (!s || typeof s !== "object")
+            continue;
+        if (s.transport === "stdio") {
+            if (typeof s.command !== "string" || !s.command.trim()) {
+                console.warn("[mcp] 跳过无效 stdio 配置：缺少或无效 command");
+                continue;
+            }
+            result.push({
+                transport: "stdio",
+                command: s.command.trim(),
+                args: Array.isArray(s.args) ? s.args : undefined,
+                env: s.env && typeof s.env === "object" ? s.env : undefined,
+            });
+        }
+        else if (s.transport === "sse") {
+            const url = s.url?.trim();
+            if (!url) {
+                console.warn("[mcp] 跳过无效 sse 配置：缺少或无效 url");
+                continue;
+            }
+            result.push({
+                transport: "sse",
+                url,
+                headers: s.headers && typeof s.headers === "object" ? s.headers : undefined,
+            });
+        }
+        else {
+            console.warn("[mcp] 未知 transport:", s.transport);
+        }
+    }
+    return result;
+}
+/**
+ * 为 stdio 配置生成缓存键（用于 Operator 复用同一进程连接）
+ */
+export function stdioConfigKey(config) {
+    const args = (config.args ?? []).join(" ");
+    const envStr = config.env ? JSON.stringify(config.env) : "";
+    return `stdio:${config.command}\0${args}\0${envStr}`;
+}
+/**
+ * 为 sse 配置生成缓存键
+ */
+export function sseConfigKey(config) {
+    const headersStr = config.headers ? JSON.stringify(config.headers) : "";
+    return `sse:${config.url}\0${headersStr}`;
+}
+/**
+ * 任意 MCP 配置的缓存键
+ */
+export function mcpConfigKey(config) {
+    if (config.transport === "stdio")
+        return stdioConfigKey(config);
+    return sseConfigKey(config);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Core MCP 模块：为 SessionAgent 提供 MCP Tools 能力（Client 端）。
+ * 配置在创建 Session 时通过 options.mcpServers 传入，与 Skill 类似。
+ */
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { McpServerConfig } from "./types.js";
+export type { McpServerConfig, McpServerConfigStdio, McpServerConfigSse, McpTool } from "./types.js";
+export { resolveMcpServersForSession, stdioConfigKey, sseConfigKey, mcpConfigKey } from "./config.js";
+export { McpClient } from "./client.js";
+export { getMcpToolDefinitions, shutdownMcpClients } from "./operator.js";
+export { mcpToolToToolDefinition, mcpToolsToToolDefinitions } from "./adapter.js";
+/**
+ * 根据会话选项中的 mcpServers 配置，返回该会话可用的 MCP 工具（ToolDefinition 数组）。
+ * 在 AgentManager.getOrCreateSession 中调用，并入 customTools。
+ */
+export declare function createMcpToolsForSession(options: {
+    mcpServers?: McpServerConfig[];
+}): Promise<ToolDefinition[]>;

package/dist/core/mcp/index.js

@@ -0,0 +1,20 @@
+/**
+ * Core MCP 模块：为 SessionAgent 提供 MCP Tools 能力（Client 端）。
+ * 配置在创建 Session 时通过 options.mcpServers 传入，与 Skill 类似。
+ */
+import { resolveMcpServersForSession } from "./config.js";
+import { getMcpToolDefinitions } from "./operator.js";
+export { resolveMcpServersForSession, stdioConfigKey, sseConfigKey, mcpConfigKey } from "./config.js";
+export { McpClient } from "./client.js";
+export { getMcpToolDefinitions, shutdownMcpClients } from "./operator.js";
+export { mcpToolToToolDefinition, mcpToolsToToolDefinitions } from "./adapter.js";
+/**
+ * 根据会话选项中的 mcpServers 配置，返回该会话可用的 MCP 工具（ToolDefinition 数组）。
+ * 在 AgentManager.getOrCreateSession 中调用，并入 customTools。
+ */
+export async function createMcpToolsForSession(options) {
+    const configs = resolveMcpServersForSession(options.mcpServers);
+    if (configs.length === 0)
+        return [];
+    return getMcpToolDefinitions(configs);
+}

package/dist/core/mcp/operator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP Operator：管理 MCP 客户端生命周期，按配置为会话提供 ToolDefinition 列表。
+ * 支持 stdio（本地）与 sse（远程）两种传输。
+ */
+import type { McpServerConfig } from "./types.js";
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 为给定 MCP 服务器配置列表获取或创建客户端，并返回其工具对应的 ToolDefinition 数组。
+ * 连接失败或 list_tools 失败的 server 会被跳过并打日志，不阻塞整体。
+ */
+export declare function getMcpToolDefinitions(serverConfigs: McpServerConfig[]): Promise<ToolDefinition[]>;
+/**
+ * 关闭并移除所有缓存的 MCP 客户端（进程退出或显式清理时调用）。
+ */
+export declare function shutdownMcpClients(): Promise<void>;

package/dist/core/mcp/operator.js

@@ -0,0 +1,72 @@
+/**
+ * MCP Operator：管理 MCP 客户端生命周期，按配置为会话提供 ToolDefinition 列表。
+ * 支持 stdio（本地）与 sse（远程）两种传输。
+ */
+import { mcpConfigKey } from "./config.js";
+import { McpClient } from "./client.js";
+import { mcpToolsToToolDefinitions } from "./adapter.js";
+/** 按配置键缓存的客户端 */
+const clientCache = new Map();
+function configLabel(config) {
+    if (config.transport === "stdio")
+        return config.command;
+    return config.url;
+}
+/**
+ * 为给定 MCP 服务器配置列表获取或创建客户端，并返回其工具对应的 ToolDefinition 数组。
+ * 连接失败或 list_tools 失败的 server 会被跳过并打日志，不阻塞整体。
+ */
+export async function getMcpToolDefinitions(serverConfigs) {
+    const allTools = [];
+    for (let i = 0; i < serverConfigs.length; i++) {
+        const config = serverConfigs[i];
+        const key = mcpConfigKey(config);
+        let client = clientCache.get(key);
+        if (!client) {
+            client = new McpClient(config);
+            try {
+                await client.connect();
+                clientCache.set(key, client);
+            }
+            catch (err) {
+                console.warn(`[mcp] 连接失败 (${configLabel(config)}):`, err instanceof Error ? err.message : err);
+                continue;
+            }
+        }
+        if (!client.isConnected) {
+            clientCache.delete(key);
+            try {
+                await client.close();
+            }
+            catch { }
+            const newClient = new McpClient(config);
+            try {
+                await newClient.connect();
+                clientCache.set(key, newClient);
+                client = newClient;
+            }
+            catch (err) {
+                console.warn(`[mcp] 重连失败 (${configLabel(config)}):`, err instanceof Error ? err.message : err);
+                continue;
+            }
+        }
+        try {
+            const tools = await client.listTools();
+            const serverId = `mcp${i}`;
+            const definitions = mcpToolsToToolDefinitions(tools, client, serverId);
+            allTools.push(...definitions);
+        }
+        catch (err) {
+            console.warn(`[mcp] list_tools 失败 (${configLabel(config)}):`, err instanceof Error ? err.message : err);
+        }
+    }
+    return allTools;
+}
+/**
+ * 关闭并移除所有缓存的 MCP 客户端（进程退出或显式清理时调用）。
+ */
+export async function shutdownMcpClients() {
+    const closeAll = Array.from(clientCache.values()).map((c) => c.close().catch(() => { }));
+    clientCache.clear();
+    await Promise.all(closeAll);
+}

package/dist/core/mcp/transport/index.d.ts

@@ -0,0 +1,11 @@
+import type { McpServerConfig, IMcpTransport } from "../types.js";
+export interface TransportOptions {
+    initTimeoutMs?: number;
+    requestTimeoutMs?: number;
+}
+/**
+ * 根据配置创建对应的传输层实例。
+ */
+export declare function createTransport(config: McpServerConfig, options?: TransportOptions): IMcpTransport;
+export { StdioTransport } from "./stdio.js";
+export { SseTransport } from "./sse.js";

package/dist/core/mcp/transport/index.js

@@ -0,0 +1,16 @@
+import { StdioTransport } from "./stdio.js";
+import { SseTransport } from "./sse.js";
+/**
+ * 根据配置创建对应的传输层实例。
+ */
+export function createTransport(config, options) {
+    if (config.transport === "stdio") {
+        return new StdioTransport(config, options);
+    }
+    if (config.transport === "sse") {
+        return new SseTransport(config, options);
+    }
+    throw new Error(`Unsupported MCP transport: ${config.transport}`);
+}
+export { StdioTransport } from "./stdio.js";
+export { SseTransport } from "./sse.js";

package/dist/core/mcp/transport/sse.d.ts

@@ -0,0 +1,20 @@
+/**
+ * MCP SSE/HTTP 传输：通过 HTTP POST 向远程 URL 发送 JSON-RPC 请求，响应在 response body。
+ */
+import type { McpServerConfigSse } from "../types.js";
+import type { JsonRpcRequest, JsonRpcResponse } from "../types.js";
+export interface SseTransportOptions {
+    initTimeoutMs?: number;
+    requestTimeoutMs?: number;
+}
+export declare class SseTransport {
+    private config;
+    private initTimeoutMs;
+    private requestTimeoutMs;
+    private _connected;
+    constructor(config: McpServerConfigSse, options?: SseTransportOptions);
+    start(): Promise<void>;
+    request(req: JsonRpcRequest, timeoutMs?: number): Promise<JsonRpcResponse>;
+    close(): Promise<void>;
+    get isConnected(): boolean;
+}

package/dist/core/mcp/transport/sse.js

@@ -0,0 +1,82 @@
+/**
+ * MCP SSE/HTTP 传输：通过 HTTP POST 向远程 URL 发送 JSON-RPC 请求，响应在 response body。
+ */
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+export class SseTransport {
+    config;
+    initTimeoutMs;
+    requestTimeoutMs;
+    _connected = false;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.initTimeoutMs = options.initTimeoutMs ?? 15_000;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
+    }
+    async start() {
+        if (this._connected)
+            return;
+        const url = (this.config.url ?? "").trim();
+        if (!url)
+            throw new Error("MCP SSE url is required");
+        const initResult = await this.request({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "initialize",
+            params: {
+                protocolVersion: MCP_PROTOCOL_VERSION,
+                capabilities: {},
+                clientInfo: { name: "openbot", version: "0.1.0" },
+            },
+        }, this.initTimeoutMs);
+        if (initResult.error) {
+            throw new Error(`MCP initialize failed: ${initResult.error.message}`);
+        }
+        await this.request({ jsonrpc: "2.0", id: 2, method: "notifications/initialized" }, this.requestTimeoutMs).catch(() => ({}));
+        this._connected = true;
+    }
+    request(req, timeoutMs) {
+        const url = (this.config.url ?? "").trim();
+        if (!url) {
+            return Promise.reject(new Error("MCP SSE url is required"));
+        }
+        const t = timeoutMs ?? this.requestTimeoutMs;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), t);
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...this.config.headers,
+        };
+        return fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(req),
+            signal: controller.signal,
+        })
+            .then(async (res) => {
+            clearTimeout(timeoutId);
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`MCP HTTP ${res.status}: ${text.slice(0, 200)}`);
+            }
+            const json = (await res.json());
+            if (!json || json.jsonrpc !== "2.0") {
+                throw new Error("Invalid MCP response");
+            }
+            return json;
+        })
+            .catch((err) => {
+            clearTimeout(timeoutId);
+            if (err.name === "AbortError") {
+                throw new Error(`MCP request timeout (${t}ms)`);
+            }
+            throw err;
+        });
+    }
+    async close() {
+        this._connected = false;
+    }
+    get isConnected() {
+        return this._connected;
+    }
+}

package/dist/core/mcp/transport/stdio.d.ts

@@ -0,0 +1,32 @@
+/**
+ * MCP stdio 传输：子进程 + 标准输入/输出上的 Newline-delimited JSON-RPC。
+ */
+import type { McpServerConfigStdio } from "../types.js";
+import type { JsonRpcRequest, JsonRpcResponse } from "../types.js";
+export interface StdioTransportOptions {
+    /** 初始化超时（毫秒） */
+    initTimeoutMs?: number;
+    /** 单次请求超时（毫秒） */
+    requestTimeoutMs?: number;
+}
+export declare class StdioTransport {
+    private process;
+    private config;
+    private initTimeoutMs;
+    private requestTimeoutMs;
+    private nextId;
+    private pending;
+    private buffer;
+    constructor(config: McpServerConfigStdio, options?: StdioTransportOptions);
+    /** 启动子进程并完成 MCP initialize 握手 */
+    start(): Promise<void>;
+    private flushLines;
+    private rejectAll;
+    private initialize;
+    private sendNotification;
+    /** 发送 JSON-RPC 请求并等待响应 */
+    request(req: JsonRpcRequest, timeoutMs?: number): Promise<JsonRpcResponse>;
+    /** 关闭子进程 */
+    close(): Promise<void>;
+    get isConnected(): boolean;
+}

package/dist/core/mcp/transport/stdio.js

@@ -0,0 +1,132 @@
+/**
+ * MCP stdio 传输：子进程 + 标准输入/输出上的 Newline-delimited JSON-RPC。
+ */
+import { spawn } from "node:child_process";
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+export class StdioTransport {
+    process = null;
+    config;
+    initTimeoutMs;
+    requestTimeoutMs;
+    nextId = 1;
+    pending = new Map();
+    buffer = "";
+    constructor(config, options = {}) {
+        this.config = config;
+        this.initTimeoutMs = options.initTimeoutMs ?? 10_000;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
+    }
+    /** 启动子进程并完成 MCP initialize 握手 */
+    async start() {
+        if (this.process) {
+            return;
+        }
+        const env = { ...process.env, ...this.config.env };
+        this.process = spawn(this.config.command, this.config.args ?? [], {
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const child = this.process;
+        child.stdout?.on("data", (chunk) => {
+            this.buffer += chunk.toString("utf-8");
+            this.flushLines();
+        });
+        child.stderr?.on("data", (data) => {
+            const msg = data.toString("utf-8").trim();
+            if (msg)
+                console.warn("[mcp stdio stderr]", msg);
+        });
+        child.on("error", (err) => {
+            this.rejectAll(new Error(`MCP process error: ${err.message}`));
+        });
+        child.on("exit", (code, signal) => {
+            this.rejectAll(new Error(`MCP process exited: code=${code} signal=${signal}`));
+            this.process = null;
+        });
+        await this.initialize();
+    }
+    flushLines() {
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if ("id" in msg && msg.id !== undefined) {
+                    const pending = this.pending.get(msg.id);
+                    if (pending) {
+                        clearTimeout(pending.timer);
+                        this.pending.delete(msg.id);
+                        if (msg.error) {
+                            pending.reject(new Error(msg.error.message));
+                        }
+                        else {
+                            pending.resolve(msg);
+                        }
+                    }
+                }
+            }
+            catch {
+                // 忽略非 JSON 行
+            }
+        }
+    }
+    rejectAll(err) {
+        for (const [, { reject, timer }] of this.pending) {
+            clearTimeout(timer);
+            reject(err);
+        }
+        this.pending.clear();
+    }
+    async initialize() {
+        const initResult = await this.request({
+            jsonrpc: "2.0",
+            id: this.nextId++,
+            method: "initialize",
+            params: {
+                protocolVersion: MCP_PROTOCOL_VERSION,
+                capabilities: {},
+                clientInfo: { name: "openbot", version: "0.1.0" },
+            },
+        }, this.initTimeoutMs);
+        if (initResult.error) {
+            throw new Error(`MCP initialize failed: ${initResult.error.message}`);
+        }
+        this.sendNotification({ jsonrpc: "2.0", method: "notifications/initialized" });
+    }
+    sendNotification(msg) {
+        if (!this.process?.stdin?.writable)
+            return;
+        this.process.stdin.write(JSON.stringify(msg) + "\n", "utf-8");
+    }
+    /** 发送 JSON-RPC 请求并等待响应 */
+    request(req, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            if (!this.process?.stdin?.writable) {
+                reject(new Error("MCP transport not connected"));
+                return;
+            }
+            const t = timeoutMs ?? this.requestTimeoutMs;
+            const timer = setTimeout(() => {
+                if (this.pending.delete(req.id)) {
+                    reject(new Error(`MCP request timeout (${t}ms)`));
+                }
+            }, t);
+            this.pending.set(req.id, { resolve, reject, timer });
+            this.process.stdin.write(JSON.stringify(req) + "\n", "utf-8");
+        });
+    }
+    /** 关闭子进程 */
+    async close() {
+        if (this.process) {
+            this.rejectAll(new Error("MCP transport closed"));
+            this.process.kill("SIGTERM");
+            this.process = null;
+        }
+    }
+    get isConnected() {
+        return this.process != null && this.process.stdin?.writable === true;
+    }
+}

package/dist/core/mcp/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * MCP (Model Context Protocol) 相关类型定义。
+ * 仅实现 Client 端 Tools 能力；Resources/Prompts 类型预留扩展。
+ */
+/** stdio 传输：通过子进程 stdin/stdout 进行 JSON-RPC 通信 */
+export interface McpServerConfigStdio {
+    transport: "stdio";
+    /** 可执行路径（禁止从用户输入拼接，需白名单或配置） */
+    command: string;
+    /** 命令行参数 */
+    args?: string[];
+    /** 环境变量（可选，合并到 process.env） */
+    env?: Record<string, string>;
+}
+/** SSE/HTTP 远程传输：通过 URL POST JSON-RPC 请求 */
+export interface McpServerConfigSse {
+    transport: "sse";
+    /** 远程 MCP 服务地址（如 https://example.com/mcp） */
+    url: string;
+    /** 可选请求头（如 Authorization） */
+    headers?: Record<string, string>;
+}
+/** 单条 MCP 服务器配置（由调用方在创建 Session 时传入，与 Skill 类似） */
+export type McpServerConfig = McpServerConfigStdio | McpServerConfigSse;
+/** MCP 协议中 Tool 的 inputSchema 为 JSON Schema 对象 */
+export interface McpToolInputSchema {
+    type?: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+/** MCP tools/list 返回的单个工具描述 */
+export interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema?: McpToolInputSchema;
+}
+/** MCP tools/call 返回的 content 项 */
+export interface McpToolCallContentItem {
+    type: "text";
+    text: string;
+}
+/** MCP tools/call 的 result */
+export interface McpToolCallResult {
+    content: McpToolCallContentItem[];
+    isError?: boolean;
+}
+/** JSON-RPC 2.0 请求 */
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number | string;
+    method: string;
+    params?: unknown;
+}
+/** JSON-RPC 2.0 成功响应 */
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc: "2.0";
+    id: number | string;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/** 传输层抽象：stdio / sse 等实现此接口供 McpClient 使用 */
+export interface IMcpTransport {
+    start(): Promise<void>;
+    request(req: JsonRpcRequest, timeoutMs?: number): Promise<JsonRpcResponse>;
+    close(): Promise<void>;
+    readonly isConnected: boolean;
+}

package/dist/core/mcp/types.js

@@ -0,0 +1,5 @@
+/**
+ * MCP (Model Context Protocol) 相关类型定义。
+ * 仅实现 Client 端 Tools 能力；Resources/Prompts 类型预留扩展。
+ */
+export {};

package/dist/core/session-current-agent.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 当前 session 使用的 agent 解析与更新、以及节点上 agent 列表提供。
+ * 由 Gateway 启动时注入，供 agent-chat、channel-core、以及 Core 层 switch_agent / list_agents 工具使用。
+ */
+export type SessionCurrentAgentResolver = (sessionId: string) => string | undefined;
+export type SessionCurrentAgentUpdater = (sessionId: string, agentId: string) => void;
+export type AgentListProvider = () => Promise<{
+    id: string;
+    name?: string;
+}[]>;
+/** 创建智能体参数：由 create_agent 工具传入，缺省由工具层补齐 */
+export type CreateAgentParams = {
+    name: string;
+    workspace: string;
+    systemPrompt?: string;
+    provider?: string;
+    model?: string;
+    modelItemCode?: string;
+};
+export type CreateAgentResult = {
+    id: string;
+    name: string;
+} | {
+    error: string;
+};
+export type CreateAgentProvider = (params: CreateAgentParams) => Promise<CreateAgentResult>;
+export declare function setSessionCurrentAgentResolver(fn: SessionCurrentAgentResolver | null): void;
+export declare function getSessionCurrentAgentResolver(): SessionCurrentAgentResolver | null;
+export declare function setSessionCurrentAgentUpdater(fn: SessionCurrentAgentUpdater | null): void;
+export declare function getSessionCurrentAgentUpdater(): SessionCurrentAgentUpdater | null;
+export declare function setAgentListProvider(fn: AgentListProvider | null): void;
+export declare function getAgentListProvider(): AgentListProvider | null;
+export declare function setCreateAgentProvider(fn: CreateAgentProvider | null): void;
+export declare function getCreateAgentProvider(): CreateAgentProvider | null;

package/dist/core/session-current-agent.js

@@ -0,0 +1,32 @@
+/**
+ * 当前 session 使用的 agent 解析与更新、以及节点上 agent 列表提供。
+ * 由 Gateway 启动时注入，供 agent-chat、channel-core、以及 Core 层 switch_agent / list_agents 工具使用。
+ */
+let resolver = null;
+let updater = null;
+let agentListProvider = null;
+let createAgentProvider = null;
+export function setSessionCurrentAgentResolver(fn) {
+    resolver = fn;
+}
+export function getSessionCurrentAgentResolver() {
+    return resolver;
+}
+export function setSessionCurrentAgentUpdater(fn) {
+    updater = fn;
+}
+export function getSessionCurrentAgentUpdater() {
+    return updater;
+}
+export function setAgentListProvider(fn) {
+    agentListProvider = fn;
+}
+export function getAgentListProvider() {
+    return agentListProvider;
+}
+export function setCreateAgentProvider(fn) {
+    createAgentProvider = fn;
+}
+export function getCreateAgentProvider() {
+    return createAgentProvider;
+}

package/dist/core/tools/bookmark-tool.d.ts

@@ -0,0 +1,9 @@
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 获取当前系统中已维护的标签列表，供保存 URL 时选择匹配的标签。
+ */
+export declare function createGetBookmarkTagsTool(): ToolDefinition;
+/**
+ * 将 URL 保存为收藏，并关联指定标签（标签名须与 get_bookmark_tags 返回的一致）。
+ */
+export declare function createSaveBookmarkTool(): ToolDefinition;