@yh-ui/ai-sdk 0.1.21

package/dist/mcp.d.ts

@@ -0,0 +1,206 @@
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface MCPConnectionConfig {
+    /** HTTP Server URL */
+    serverUrl?: string;
+    /** Stdio Command */
+    command?: string;
+    /** Stdio Arguments */
+    args?: string[];
+    /** Stdio Environment */
+    env?: Record<string, string>;
+    /** Timeout for requests */
+    timeout?: number;
+}
+export interface MCPClientState {
+    isConnected: boolean;
+    isConnecting: boolean;
+    error: Error | null;
+    tools: MCPTool[];
+}
+export interface MCPInitializeParams {
+    protocolVersion: string;
+    capabilities: Record<string, unknown>;
+    clientInfo: {
+        name: string;
+        version: string;
+    };
+}
+export interface MCPToolsListParams {
+}
+export interface MCPToolsCallParams {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface UseMCPClientOptions {
+    /** MCP Server configuration */
+    config: MCPConnectionConfig;
+    /** Auto-connect on mount */
+    autoConnect?: boolean;
+    /** Client name for initialization */
+    clientName?: string;
+    /** Client version for initialization */
+    clientVersion?: string;
+    /** Callback when tools are updated */
+    onToolsUpdate?: (tools: MCPTool[]) => void;
+    /** Callback when connection state changes */
+    onConnectionChange?: (isConnected: boolean) => void;
+}
+export interface UseMCPClientReturn {
+    /** Connection state */
+    state: MCPClientState;
+    /** Connect to MCP server */
+    connect: () => Promise<void>;
+    /** Disconnect from MCP server */
+    disconnect: () => Promise<void>;
+    /** Call a tool */
+    callTool: <T = unknown>(name: string, args?: Record<string, unknown>) => Promise<T>;
+    /** Tool call loading state */
+    isCallingTool: {
+        value: boolean;
+    };
+}
+/**
+ * useMCPClient - MCP Client Hook
+ *
+ * 连接外部 MCP Server 并调用其工具
+ *
+ * @example
+ * ```ts
+ * const { state, connect, disconnect, callTool } = useMCPClient({
+ *   config: {
+ *     serverUrl: 'http://localhost:3000/mcp'
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using stdio transport
+ * const { state, connect, callTool } = useMCPClient({
+ *   config: {
+ *     command: 'npx',
+ *     args: ['-y', '@modelcontextprotocol/server-filesystem', './data']
+ *   }
+ * })
+ * ```
+ */
+export declare function useMCPClient(options: UseMCPClientOptions): {
+    state: import("vue").ShallowRef<MCPClientState, MCPClientState>;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    callTool: <T = unknown>(name: string, args?: Record<string, unknown>) => Promise<T>;
+    isCallingTool: import("vue").Ref<boolean, boolean>;
+};
+export interface UseMCPToolsOptions {
+    /** MCP Server configurations (支持多个 server) */
+    servers: MCPConnectionConfig[];
+    /** Auto-connect on mount */
+    autoConnect?: boolean;
+    /** Convert MCP tools to AI SDK format */
+    convertToAITools?: boolean;
+    /** Callback when any server connects */
+    onServerConnect?: (serverIndex: number, tools: MCPTool[]) => void;
+}
+export interface MCPServerState {
+    index: number;
+    config: MCPConnectionConfig;
+    isConnected: boolean;
+    tools: MCPTool[];
+    error: Error | null;
+}
+export interface UseMCPToolsReturn {
+    /** All available tools from all servers */
+    allTools: {
+        value: MCPTool[];
+    };
+    /** Individual server states */
+    serverStates: {
+        value: MCPServerState[];
+    };
+    /** Connect to all servers */
+    connectAll: () => Promise<void>;
+    /** Disconnect from all servers */
+    disconnectAll: () => Promise<void>;
+    /** Call tool by name (resolves to correct server) */
+    callTool: <T = unknown>(name: string, args?: Record<string, unknown>) => Promise<T>;
+}
+/**
+ * useMCPTools - 管理多个 MCP Server 的工具
+ *
+ * @example
+ * ```ts
+ * const { allTools, serverStates, callTool } = useMCPTools({
+ *   servers: [
+ *     { serverUrl: 'http://localhost:3001/mcp' },
+ *     { command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', './data'] }
+ *   ]
+ * })
+ * ```
+ */
+export declare function useMCPTools(options: UseMCPToolsOptions): {
+    allTools: import("vue").Ref<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    }[], MCPTool[] | {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    }[]>;
+    serverStates: import("vue").Ref<{
+        index: number;
+        config: {
+            serverUrl?: string
+            /** Stdio Command */
+             | undefined;
+            command?: string
+            /** Stdio Arguments */
+             | undefined;
+            args?: string[]
+            /** Stdio Environment */
+             | undefined;
+            env?: Record<string, string>
+            /** Timeout for requests */
+             | undefined;
+            timeout?: number | undefined;
+        };
+        isConnected: boolean;
+        tools: {
+            name: string;
+            description: string;
+            inputSchema: Record<string, unknown>;
+        }[];
+        error: Error | null;
+    }[], MCPServerState[] | {
+        index: number;
+        config: {
+            serverUrl?: string
+            /** Stdio Command */
+             | undefined;
+            command?: string
+            /** Stdio Arguments */
+             | undefined;
+            args?: string[]
+            /** Stdio Environment */
+             | undefined;
+            env?: Record<string, string>
+            /** Timeout for requests */
+             | undefined;
+            timeout?: number | undefined;
+        };
+        isConnected: boolean;
+        tools: {
+            name: string;
+            description: string;
+            inputSchema: Record<string, unknown>;
+        }[];
+        error: Error | null;
+    }[]>;
+    connectAll: () => Promise<void>;
+    disconnectAll: () => Promise<void>;
+    callTool: <T = unknown>(name: string, args?: Record<string, unknown>) => Promise<T>;
+};

package/dist/mcp.mjs

@@ -0,0 +1,354 @@
+import { ref, shallowRef, onUnmounted } from "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;
+    }
+  }
+}
+export function useMCPClient(options) {
+  const {
+    config,
+    autoConnect = true,
+    clientName = "@yh-ui/ai-sdk",
+    clientVersion = "1.0.0",
+    onToolsUpdate,
+    onConnectionChange
+  } = options;
+  const state = shallowRef({
+    isConnected: false,
+    isConnecting: false,
+    error: null,
+    tools: []
+  });
+  const isCallingTool = ref(false);
+  const transport = 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();
+  }
+  onUnmounted(() => {
+    disconnect();
+  });
+  return {
+    state,
+    connect,
+    disconnect,
+    callTool,
+    isCallingTool
+  };
+}
+export function useMCPTools(options) {
+  const { servers, autoConnect = true, onServerConnect } = options;
+  const allTools = ref([]);
+  const serverStates = 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
+  };
+}

package/dist/observability.cjs

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLangSmithExporter = createLangSmithExporter;
+exports.createOTelConsoleExporter = createOTelConsoleExporter;
+exports.createObservabilityManager = createObservabilityManager;
+exports.toOTelSpan = toOTelSpan;
+function createOTelConsoleExporter() {
+  return {
+    async exportSpans(spans) {
+      const payload = {
+        resourceSpans: [{
+          resource: {
+            attributes: [{
+              key: "service.name",
+              value: {
+                stringValue: "yh-ai-sdk"
+              }
+            }]
+          },
+          scopeSpans: [{
+            spans
+          }]
+        }]
+      };
+      console.log("[OTel Export]", JSON.stringify(payload, null, 2));
+    }
+  };
+}
+function createLangSmithExporter(config) {
+  const {
+    apiUrl = "https://api.langsmith.com/v1/runs",
+    apiKey,
+    projectName = "yh-ai-sdk"
+  } = config;
+  return {
+    async exportSpans(spans) {
+      if (!apiKey) {
+        console.warn("[LangSmith] No API key configured, skipping export");
+        return;
+      }
+      const runs = spans.map(span => {
+        const inputs = {};
+        const outputs = {};
+        let runType = "chain";
+        for (const attr of span.attributes) {
+          const key = attr.key;
+          const val = attr.value.stringValue ?? attr.value.intValue ?? attr.value.boolValue;
+          if (key.startsWith("input.")) {
+            inputs[key.slice(6)] = val;
+          } else if (key.startsWith("output.")) {
+            outputs[key.slice(7)] = val;
+          } else if (key === "run_type") {
+            runType = val;
+          }
+        }
+        return {
+          id: span.spanId,
+          name: span.name,
+          run_type: runType,
+          start_time: span.startTimeUnixNano / 1e6,
+          end_time: span.endTimeUnixNano ? span.endTimeUnixNano / 1e6 : Date.now(),
+          inputs,
+          outputs: Object.keys(outputs).length ? outputs : void 0,
+          error: span.status?.code === 2 ? span.status.message : void 0,
+          parent_run_id: span.parentSpanId,
+          metadata: {
+            project: projectName
+          }
+        };
+      });
+      try {
+        await fetch(apiUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            runs
+          })
+        });
+      } catch (err) {
+        console.error("[LangSmith] Export failed:", err);
+      }
+    }
+  };
+}
+function toOTelSpan(span, traceId) {
+  const startNs = span.startTime.getTime() * 1e6;
+  const endNs = span.endTime ? span.endTime.getTime() * 1e6 : Date.now() * 1e6;
+  const attrs = Object.entries(span.attributes).map(([key, value]) => ({
+    key,
+    value: typeof value === "string" ? {
+      stringValue: value
+    } : typeof value === "number" ? {
+      intValue: value
+    } : {
+      boolValue: Boolean(value)
+    }
+  }));
+  const events = span.events.map(e => ({
+    timeUnixNano: e.timestamp.getTime() * 1e6,
+    name: e.type,
+    attributes: Object.entries(e.data).map(([k, v]) => ({
+      key: k,
+      value: {
+        stringValue: String(v)
+      }
+    }))
+  }));
+  return {
+    traceId,
+    spanId: span.id,
+    name: span.name,
+    kind: "INTERNAL",
+    startTimeUnixNano: startNs,
+    endTimeUnixNano: endNs,
+    status: span.events.some(e => e.type === "error") ? {
+      code: 2,
+      message: "Error occurred"
+    } : {
+      code: 0
+    },
+    attributes: attrs,
+    events
+  };
+}
+function createObservabilityManager(config) {
+  const exporters = config?.exporters || [];
+  const traceId = config?.traceId || Math.random().toString(16).slice(2).padStart(32, "0");
+  return {
+    addExporter(exporter) {
+      exporters.push(exporter);
+    },
+    async flush() {
+      await Promise.all(exporters.map(async ex => {
+        if ("flush" in ex && typeof ex.flush === "function") {
+          await ex.flush();
+        }
+      }));
+    },
+    async export(tracerSpans) {
+      const otelSpans = tracerSpans.map(s => toOTelSpan(s, traceId));
+      await Promise.all(exporters.map(ex => ex.exportSpans(otelSpans)));
+    }
+  };
+}