praisonai 1.3.6 → 1.5.0

package/dist/ai/mcp.d.ts

@@ -0,0 +1,181 @@
+/**
+ * MCP (Model Context Protocol) - AI SDK Wrapper
+ *
+ * Provides MCP client utilities for connecting to MCP servers and using their tools.
+ */
+export interface MCPConfig {
+    /** Transport configuration */
+    transport: MCPTransportConfig;
+    /** Client name */
+    name?: string;
+    /** Client version */
+    version?: string;
+    /** Callback for uncaught errors */
+    onUncaughtError?: (error: unknown) => void;
+}
+export type MCPTransportConfig = {
+    type: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+} | {
+    type: 'sse';
+    url: string;
+    headers?: Record<string, string>;
+    authProvider?: OAuthClientProvider;
+} | {
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
+    authProvider?: OAuthClientProvider;
+} | {
+    type: 'websocket';
+    url: string;
+    headers?: Record<string, string>;
+};
+/**
+ * OAuth client provider for MCP authentication.
+ */
+export interface OAuthClientProvider {
+    /** Get the current access token */
+    getAccessToken(): Promise<string | null>;
+    /** Refresh the access token */
+    refreshToken?(): Promise<string | null>;
+    /** Handle OAuth redirect */
+    handleRedirect?(url: string): Promise<void>;
+}
+export interface MCPClient {
+    /** Get tools from the MCP server */
+    tools(): Promise<Record<string, MCPTool>>;
+    /** List available resources */
+    listResources(): Promise<MCPResource[]>;
+    /** Read a resource */
+    readResource(uri: string): Promise<MCPResourceContent>;
+    /** List available prompts */
+    listPrompts(): Promise<MCPPrompt[]>;
+    /** Get a prompt */
+    getPrompt(name: string, args?: Record<string, string>): Promise<MCPPromptResult>;
+    /** Close the connection */
+    close(): Promise<void>;
+}
+export interface MCPTool {
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description?: string;
+    /** Input schema */
+    inputSchema: any;
+    /** Execute the tool */
+    execute: (args: any) => Promise<any>;
+}
+export interface MCPResource {
+    /** Resource URI */
+    uri: string;
+    /** Resource name */
+    name: string;
+    /** Resource description */
+    description?: string;
+    /** MIME type */
+    mimeType?: string;
+}
+export interface MCPResourceContent {
+    /** Content URI */
+    uri: string;
+    /** Content MIME type */
+    mimeType?: string;
+    /** Text content */
+    text?: string;
+    /** Binary content (base64) */
+    blob?: string;
+}
+export interface MCPPrompt {
+    /** Prompt name */
+    name: string;
+    /** Prompt description */
+    description?: string;
+    /** Arguments */
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+}
+export interface MCPPromptResult {
+    /** Prompt description */
+    description?: string;
+    /** Messages */
+    messages: Array<{
+        role: 'user' | 'assistant';
+        content: {
+            type: 'text';
+            text: string;
+        } | {
+            type: 'image';
+            data: string;
+            mimeType: string;
+        };
+    }>;
+}
+/**
+ * Create an MCP client.
+ *
+ * @example Stdio transport (local server)
+ * ```typescript
+ * const client = await createMCP({
+ *   transport: {
+ *     type: 'stdio',
+ *     command: 'npx',
+ *     args: ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/dir']
+ *   }
+ * });
+ *
+ * const tools = await client.tools();
+ * ```
+ *
+ * @example SSE transport (remote server)
+ * ```typescript
+ * const client = await createMCP({
+ *   transport: {
+ *     type: 'sse',
+ *     url: 'https://mcp-server.example.com/sse'
+ *   }
+ * });
+ * ```
+ */
+export declare function createMCP(config: MCPConfig): Promise<MCPClient>;
+/**
+ * Get or create a pooled MCP client.
+ *
+ * @example
+ * ```typescript
+ * const client = await getMCPClient('filesystem', {
+ *   transport: { type: 'stdio', command: 'npx', args: ['-y', '@mcp/server-fs'] }
+ * });
+ * ```
+ */
+export declare function getMCPClient(key: string, config: MCPConfig): Promise<MCPClient>;
+/**
+ * Close and remove a pooled MCP client.
+ */
+export declare function closeMCPClient(key: string): Promise<void>;
+/**
+ * Close all pooled MCP clients.
+ */
+export declare function closeAllMCPClients(): Promise<void>;
+/**
+ * Convert MCP tools to AI SDK tool format.
+ *
+ * @example
+ * ```typescript
+ * const client = await createMCP({ ... });
+ * const mcpTools = await client.tools();
+ * const aiTools = mcpToolsToAITools(mcpTools);
+ *
+ * const result = await generateText({
+ *   model: 'gpt-4o',
+ *   prompt: 'List files in the current directory',
+ *   tools: aiTools
+ * });
+ * ```
+ */
+export declare function mcpToolsToAITools(mcpTools: Record<string, MCPTool>): Record<string, any>;

package/dist/ai/mcp.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * MCP (Model Context Protocol) - AI SDK Wrapper
+ *
+ * Provides MCP client utilities for connecting to MCP servers and using their tools.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMCP = createMCP;
+exports.getMCPClient = getMCPClient;
+exports.closeMCPClient = closeMCPClient;
+exports.closeAllMCPClients = closeAllMCPClients;
+exports.mcpToolsToAITools = mcpToolsToAITools;
+// Connection pool for MCP clients
+const clientPool = new Map();
+/**
+ * Create an MCP client.
+ *
+ * @example Stdio transport (local server)
+ * ```typescript
+ * const client = await createMCP({
+ *   transport: {
+ *     type: 'stdio',
+ *     command: 'npx',
+ *     args: ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/dir']
+ *   }
+ * });
+ *
+ * const tools = await client.tools();
+ * ```
+ *
+ * @example SSE transport (remote server)
+ * ```typescript
+ * const client = await createMCP({
+ *   transport: {
+ *     type: 'sse',
+ *     url: 'https://mcp-server.example.com/sse'
+ *   }
+ * });
+ * ```
+ */
+async function createMCP(config) {
+    // Try to use AI SDK MCP client (optional dependency)
+    try {
+        // @ts-ignore - Optional dependency
+        const mcpModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/mcp')));
+        const transport = createTransport(config.transport);
+        const client = await mcpModule.createMCPClient({
+            transport,
+            name: config.name,
+            version: config.version,
+            onUncaughtError: config.onUncaughtError,
+        });
+        return {
+            tools: async () => {
+                const toolSet = await client.tools();
+                return toolSet;
+            },
+            listResources: async () => {
+                const result = await client.listResources();
+                return result.resources || [];
+            },
+            readResource: async (uri) => {
+                const result = await client.readResource({ uri });
+                return result.contents?.[0] || { uri };
+            },
+            listPrompts: async () => {
+                const result = await client.listPrompts();
+                return result.prompts || [];
+            },
+            getPrompt: async (name, args) => {
+                const result = await client.getPrompt({ name, arguments: args });
+                return result;
+            },
+            close: async () => {
+                await client.close();
+            },
+        };
+    }
+    catch (error) {
+        // Fall back to native implementation
+        return createNativeMCPClient(config);
+    }
+}
+/**
+ * Create transport configuration for AI SDK MCP.
+ */
+function createTransport(config) {
+    switch (config.type) {
+        case 'stdio':
+            return {
+                type: 'stdio',
+                command: config.command,
+                args: config.args,
+                env: config.env,
+            };
+        case 'sse':
+            return {
+                type: 'sse',
+                url: config.url,
+                headers: config.headers,
+                authProvider: config.authProvider,
+            };
+        case 'http':
+            return {
+                type: 'http',
+                url: config.url,
+                headers: config.headers,
+                authProvider: config.authProvider,
+            };
+        case 'websocket':
+            return {
+                type: 'websocket',
+                url: config.url,
+                headers: config.headers,
+            };
+        default:
+            throw new Error(`Unknown transport type: ${config.type}`);
+    }
+}
+/**
+ * Native MCP client implementation (fallback).
+ */
+async function createNativeMCPClient(config) {
+    // This is a simplified native implementation
+    // In production, this would use the @modelcontextprotocol/sdk directly
+    const tools = {};
+    const resources = [];
+    const prompts = [];
+    return {
+        tools: async () => tools,
+        listResources: async () => resources,
+        readResource: async (uri) => ({ uri }),
+        listPrompts: async () => prompts,
+        getPrompt: async (name) => ({ messages: [] }),
+        close: async () => { },
+    };
+}
+/**
+ * Get or create a pooled MCP client.
+ *
+ * @example
+ * ```typescript
+ * const client = await getMCPClient('filesystem', {
+ *   transport: { type: 'stdio', command: 'npx', args: ['-y', '@mcp/server-fs'] }
+ * });
+ * ```
+ */
+async function getMCPClient(key, config) {
+    if (clientPool.has(key)) {
+        return clientPool.get(key);
+    }
+    const client = await createMCP(config);
+    clientPool.set(key, client);
+    return client;
+}
+/**
+ * Close and remove a pooled MCP client.
+ */
+async function closeMCPClient(key) {
+    const client = clientPool.get(key);
+    if (client) {
+        await client.close();
+        clientPool.delete(key);
+    }
+}
+/**
+ * Close all pooled MCP clients.
+ */
+async function closeAllMCPClients() {
+    for (const [key, client] of clientPool) {
+        await client.close();
+        clientPool.delete(key);
+    }
+}
+/**
+ * Convert MCP tools to AI SDK tool format.
+ *
+ * @example
+ * ```typescript
+ * const client = await createMCP({ ... });
+ * const mcpTools = await client.tools();
+ * const aiTools = mcpToolsToAITools(mcpTools);
+ *
+ * const result = await generateText({
+ *   model: 'gpt-4o',
+ *   prompt: 'List files in the current directory',
+ *   tools: aiTools
+ * });
+ * ```
+ */
+function mcpToolsToAITools(mcpTools) {
+    const aiTools = {};
+    for (const [name, tool] of Object.entries(mcpTools)) {
+        aiTools[name] = {
+            description: tool.description || `MCP tool: ${name}`,
+            parameters: tool.inputSchema,
+            execute: tool.execute,
+        };
+    }
+    return aiTools;
+}

package/dist/ai/middleware.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Middleware - AI SDK Wrapper
+ *
+ * Provides middleware utilities for caching, logging, and model wrapping.
+ */
+export interface Middleware {
+    /** Middleware name */
+    name: string;
+    /** Transform request before sending */
+    transformRequest?: (request: MiddlewareRequest) => Promise<MiddlewareRequest> | MiddlewareRequest;
+    /** Transform response after receiving */
+    transformResponse?: (response: MiddlewareResponse) => Promise<MiddlewareResponse> | MiddlewareResponse;
+    /** Handle errors */
+    onError?: (error: Error) => Promise<void> | void;
+}
+export interface MiddlewareRequest {
+    model: string;
+    prompt?: string;
+    messages?: any[];
+    system?: string;
+    tools?: Record<string, any>;
+    [key: string]: any;
+}
+export interface MiddlewareResponse {
+    text?: string;
+    object?: any;
+    toolCalls?: any[];
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    [key: string]: any;
+}
+export interface MiddlewareConfig {
+    /** Enable caching */
+    cache?: boolean;
+    /** Cache TTL in seconds */
+    cacheTTL?: number;
+    /** Enable logging */
+    logging?: boolean;
+    /** Log level */
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    /** Custom middlewares */
+    middlewares?: Middleware[];
+}
+/**
+ * Create a caching middleware.
+ *
+ * @example
+ * ```typescript
+ * const cachingMiddleware = createCachingMiddleware({
+ *   ttl: 3600, // 1 hour
+ *   keyGenerator: (request) => `${request.model}:${request.prompt}`
+ * });
+ * ```
+ */
+export declare function createCachingMiddleware(options?: {
+    ttl?: number;
+    keyGenerator?: (request: MiddlewareRequest) => string;
+    storage?: {
+        get: (key: string) => Promise<any>;
+        set: (key: string, value: any, ttl?: number) => Promise<void>;
+    };
+}): Middleware;
+/**
+ * Create a logging middleware.
+ *
+ * @example
+ * ```typescript
+ * const loggingMiddleware = createLoggingMiddleware({
+ *   level: 'debug',
+ *   onRequest: (request) => console.log('Request:', request),
+ *   onResponse: (response) => console.log('Response:', response)
+ * });
+ * ```
+ */
+export declare function createLoggingMiddleware(options?: {
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    onRequest?: (request: MiddlewareRequest) => void;
+    onResponse?: (response: MiddlewareResponse) => void;
+    onError?: (error: Error) => void;
+}): Middleware;
+/**
+ * Wrap a model with middleware.
+ *
+ * @example
+ * ```typescript
+ * const wrappedModel = wrapModel(model, [
+ *   createCachingMiddleware(),
+ *   createLoggingMiddleware()
+ * ]);
+ * ```
+ */
+export declare function wrapModel(model: any, middlewares: Middleware[]): any;
+/**
+ * Apply middleware to a request/response cycle.
+ */
+export declare function applyMiddleware(middlewares: Middleware[], request: MiddlewareRequest, execute: (req: MiddlewareRequest) => Promise<MiddlewareResponse>): Promise<MiddlewareResponse>;
+/**
+ * Clear the response cache.
+ */
+export declare function clearCache(): void;
+/**
+ * Get cache statistics.
+ */
+export declare function getCacheStats(): {
+    size: number;
+    keys: string[];
+};

package/dist/ai/middleware.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Middleware - AI SDK Wrapper
+ *
+ * Provides middleware utilities for caching, logging, and model wrapping.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCachingMiddleware = createCachingMiddleware;
+exports.createLoggingMiddleware = createLoggingMiddleware;
+exports.wrapModel = wrapModel;
+exports.applyMiddleware = applyMiddleware;
+exports.clearCache = clearCache;
+exports.getCacheStats = getCacheStats;
+// In-memory cache for middleware
+const responseCache = new Map();
+/**
+ * Create a caching middleware.
+ *
+ * @example
+ * ```typescript
+ * const cachingMiddleware = createCachingMiddleware({
+ *   ttl: 3600, // 1 hour
+ *   keyGenerator: (request) => `${request.model}:${request.prompt}`
+ * });
+ * ```
+ */
+function createCachingMiddleware(options) {
+    const ttl = options?.ttl ?? 3600;
+    const keyGenerator = options?.keyGenerator ?? defaultKeyGenerator;
+    const storage = options?.storage;
+    return {
+        name: 'caching',
+        transformRequest: async (request) => {
+            const key = keyGenerator(request);
+            if (storage) {
+                const cached = await storage.get(key);
+                if (cached) {
+                    request.__cached = cached;
+                    request.__cacheHit = true;
+                }
+            }
+            else {
+                const cached = responseCache.get(key);
+                if (cached && Date.now() - cached.timestamp < ttl * 1000) {
+                    request.__cached = cached.response;
+                    request.__cacheHit = true;
+                }
+            }
+            request.__cacheKey = key;
+            return request;
+        },
+        transformResponse: async (response) => {
+            const key = response.__cacheKey;
+            if (key && !response.__cacheHit) {
+                if (storage) {
+                    await storage.set(key, response, ttl);
+                }
+                else {
+                    responseCache.set(key, { response, timestamp: Date.now() });
+                }
+            }
+            return response;
+        },
+    };
+}
+/**
+ * Create a logging middleware.
+ *
+ * @example
+ * ```typescript
+ * const loggingMiddleware = createLoggingMiddleware({
+ *   level: 'debug',
+ *   onRequest: (request) => console.log('Request:', request),
+ *   onResponse: (response) => console.log('Response:', response)
+ * });
+ * ```
+ */
+function createLoggingMiddleware(options) {
+    const level = options?.level ?? 'info';
+    const log = (msg, data) => {
+        const timestamp = new Date().toISOString();
+        console[level](`[${timestamp}] ${msg}`, data ?? '');
+    };
+    return {
+        name: 'logging',
+        transformRequest: async (request) => {
+            log('AI Request', { model: request.model, hasPrompt: !!request.prompt, hasMessages: !!request.messages });
+            options?.onRequest?.(request);
+            return request;
+        },
+        transformResponse: async (response) => {
+            log('AI Response', { hasText: !!response.text, hasObject: !!response.object, usage: response.usage });
+            options?.onResponse?.(response);
+            return response;
+        },
+        onError: async (error) => {
+            log('AI Error', { message: error.message });
+            options?.onError?.(error);
+        },
+    };
+}
+/**
+ * Wrap a model with middleware.
+ *
+ * @example
+ * ```typescript
+ * const wrappedModel = wrapModel(model, [
+ *   createCachingMiddleware(),
+ *   createLoggingMiddleware()
+ * ]);
+ * ```
+ */
+function wrapModel(model, middlewares) {
+    // This is a placeholder - actual implementation would wrap the model's
+    // doGenerate and doStream methods with middleware transformations
+    return {
+        ...model,
+        __middlewares: middlewares,
+    };
+}
+/**
+ * Apply middleware to a request/response cycle.
+ */
+async function applyMiddleware(middlewares, request, execute) {
+    // Transform request through all middlewares
+    let transformedRequest = request;
+    for (const middleware of middlewares) {
+        if (middleware.transformRequest) {
+            transformedRequest = await middleware.transformRequest(transformedRequest);
+        }
+    }
+    // Check for cache hit
+    if (transformedRequest.__cacheHit) {
+        return transformedRequest.__cached;
+    }
+    // Execute the actual request
+    let response;
+    try {
+        response = await execute(transformedRequest);
+        response.__cacheKey = transformedRequest.__cacheKey;
+    }
+    catch (error) {
+        // Handle errors through middlewares
+        for (const middleware of middlewares) {
+            if (middleware.onError) {
+                await middleware.onError(error);
+            }
+        }
+        throw error;
+    }
+    // Transform response through all middlewares (in reverse order)
+    let transformedResponse = response;
+    for (const middleware of [...middlewares].reverse()) {
+        if (middleware.transformResponse) {
+            transformedResponse = await middleware.transformResponse(transformedResponse);
+        }
+    }
+    return transformedResponse;
+}
+/**
+ * Default cache key generator.
+ */
+function defaultKeyGenerator(request) {
+    const parts = [
+        request.model,
+        request.prompt || '',
+        JSON.stringify(request.messages || []),
+        request.system || '',
+    ];
+    return parts.join(':').slice(0, 256);
+}
+/**
+ * Clear the response cache.
+ */
+function clearCache() {
+    responseCache.clear();
+}
+/**
+ * Get cache statistics.
+ */
+function getCacheStats() {
+    return {
+        size: responseCache.size,
+        keys: Array.from(responseCache.keys()),
+    };
+}