overai 1.4.0

package/dist/llm/providers/google.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Google Provider - Implementation for Google Gemini API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleProvider = void 0;
+const base_1 = require("./base");
+class GoogleProvider extends base_1.BaseProvider {
+    constructor(modelId, config = {}) {
+        super(modelId, config);
+        this.providerId = 'google';
+        this.apiKey = config.apiKey || process.env.GOOGLE_API_KEY || '';
+        this.baseUrl = config.baseUrl || 'https://generativelanguage.googleapis.com/v1beta';
+        if (!this.apiKey) {
+            throw new Error('GOOGLE_API_KEY is required');
+        }
+    }
+    async generateText(options) {
+        return this.withRetry(async () => {
+            const { systemInstruction, contents } = this.formatRequest(options.messages);
+            const response = await fetch(`${this.baseUrl}/models/${this.modelId}:generateContent?key=${this.apiKey}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+                    contents,
+                    generationConfig: {
+                        temperature: options.temperature ?? 0.7,
+                        maxOutputTokens: options.maxTokens,
+                        topP: options.topP,
+                        stopSequences: options.stop,
+                    },
+                    tools: options.tools ? this.formatTools(options.tools) : undefined,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw Object.assign(new Error(error.error?.message || `Google API error: ${response.status}`), {
+                    status: response.status,
+                });
+            }
+            const data = await response.json();
+            const candidate = data.candidates?.[0];
+            let text = '';
+            const toolCalls = [];
+            for (const part of candidate?.content?.parts || []) {
+                if (part.text) {
+                    text += part.text;
+                }
+                else if (part.functionCall) {
+                    toolCalls.push({
+                        id: `call_${Math.random().toString(36).substr(2, 9)}`,
+                        type: 'function',
+                        function: {
+                            name: part.functionCall.name,
+                            arguments: JSON.stringify(part.functionCall.args || {}),
+                        },
+                    });
+                }
+            }
+            return {
+                text,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                usage: {
+                    promptTokens: data.usageMetadata?.promptTokenCount || 0,
+                    completionTokens: data.usageMetadata?.candidatesTokenCount || 0,
+                    totalTokens: data.usageMetadata?.totalTokenCount || 0,
+                },
+                finishReason: this.mapFinishReason(candidate?.finishReason),
+                raw: data,
+            };
+        });
+    }
+    async streamText(options) {
+        const self = this;
+        const { systemInstruction, contents } = this.formatRequest(options.messages);
+        return {
+            async *[Symbol.asyncIterator]() {
+                const response = await fetch(`${self.baseUrl}/models/${self.modelId}:streamGenerateContent?key=${self.apiKey}&alt=sse`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+                        contents,
+                        generationConfig: {
+                            temperature: options.temperature ?? 0.7,
+                            maxOutputTokens: options.maxTokens,
+                        },
+                        tools: options.tools ? self.formatTools(options.tools) : undefined,
+                    }),
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({}));
+                    throw new Error(error.error?.message || `Google API error: ${response.status}`);
+                }
+                const reader = response.body?.getReader();
+                if (!reader)
+                    throw new Error('No response body');
+                const decoder = new TextDecoder();
+                let buffer = '';
+                const toolCalls = [];
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const data = line.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const event = JSON.parse(data);
+                            const candidate = event.candidates?.[0];
+                            for (const part of candidate?.content?.parts || []) {
+                                if (part.text) {
+                                    if (options.onToken)
+                                        options.onToken(part.text);
+                                    yield { text: part.text };
+                                }
+                                else if (part.functionCall) {
+                                    toolCalls.push({
+                                        id: `call_${Math.random().toString(36).substr(2, 9)}`,
+                                        type: 'function',
+                                        function: {
+                                            name: part.functionCall.name,
+                                            arguments: JSON.stringify(part.functionCall.args || {}),
+                                        },
+                                    });
+                                }
+                            }
+                            if (candidate?.finishReason) {
+                                yield {
+                                    finishReason: self.mapFinishReason(candidate.finishReason),
+                                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                                    usage: event.usageMetadata ? {
+                                        promptTokens: event.usageMetadata.promptTokenCount || 0,
+                                        completionTokens: event.usageMetadata.candidatesTokenCount || 0,
+                                        totalTokens: event.usageMetadata.totalTokenCount || 0,
+                                    } : undefined,
+                                };
+                            }
+                        }
+                        catch (e) {
+                            // Skip malformed JSON
+                        }
+                    }
+                }
+            },
+        };
+    }
+    async generateObject(options) {
+        const { systemInstruction, contents } = this.formatRequest(options.messages);
+        return this.withRetry(async () => {
+            const response = await fetch(`${this.baseUrl}/models/${this.modelId}:generateContent?key=${this.apiKey}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    systemInstruction: systemInstruction
+                        ? { parts: [{ text: `${systemInstruction}\n\nRespond with valid JSON matching this schema:\n${JSON.stringify(options.schema, null, 2)}` }] }
+                        : { parts: [{ text: `Respond with valid JSON matching this schema:\n${JSON.stringify(options.schema, null, 2)}` }] },
+                    contents,
+                    generationConfig: {
+                        temperature: options.temperature ?? 0.7,
+                        maxOutputTokens: options.maxTokens,
+                        responseMimeType: 'application/json',
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || `Google API error: ${response.status}`);
+            }
+            const data = await response.json();
+            const candidate = data.candidates?.[0];
+            let text = '';
+            for (const part of candidate?.content?.parts || []) {
+                if (part.text)
+                    text += part.text;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch (e) {
+                // Try to extract JSON from text
+                const jsonMatch = text.match(/\{[\s\S]*\}/);
+                if (!jsonMatch)
+                    throw new Error(`No JSON found: ${text}`);
+                parsed = JSON.parse(jsonMatch[0]);
+            }
+            return {
+                object: parsed,
+                usage: {
+                    promptTokens: data.usageMetadata?.promptTokenCount || 0,
+                    completionTokens: data.usageMetadata?.candidatesTokenCount || 0,
+                    totalTokens: data.usageMetadata?.totalTokenCount || 0,
+                },
+                raw: data,
+            };
+        });
+    }
+    formatRequest(messages) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const otherMessages = messages.filter(m => m.role !== 'system');
+        const systemInstruction = systemMessages.length > 0
+            ? systemMessages.map(m => m.content).join('\n')
+            : null;
+        return {
+            systemInstruction,
+            contents: this.formatMessages(otherMessages),
+        };
+    }
+    formatMessages(messages) {
+        const result = [];
+        for (const msg of messages) {
+            if (msg.role === 'system')
+                continue;
+            const role = msg.role === 'assistant' ? 'model' : 'user';
+            if (msg.role === 'tool') {
+                result.push({
+                    role: 'user',
+                    parts: [{
+                            functionResponse: {
+                                name: msg.name || 'function',
+                                response: { result: msg.content },
+                            },
+                        }],
+                });
+            }
+            else if (msg.role === 'assistant' && msg.tool_calls) {
+                const parts = [];
+                if (msg.content)
+                    parts.push({ text: msg.content });
+                for (const tc of msg.tool_calls) {
+                    parts.push({
+                        functionCall: {
+                            name: tc.function.name,
+                            args: JSON.parse(tc.function.arguments),
+                        },
+                    });
+                }
+                result.push({ role: 'model', parts });
+            }
+            else {
+                result.push({
+                    role,
+                    parts: [{ text: msg.content || '' }],
+                });
+            }
+        }
+        return result;
+    }
+    formatTools(tools) {
+        return [{
+                functionDeclarations: tools.map(tool => ({
+                    name: tool.name,
+                    description: tool.description || `Function ${tool.name}`,
+                    parameters: tool.parameters || { type: 'object', properties: {} },
+                })),
+            }];
+    }
+    mapFinishReason(reason) {
+        switch (reason) {
+            case 'STOP': return 'stop';
+            case 'MAX_TOKENS': return 'length';
+            case 'SAFETY': return 'content_filter';
+            default: return 'stop';
+        }
+    }
+}
+exports.GoogleProvider = GoogleProvider;

package/dist/llm/providers/index.d.ts

@@ -0,0 +1,107 @@
+/**
+ * LLM Providers - Factory and exports for multi-provider support
+ *
+ * This module provides an extensible provider registry system that allows
+ * users to register custom providers (e.g., Cloudflare, Ollama) alongside
+ * the built-in providers (OpenAI, Anthropic, Google).
+ *
+ * @example Register a custom provider
+ * ```typescript
+ * import { registerProvider, Agent } from 'praisonai';
+ * import { CloudflareProvider } from './my-cloudflare-provider';
+ *
+ * registerProvider('cloudflare', CloudflareProvider);
+ * const agent = new Agent({ llm: 'cloudflare/workers-ai' });
+ * ```
+ */
+export * from './types';
+export * from './base';
+export { OpenAIProvider } from './openai';
+export { AnthropicProvider } from './anthropic';
+export { GoogleProvider } from './google';
+export { ProviderRegistry, ProviderConstructor, ProviderLoader, RegisterOptions, IProviderRegistry, getDefaultRegistry, createProviderRegistry, registerProvider, unregisterProvider, hasProvider, listProviders, registerBuiltinProviders, } from './registry';
+import type { LLMProvider, ProviderConfig } from './types';
+import type { ProviderRegistry } from './registry';
+/**
+ * Parse model string into provider and model ID
+ * Supports formats:
+ * - "provider/model" (e.g., "openai/gpt-4o")
+ * - "model" (defaults to OpenAI, e.g., "gpt-4o-mini")
+ */
+export declare function parseModelString(model: string): {
+    providerId: string;
+    modelId: string;
+};
+/**
+ * Input types for createProvider
+ */
+export type ProviderInput = string | LLMProvider | {
+    name: string;
+    modelId?: string;
+    config?: ProviderConfig;
+};
+/**
+ * Options for createProvider
+ */
+export interface CreateProviderOptions {
+    /** Override the default registry */
+    registry?: ProviderRegistry;
+    /** Provider configuration */
+    config?: ProviderConfig;
+    /** Model ID (used when input is a constructor or spec without modelId) */
+    modelId?: string;
+}
+/**
+ * Create a provider instance from various input types
+ *
+ * @example String input (backward compatible)
+ * ```typescript
+ * const provider = createProvider('openai/gpt-4o');
+ * const provider = createProvider('anthropic/claude-3-5-sonnet-latest');
+ * const provider = createProvider('google/gemini-2.0-flash');
+ * const provider = createProvider('gpt-4o-mini'); // Defaults to OpenAI
+ * ```
+ *
+ * @example Custom provider (after registration)
+ * ```typescript
+ * registerProvider('cloudflare', CloudflareProvider);
+ * const provider = createProvider('cloudflare/workers-ai');
+ * ```
+ *
+ * @example Provider instance (pass-through)
+ * ```typescript
+ * const myProvider = new CustomProvider('model');
+ * const provider = createProvider(myProvider); // Returns same instance
+ * ```
+ *
+ * @example Spec object
+ * ```typescript
+ * const provider = createProvider({ name: 'openai', modelId: 'gpt-4o', config: { timeout: 5000 } });
+ * ```
+ */
+export declare function createProvider(input: ProviderInput, options?: CreateProviderOptions | ProviderConfig): LLMProvider;
+/**
+ * Get the default provider (OpenAI with gpt-4o-mini)
+ */
+export declare function getDefaultProvider(config?: ProviderConfig): LLMProvider;
+/**
+ * Check if a provider is available (has required API key)
+ */
+export declare function isProviderAvailable(providerId: string): boolean;
+/**
+ * Get list of available providers (registered and with API keys)
+ */
+export declare function getAvailableProviders(): string[];
+/**
+ * AI SDK Backend - Multi-provider LLM support via Vercel's AI SDK
+ *
+ * @example
+ * ```typescript
+ * import { createAISDKBackend } from 'praisonai';
+ *
+ * const backend = createAISDKBackend('anthropic/claude-3-5-sonnet');
+ * const result = await backend.generateText({ messages: [...] });
+ * ```
+ */
+export { AISDKBackend, createAISDKBackend, isProviderSupported as isAISDKProviderSupported, listSupportedProviders as listAISDKProviders, registerCustomProvider as registerAISDKCustomProvider, validateProviderApiKey as validateAISDKProviderApiKey, getMissingApiKeyMessage as getAISDKMissingApiKeyMessage, isAISDKAvailable, getAISDKVersion, AISDKError, SAFE_DEFAULTS as AISDK_SAFE_DEFAULTS, AISDK_PROVIDERS, PROVIDER_ALIASES as AISDK_PROVIDER_ALIASES, createAttributionMiddleware, createStandardMiddleware, redactSensitiveData, } from './ai-sdk';
+export type { AISDKBackendConfig, AISDKProviderOptions, AttributionContext, AISDKTelemetrySettings, AISDKErrorCode, PraisonStreamChunk, AISDKToolDefinition, AISDKToolCall, AISDKToolResult, AISDKMiddleware, } from './ai-sdk';

package/dist/llm/providers/index.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * LLM Providers - Factory and exports for multi-provider support
+ *
+ * This module provides an extensible provider registry system that allows
+ * users to register custom providers (e.g., Cloudflare, Ollama) alongside
+ * the built-in providers (OpenAI, Anthropic, Google).
+ *
+ * @example Register a custom provider
+ * ```typescript
+ * import { registerProvider, Agent } from 'praisonai';
+ * import { CloudflareProvider } from './my-cloudflare-provider';
+ *
+ * registerProvider('cloudflare', CloudflareProvider);
+ * const agent = new Agent({ llm: 'cloudflare/workers-ai' });
+ * ```
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactSensitiveData = exports.createStandardMiddleware = exports.createAttributionMiddleware = exports.AISDK_PROVIDER_ALIASES = exports.AISDK_PROVIDERS = exports.AISDK_SAFE_DEFAULTS = exports.AISDKError = exports.getAISDKVersion = exports.isAISDKAvailable = exports.getAISDKMissingApiKeyMessage = exports.validateAISDKProviderApiKey = exports.registerAISDKCustomProvider = exports.listAISDKProviders = exports.isAISDKProviderSupported = exports.createAISDKBackend = exports.AISDKBackend = exports.registerBuiltinProviders = exports.listProviders = exports.hasProvider = exports.unregisterProvider = exports.registerProvider = exports.createProviderRegistry = exports.getDefaultRegistry = exports.ProviderRegistry = exports.GoogleProvider = exports.AnthropicProvider = exports.OpenAIProvider = void 0;
+exports.parseModelString = parseModelString;
+exports.createProvider = createProvider;
+exports.getDefaultProvider = getDefaultProvider;
+exports.isProviderAvailable = isProviderAvailable;
+exports.getAvailableProviders = getAvailableProviders;
+__exportStar(require("./types"), exports);
+__exportStar(require("./base"), exports);
+var openai_1 = require("./openai");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_1.OpenAIProvider; } });
+var anthropic_1 = require("./anthropic");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_1.AnthropicProvider; } });
+var google_1 = require("./google");
+Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return google_1.GoogleProvider; } });
+// Export registry types and functions
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "ProviderRegistry", { enumerable: true, get: function () { return registry_1.ProviderRegistry; } });
+Object.defineProperty(exports, "getDefaultRegistry", { enumerable: true, get: function () { return registry_1.getDefaultRegistry; } });
+Object.defineProperty(exports, "createProviderRegistry", { enumerable: true, get: function () { return registry_1.createProviderRegistry; } });
+Object.defineProperty(exports, "registerProvider", { enumerable: true, get: function () { return registry_1.registerProvider; } });
+Object.defineProperty(exports, "unregisterProvider", { enumerable: true, get: function () { return registry_1.unregisterProvider; } });
+Object.defineProperty(exports, "hasProvider", { enumerable: true, get: function () { return registry_1.hasProvider; } });
+Object.defineProperty(exports, "listProviders", { enumerable: true, get: function () { return registry_1.listProviders; } });
+Object.defineProperty(exports, "registerBuiltinProviders", { enumerable: true, get: function () { return registry_1.registerBuiltinProviders; } });
+const registry_2 = require("./registry");
+/**
+ * Parse model string into provider and model ID
+ * Supports formats:
+ * - "provider/model" (e.g., "openai/gpt-4o")
+ * - "model" (defaults to OpenAI, e.g., "gpt-4o-mini")
+ */
+function parseModelString(model) {
+    if (model.includes('/')) {
+        const [providerId, ...rest] = model.split('/');
+        return { providerId: providerId.toLowerCase(), modelId: rest.join('/') };
+    }
+    // Default to OpenAI for common model prefixes
+    if (model.startsWith('gpt-') || model.startsWith('o1') || model.startsWith('o3')) {
+        return { providerId: 'openai', modelId: model };
+    }
+    if (model.startsWith('claude-')) {
+        return { providerId: 'anthropic', modelId: model };
+    }
+    if (model.startsWith('gemini-')) {
+        return { providerId: 'google', modelId: model };
+    }
+    // Default to OpenAI
+    return { providerId: 'openai', modelId: model };
+}
+/**
+ * Create a provider instance from various input types
+ *
+ * @example String input (backward compatible)
+ * ```typescript
+ * const provider = createProvider('openai/gpt-4o');
+ * const provider = createProvider('anthropic/claude-3-5-sonnet-latest');
+ * const provider = createProvider('google/gemini-2.0-flash');
+ * const provider = createProvider('gpt-4o-mini'); // Defaults to OpenAI
+ * ```
+ *
+ * @example Custom provider (after registration)
+ * ```typescript
+ * registerProvider('cloudflare', CloudflareProvider);
+ * const provider = createProvider('cloudflare/workers-ai');
+ * ```
+ *
+ * @example Provider instance (pass-through)
+ * ```typescript
+ * const myProvider = new CustomProvider('model');
+ * const provider = createProvider(myProvider); // Returns same instance
+ * ```
+ *
+ * @example Spec object
+ * ```typescript
+ * const provider = createProvider({ name: 'openai', modelId: 'gpt-4o', config: { timeout: 5000 } });
+ * ```
+ */
+function createProvider(input, options) {
+    // Handle legacy signature: createProvider(model, config)
+    const opts = options && 'registry' in options
+        ? options
+        : { config: options };
+    const registry = opts.registry || (0, registry_2.getDefaultRegistry)();
+    // Case 1: Already a provider instance - pass through
+    if (isProviderInstance(input)) {
+        return input;
+    }
+    // Case 2: Spec object
+    if (typeof input === 'object' && 'name' in input) {
+        const { name, modelId, config } = input;
+        return registry.resolve(name, modelId || 'default', config || opts.config);
+    }
+    // Case 3: String - parse and resolve
+    if (typeof input === 'string') {
+        const { providerId, modelId } = parseModelString(input);
+        return registry.resolve(providerId, modelId, opts.config);
+    }
+    throw new Error(`Invalid provider input. Expected string, provider instance, or spec object. ` +
+        `Got: ${typeof input}`);
+}
+/**
+ * Type guard to check if value is a provider instance
+ */
+function isProviderInstance(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'providerId' in value &&
+        'modelId' in value &&
+        'generateText' in value &&
+        typeof value.generateText === 'function');
+}
+/**
+ * Get the default provider (OpenAI with gpt-4o-mini)
+ */
+function getDefaultProvider(config) {
+    return createProvider('openai/gpt-4o-mini', config);
+}
+/**
+ * Check if a provider is available (has required API key)
+ */
+function isProviderAvailable(providerId) {
+    const normalizedId = providerId.toLowerCase();
+    // Check if provider is registered
+    if (!(0, registry_2.getDefaultRegistry)().has(normalizedId)) {
+        return false;
+    }
+    // Check for API keys based on known providers
+    switch (normalizedId) {
+        case 'openai':
+        case 'oai':
+            return !!process.env.OPENAI_API_KEY;
+        case 'anthropic':
+        case 'claude':
+            return !!process.env.ANTHROPIC_API_KEY;
+        case 'google':
+        case 'gemini':
+            return !!process.env.GOOGLE_API_KEY;
+        default:
+            // For custom providers, assume available if registered
+            // Users can override this behavior
+            return true;
+    }
+}
+/**
+ * Get list of available providers (registered and with API keys)
+ */
+function getAvailableProviders() {
+    return (0, registry_2.getDefaultRegistry)().list().filter(isProviderAvailable);
+}
+// ============================================================================
+// AI SDK Integration Exports
+// ============================================================================
+/**
+ * AI SDK Backend - Multi-provider LLM support via Vercel's AI SDK
+ *
+ * @example
+ * ```typescript
+ * import { createAISDKBackend } from 'praisonai';
+ *
+ * const backend = createAISDKBackend('anthropic/claude-3-5-sonnet');
+ * const result = await backend.generateText({ messages: [...] });
+ * ```
+ */
+var ai_sdk_1 = require("./ai-sdk");
+// Backend
+Object.defineProperty(exports, "AISDKBackend", { enumerable: true, get: function () { return ai_sdk_1.AISDKBackend; } });
+Object.defineProperty(exports, "createAISDKBackend", { enumerable: true, get: function () { return ai_sdk_1.createAISDKBackend; } });
+// Provider utilities
+Object.defineProperty(exports, "isAISDKProviderSupported", { enumerable: true, get: function () { return ai_sdk_1.isProviderSupported; } });
+Object.defineProperty(exports, "listAISDKProviders", { enumerable: true, get: function () { return ai_sdk_1.listSupportedProviders; } });
+Object.defineProperty(exports, "registerAISDKCustomProvider", { enumerable: true, get: function () { return ai_sdk_1.registerCustomProvider; } });
+Object.defineProperty(exports, "validateAISDKProviderApiKey", { enumerable: true, get: function () { return ai_sdk_1.validateProviderApiKey; } });
+Object.defineProperty(exports, "getAISDKMissingApiKeyMessage", { enumerable: true, get: function () { return ai_sdk_1.getMissingApiKeyMessage; } });
+Object.defineProperty(exports, "isAISDKAvailable", { enumerable: true, get: function () { return ai_sdk_1.isAISDKAvailable; } });
+Object.defineProperty(exports, "getAISDKVersion", { enumerable: true, get: function () { return ai_sdk_1.getAISDKVersion; } });
+// Types
+Object.defineProperty(exports, "AISDKError", { enumerable: true, get: function () { return ai_sdk_1.AISDKError; } });
+Object.defineProperty(exports, "AISDK_SAFE_DEFAULTS", { enumerable: true, get: function () { return ai_sdk_1.SAFE_DEFAULTS; } });
+Object.defineProperty(exports, "AISDK_PROVIDERS", { enumerable: true, get: function () { return ai_sdk_1.AISDK_PROVIDERS; } });
+Object.defineProperty(exports, "AISDK_PROVIDER_ALIASES", { enumerable: true, get: function () { return ai_sdk_1.PROVIDER_ALIASES; } });
+// Middleware
+Object.defineProperty(exports, "createAttributionMiddleware", { enumerable: true, get: function () { return ai_sdk_1.createAttributionMiddleware; } });
+Object.defineProperty(exports, "createStandardMiddleware", { enumerable: true, get: function () { return ai_sdk_1.createStandardMiddleware; } });
+Object.defineProperty(exports, "redactSensitiveData", { enumerable: true, get: function () { return ai_sdk_1.redactSensitiveData; } });

package/dist/llm/providers/openai.d.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenAI Provider - Implementation for OpenAI API
+ */
+import type { ChatCompletionMessageParam, ChatCompletionTool } from 'openai/resources/chat/completions';
+import { BaseProvider } from './base';
+import type { ProviderConfig, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult, Message, ToolDefinition } from './types';
+export declare class OpenAIProvider extends BaseProvider {
+    readonly providerId = "openai";
+    private client;
+    constructor(modelId: string, config?: ProviderConfig);
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    protected formatMessages(messages: Message[]): ChatCompletionMessageParam[];
+    protected formatTools(tools: ToolDefinition[]): ChatCompletionTool[];
+    private mapFinishReason;
+    private normalizeSchema;
+}