overai 1.4.0

package/dist/llm/providers/ai-sdk/provider-map.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * AI SDK Provider Map
+ *
+ * Maps model strings to AI SDK providers with lazy loading.
+ * Supports formats: "provider/model" or "model" (uses default provider)
+ */
+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.parseModelString = parseModelString;
+exports.resolveProviderAlias = resolveProviderAlias;
+exports.isProviderSupported = isProviderSupported;
+exports.getProviderPackage = getProviderPackage;
+exports.getProviderEnvKey = getProviderEnvKey;
+exports.listSupportedProviders = listSupportedProviders;
+exports.registerCustomProvider = registerCustomProvider;
+exports.unregisterCustomProvider = unregisterCustomProvider;
+exports.getCustomProvider = getCustomProvider;
+exports.createAISDKProvider = createAISDKProvider;
+exports.validateProviderApiKey = validateProviderApiKey;
+exports.getMissingApiKeyMessage = getMissingApiKeyMessage;
+const types_1 = require("./types");
+/**
+ * Custom provider registration
+ */
+const customProviders = new Map();
+/**
+ * Parse a model string into provider and model ID
+ *
+ * @example
+ * parseModelString("openai/gpt-4o") // { providerId: "openai", modelId: "gpt-4o" }
+ * parseModelString("gpt-4o-mini") // { providerId: "openai", modelId: "gpt-4o-mini" }
+ * parseModelString("claude-3-5-sonnet") // { providerId: "anthropic", modelId: "claude-3-5-sonnet" }
+ */
+function parseModelString(model, defaultProvider = 'openai') {
+    if (model.includes('/')) {
+        const [providerId, ...rest] = model.split('/');
+        const resolvedProvider = resolveProviderAlias(providerId.toLowerCase());
+        return {
+            providerId: resolvedProvider,
+            modelId: rest.join('/')
+        };
+    }
+    // Infer provider from model prefix
+    const inferredProvider = inferProviderFromModel(model);
+    return {
+        providerId: inferredProvider || defaultProvider,
+        modelId: model
+    };
+}
+/**
+ * Resolve provider alias to canonical name
+ */
+function resolveProviderAlias(providerId) {
+    return types_1.PROVIDER_ALIASES[providerId] || providerId;
+}
+/**
+ * Infer provider from model name prefix
+ */
+function inferProviderFromModel(model) {
+    const lowerModel = model.toLowerCase();
+    // OpenAI models
+    if (lowerModel.startsWith('gpt-') ||
+        lowerModel.startsWith('o1') ||
+        lowerModel.startsWith('o3') ||
+        lowerModel.startsWith('text-') ||
+        lowerModel.startsWith('davinci') ||
+        lowerModel.startsWith('curie') ||
+        lowerModel.startsWith('babbage') ||
+        lowerModel.startsWith('ada')) {
+        return 'openai';
+    }
+    // Anthropic models
+    if (lowerModel.startsWith('claude-')) {
+        return 'anthropic';
+    }
+    // Google models
+    if (lowerModel.startsWith('gemini-') ||
+        lowerModel.startsWith('palm-') ||
+        lowerModel.startsWith('bison')) {
+        return 'google';
+    }
+    // Mistral models
+    if (lowerModel.startsWith('mistral-') ||
+        lowerModel.startsWith('mixtral-') ||
+        lowerModel.startsWith('codestral')) {
+        return 'mistral';
+    }
+    // Cohere models
+    if (lowerModel.startsWith('command-')) {
+        return 'cohere';
+    }
+    // DeepSeek models
+    if (lowerModel.startsWith('deepseek-')) {
+        return 'deepseek';
+    }
+    // Groq models (llama, mixtral via groq)
+    if (lowerModel.startsWith('llama-') || lowerModel.includes('groq')) {
+        return 'groq';
+    }
+    return null;
+}
+/**
+ * Check if a provider is supported
+ */
+function isProviderSupported(providerId) {
+    const resolved = resolveProviderAlias(providerId);
+    return resolved in types_1.AISDK_PROVIDERS || customProviders.has(resolved);
+}
+/**
+ * Get the package name for a provider
+ */
+function getProviderPackage(providerId) {
+    const resolved = resolveProviderAlias(providerId);
+    return types_1.AISDK_PROVIDERS[resolved]?.package || null;
+}
+/**
+ * Get the environment variable key for a provider's API key
+ */
+function getProviderEnvKey(providerId) {
+    const resolved = resolveProviderAlias(providerId);
+    return types_1.AISDK_PROVIDERS[resolved]?.envKey || null;
+}
+/**
+ * List all supported providers
+ */
+function listSupportedProviders() {
+    const builtIn = Object.keys(types_1.AISDK_PROVIDERS);
+    const custom = Array.from(customProviders.keys());
+    return [...new Set([...builtIn, ...custom])];
+}
+/**
+ * Register a custom provider factory
+ *
+ * @example
+ * registerCustomProvider('my-provider', (options) => createMyProvider(options));
+ */
+function registerCustomProvider(providerId, factory) {
+    customProviders.set(providerId.toLowerCase(), factory);
+}
+/**
+ * Unregister a custom provider
+ */
+function unregisterCustomProvider(providerId) {
+    return customProviders.delete(providerId.toLowerCase());
+}
+/**
+ * Get a custom provider factory
+ */
+function getCustomProvider(providerId) {
+    return customProviders.get(providerId.toLowerCase());
+}
+/**
+ * Dynamically import and create an AI SDK provider
+ * Uses lazy loading to avoid importing AI SDK packages until needed
+ */
+async function createAISDKProvider(providerId, options) {
+    const resolved = resolveProviderAlias(providerId);
+    // Check for custom provider first
+    const customFactory = customProviders.get(resolved);
+    if (customFactory) {
+        return customFactory(options);
+    }
+    // Check if provider is supported
+    const providerInfo = types_1.AISDK_PROVIDERS[resolved];
+    if (!providerInfo) {
+        throw new types_1.AISDKError(`Provider '${providerId}' is not supported. ` +
+            `Supported providers: ${listSupportedProviders().join(', ')}`, 'PROVIDER_NOT_FOUND', false);
+    }
+    // Dynamically import the provider package
+    try {
+        const providerModule = await Promise.resolve(`${providerInfo.package}`).then(s => __importStar(require(s)));
+        // Most AI SDK providers export a create<Provider> function
+        const createFnName = `create${capitalize(resolved.replace(/-/g, ''))}`;
+        const createFn = providerModule[createFnName] || providerModule.default;
+        if (typeof createFn !== 'function') {
+            // Try direct provider export (some packages export the provider directly)
+            const providerName = resolved.replace(/-/g, '');
+            const directProvider = providerModule[providerName];
+            if (directProvider) {
+                return directProvider;
+            }
+            throw new types_1.AISDKError(`Could not find provider factory in '${providerInfo.package}'`, 'PROVIDER_ERROR', false);
+        }
+        return createFn(options);
+    }
+    catch (error) {
+        if (error instanceof types_1.AISDKError) {
+            throw error;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Check if it's a missing dependency error
+        if (errorMessage.includes('Cannot find module') ||
+            errorMessage.includes('MODULE_NOT_FOUND')) {
+            throw new types_1.AISDKError(`AI SDK provider package '${providerInfo.package}' is not installed. ` +
+                `Install it with: npm install ${providerInfo.package}`, 'MISSING_DEPENDENCY', false, error);
+        }
+        throw new types_1.AISDKError(`Failed to create AI SDK provider '${providerId}': ${errorMessage}`, 'PROVIDER_ERROR', false, error);
+    }
+}
+/**
+ * Validate that a provider has the required API key
+ */
+function validateProviderApiKey(providerId) {
+    const envKey = getProviderEnvKey(providerId);
+    if (!envKey) {
+        return true; // Custom providers may not need env keys
+    }
+    return !!process.env[envKey];
+}
+/**
+ * Get missing API key message for a provider
+ */
+function getMissingApiKeyMessage(providerId) {
+    const envKey = getProviderEnvKey(providerId);
+    if (!envKey) {
+        return `Provider '${providerId}' may require authentication. Check provider documentation.`;
+    }
+    return `Missing API key for provider '${providerId}'. Set the ${envKey} environment variable.`;
+}
+/**
+ * Capitalize first letter of a string
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

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

@@ -0,0 +1,217 @@
+/**
+ * AI SDK Backend Types
+ *
+ * Type definitions for the AI SDK integration with praisonai-ts.
+ * These types define the configuration, errors, and stream chunk formats.
+ */
+/**
+ * Attribution context for multi-agent safety
+ * Propagated to AI SDK calls via middleware
+ */
+export interface AttributionContext {
+    /** Unique identifier for the agent instance */
+    agentId?: string;
+    /** Unique identifier for this execution run */
+    runId?: string;
+    /** Trace ID for distributed tracing (OpenTelemetry compatible) */
+    traceId?: string;
+    /** Session ID for conversation continuity */
+    sessionId?: string;
+    /** Parent span ID for nested operations */
+    parentSpanId?: string;
+}
+/**
+ * Provider-specific configuration options
+ */
+export interface AISDKProviderOptions {
+    /** API key for the provider */
+    apiKey?: string;
+    /** Base URL override for the provider */
+    baseURL?: string;
+    /** Custom headers to include in requests */
+    headers?: Record<string, string>;
+    /** Custom fetch implementation */
+    fetch?: typeof fetch;
+}
+/**
+ * Telemetry settings for AI SDK calls
+ */
+export interface AISDKTelemetrySettings {
+    /** Enable or disable telemetry */
+    isEnabled?: boolean;
+    /** Enable or disable input recording */
+    recordInputs?: boolean;
+    /** Enable or disable output recording */
+    recordOutputs?: boolean;
+    /** Function identifier for grouping telemetry */
+    functionId?: string;
+    /** Additional metadata for telemetry */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Configuration for the AI SDK backend
+ */
+export interface AISDKBackendConfig {
+    /** Default provider if not specified in model string */
+    defaultProvider?: string;
+    /** Provider-specific configurations */
+    providers?: Record<string, AISDKProviderOptions>;
+    /** Attribution context for multi-agent safety */
+    attribution?: AttributionContext;
+    /** Telemetry settings */
+    telemetry?: AISDKTelemetrySettings;
+    /** Request timeout in milliseconds (default: 60000) */
+    timeout?: number;
+    /** Number of retries for retryable errors (default: 2) */
+    maxRetries?: number;
+    /** Maximum output tokens (default: 4096) */
+    maxOutputTokens?: number;
+    /** Enable debug logging (default: false) */
+    debugLogging?: boolean;
+    /** Redact sensitive data in logs (default: true) */
+    redactLogs?: boolean;
+}
+/**
+ * Error codes for AI SDK errors
+ */
+export type AISDKErrorCode = 'PROVIDER_ERROR' | 'RATE_LIMIT' | 'AUTHENTICATION' | 'INVALID_REQUEST' | 'MODEL_NOT_FOUND' | 'PROVIDER_NOT_FOUND' | 'TIMEOUT' | 'NETWORK' | 'CANCELLED' | 'MISSING_DEPENDENCY' | 'UNKNOWN';
+/**
+ * Custom error class for AI SDK errors
+ */
+export declare class AISDKError extends Error {
+    readonly code: AISDKErrorCode;
+    readonly isRetryable: boolean;
+    readonly cause?: unknown;
+    readonly statusCode?: number;
+    constructor(message: string, code: AISDKErrorCode, isRetryable: boolean, cause?: unknown, statusCode?: number);
+}
+/**
+ * Stream chunk types for streaming responses
+ */
+export type PraisonStreamChunk = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool-call-start';
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: 'tool-call-delta';
+    toolCallId: string;
+    argsTextDelta: string;
+} | {
+    type: 'tool-call-end';
+    toolCallId: string;
+    args: unknown;
+} | {
+    type: 'finish';
+    finishReason: string;
+    usage?: TokenUsage;
+} | {
+    type: 'error';
+    error: AISDKError;
+};
+/**
+ * Token usage information
+ */
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Finish reasons for generation
+ */
+export type FinishReason = 'stop' | 'length' | 'tool-calls' | 'content-filter' | 'error' | 'cancelled' | 'unknown';
+/**
+ * Tool definition for AI SDK
+ */
+export interface AISDKToolDefinition {
+    type: 'function';
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+}
+/**
+ * Tool call from AI SDK response
+ */
+export interface AISDKToolCall {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+}
+/**
+ * Tool result to send back to AI SDK
+ */
+export interface AISDKToolResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+}
+/**
+ * Safe defaults for AI SDK backend
+ */
+export declare const SAFE_DEFAULTS: {
+    readonly timeout: 60000;
+    readonly maxRetries: 2;
+    readonly maxOutputTokens: 4096;
+    readonly redactLogs: true;
+    readonly debugLogging: false;
+};
+/**
+ * Provider modality support
+ */
+export interface ProviderModalities {
+    text: boolean;
+    chat: boolean;
+    embeddings: boolean;
+    image: boolean;
+    audio: boolean;
+    speech: boolean;
+    tools: boolean;
+}
+/**
+ * Provider info with package, env key, and modalities
+ */
+export interface ProviderInfo {
+    package: string;
+    envKey: string;
+    modalities: ProviderModalities;
+    description?: string;
+    docsUrl?: string;
+}
+/**
+ * Supported AI SDK providers with their package names and capabilities
+ * Comprehensive list covering all AI SDK v6 providers
+ */
+export declare const AISDK_PROVIDERS: Record<string, ProviderInfo>;
+/**
+ * Provider aliases for convenience
+ */
+export declare const PROVIDER_ALIASES: Record<string, string>;
+/**
+ * Community provider registry for external/third-party providers
+ * These are not bundled but can be registered at runtime
+ */
+export interface CommunityProvider {
+    name: string;
+    package: string;
+    envKey: string;
+    description: string;
+    maintainer?: string;
+    repository?: string;
+}
+/**
+ * Known community providers (not bundled, user must install)
+ */
+export declare const COMMUNITY_PROVIDERS: CommunityProvider[];
+/**
+ * Adapter ecosystems (optional integrations)
+ */
+export interface AdapterInfo {
+    name: string;
+    package: string;
+    description: string;
+    type: 'langchain' | 'llamaindex' | 'other';
+}
+export declare const ADAPTERS: AdapterInfo[];