@qlingzzy/qling 1.0.0

package/dist/mcp/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../src/mcp/bridge.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CASlG;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,cAAc,EAAE,CAS3F;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,eAAe,EAAE,CAEpG"}

package/dist/mcp/bridge.js

@@ -0,0 +1,37 @@
+// ============================================================
+// 轻灵 - MCP 工具桥接
+// 将 MCP 工具转换为原生 ToolDefinition 格式
+// ============================================================
+const MCP_PREFIX = "mcp__";
+const MCP_SEPARATOR = "__";
+export function mcpToolFullName(serverName, toolName) {
+    return MCP_PREFIX + serverName + MCP_SEPARATOR + toolName;
+}
+export function isMCPTool(toolName) {
+    return toolName.startsWith(MCP_PREFIX);
+}
+export function parseMCPToolName(toolName) {
+    if (!isMCPTool(toolName))
+        return null;
+    const withoutPrefix = toolName.slice(MCP_PREFIX.length);
+    const idx = withoutPrefix.indexOf(MCP_SEPARATOR);
+    if (idx === -1)
+        return null;
+    return {
+        serverName: withoutPrefix.slice(0, idx),
+        toolName: withoutPrefix.slice(idx + MCP_SEPARATOR.length),
+    };
+}
+export function mcpToolsToNativeDefinitions(mcpTools) {
+    return mcpTools.map((t) => ({
+        name: mcpToolFullName(t.serverName, t.name),
+        description: "[MCP:" + t.serverName + "] " + t.description,
+        parameters: t.inputSchema,
+        readOnly: true,
+        scenes: ["mcp"],
+        priority: 4,
+    }));
+}
+export function buildMCPServersFromConfig(config) {
+    return Object.values(config).filter((s) => s.enabled);
+}

package/dist/mcp/client.d.ts

@@ -0,0 +1,26 @@
+import type { MCPServerConfig, MCPToolDefinition, MCPConnectResult } from "./types.js";
+import type { ToolResult } from "../types.js";
+export declare class MCPClient {
+    private config;
+    private transport;
+    private msgId;
+    private pending;
+    private connected;
+    private tools;
+    private connectionTimeout;
+    private callTimeout;
+    constructor(config: MCPServerConfig, timeouts?: {
+        connection?: number;
+        call?: number;
+    });
+    connect(): Promise<MCPConnectResult>;
+    callTool(name: string, args: Record<string, unknown>): Promise<ToolResult>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getServerName(): string;
+    getTools(): MCPToolDefinition[];
+    private handleMessage;
+    private sendRequest;
+    private sendNotification;
+}
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/mcp/client.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,gBAAgB,EAAc,MAAM,YAAY,CAAC;AACnG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAY9C,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,OAAO,CAA6F;IAC5G,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,WAAW,CAAS;gBAEhB,MAAM,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;IAMhF,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAsFpC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC;IAgD1E,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAcjC,WAAW,IAAI,OAAO;IAItB,aAAa,IAAI,MAAM;IAIvB,QAAQ,IAAI,iBAAiB,EAAE;IAM/B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,WAAW;YAiCL,gBAAgB;CAK/B"}

package/dist/mcp/client.js

@@ -0,0 +1,209 @@
+// ============================================================
+// 轻灵 - MCP 客户端（transport 抽象）
+// 支持 stdio 和 HTTP (Streamable) transport
+// ============================================================
+import { StdioTransport } from "./stdio-transport.js";
+import { HttpTransport } from "./http-transport.js";
+export class MCPClient {
+    config;
+    transport = null;
+    msgId = 0;
+    pending = new Map();
+    connected = false;
+    tools = [];
+    connectionTimeout;
+    callTimeout;
+    constructor(config, timeouts) {
+        this.config = config;
+        this.connectionTimeout = timeouts?.connection ?? 10_000;
+        this.callTimeout = timeouts?.call ?? 30_000;
+    }
+    async connect() {
+        try {
+            const transportType = this.config.transport ?? "stdio";
+            if (transportType === "http") {
+                if (!this.config.url) {
+                    return { serverName: this.config.name, tools: [], status: "failed", error: "HTTP transport requires url" };
+                }
+                this.transport = new HttpTransport(this.config.url, this.config.headers, this.callTimeout);
+            }
+            else {
+                const stdio = new StdioTransport(this.config.command, this.config.args, this.config.env);
+                // Wait for spawn
+                await Promise.race([
+                    stdio.ready(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("spawn timeout")), this.connectionTimeout)),
+                ]);
+                if (!stdio.isAlive()) {
+                    return { serverName: this.config.name, tools: [], status: "failed", error: "Failed to spawn process" };
+                }
+                this.transport = stdio;
+            }
+            // Wire up message/error/close handlers
+            this.transport.onMessage((msg) => this.handleMessage(msg));
+            this.transport.onError((err) => {
+                this.connected = false;
+                for (const [id, { reject }] of this.pending) {
+                    reject(err);
+                    this.pending.delete(id);
+                }
+            });
+            this.transport.onClose(() => {
+                this.connected = false;
+                for (const [id, { reject }] of this.pending) {
+                    reject(new Error("MCP transport closed"));
+                    this.pending.delete(id);
+                }
+            });
+            // 1. initialize
+            const initResult = await this.sendRequest("initialize", {
+                protocolVersion: "2024-11-05",
+                capabilities: {},
+                clientInfo: { name: "qling", version: "0.2" },
+            });
+            if (!initResult) {
+                return { serverName: this.config.name, tools: [], status: "failed", error: "initialize failed: no response" };
+            }
+            // 2. initialized notification
+            await this.sendNotification("notifications/initialized");
+            // 3. tools/list
+            const toolsResult = await this.sendRequest("tools/list", {});
+            if (toolsResult && typeof toolsResult === "object" && "tools" in toolsResult) {
+                const rawTools = toolsResult.tools;
+                this.tools = rawTools.map((t) => ({
+                    serverName: this.config.name,
+                    name: t.name,
+                    description: t.description ?? "",
+                    inputSchema: t.inputSchema ?? {},
+                }));
+            }
+            this.connected = true;
+            return { serverName: this.config.name, tools: this.tools, status: "connected" };
+        }
+        catch (err) {
+            return {
+                serverName: this.config.name,
+                tools: [],
+                status: "failed",
+                error: err.message,
+            };
+        }
+    }
+    async callTool(name, args) {
+        if (!this.connected || !this.transport) {
+            return {
+                tool_call_id: "mcp_" + name,
+                output: "[MCP Error] Server " + this.config.name + " not connected",
+                is_error: true,
+            };
+        }
+        try {
+            const result = await this.sendRequest("tools/call", { name, arguments: args });
+            if (!result) {
+                return {
+                    tool_call_id: "mcp_" + name,
+                    output: "[MCP Error] No response from " + this.config.name,
+                    is_error: true,
+                };
+            }
+            const r = result;
+            if (r.isError) {
+                const errorText = r.error?.message ?? r.content?.[0]?.text ?? JSON.stringify(r);
+                return {
+                    tool_call_id: "mcp_" + name,
+                    output: "[MCP Error] " + errorText,
+                    is_error: true,
+                };
+            }
+            const texts = r.content
+                ?.filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n") ?? JSON.stringify(r);
+            return {
+                tool_call_id: "mcp_" + name,
+                output: texts,
+                is_error: false,
+            };
+        }
+        catch (err) {
+            return {
+                tool_call_id: "mcp_" + name,
+                output: "[MCP Error] " + err.message,
+                is_error: true,
+            };
+        }
+    }
+    async disconnect() {
+        if (this.transport) {
+            try {
+                await this.sendNotification("shutdown");
+                await new Promise((r) => setTimeout(r, 500));
+            }
+            catch {
+                // ignore
+            }
+            await this.transport.close();
+            this.transport = null;
+            this.connected = false;
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getServerName() {
+        return this.config.name;
+    }
+    getTools() {
+        return [...this.tools];
+    }
+    // --- Private ---
+    handleMessage(msg) {
+        if (msg.id !== undefined && this.pending.has(msg.id)) {
+            const { resolve, reject } = this.pending.get(msg.id);
+            this.pending.delete(msg.id);
+            if (msg.error) {
+                reject(new Error("MCP error: " + msg.error.message));
+            }
+            else {
+                resolve(msg.result);
+            }
+        }
+    }
+    sendRequest(method, params, timeout) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.msgId;
+            const msg = { jsonrpc: "2.0", id, method, params };
+            this.pending.set(id, { resolve, reject });
+            try {
+                const result = this.transport.send(msg);
+                // If transport.send returns a promise (HTTP), handle errors
+                if (result && typeof result.catch === "function") {
+                    result.catch((err) => {
+                        if (this.pending.has(id)) {
+                            this.pending.delete(id);
+                            reject(err);
+                        }
+                    });
+                }
+            }
+            catch (err) {
+                this.pending.delete(id);
+                reject(err);
+                return;
+            }
+            const ms = timeout ?? (method === "initialize" ? this.connectionTimeout : this.callTimeout);
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error("MCP request timeout: " + method));
+                }
+            }, ms);
+        });
+    }
+    async sendNotification(method, params) {
+        if (!this.transport)
+            return;
+        const msg = { jsonrpc: "2.0", method, params };
+        await this.transport.send(msg);
+    }
+}

package/dist/mcp/http-transport.d.ts

@@ -0,0 +1,21 @@
+import type { MCPMessage } from "./types.js";
+export type MessageHandler = (msg: MCPMessage) => void;
+export type ErrorHandler = (err: Error) => void;
+export type CloseHandler = () => void;
+export declare class HttpTransport {
+    private url;
+    private headers;
+    private timeout;
+    private sessionId;
+    private messageHandler;
+    private errorHandler;
+    private closeHandler;
+    constructor(url: string, headers?: Record<string, string>, timeout?: number);
+    send(msg: MCPMessage): Promise<void>;
+    onMessage(handler: MessageHandler): void;
+    onError(handler: ErrorHandler): void;
+    onClose(handler: CloseHandler): void;
+    close(): Promise<void>;
+    private handleSSE;
+}
+//# sourceMappingURL=http-transport.d.ts.map

package/dist/mcp/http-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-transport.d.ts","sourceRoot":"","sources":["../../src/mcp/http-transport.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,UAAU,KAAK,IAAI,CAAC;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;AAChD,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC;AAEtC,qBAAa,aAAa;IACxB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,YAAY,CAA6B;gBAG/C,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,CAAC,EAAE,MAAM;IAOZ,IAAI,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAoD1C,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAIxC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAI9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAOd,SAAS;CAsCxB"}

package/dist/mcp/http-transport.js

@@ -0,0 +1,126 @@
+// ============================================================
+// 轻灵 - MCP Streamable HTTP transport
+// JSON-RPC 2.0 over HTTP POST with SSE support
+// ============================================================
+export class HttpTransport {
+    url;
+    headers;
+    timeout;
+    sessionId = null;
+    messageHandler = null;
+    errorHandler = null;
+    closeHandler = null;
+    constructor(url, headers, timeout) {
+        this.url = url;
+        this.headers = { ...headers };
+        this.timeout = timeout ?? 30_000;
+    }
+    async send(msg) {
+        const reqHeaders = {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...this.headers,
+        };
+        if (this.sessionId) {
+            reqHeaders["mcp-session-id"] = this.sessionId;
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(this.url, {
+                method: "POST",
+                headers: reqHeaders,
+                body: JSON.stringify(msg),
+                signal: controller.signal,
+            });
+            // Capture Mcp-Session-Id from initialize response
+            const sid = res.headers.get("mcp-session-id");
+            if (sid)
+                this.sessionId = sid;
+            const contentType = res.headers.get("content-type") ?? "";
+            if (contentType.includes("text/event-stream")) {
+                await this.handleSSE(res);
+            }
+            else if (contentType.includes("application/json")) {
+                const text = await res.text();
+                if (text.length > 0) {
+                    const body = JSON.parse(text);
+                    if (this.messageHandler)
+                        this.messageHandler(body);
+                }
+            }
+            else {
+                // Empty response (e.g., 202 Accepted for notifications)
+                if (res.status >= 400) {
+                    throw new Error(`MCP HTTP ${res.status}: ${await res.text()}`);
+                }
+            }
+        }
+        catch (err) {
+            if (err.name === "AbortError") {
+                throw new Error("MCP HTTP request timeout");
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+    }
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    async close() {
+        // HTTP transport is stateless, nothing to close
+        if (this.closeHandler)
+            this.closeHandler();
+    }
+    // --- Private ---
+    async handleSSE(res) {
+        const reader = res.body?.getReader();
+        if (!reader)
+            return;
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith(":"))
+                        continue; // skip empty lines and comments
+                    if (trimmed.startsWith("data: ")) {
+                        const data = trimmed.slice(6);
+                        if (data === "[DONE]")
+                            return;
+                        try {
+                            const msg = JSON.parse(data);
+                            if (this.messageHandler)
+                                this.messageHandler(msg);
+                        }
+                        catch {
+                            // skip malformed JSON
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (this.errorHandler)
+                this.errorHandler(err);
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/mcp/presets.d.ts

@@ -0,0 +1,22 @@
+export interface McpPreset {
+    id: string;
+    displayName: string;
+    description: string;
+    /** 写入 store 的 server 配置（不含 name 键） */
+    server: {
+        command: string;
+        args: string[];
+        env?: Record<string, string>;
+        enabled: boolean;
+        transport?: "stdio" | "http";
+        url?: string;
+        headers?: Record<string, string>;
+    };
+    /** 需要用户额外提供的 env 键（仅提示，不写密钥） */
+    requiredEnv?: string[];
+    tags?: string[];
+}
+export declare function listMcpPresets(): McpPreset[];
+export declare function getMcpPreset(idOrAlias: string): McpPreset | undefined;
+export declare function formatMcpPresetTable(): string[];
+//# sourceMappingURL=presets.d.ts.map

package/dist/mcp/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/mcp/presets.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,MAAM,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC7B,OAAO,EAAE,OAAO,CAAC;QACjB,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;QAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAClC,CAAC;IACF,gCAAgC;IAChC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAiED,wBAAgB,cAAc,IAAI,SAAS,EAAE,CAE5C;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAOrE;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAK/C"}

package/dist/mcp/presets.js

@@ -0,0 +1,80 @@
+// ============================================================
+// 轻灵 - MCP 服务器预设（可 qling mcp add <id>）
+// 预设为常见社区包；实际连接依赖本机 npx/网络
+// ============================================================
+const PRESETS = {
+    filesystem: {
+        id: "filesystem",
+        displayName: "Filesystem",
+        description: "官方 filesystem MCP（工作区文件访问）。",
+        server: {
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+            enabled: true,
+            transport: "stdio",
+        },
+        tags: ["local", "files"],
+    },
+    memory: {
+        id: "memory",
+        displayName: "Memory",
+        description: "官方 memory MCP（知识图谱式记忆）。",
+        server: {
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-memory"],
+            enabled: true,
+            transport: "stdio",
+        },
+        tags: ["memory"],
+    },
+    fetch: {
+        id: "fetch",
+        displayName: "Fetch",
+        description: "官方 fetch MCP（HTTP 抓取）。仍受本机网络策略约束。",
+        server: {
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-fetch"],
+            enabled: true,
+            transport: "stdio",
+        },
+        tags: ["network"],
+    },
+    git: {
+        id: "git",
+        displayName: "Git",
+        description: "社区 git MCP（仓库操作辅助）。",
+        server: {
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-git", "--repository", "."],
+            enabled: true,
+            transport: "stdio",
+        },
+        tags: ["git", "local"],
+    },
+    time: {
+        id: "time",
+        displayName: "Time",
+        description: "官方 time MCP（时区/时间查询）。",
+        server: {
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-time"],
+            enabled: true,
+            transport: "stdio",
+        },
+        tags: ["utility"],
+    },
+};
+export function listMcpPresets() {
+    return Object.values(PRESETS);
+}
+export function getMcpPreset(idOrAlias) {
+    const raw = String(idOrAlias ?? "").trim().toLowerCase();
+    if (!raw)
+        return undefined;
+    if (PRESETS[raw])
+        return PRESETS[raw];
+    return listMcpPresets().find((p) => p.id === raw || p.displayName.toLowerCase() === raw);
+}
+export function formatMcpPresetTable() {
+    return listMcpPresets().map((p, i) => `${String(i + 1).padStart(2, " ")}. ${p.id.padEnd(12)} ${p.displayName} — ${p.description}`);
+}

package/dist/mcp/registry.d.ts

@@ -0,0 +1,23 @@
+import { MCPClient } from "./client.js";
+import type { MCPServerConfig, MCPToolDefinition, MCPConnectResult } from "./types.js";
+import type { ToolResult } from "../types.js";
+export declare class MCPRegistry {
+    private clients;
+    private connectionTimeout;
+    private callTimeout;
+    constructor(timeouts?: {
+        connection?: number;
+        call?: number;
+    });
+    registerServer(config: MCPServerConfig): void;
+    connectAll(): Promise<MCPConnectResult[]>;
+    connectServer(name: string): Promise<MCPConnectResult>;
+    disconnectAll(): Promise<void>;
+    disconnectServer(name: string): Promise<void>;
+    getAllTools(): MCPToolDefinition[];
+    callTool(serverName: string, toolName: string, args: Record<string, unknown>): Promise<ToolResult>;
+    getConnectedServers(): string[];
+    getStatus(): Record<string, "connected" | "disconnected">;
+    getClient(serverName: string): MCPClient | undefined;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/mcp/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/mcp/registry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,WAAW,CAAS;gBAEhB,QAAQ,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;IAK7D,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAQvC,UAAU,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAWzC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAQtD,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAM9B,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnD,WAAW,IAAI,iBAAiB,EAAE;IAU5B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC;IAYxG,mBAAmB,IAAI,MAAM,EAAE;IAQ/B,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,cAAc,CAAC;IAQzD,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;CAGrD"}

package/dist/mcp/registry.js

@@ -0,0 +1,85 @@
+// ============================================================
+// 轻灵 - MCP 服务器注册表（生命周期管理）
+// ============================================================
+import { MCPClient } from "./client.js";
+export class MCPRegistry {
+    clients = new Map();
+    connectionTimeout;
+    callTimeout;
+    constructor(timeouts) {
+        this.connectionTimeout = timeouts?.connection ?? 10_000;
+        this.callTimeout = timeouts?.call ?? 30_000;
+    }
+    registerServer(config) {
+        const client = new MCPClient(config, {
+            connection: this.connectionTimeout,
+            call: this.callTimeout,
+        });
+        this.clients.set(config.name, client);
+    }
+    async connectAll() {
+        const results = [];
+        for (const [name, client] of this.clients) {
+            if (!client.isConnected()) {
+                const result = await client.connect();
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    async connectServer(name) {
+        const client = this.clients.get(name);
+        if (!client) {
+            return { serverName: name, tools: [], status: "failed", error: "Server not registered" };
+        }
+        return client.connect();
+    }
+    async disconnectAll() {
+        for (const client of this.clients.values()) {
+            await client.disconnect();
+        }
+    }
+    async disconnectServer(name) {
+        const client = this.clients.get(name);
+        if (client)
+            await client.disconnect();
+    }
+    getAllTools() {
+        const all = [];
+        for (const client of this.clients.values()) {
+            if (client.isConnected()) {
+                all.push(...client.getTools());
+            }
+        }
+        return all;
+    }
+    async callTool(serverName, toolName, args) {
+        const client = this.clients.get(serverName);
+        if (!client || !client.isConnected()) {
+            return {
+                tool_call_id: "mcp_" + serverName + "__" + toolName,
+                output: "[MCP Error] Server " + serverName + " not connected",
+                is_error: true,
+            };
+        }
+        return client.callTool(toolName, args);
+    }
+    getConnectedServers() {
+        const names = [];
+        for (const [name, client] of this.clients) {
+            if (client.isConnected())
+                names.push(name);
+        }
+        return names;
+    }
+    getStatus() {
+        const status = {};
+        for (const [name, client] of this.clients) {
+            status[name] = client.isConnected() ? "connected" : "disconnected";
+        }
+        return status;
+    }
+    getClient(serverName) {
+        return this.clients.get(serverName);
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { MCPMessage } from "./types.js";
+export type MessageHandler = (msg: MCPMessage) => void;
+export type ErrorHandler = (err: Error) => void;
+export type CloseHandler = () => void;
+export declare class StdioTransport {
+    private command;
+    private args;
+    private env?;
+    private proc;
+    private buffer;
+    private messageHandler;
+    private errorHandler;
+    private closeHandler;
+    private spawnPromise;
+    constructor(command: string, args: string[], env?: Record<string, string> | undefined);
+    ready(): Promise<void>;
+    isAlive(): boolean;
+    send(msg: MCPMessage): void;
+    onMessage(handler: MessageHandler): void;
+    onError(handler: ErrorHandler): void;
+    onClose(handler: CloseHandler): void;
+    close(): Promise<void>;
+    private processBuffer;
+}
+//# sourceMappingURL=stdio-transport.d.ts.map