overai 1.4.0

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()),
+    };
+}

package/dist/ai/models.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Models - AI SDK Wrapper
+ *
+ * Provides model aliases and utilities for model resolution.
+ */
+/**
+ * Model aliases for common models across providers.
+ * Maps friendly names to provider/model format.
+ */
+export declare const MODEL_ALIASES: Record<string, string>;
+export type ModelId = keyof typeof MODEL_ALIASES | string;
+export interface ModelConfig {
+    /** Provider name */
+    provider: string;
+    /** Model ID */
+    modelId: string;
+    /** Original model string */
+    original: string;
+}
+/**
+ * Parse a model string into provider and model ID.
+ *
+ * @example
+ * ```typescript
+ * parseModel('gpt-4o') // { provider: 'openai', modelId: 'gpt-4o', original: 'gpt-4o' }
+ * parseModel('anthropic/claude-3-sonnet') // { provider: 'anthropic', modelId: 'claude-3-sonnet', original: 'anthropic/claude-3-sonnet' }
+ * ```
+ */
+export declare function parseModel(model: ModelId): ModelConfig;
+/**
+ * Get a model instance from a model string.
+ *
+ * @example
+ * ```typescript
+ * const model = await getModel('gpt-4o');
+ * const result = await generateText({ model, prompt: 'Hello' });
+ * ```
+ */
+export declare function getModel(model: ModelId): Promise<any>;
+/**
+ * Create a model with custom configuration.
+ *
+ * @example
+ * ```typescript
+ * const model = await createModel('gpt-4o', {
+ *   baseURL: 'https://custom-endpoint.com/v1',
+ *   apiKey: 'custom-key'
+ * });
+ * ```
+ */
+export declare function createModel(model: ModelId, options?: {
+    baseURL?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+}): Promise<any>;
+/**
+ * List all available model aliases.
+ */
+export declare function listModelAliases(): string[];
+/**
+ * Check if a model alias exists.
+ */
+export declare function hasModelAlias(alias: string): boolean;
+/**
+ * Resolve a model alias to its full provider/model format.
+ */
+export declare function resolveModelAlias(alias: string): string;