@yh-ui/ai-sdk 0.1.21

package/dist/mcp-server.mjs

@@ -0,0 +1,234 @@
+import { ref, onUnmounted } from "vue";
+export class MCPServer {
+  config;
+  tools = /* @__PURE__ */ new Map();
+  requestHandlers = /* @__PURE__ */ new Map();
+  isRunning = false;
+  constructor(options) {
+    this.config = options.config;
+    if (options.tools) {
+      for (const tool of options.tools) {
+        this.tools.set(tool.name, tool);
+      }
+    }
+    this.registerRequestHandler("initialize", this.handleInitialize.bind(this));
+    this.registerRequestHandler("tools/list", this.handleToolsList.bind(this));
+    this.registerRequestHandler("tools/call", this.handleToolsCall.bind(this));
+    this.registerRequestHandler("ping", this.handlePing.bind(this));
+    options.onStart?.(this);
+  }
+  registerRequestHandler(method, handler) {
+    this.requestHandlers.set(method, handler);
+  }
+  generateId() {
+    return Math.random().toString(36).substring(2, 9);
+  }
+  // ── Request Handlers ─────────────────────────────────────────────────────
+  handleInitialize(params) {
+    const initParams = params;
+    return {
+      protocolVersion: initParams?.protocolVersion || "2024-11-05",
+      capabilities: {
+        tools: {}
+      },
+      serverInfo: {
+        name: this.config.name,
+        version: this.config.version
+      }
+    };
+  }
+  handleToolsList() {
+    const tools = Array.from(this.tools.values()).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+    return { tools };
+  }
+  async handleToolsCall(params) {
+    const callParams = params;
+    if (!callParams?.name) {
+      throw new Error("Missing tool name");
+    }
+    const tool = this.tools.get(callParams.name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${callParams.name}`);
+    }
+    try {
+      const result = await tool.execute(callParams.arguments || {});
+      return { content: result };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: errorMessage }],
+        isError: true
+      };
+    }
+  }
+  handlePing() {
+    return { pong: true };
+  }
+  // ── Public API ───────────────────────────────────────────────────────────
+  /** Add a tool to the server */
+  addTool(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /** Remove a tool from the server */
+  removeTool(name) {
+    return this.tools.delete(name);
+  }
+  /** Get all tools */
+  getTools() {
+    return Array.from(this.tools.values());
+  }
+  /** Check if server is running */
+  getRunning() {
+    return this.isRunning;
+  }
+  /** Set running state */
+  setRunning(running) {
+    this.isRunning = running;
+  }
+  /** Handle a JSON-RPC request */
+  async handleRequest(request) {
+    const { method, params, id } = request;
+    const handler = this.requestHandlers.get(method);
+    if (!handler) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32601,
+          // Method not found
+          message: `Method not found: ${method}`
+        }
+      };
+    }
+    try {
+      const result = await handler(params);
+      return {
+        jsonrpc: "2.0",
+        id,
+        result
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32e3,
+          message: errorMessage
+        }
+      };
+    }
+  }
+  /** Handle a batch of JSON-RPC requests */
+  async handleBatch(requests) {
+    return Promise.all(requests.map((req) => this.handleRequest(req)));
+  }
+  /** Cleanup */
+  destroy() {
+    this.tools.clear();
+    this.requestHandlers.clear();
+    this.isRunning = false;
+  }
+}
+export function useMCPServer(options) {
+  const config = {
+    name: options.name,
+    version: options.version,
+    capabilities: {
+      tools: true
+    }
+  };
+  const tools = ref(options.tools || []);
+  const isRunning = ref(false);
+  const server = new MCPServer({
+    config,
+    tools: options.tools,
+    onStart: () => {
+      isRunning.value = true;
+    },
+    onStop: () => {
+      isRunning.value = false;
+    }
+  });
+  const addTool = (tool) => {
+    server.addTool(tool);
+    tools.value = server.getTools();
+    options.onToolsChange?.(tools.value);
+  };
+  const removeTool = (name) => {
+    const result = server.removeTool(name);
+    tools.value = server.getTools();
+    options.onToolsChange?.(tools.value);
+    return result;
+  };
+  const handleRequest = async (request) => {
+    return server.handleRequest(request);
+  };
+  const start = () => {
+    server.setRunning(true);
+    isRunning.value = true;
+  };
+  const stop = () => {
+    server.setRunning(false);
+    isRunning.value = false;
+    server.destroy();
+  };
+  onUnmounted(() => {
+    stop();
+  });
+  return {
+    server,
+    config,
+    tools,
+    isRunning,
+    addTool,
+    removeTool,
+    handleRequest,
+    start,
+    stop
+  };
+}
+export function createMCPServerHTTPHandler(options) {
+  const { server, handleRequest } = useMCPServer(options);
+  return async function(request) {
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST",
+          "Access-Control-Allow-Headers": "Content-Type"
+        }
+      });
+    }
+    try {
+      const body = await request.json();
+      if (Array.isArray(body)) {
+        const responses = await server.handleBatch(body);
+        return new Response(JSON.stringify(responses), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const response = await handleRequest(body);
+      return new Response(JSON.stringify(response), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return new Response(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32603,
+            message: errorMessage
+          }
+        }),
+        { status: 500, headers: { "Content-Type": "application/json" } }
+      );
+    }
+  };
+}

package/dist/mcp.cjs

@@ -0,0 +1,370 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMCPClient = useMCPClient;
+exports.useMCPTools = useMCPTools;
+var _vue = require("vue");
+let requestId = 0;
+function createJSONRPCRequest(method, params) {
+  return {
+    jsonrpc: "2.0",
+    id: ++requestId,
+    method,
+    params
+  };
+}
+class MCPHTTPTransport {
+  serverUrl;
+  timeout;
+  constructor(serverUrl, timeout = 3e4) {
+    this.serverUrl = serverUrl;
+    this.timeout = timeout;
+  }
+  async sendRequest(method, params) {
+    const response = await fetch(this.serverUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(createJSONRPCRequest(method, params)),
+      signal: AbortSignal.timeout(this.timeout)
+    });
+    if (!response.ok) {
+      throw new Error(`MCP HTTP Error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`MCP Error: ${data.error.message}`);
+    }
+    return data.result;
+  }
+}
+class MCPStdioTransport {
+  command;
+  args;
+  env;
+  process = null;
+  requestMap = /* @__PURE__ */new Map();
+  notificationHandlers = /* @__PURE__ */new Map();
+  messageBuffer = "";
+  initialized;
+  constructor(command, args = [], env = {}) {
+    this.command = command;
+    this.args = args;
+    this.env = env;
+    this.initialized = this.init();
+  }
+  init() {
+    return new Promise((resolve, reject) => {
+      try {
+        const {
+          spawn
+        } = require("child_process");
+        this.process = spawn(this.command, this.args, {
+          env: {
+            ...process.env,
+            ...this.env
+          },
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        this.process.on("error", err => {
+          reject(err);
+        });
+        this.process.on("close", () => {
+          this.process = null;
+        });
+        this.process.stdout?.on("data", data => {
+          this.handleData(data.toString());
+        });
+        this.process.stderr?.on("data", data => {
+          console.error("[MCP Stdio]", data.toString());
+        });
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  handleData(data) {
+    this.messageBuffer += data;
+    let newlineIndex;
+    while ((newlineIndex = this.messageBuffer.indexOf("\n")) !== -1) {
+      const line = this.messageBuffer.slice(0, newlineIndex);
+      this.messageBuffer = this.messageBuffer.slice(newlineIndex + 1);
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        this.handleMessage(message);
+      } catch {}
+    }
+  }
+  handleMessage(message) {
+    if ("id" in message && message.id !== void 0) {
+      const pending = this.requestMap.get(message.id);
+      if (pending) {
+        this.requestMap.delete(message.id);
+        if ("error" in message && message.error) {
+          pending.reject(new Error(message.error.message));
+        } else {
+          pending.resolve(message.result);
+        }
+      }
+    } else if ("method" in message) {
+      const handler = this.notificationHandlers.get(message.method);
+      if (handler) {
+        handler(message.params);
+      }
+    }
+  }
+  async sendRequest(method, params) {
+    await this.initialized;
+    if (!this.process) {
+      throw new Error("MCP process not running");
+    }
+    const request = createJSONRPCRequest(method, params);
+    const requestId2 = request.id;
+    return new Promise((resolve, reject) => {
+      this.requestMap.set(requestId2, {
+        resolve,
+        reject
+      });
+      this.process.stdin?.write(JSON.stringify(request) + "\n");
+      setTimeout(() => {
+        if (this.requestMap.has(requestId2)) {
+          this.requestMap.delete(requestId2);
+          reject(new Error(`MCP request timeout: ${method}`));
+        }
+      }, 3e4);
+    });
+  }
+  onNotification(method, handler) {
+    this.notificationHandlers.set(method, handler);
+  }
+  async close() {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+  }
+}
+function useMCPClient(options) {
+  const {
+    config,
+    autoConnect = true,
+    clientName = "@yh-ui/ai-sdk",
+    clientVersion = "1.0.0",
+    onToolsUpdate,
+    onConnectionChange
+  } = options;
+  const state = (0, _vue.shallowRef)({
+    isConnected: false,
+    isConnecting: false,
+    error: null,
+    tools: []
+  });
+  const isCallingTool = (0, _vue.ref)(false);
+  const transport = (0, _vue.shallowRef)(null);
+  const connect = async () => {
+    if (state.value.isConnected || state.value.isConnecting) {
+      return;
+    }
+    state.value = {
+      ...state.value,
+      isConnecting: true,
+      error: null
+    };
+    try {
+      let t;
+      if (config.serverUrl) {
+        t = new MCPHTTPTransport(config.serverUrl, config.timeout);
+      } else if (config.command) {
+        t = new MCPStdioTransport(config.command, config.args, config.env);
+      } else {
+        throw new Error("Invalid MCP config: must provide either serverUrl or command");
+      }
+      transport.value = t;
+      const _initResult = await t.sendRequest("initialize", {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: {
+          name: clientName,
+          version: clientVersion
+        }
+      });
+      await t.sendRequest("initialized", {});
+      const toolsResult = await t.sendRequest("tools/list", {});
+      const tools = toolsResult.tools.map(tool => ({
+        name: tool.name,
+        description: tool.description || "",
+        inputSchema: tool.inputSchema
+      }));
+      state.value = {
+        isConnected: true,
+        isConnecting: false,
+        error: null,
+        tools
+      };
+      onToolsUpdate?.(tools);
+      onConnectionChange?.(true);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      state.value = {
+        isConnected: false,
+        isConnecting: false,
+        error,
+        tools: []
+      };
+      onConnectionChange?.(false);
+      throw error;
+    }
+  };
+  const disconnect = async () => {
+    const t = transport.value;
+    if (t) {
+      if ("close" in t) {
+        await t.close();
+      }
+      transport.value = null;
+    }
+    state.value = {
+      isConnected: false,
+      isConnecting: false,
+      error: null,
+      tools: []
+    };
+    onConnectionChange?.(false);
+  };
+  const callTool = async (name, args = {}) => {
+    if (!state.value.isConnected) {
+      throw new Error("MCP client not connected");
+    }
+    const t = transport.value;
+    if (!t) {
+      throw new Error("MCP transport not initialized");
+    }
+    isCallingTool.value = true;
+    try {
+      const result = await t.sendRequest("tools/call", {
+        name,
+        arguments: args
+      });
+      const textContent = result.content.find(c => c.type === "text");
+      if (result.isError) {
+        throw new Error(textContent?.text || "Tool execution failed");
+      }
+      if (textContent?.text) {
+        try {
+          return JSON.parse(textContent.text);
+        } catch {
+          return textContent.text;
+        }
+      }
+      return result;
+    } finally {
+      isCallingTool.value = false;
+    }
+  };
+  if (autoConnect) {
+    connect();
+  }
+  (0, _vue.onUnmounted)(() => {
+    disconnect();
+  });
+  return {
+    state,
+    connect,
+    disconnect,
+    callTool,
+    isCallingTool
+  };
+}
+function useMCPTools(options) {
+  const {
+    servers,
+    autoConnect = true,
+    onServerConnect
+  } = options;
+  const allTools = (0, _vue.ref)([]);
+  const serverStates = (0, _vue.ref)(servers.map((config, index) => ({
+    index,
+    config,
+    isConnected: false,
+    tools: [],
+    error: null
+  })));
+  const clients = [];
+  for (let i = 0; i < servers.length; i++) {
+    const serverState = serverStates.value[i];
+    const client = useMCPClient({
+      config: servers[i],
+      autoConnect: false,
+      onToolsUpdate: tools => {
+        serverState.tools = tools;
+        updateAllTools();
+      },
+      onConnectionChange: isConnected => {
+        serverState.isConnected = isConnected;
+      }
+    });
+    clients.push({
+      get state() {
+        return client.state.value;
+      },
+      connect: client.connect,
+      disconnect: client.disconnect
+    });
+  }
+  function updateAllTools() {
+    const tools = [];
+    for (const server of serverStates.value) {
+      if (server.isConnected) {
+        tools.push(...server.tools);
+      }
+    }
+    allTools.value = tools;
+  }
+  const connectAll = async () => {
+    for (let i = 0; i < clients.length; i++) {
+      const client = clients[i];
+      try {
+        await client.connect();
+        const tools = serverStates.value[i].tools;
+        onServerConnect?.(i, tools);
+      } catch (err) {
+        serverStates.value[i].error = err instanceof Error ? err : new Error(String(err));
+      }
+    }
+  };
+  const disconnectAll = async () => {
+    for (const client of clients) {
+      await client.disconnect();
+    }
+  };
+  const callTool = async (name, args = {}) => {
+    for (const server of serverStates.value) {
+      const tool = server.tools.find(t => t.name === name);
+      if (tool) {
+        const clientIndex = serverStates.value.indexOf(server);
+        const _client = clients[clientIndex];
+        const mcpClient = useMCPClient({
+          config: server.config,
+          autoConnect: false
+        });
+        return mcpClient.callTool(name, args);
+      }
+    }
+    throw new Error(`Tool not found: ${name}`);
+  };
+  if (autoConnect) {
+    connectAll();
+  }
+  return {
+    allTools,
+    serverStates,
+    connectAll,
+    disconnectAll,
+    callTool
+  };
+}