overai 1.4.0

package/dist/llm/providers/ai-sdk/backend.js

@@ -0,0 +1,421 @@
+"use strict";
+/**
+ * AI SDK Backend
+ *
+ * Main implementation of the AI SDK backend for praisonai-ts.
+ * Provides generateText, streamText, and generateObject methods
+ * with retry logic, timeouts, and attribution support.
+ */
+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.AISDKBackend = void 0;
+exports.createAISDKBackend = createAISDKBackend;
+const types_1 = require("./types");
+const provider_map_1 = require("./provider-map");
+const adapter_1 = require("./adapter");
+/**
+ * Lazy-loaded AI SDK modules
+ * These are only imported when actually used to avoid startup cost
+ *
+ * Note: We use 'any' type here because the 'ai' package is an optional
+ * peer dependency. The actual types are checked at runtime.
+ */
+let _aiModule = null;
+async function getAIModule() {
+    if (!_aiModule) {
+        try {
+            // Dynamic import - 'ai' is an optional peer dependency
+            // Use variable to prevent TypeScript from resolving the module at compile time
+            const moduleName = 'ai';
+            _aiModule = await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+        }
+        catch (error) {
+            throw new types_1.AISDKError('AI SDK is not installed. Install it with: npm install ai', 'MISSING_DEPENDENCY', false, error);
+        }
+    }
+    return _aiModule;
+}
+/**
+ * AI SDK Backend - implements LLMProvider interface
+ */
+class AISDKBackend {
+    constructor(modelString, config = {}) {
+        this.provider = null;
+        this.model = null;
+        const parsed = (0, provider_map_1.parseModelString)(modelString, config.defaultProvider);
+        this.providerId = parsed.providerId;
+        this.modelId = parsed.modelId;
+        // Merge with safe defaults
+        this.config = {
+            ...types_1.SAFE_DEFAULTS,
+            ...config
+        };
+        this.attribution = config.attribution;
+    }
+    /**
+     * Initialize the AI SDK provider and model (lazy)
+     */
+    async ensureInitialized() {
+        if (this.model) {
+            return;
+        }
+        // Validate API key
+        if (!(0, provider_map_1.validateProviderApiKey)(this.providerId)) {
+            throw new types_1.AISDKError((0, provider_map_1.getMissingApiKeyMessage)(this.providerId), 'AUTHENTICATION', false);
+        }
+        // Get provider options from config
+        const providerOptions = this.config.providers?.[this.providerId] || {};
+        // Create the AI SDK provider
+        this.provider = await (0, provider_map_1.createAISDKProvider)(this.providerId, providerOptions);
+        // Get the language model from the provider
+        if (typeof this.provider === 'function') {
+            // Provider is callable (e.g., openai('gpt-4o'))
+            this.model = this.provider(this.modelId);
+        }
+        else if (this.provider && typeof this.provider.languageModel === 'function') {
+            // Provider has languageModel method
+            this.model = this.provider.languageModel(this.modelId);
+        }
+        else if (this.provider && typeof this.provider.chat === 'function') {
+            // Provider has chat method (OpenAI style)
+            this.model = this.provider.chat(this.modelId);
+        }
+        else {
+            throw new types_1.AISDKError(`Could not get language model from provider '${this.providerId}'`, 'PROVIDER_ERROR', false);
+        }
+    }
+    /**
+     * Generate text (non-streaming)
+     */
+    async generateText(options) {
+        await this.ensureInitialized();
+        const ai = await getAIModule();
+        // Convert messages to AI SDK format
+        const prompt = (0, adapter_1.toAISDKPrompt)(options.messages);
+        // Convert tools if provided (now async)
+        const tools = options.tools ? await (0, adapter_1.toAISDKTools)(options.tools) : undefined;
+        // Build call options
+        const callOptions = {
+            model: this.model,
+            messages: prompt,
+            maxTokens: options.maxTokens || this.config.maxOutputTokens,
+            temperature: options.temperature,
+            topP: options.topP,
+            frequencyPenalty: options.frequencyPenalty,
+            presencePenalty: options.presencePenalty,
+            stopSequences: options.stop,
+            maxRetries: this.config.maxRetries,
+        };
+        if (tools && Object.keys(tools).length > 0) {
+            callOptions.tools = tools;
+            callOptions.toolChoice = (0, adapter_1.toAISDKToolChoice)(options.toolChoice);
+        }
+        // Add telemetry settings if configured
+        if (this.config.telemetry) {
+            callOptions.experimental_telemetry = this.config.telemetry;
+        }
+        // Execute with retry logic
+        let lastError;
+        const maxRetries = this.config.maxRetries || types_1.SAFE_DEFAULTS.maxRetries;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                // Create abort controller for timeout
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => {
+                    controller.abort();
+                }, this.config.timeout || types_1.SAFE_DEFAULTS.timeout);
+                try {
+                    callOptions.abortSignal = controller.signal;
+                    const result = await ai.generateText(callOptions);
+                    clearTimeout(timeoutId);
+                    return (0, adapter_1.fromAISDKResult)({
+                        text: result.text,
+                        toolCalls: result.toolCalls?.map((tc) => ({
+                            toolCallId: tc.toolCallId,
+                            toolName: tc.toolName,
+                            args: tc.args
+                        })),
+                        usage: result.usage,
+                        finishReason: result.finishReason
+                    });
+                }
+                finally {
+                    clearTimeout(timeoutId);
+                }
+            }
+            catch (error) {
+                lastError = error;
+                const classifiedError = classifyError(error);
+                // Don't retry non-retryable errors
+                if (!classifiedError.isRetryable || attempt === maxRetries) {
+                    throw classifiedError;
+                }
+                // Exponential backoff
+                const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
+                await sleep(delay);
+            }
+        }
+        throw classifyError(lastError);
+    }
+    /**
+     * Stream text generation
+     */
+    async streamText(options) {
+        await this.ensureInitialized();
+        const ai = await getAIModule();
+        // Convert messages to AI SDK format
+        const prompt = (0, adapter_1.toAISDKPrompt)(options.messages);
+        // Convert tools if provided (now async)
+        const tools = options.tools ? await (0, adapter_1.toAISDKTools)(options.tools) : undefined;
+        // Build call options
+        const callOptions = {
+            model: this.model,
+            messages: prompt,
+            maxTokens: options.maxTokens || this.config.maxOutputTokens,
+            temperature: options.temperature,
+            topP: options.topP,
+            frequencyPenalty: options.frequencyPenalty,
+            presencePenalty: options.presencePenalty,
+            stopSequences: options.stop,
+        };
+        if (tools && Object.keys(tools).length > 0) {
+            callOptions.tools = tools;
+            callOptions.toolChoice = (0, adapter_1.toAISDKToolChoice)(options.toolChoice);
+        }
+        // Add telemetry settings if configured
+        if (this.config.telemetry) {
+            callOptions.experimental_telemetry = this.config.telemetry;
+        }
+        // Create abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+        }, this.config.timeout || types_1.SAFE_DEFAULTS.timeout);
+        callOptions.abortSignal = controller.signal;
+        const self = this;
+        const onToken = options.onToken;
+        const onToolCall = options.onToolCall;
+        // Return async iterable
+        return {
+            async *[Symbol.asyncIterator]() {
+                try {
+                    const result = await ai.streamText(callOptions);
+                    let accumulatedText = '';
+                    const toolCalls = new Map();
+                    for await (const chunk of result.textStream) {
+                        // AI SDK streamText returns text chunks directly
+                        if (typeof chunk === 'string') {
+                            accumulatedText += chunk;
+                            if (onToken) {
+                                onToken(chunk);
+                            }
+                            yield {
+                                text: chunk
+                            };
+                        }
+                    }
+                    // Get final result for usage and tool calls
+                    const finalResult = await result;
+                    // Yield tool calls if any
+                    if (finalResult.toolCalls && finalResult.toolCalls.length > 0) {
+                        for (const tc of finalResult.toolCalls) {
+                            const toolCall = {
+                                id: tc.toolCallId,
+                                type: 'function',
+                                function: {
+                                    name: tc.toolName,
+                                    arguments: typeof tc.args === 'string' ? tc.args : JSON.stringify(tc.args)
+                                }
+                            };
+                            if (onToolCall) {
+                                onToolCall(toolCall);
+                            }
+                            yield {
+                                toolCalls: [toolCall]
+                            };
+                        }
+                    }
+                    // Yield final chunk with usage
+                    yield {
+                        usage: finalResult.usage ? {
+                            promptTokens: finalResult.usage.promptTokens,
+                            completionTokens: finalResult.usage.completionTokens,
+                            totalTokens: finalResult.usage.promptTokens + finalResult.usage.completionTokens
+                        } : undefined,
+                        finishReason: finalResult.finishReason
+                    };
+                }
+                catch (error) {
+                    throw classifyError(error);
+                }
+                finally {
+                    clearTimeout(timeoutId);
+                }
+            }
+        };
+    }
+    /**
+     * Generate structured object output
+     */
+    async generateObject(options) {
+        await this.ensureInitialized();
+        const ai = await getAIModule();
+        // Convert messages to AI SDK format
+        const prompt = (0, adapter_1.toAISDKPrompt)(options.messages);
+        // Build call options
+        const callOptions = {
+            model: this.model,
+            messages: prompt,
+            schema: options.schema,
+            maxTokens: options.maxTokens || this.config.maxOutputTokens,
+            temperature: options.temperature,
+            maxRetries: options.maxRetries || this.config.maxRetries,
+        };
+        // Add telemetry settings if configured
+        if (this.config.telemetry) {
+            callOptions.experimental_telemetry = this.config.telemetry;
+        }
+        // Create abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+        }, this.config.timeout || types_1.SAFE_DEFAULTS.timeout);
+        try {
+            callOptions.abortSignal = controller.signal;
+            const result = await ai.generateObject(callOptions);
+            return {
+                object: result.object,
+                usage: result.usage ? {
+                    promptTokens: result.usage.promptTokens,
+                    completionTokens: result.usage.completionTokens,
+                    totalTokens: result.usage.promptTokens + result.usage.completionTokens
+                } : {
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: 0
+                },
+                raw: result
+            };
+        }
+        catch (error) {
+            throw classifyError(error);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Get the underlying AI SDK model (for advanced use)
+     */
+    async getModel() {
+        await this.ensureInitialized();
+        return this.model;
+    }
+    /**
+     * Get the underlying AI SDK provider (for advanced use)
+     */
+    async getProvider() {
+        await this.ensureInitialized();
+        return this.provider;
+    }
+}
+exports.AISDKBackend = AISDKBackend;
+/**
+ * Create an AI SDK backend instance
+ */
+function createAISDKBackend(modelString, config) {
+    return new AISDKBackend(modelString, config);
+}
+/**
+ * Classify an error into an AISDKError
+ */
+function classifyError(error) {
+    if (error instanceof types_1.AISDKError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const lowerMessage = message.toLowerCase();
+    // Check for timeout/abort
+    if (lowerMessage.includes('abort') || lowerMessage.includes('timeout')) {
+        return new types_1.AISDKError(`Request timed out: ${message}`, 'TIMEOUT', true, error);
+    }
+    // Check for rate limit
+    if (lowerMessage.includes('rate limit') || lowerMessage.includes('429') || lowerMessage.includes('too many')) {
+        return new types_1.AISDKError(`Rate limit exceeded: ${message}`, 'RATE_LIMIT', true, error, 429);
+    }
+    // Check for authentication
+    if (lowerMessage.includes('unauthorized') || lowerMessage.includes('401') ||
+        lowerMessage.includes('forbidden') || lowerMessage.includes('403') ||
+        lowerMessage.includes('api key') || lowerMessage.includes('authentication')) {
+        return new types_1.AISDKError(`Authentication failed: ${message}`, 'AUTHENTICATION', false, error, 401);
+    }
+    // Check for invalid request
+    if (lowerMessage.includes('bad request') || lowerMessage.includes('400') ||
+        lowerMessage.includes('invalid')) {
+        return new types_1.AISDKError(`Invalid request: ${message}`, 'INVALID_REQUEST', false, error, 400);
+    }
+    // Check for model not found
+    if (lowerMessage.includes('model not found') || lowerMessage.includes('404') ||
+        lowerMessage.includes('does not exist')) {
+        return new types_1.AISDKError(`Model not found: ${message}`, 'MODEL_NOT_FOUND', false, error, 404);
+    }
+    // Check for network errors
+    if (lowerMessage.includes('network') || lowerMessage.includes('econnrefused') ||
+        lowerMessage.includes('enotfound') || lowerMessage.includes('socket')) {
+        return new types_1.AISDKError(`Network error: ${message}`, 'NETWORK', true, error);
+    }
+    // Check for cancelled
+    if (lowerMessage.includes('cancel')) {
+        return new types_1.AISDKError(`Request cancelled: ${message}`, 'CANCELLED', false, error);
+    }
+    // Check for missing dependency
+    if (lowerMessage.includes('cannot find module') || lowerMessage.includes('module_not_found')) {
+        return new types_1.AISDKError(`Missing dependency: ${message}`, 'MISSING_DEPENDENCY', false, error);
+    }
+    // Check for server errors (retryable)
+    if (lowerMessage.includes('500') || lowerMessage.includes('502') ||
+        lowerMessage.includes('503') || lowerMessage.includes('504') ||
+        lowerMessage.includes('server error')) {
+        return new types_1.AISDKError(`Server error: ${message}`, 'PROVIDER_ERROR', true, error, 500);
+    }
+    // Default to unknown error
+    return new types_1.AISDKError(message, 'UNKNOWN', false, error);
+}
+/**
+ * Sleep for a given number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/llm/providers/ai-sdk/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * AI SDK Integration for praisonai-ts
+ *
+ * This module provides integration with Vercel's AI SDK for multi-provider LLM support.
+ * All imports are lazy-loaded to avoid startup cost when AI SDK is not used.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createAISDKBackend, registerAISDKProviders } from 'praisonai';
+ *
+ * // Register AI SDK providers (one-time)
+ * registerAISDKProviders();
+ *
+ * // Create a backend for any supported provider
+ * const backend = createAISDKBackend('anthropic/claude-3-5-sonnet');
+ * const result = await backend.generateText({ messages: [...] });
+ * ```
+ */
+export type { AISDKBackendConfig, AISDKProviderOptions, AttributionContext, AISDKTelemetrySettings, AISDKErrorCode, PraisonStreamChunk, TokenUsage, FinishReason, AISDKToolDefinition, AISDKToolCall, AISDKToolResult, } from './types';
+export { AISDKError, SAFE_DEFAULTS, AISDK_PROVIDERS, PROVIDER_ALIASES } from './types';
+export { parseModelString, resolveProviderAlias, isProviderSupported, getProviderPackage, getProviderEnvKey, listSupportedProviders, registerCustomProvider, unregisterCustomProvider, getCustomProvider, createAISDKProvider, validateProviderApiKey, getMissingApiKeyMessage, type ParsedModel, type ProviderFactory, } from './provider-map';
+export { toAISDKPrompt, toAISDKTools, fromAISDKToolCall, toAISDKToolResult, fromAISDKResult, fromAISDKStreamChunk, mapFinishReason, mapFinishReasonToProvider, toAISDKToolChoice, createSimplePrompt, type AISDKMessage, type AISDKSystemMessage, type AISDKUserMessage, type AISDKAssistantMessage, type AISDKToolMessage, } from './adapter';
+export { createAttributionMiddleware, createLoggingMiddleware, createTimeoutMiddleware, composeMiddleware, createStandardMiddleware, redactSensitiveData, type AISDKMiddleware, } from './middleware';
+/**
+ * Get the AISDKBackend class (lazy loaded)
+ */
+export declare function getAISDKBackendClass(): typeof import('./backend').AISDKBackend;
+/**
+ * Create an AI SDK backend instance
+ *
+ * @param modelString - Model string in format "provider/model" or just "model"
+ * @param config - Optional configuration
+ * @returns AISDKBackend instance implementing LLMProvider
+ *
+ * @example
+ * ```typescript
+ * const backend = createAISDKBackend('openai/gpt-4o');
+ * const backend = createAISDKBackend('anthropic/claude-3-5-sonnet');
+ * const backend = createAISDKBackend('google/gemini-2.0-flash');
+ * ```
+ */
+export declare function createAISDKBackend(modelString: string, config?: import('./types').AISDKBackendConfig): import('./backend').AISDKBackend;
+export { AISDKBackend } from './backend';
+/**
+ * Register AI SDK providers with the praisonai-ts provider registry
+ * This allows using AI SDK providers via the standard createProvider() function
+ *
+ * @param customProviders - Optional map of custom provider factories
+ *
+ * @example
+ * ```typescript
+ * import { registerAISDKProviders, createProvider } from 'praisonai';
+ *
+ * // Register all AI SDK providers
+ * registerAISDKProviders();
+ *
+ * // Now you can use AI SDK providers via createProvider
+ * const provider = createProvider('aisdk:anthropic/claude-3-5-sonnet');
+ * ```
+ */
+export declare function registerAISDKProviders(customProviders?: Record<string, import('./provider-map').ProviderFactory>): void;
+/**
+ * Check if AI SDK is available (installed)
+ */
+export declare function isAISDKAvailable(): Promise<boolean>;
+/**
+ * Get AI SDK version if available
+ */
+export declare function getAISDKVersion(): Promise<string | null>;