overai 1.4.0

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

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * 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: [...] });
+ * ```
+ */
+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 = exports.redactSensitiveData = exports.createStandardMiddleware = exports.composeMiddleware = exports.createTimeoutMiddleware = exports.createLoggingMiddleware = exports.createAttributionMiddleware = exports.createSimplePrompt = exports.toAISDKToolChoice = exports.mapFinishReasonToProvider = exports.mapFinishReason = exports.fromAISDKStreamChunk = exports.fromAISDKResult = exports.toAISDKToolResult = exports.fromAISDKToolCall = exports.toAISDKTools = exports.toAISDKPrompt = exports.getMissingApiKeyMessage = exports.validateProviderApiKey = exports.createAISDKProvider = exports.getCustomProvider = exports.unregisterCustomProvider = exports.registerCustomProvider = exports.listSupportedProviders = exports.getProviderEnvKey = exports.getProviderPackage = exports.isProviderSupported = exports.resolveProviderAlias = exports.parseModelString = exports.PROVIDER_ALIASES = exports.AISDK_PROVIDERS = exports.SAFE_DEFAULTS = exports.AISDKError = void 0;
+exports.getAISDKBackendClass = getAISDKBackendClass;
+exports.createAISDKBackend = createAISDKBackend;
+exports.registerAISDKProviders = registerAISDKProviders;
+exports.isAISDKAvailable = isAISDKAvailable;
+exports.getAISDKVersion = getAISDKVersion;
+var types_1 = require("./types");
+Object.defineProperty(exports, "AISDKError", { enumerable: true, get: function () { return types_1.AISDKError; } });
+Object.defineProperty(exports, "SAFE_DEFAULTS", { enumerable: true, get: function () { return types_1.SAFE_DEFAULTS; } });
+Object.defineProperty(exports, "AISDK_PROVIDERS", { enumerable: true, get: function () { return types_1.AISDK_PROVIDERS; } });
+Object.defineProperty(exports, "PROVIDER_ALIASES", { enumerable: true, get: function () { return types_1.PROVIDER_ALIASES; } });
+// Re-export provider map functions
+var provider_map_1 = require("./provider-map");
+Object.defineProperty(exports, "parseModelString", { enumerable: true, get: function () { return provider_map_1.parseModelString; } });
+Object.defineProperty(exports, "resolveProviderAlias", { enumerable: true, get: function () { return provider_map_1.resolveProviderAlias; } });
+Object.defineProperty(exports, "isProviderSupported", { enumerable: true, get: function () { return provider_map_1.isProviderSupported; } });
+Object.defineProperty(exports, "getProviderPackage", { enumerable: true, get: function () { return provider_map_1.getProviderPackage; } });
+Object.defineProperty(exports, "getProviderEnvKey", { enumerable: true, get: function () { return provider_map_1.getProviderEnvKey; } });
+Object.defineProperty(exports, "listSupportedProviders", { enumerable: true, get: function () { return provider_map_1.listSupportedProviders; } });
+Object.defineProperty(exports, "registerCustomProvider", { enumerable: true, get: function () { return provider_map_1.registerCustomProvider; } });
+Object.defineProperty(exports, "unregisterCustomProvider", { enumerable: true, get: function () { return provider_map_1.unregisterCustomProvider; } });
+Object.defineProperty(exports, "getCustomProvider", { enumerable: true, get: function () { return provider_map_1.getCustomProvider; } });
+Object.defineProperty(exports, "createAISDKProvider", { enumerable: true, get: function () { return provider_map_1.createAISDKProvider; } });
+Object.defineProperty(exports, "validateProviderApiKey", { enumerable: true, get: function () { return provider_map_1.validateProviderApiKey; } });
+Object.defineProperty(exports, "getMissingApiKeyMessage", { enumerable: true, get: function () { return provider_map_1.getMissingApiKeyMessage; } });
+// Re-export adapter functions
+var adapter_1 = require("./adapter");
+Object.defineProperty(exports, "toAISDKPrompt", { enumerable: true, get: function () { return adapter_1.toAISDKPrompt; } });
+Object.defineProperty(exports, "toAISDKTools", { enumerable: true, get: function () { return adapter_1.toAISDKTools; } });
+Object.defineProperty(exports, "fromAISDKToolCall", { enumerable: true, get: function () { return adapter_1.fromAISDKToolCall; } });
+Object.defineProperty(exports, "toAISDKToolResult", { enumerable: true, get: function () { return adapter_1.toAISDKToolResult; } });
+Object.defineProperty(exports, "fromAISDKResult", { enumerable: true, get: function () { return adapter_1.fromAISDKResult; } });
+Object.defineProperty(exports, "fromAISDKStreamChunk", { enumerable: true, get: function () { return adapter_1.fromAISDKStreamChunk; } });
+Object.defineProperty(exports, "mapFinishReason", { enumerable: true, get: function () { return adapter_1.mapFinishReason; } });
+Object.defineProperty(exports, "mapFinishReasonToProvider", { enumerable: true, get: function () { return adapter_1.mapFinishReasonToProvider; } });
+Object.defineProperty(exports, "toAISDKToolChoice", { enumerable: true, get: function () { return adapter_1.toAISDKToolChoice; } });
+Object.defineProperty(exports, "createSimplePrompt", { enumerable: true, get: function () { return adapter_1.createSimplePrompt; } });
+// Re-export middleware functions
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "createAttributionMiddleware", { enumerable: true, get: function () { return middleware_1.createAttributionMiddleware; } });
+Object.defineProperty(exports, "createLoggingMiddleware", { enumerable: true, get: function () { return middleware_1.createLoggingMiddleware; } });
+Object.defineProperty(exports, "createTimeoutMiddleware", { enumerable: true, get: function () { return middleware_1.createTimeoutMiddleware; } });
+Object.defineProperty(exports, "composeMiddleware", { enumerable: true, get: function () { return middleware_1.composeMiddleware; } });
+Object.defineProperty(exports, "createStandardMiddleware", { enumerable: true, get: function () { return middleware_1.createStandardMiddleware; } });
+Object.defineProperty(exports, "redactSensitiveData", { enumerable: true, get: function () { return middleware_1.redactSensitiveData; } });
+// Lazy-loaded backend exports
+// These use getters to avoid importing the backend module until needed
+let _AISDKBackend = null;
+let _createAISDKBackend = null;
+/**
+ * Get the AISDKBackend class (lazy loaded)
+ */
+function getAISDKBackendClass() {
+    if (!_AISDKBackend) {
+        const backend = require('./backend');
+        _AISDKBackend = backend.AISDKBackend;
+    }
+    return _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');
+ * ```
+ */
+function createAISDKBackend(modelString, config) {
+    if (!_createAISDKBackend) {
+        const backend = require('./backend');
+        _createAISDKBackend = backend.createAISDKBackend;
+    }
+    return _createAISDKBackend(modelString, config);
+}
+// Re-export the class for direct instantiation
+var backend_1 = require("./backend");
+Object.defineProperty(exports, "AISDKBackend", { enumerable: true, get: function () { return backend_1.AISDKBackend; } });
+/**
+ * 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');
+ * ```
+ */
+function registerAISDKProviders(customProviders) {
+    // Register custom providers if provided
+    if (customProviders) {
+        const { registerCustomProvider } = require('./provider-map');
+        for (const [id, factory] of Object.entries(customProviders)) {
+            registerCustomProvider(id, factory);
+        }
+    }
+    // Note: Integration with main provider registry is done in ../index.ts
+    // This function is mainly for registering custom AI SDK providers
+}
+/**
+ * Check if AI SDK is available (installed)
+ */
+async function isAISDKAvailable() {
+    try {
+        // Use variable to prevent TypeScript from resolving at compile time
+        const moduleName = 'ai';
+        await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get AI SDK version if available
+ */
+async function getAISDKVersion() {
+    try {
+        // Use variable to prevent TypeScript from resolving at compile time
+        const moduleName = 'ai';
+        await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+        // AI SDK doesn't export version directly, so we check package.json
+        try {
+            const pkgPath = 'ai/package.json';
+            const pkg = require(pkgPath);
+            return pkg.version;
+        }
+        catch {
+            return 'installed';
+        }
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,60 @@
+/**
+ * AI SDK Middleware
+ *
+ * Provides middleware for injecting attribution context into AI SDK calls.
+ * Supports multi-agent safety with agent_id, run_id, trace_id, session_id.
+ */
+import type { AttributionContext, AISDKBackendConfig } from './types';
+/**
+ * Middleware interface for AI SDK language models
+ * Compatible with AI SDK's LanguageModelMiddleware type
+ */
+export interface AISDKMiddleware {
+    transformParams?: (options: {
+        params: Record<string, unknown>;
+        type: 'generate' | 'stream';
+        model: unknown;
+    }) => Promise<Record<string, unknown>> | Record<string, unknown>;
+    wrapGenerate?: (options: {
+        doGenerate: () => Promise<unknown>;
+        doStream: () => Promise<unknown>;
+        params: Record<string, unknown>;
+        model: unknown;
+    }) => Promise<unknown>;
+    wrapStream?: (options: {
+        doGenerate: () => Promise<unknown>;
+        doStream: () => Promise<unknown>;
+        params: Record<string, unknown>;
+        model: unknown;
+    }) => Promise<unknown>;
+}
+/**
+ * Create attribution middleware that injects agent context into requests
+ *
+ * Injects:
+ * - Headers: X-Agent-Id, X-Run-Id, X-Trace-Id, X-Session-Id
+ * - Provider options metadata where supported
+ */
+export declare function createAttributionMiddleware(ctx: AttributionContext): AISDKMiddleware;
+/**
+ * Create logging middleware for debug purposes
+ * Only logs when debugLogging is enabled
+ */
+export declare function createLoggingMiddleware(config: AISDKBackendConfig): AISDKMiddleware;
+/**
+ * Create timeout middleware that wraps requests with AbortController
+ */
+export declare function createTimeoutMiddleware(timeoutMs: number): AISDKMiddleware;
+/**
+ * Compose multiple middlewares into one
+ * Middlewares are applied in order (first transforms first, last wraps innermost)
+ */
+export declare function composeMiddleware(...middlewares: AISDKMiddleware[]): AISDKMiddleware;
+/**
+ * Redact sensitive data from objects for safe logging
+ */
+export declare function redactSensitiveData(obj: unknown): unknown;
+/**
+ * Create all standard middlewares for the AI SDK backend
+ */
+export declare function createStandardMiddleware(config: AISDKBackendConfig, attribution?: AttributionContext): AISDKMiddleware;

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

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * AI SDK Middleware
+ *
+ * Provides middleware for injecting attribution context into AI SDK calls.
+ * Supports multi-agent safety with agent_id, run_id, trace_id, session_id.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAttributionMiddleware = createAttributionMiddleware;
+exports.createLoggingMiddleware = createLoggingMiddleware;
+exports.createTimeoutMiddleware = createTimeoutMiddleware;
+exports.composeMiddleware = composeMiddleware;
+exports.redactSensitiveData = redactSensitiveData;
+exports.createStandardMiddleware = createStandardMiddleware;
+/**
+ * Create attribution middleware that injects agent context into requests
+ *
+ * Injects:
+ * - Headers: X-Agent-Id, X-Run-Id, X-Trace-Id, X-Session-Id
+ * - Provider options metadata where supported
+ */
+function createAttributionMiddleware(ctx) {
+    return {
+        transformParams: async ({ params }) => {
+            // Build attribution headers
+            const attributionHeaders = {};
+            if (ctx.agentId) {
+                attributionHeaders['X-Agent-Id'] = ctx.agentId;
+            }
+            if (ctx.runId) {
+                attributionHeaders['X-Run-Id'] = ctx.runId;
+            }
+            if (ctx.traceId) {
+                attributionHeaders['X-Trace-Id'] = ctx.traceId;
+            }
+            if (ctx.sessionId) {
+                attributionHeaders['X-Session-Id'] = ctx.sessionId;
+            }
+            if (ctx.parentSpanId) {
+                attributionHeaders['X-Parent-Span-Id'] = ctx.parentSpanId;
+            }
+            // Merge with existing headers
+            const existingHeaders = params.headers || {};
+            const mergedHeaders = {
+                ...existingHeaders,
+                ...attributionHeaders
+            };
+            // Build provider options metadata
+            const attributionMetadata = {};
+            if (ctx.agentId)
+                attributionMetadata.agentId = ctx.agentId;
+            if (ctx.runId)
+                attributionMetadata.runId = ctx.runId;
+            if (ctx.traceId)
+                attributionMetadata.traceId = ctx.traceId;
+            if (ctx.sessionId)
+                attributionMetadata.sessionId = ctx.sessionId;
+            // Merge with existing provider options
+            const existingProviderOptions = params.providerOptions || {};
+            const existingMetadata = existingProviderOptions.metadata || {};
+            const mergedProviderOptions = {
+                ...existingProviderOptions,
+                metadata: {
+                    ...existingMetadata,
+                    ...attributionMetadata
+                }
+            };
+            return {
+                ...params,
+                headers: mergedHeaders,
+                providerOptions: mergedProviderOptions
+            };
+        }
+    };
+}
+/**
+ * Create logging middleware for debug purposes
+ * Only logs when debugLogging is enabled
+ */
+function createLoggingMiddleware(config) {
+    if (!config.debugLogging) {
+        return {};
+    }
+    return {
+        transformParams: async ({ params, type }) => {
+            const safeParams = config.redactLogs !== false
+                ? redactSensitiveData(params)
+                : params;
+            console.log(`[AI SDK] ${type} request:`, JSON.stringify(safeParams, null, 2));
+            return params;
+        },
+        wrapGenerate: async ({ doGenerate, params }) => {
+            const startTime = Date.now();
+            try {
+                const result = await doGenerate();
+                const duration = Date.now() - startTime;
+                console.log(`[AI SDK] generate completed in ${duration}ms`);
+                return result;
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                console.error(`[AI SDK] generate failed after ${duration}ms:`, error);
+                throw error;
+            }
+        },
+        wrapStream: async ({ doStream, params }) => {
+            const startTime = Date.now();
+            console.log(`[AI SDK] stream started`);
+            try {
+                const result = await doStream();
+                const duration = Date.now() - startTime;
+                console.log(`[AI SDK] stream setup completed in ${duration}ms`);
+                return result;
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                console.error(`[AI SDK] stream failed after ${duration}ms:`, error);
+                throw error;
+            }
+        }
+    };
+}
+/**
+ * Create timeout middleware that wraps requests with AbortController
+ */
+function createTimeoutMiddleware(timeoutMs) {
+    return {
+        transformParams: async ({ params }) => {
+            // If there's already an abort signal, don't override it
+            if (params.abortSignal) {
+                return params;
+            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => {
+                controller.abort(new Error(`Request timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            // Store timeout ID for cleanup (attached to signal)
+            controller.signal.__timeoutId = timeoutId;
+            return {
+                ...params,
+                abortSignal: controller.signal
+            };
+        }
+    };
+}
+/**
+ * Compose multiple middlewares into one
+ * Middlewares are applied in order (first transforms first, last wraps innermost)
+ */
+function composeMiddleware(...middlewares) {
+    const validMiddlewares = middlewares.filter(m => m && Object.keys(m).length > 0);
+    if (validMiddlewares.length === 0) {
+        return {};
+    }
+    if (validMiddlewares.length === 1) {
+        return validMiddlewares[0];
+    }
+    return {
+        transformParams: async (options) => {
+            let params = options.params;
+            for (const middleware of validMiddlewares) {
+                if (middleware.transformParams) {
+                    params = await middleware.transformParams({
+                        ...options,
+                        params
+                    });
+                }
+            }
+            return params;
+        },
+        wrapGenerate: async (options) => {
+            // Build nested wrapper from inside out
+            let doGenerate = options.doGenerate;
+            for (let i = validMiddlewares.length - 1; i >= 0; i--) {
+                const middleware = validMiddlewares[i];
+                if (middleware.wrapGenerate) {
+                    const currentDoGenerate = doGenerate;
+                    const currentMiddleware = middleware;
+                    doGenerate = () => currentMiddleware.wrapGenerate({
+                        ...options,
+                        doGenerate: currentDoGenerate
+                    });
+                }
+            }
+            return doGenerate();
+        },
+        wrapStream: async (options) => {
+            // Build nested wrapper from inside out
+            let doStream = options.doStream;
+            for (let i = validMiddlewares.length - 1; i >= 0; i--) {
+                const middleware = validMiddlewares[i];
+                if (middleware.wrapStream) {
+                    const currentDoStream = doStream;
+                    const currentMiddleware = middleware;
+                    doStream = () => currentMiddleware.wrapStream({
+                        ...options,
+                        doStream: currentDoStream
+                    });
+                }
+            }
+            return doStream();
+        }
+    };
+}
+/**
+ * Redact sensitive data from objects for safe logging
+ */
+function redactSensitiveData(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(redactSensitiveData);
+    }
+    const result = {};
+    const sensitiveKeys = [
+        'apiKey', 'api_key', 'apikey',
+        'token', 'secret', 'password',
+        'authorization', 'auth',
+        'key', 'credential', 'credentials'
+    ];
+    for (const [key, value] of Object.entries(obj)) {
+        const lowerKey = key.toLowerCase();
+        if (sensitiveKeys.some(sk => lowerKey.includes(sk))) {
+            if (typeof value === 'string' && value.length > 4) {
+                result[key] = value.slice(0, 4) + '****';
+            }
+            else {
+                result[key] = '****';
+            }
+        }
+        else if (typeof value === 'object') {
+            result[key] = redactSensitiveData(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Create all standard middlewares for the AI SDK backend
+ */
+function createStandardMiddleware(config, attribution) {
+    const middlewares = [];
+    // Attribution middleware (if context provided)
+    if (attribution && Object.keys(attribution).length > 0) {
+        middlewares.push(createAttributionMiddleware(attribution));
+    }
+    // Timeout middleware
+    if (config.timeout && config.timeout > 0) {
+        middlewares.push(createTimeoutMiddleware(config.timeout));
+    }
+    // Logging middleware (only if debug enabled)
+    if (config.debugLogging) {
+        middlewares.push(createLoggingMiddleware(config));
+    }
+    return composeMiddleware(...middlewares);
+}

package/dist/llm/providers/ai-sdk/provider-map.d.ts

@@ -0,0 +1,75 @@
+/**
+ * AI SDK Provider Map
+ *
+ * Maps model strings to AI SDK providers with lazy loading.
+ * Supports formats: "provider/model" or "model" (uses default provider)
+ */
+import { AISDKProviderOptions } from './types';
+/**
+ * Parsed model string result
+ */
+export interface ParsedModel {
+    providerId: string;
+    modelId: string;
+}
+/**
+ * Provider factory function type
+ */
+export type ProviderFactory = (options?: AISDKProviderOptions) => unknown;
+/**
+ * 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" }
+ */
+export declare function parseModelString(model: string, defaultProvider?: string): ParsedModel;
+/**
+ * Resolve provider alias to canonical name
+ */
+export declare function resolveProviderAlias(providerId: string): string;
+/**
+ * Check if a provider is supported
+ */
+export declare function isProviderSupported(providerId: string): boolean;
+/**
+ * Get the package name for a provider
+ */
+export declare function getProviderPackage(providerId: string): string | null;
+/**
+ * Get the environment variable key for a provider's API key
+ */
+export declare function getProviderEnvKey(providerId: string): string | null;
+/**
+ * List all supported providers
+ */
+export declare function listSupportedProviders(): string[];
+/**
+ * Register a custom provider factory
+ *
+ * @example
+ * registerCustomProvider('my-provider', (options) => createMyProvider(options));
+ */
+export declare function registerCustomProvider(providerId: string, factory: ProviderFactory): void;
+/**
+ * Unregister a custom provider
+ */
+export declare function unregisterCustomProvider(providerId: string): boolean;
+/**
+ * Get a custom provider factory
+ */
+export declare function getCustomProvider(providerId: string): ProviderFactory | undefined;
+/**
+ * Dynamically import and create an AI SDK provider
+ * Uses lazy loading to avoid importing AI SDK packages until needed
+ */
+export declare function createAISDKProvider(providerId: string, options?: AISDKProviderOptions): Promise<unknown>;
+/**
+ * Validate that a provider has the required API key
+ */
+export declare function validateProviderApiKey(providerId: string): boolean;
+/**
+ * Get missing API key message for a provider
+ */
+export declare function getMissingApiKeyMessage(providerId: string): string;