@yh-ui/ai-sdk 0.1.21

package/dist/loaders.d.ts

@@ -0,0 +1,58 @@
+/**
+ * YH-UI AI SDK - 文档加载器
+ *
+ * 支持 Markdown / 纯文本 / 结构化拆分。
+ * PDF、DOCX 通过接口预留，可由可选依赖或用户实现。
+ */
+export interface LoadedDocument {
+    content: string;
+    metadata?: Record<string, unknown>;
+    source?: string;
+}
+export interface DocumentLoaderOptions {
+    /** 是否按段落/块拆分 */
+    split?: boolean;
+    /** 块大小（字符数） */
+    chunkSize?: number;
+    /** 块重叠（字符数） */
+    chunkOverlap?: number;
+}
+/**
+ * 文本加载器：直接使用字符串
+ */
+export declare function createTextLoader(content: string, metadata?: Record<string, unknown>): LoadedDocument;
+/**
+ * Markdown 加载器：按标题或段落拆分
+ */
+export declare function loadMarkdown(markdown: string, options?: DocumentLoaderOptions): LoadedDocument[];
+/**
+ * 通用分块：按固定大小拆分，带重叠
+ */
+export declare function chunkText(text: string, options?: {
+    chunkSize?: number;
+    chunkOverlap?: number;
+}): LoadedDocument[];
+/**
+ * PDF 加载器接口（由用户或可选包实现）
+ * 可选依赖：pdf-parse / pdfjs-dist 等
+ */
+export type PDFLoader = (input: string | ArrayBuffer | Buffer) => Promise<LoadedDocument[]>;
+/**
+ * DOCX 加载器接口（由用户或可选包实现）
+ * 可选依赖：mammoth 等
+ */
+export type DOCXLoader = (input: string | ArrayBuffer | Buffer) => Promise<LoadedDocument[]>;
+/**
+ * 创建复合加载器：根据扩展名选择策略
+ */
+export declare function createFileLoader(options: {
+    pdf?: PDFLoader;
+    docx?: DOCXLoader;
+    chunkSize?: number;
+    chunkOverlap?: number;
+}): {
+    loadFromText(content: string): Promise<LoadedDocument[]>;
+    loadFromMarkdown(content: string): Promise<LoadedDocument[]>;
+    loadFromPDF(input: string | ArrayBuffer | Buffer): Promise<LoadedDocument[]>;
+    loadFromDOCX(input: string | ArrayBuffer | Buffer): Promise<LoadedDocument[]>;
+};

package/dist/loaders.mjs

@@ -0,0 +1,76 @@
+export function createTextLoader(content, metadata) {
+  return { content: content.trim(), metadata };
+}
+export function loadMarkdown(markdown, options = {}) {
+  const chunkSize = options.chunkSize ?? 1e3;
+  const chunkOverlap = Math.min(options.chunkOverlap ?? 200, Math.floor(chunkSize * 0.5));
+  const { split = true } = options;
+  if (!split) {
+    return [{ content: markdown.trim(), metadata: { type: "markdown" } }];
+  }
+  const blocks = [];
+  const lines = markdown.split(/\r?\n/);
+  let current = "";
+  for (const line of lines) {
+    const isHeading = /^#{1,6}\s/.test(line);
+    if (isHeading && current.length >= chunkSize) {
+      if (current.trim()) blocks.push(current.trim());
+      current = line + "\n";
+    } else {
+      current += line + "\n";
+      if (current.length >= chunkSize) {
+        if (current.trim()) blocks.push(current.trim());
+        current = current.slice(-chunkOverlap);
+      }
+    }
+  }
+  if (current.trim()) blocks.push(current.trim());
+  return blocks.map((content, i) => ({
+    content,
+    metadata: { type: "markdown", index: i }
+  }));
+}
+export function chunkText(text, options = {}) {
+  const chunkSize = options.chunkSize ?? 800;
+  const chunkOverlap = Math.min(options.chunkOverlap ?? 100, Math.floor(chunkSize * 0.5));
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const end = Math.min(start + chunkSize, text.length);
+    let slice = text.slice(start, end);
+    if (end < text.length) {
+      const lastSpace = slice.lastIndexOf(" ");
+      if (lastSpace > chunkSize / 2) slice = slice.slice(0, lastSpace + 1);
+    }
+    if (slice.trim()) {
+      chunks.push({ content: slice.trim(), metadata: { index: chunks.length } });
+    }
+    const nextStart = start + slice.length - chunkOverlap;
+    start = nextStart > start ? nextStart : start + slice.length;
+    if (start >= text.length) break;
+  }
+  return chunks;
+}
+export function createFileLoader(options) {
+  const { pdf, docx, chunkSize = 800, chunkOverlap = 100 } = options;
+  return {
+    async loadFromText(content) {
+      return chunkText(content, { chunkSize, chunkOverlap });
+    },
+    async loadFromMarkdown(content) {
+      return loadMarkdown(content, { chunkSize, chunkOverlap });
+    },
+    async loadFromPDF(input) {
+      if (!pdf)
+        throw new Error("PDF loader not configured. Provide options.pdf or install a PDF library.");
+      return pdf(input);
+    },
+    async loadFromDOCX(input) {
+      if (!docx)
+        throw new Error(
+          "DOCX loader not configured. Provide options.docx or install a DOCX library."
+        );
+      return docx(input);
+    }
+  };
+}

package/dist/mcp-server.cjs

@@ -0,0 +1,265 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MCPServer = void 0;
+exports.createMCPServerHTTPHandler = createMCPServerHTTPHandler;
+exports.useMCPServer = useMCPServer;
+var _vue = require("vue");
+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;
+  }
+}
+exports.MCPServer = MCPServer;
+function useMCPServer(options) {
+  const config = {
+    name: options.name,
+    version: options.version,
+    capabilities: {
+      tools: true
+    }
+  };
+  const tools = (0, _vue.ref)(options.tools || []);
+  const isRunning = (0, _vue.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();
+  };
+  (0, _vue.onUnmounted)(() => {
+    stop();
+  });
+  return {
+    server,
+    config,
+    tools,
+    isRunning,
+    addTool,
+    removeTool,
+    handleRequest,
+    start,
+    stop
+  };
+}
+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-server.d.ts

@@ -0,0 +1,186 @@
+export interface MCPServerTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    /** Execute function - returns content array per MCP spec */
+    execute: (args: Record<string, unknown>) => Promise<MCPToolContent[]>;
+}
+export interface MCPToolContent {
+    type: 'text' | 'image' | 'resource';
+    text?: string;
+    data?: string;
+    mimeType?: string;
+}
+export interface MCPServerConfig {
+    /** Server name */
+    name: string;
+    /** Server version */
+    version: string;
+    /** Server capabilities */
+    capabilities?: {
+        tools?: boolean;
+        resources?: boolean;
+        prompts?: boolean;
+    };
+}
+export interface MCPServerOptions {
+    /** Server configuration */
+    config: MCPServerConfig;
+    /** Tools to expose */
+    tools?: MCPServerTool[];
+    /** Callback when server starts */
+    onStart?: (server: MCPServer) => void;
+    /** Callback when server stops */
+    onStop?: () => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+export type MCPServerTransport = 'http' | 'stdio';
+export interface MCPHTTPHandler {
+    (request: MCPJSONRPCRequest): Promise<MCPJSONRPCResponse>;
+}
+export interface MCPJSONRPCRequest {
+    jsonrpc: '2.0';
+    id: number | string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface MCPJSONRPCResponse {
+    jsonrpc: '2.0';
+    id: number | string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface MCPJSONRPCNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown>;
+}
+export declare class MCPServer {
+    readonly config: MCPServerConfig;
+    private tools;
+    private requestHandlers;
+    private isRunning;
+    constructor(options: MCPServerOptions);
+    private registerRequestHandler;
+    private generateId;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+    private handlePing;
+    /** Add a tool to the server */
+    addTool(tool: MCPServerTool): void;
+    /** Remove a tool from the server */
+    removeTool(name: string): boolean;
+    /** Get all tools */
+    getTools(): MCPServerTool[];
+    /** Check if server is running */
+    getRunning(): boolean;
+    /** Set running state */
+    setRunning(running: boolean): void;
+    /** Handle a JSON-RPC request */
+    handleRequest(request: MCPJSONRPCRequest): Promise<MCPJSONRPCResponse>;
+    /** Handle a batch of JSON-RPC requests */
+    handleBatch(requests: MCPJSONRPCRequest[]): Promise<MCPJSONRPCResponse[]>;
+    /** Cleanup */
+    destroy(): void;
+}
+export interface UseMCPServerOptions {
+    /** Server name */
+    name: string;
+    /** Server version */
+    version: string;
+    /** Initial tools */
+    tools?: MCPServerTool[];
+    /** Callback when tools change */
+    onToolsChange?: (tools: MCPServerTool[]) => void;
+}
+export interface UseMCPServerReturn {
+    /** Server instance */
+    server: MCPServer;
+    /** Server config */
+    config: MCPServerConfig;
+    /** Tools list (reactive) */
+    tools: {
+        value: MCPServerTool[];
+    };
+    /** Running state */
+    isRunning: {
+        value: boolean;
+    };
+    /** Add a tool */
+    addTool: (tool: MCPServerTool) => void;
+    /** Remove a tool */
+    removeTool: (name: string) => boolean;
+    /** Handle HTTP request */
+    handleRequest: (request: MCPJSONRPCRequest) => Promise<MCPJSONRPCResponse>;
+    /** Start server */
+    start: () => void;
+    /** Stop server */
+    stop: () => void;
+}
+/**
+ * useMCPServer - MCP Server Hook
+ *
+ * 将 AI 应用作为 MCP Server 暴露工具
+ *
+ * @example
+ * ```ts
+ * const { server, addTool, tools } = useMCPServer({
+ *   name: 'my-ai-server',
+ *   version: '1.0.0',
+ *   tools: [
+ *     {
+ *       name: 'get_weather',
+ *       description: 'Get weather for a city',
+ *       inputSchema: {
+ *         type: 'object',
+ *         properties: {
+ *           city: { type: 'string', description: 'City name' }
+ *         },
+ *         required: ['city']
+ *       },
+ *       execute: async ({ city }) => {
+ *         return [{ type: 'text', text: `Weather in ${city}: Sunny, 25°C` }]
+ *       }
+ *     }
+ *   ]
+ * })
+ * ```
+ */
+export declare function useMCPServer(options: UseMCPServerOptions): UseMCPServerReturn;
+/**
+ * createMCPServerHTTPHandler - 创建 HTTP 处理函数
+ *
+ * 用于在 Express/Next.js API Route 中暴露 MCP Server
+ *
+ * @example
+ * ```ts
+ * // Next.js API Route (app/api/mcp/route.ts)
+ * import { createMCPServerHTTPHandler } from '@yh-ui/ai-sdk/mcp'
+ *
+ * const handler = createMCPServerHTTPHandler({
+ *   name: 'my-ai-server',
+ *   version: '1.0.0',
+ *   tools: [
+ *     {
+ *       name: 'search',
+ *       description: 'Search for information',
+ *       inputSchema: { type: 'object', properties: { query: { type: 'string' } } },
+ *       execute: async ({ query }) => {
+ *         // Search logic here
+ *         return [{ type: 'text', text: `Results for: ${query}` }]
+ *       }
+ *     }
+ *   ]
+ * })
+ *
+ * export const GET = handler
+ * export const POST = handler
+ * ```
+ */
+export declare function createMCPServerHTTPHandler(options: UseMCPServerOptions): (request: Request) => Promise<Response>;