overai 1.4.0

package/dist/llm/providers/openai.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * OpenAI Provider - Implementation for OpenAI API
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const openai_1 = __importDefault(require("openai"));
+const base_1 = require("./base");
+class OpenAIProvider extends base_1.BaseProvider {
+    constructor(modelId, config = {}) {
+        super(modelId, config);
+        this.providerId = 'openai';
+        this.client = new openai_1.default({
+            apiKey: config.apiKey || process.env.OPENAI_API_KEY,
+            baseURL: config.baseUrl,
+            timeout: config.timeout || 60000,
+            maxRetries: 0, // We handle retries ourselves
+        });
+    }
+    async generateText(options) {
+        return this.withRetry(async () => {
+            const response = await this.client.chat.completions.create({
+                model: this.modelId,
+                messages: this.formatMessages(options.messages),
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.maxTokens,
+                tools: options.tools ? this.formatTools(options.tools) : undefined,
+                tool_choice: options.toolChoice,
+                stop: options.stop,
+                top_p: options.topP,
+                frequency_penalty: options.frequencyPenalty,
+                presence_penalty: options.presencePenalty,
+            });
+            const choice = response.choices[0];
+            const message = choice.message;
+            return {
+                text: message.content || '',
+                toolCalls: message.tool_calls?.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                    },
+                })),
+                usage: {
+                    promptTokens: response.usage?.prompt_tokens || 0,
+                    completionTokens: response.usage?.completion_tokens || 0,
+                    totalTokens: response.usage?.total_tokens || 0,
+                },
+                finishReason: this.mapFinishReason(choice.finish_reason),
+                raw: response,
+            };
+        });
+    }
+    async streamText(options) {
+        const self = this;
+        return {
+            async *[Symbol.asyncIterator]() {
+                const stream = await self.client.chat.completions.create({
+                    model: self.modelId,
+                    messages: self.formatMessages(options.messages),
+                    temperature: options.temperature ?? 0.7,
+                    max_tokens: options.maxTokens,
+                    tools: options.tools ? self.formatTools(options.tools) : undefined,
+                    tool_choice: options.toolChoice,
+                    stop: options.stop,
+                    stream: true,
+                });
+                let toolCalls = [];
+                for await (const chunk of stream) {
+                    const delta = chunk.choices[0]?.delta;
+                    if (delta?.content) {
+                        if (options.onToken) {
+                            options.onToken(delta.content);
+                        }
+                        yield { text: delta.content };
+                    }
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            if (tc.index !== undefined) {
+                                if (!toolCalls[tc.index]) {
+                                    toolCalls[tc.index] = {
+                                        id: tc.id || '',
+                                        type: 'function',
+                                        function: { name: '', arguments: '' },
+                                    };
+                                }
+                                if (tc.id)
+                                    toolCalls[tc.index].id = tc.id;
+                                if (tc.function?.name)
+                                    toolCalls[tc.index].function.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    toolCalls[tc.index].function.arguments += tc.function.arguments;
+                            }
+                        }
+                    }
+                    if (chunk.choices[0]?.finish_reason) {
+                        yield {
+                            finishReason: chunk.choices[0].finish_reason,
+                            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                            usage: chunk.usage ? {
+                                promptTokens: chunk.usage.prompt_tokens,
+                                completionTokens: chunk.usage.completion_tokens,
+                                totalTokens: chunk.usage.total_tokens,
+                            } : undefined,
+                        };
+                    }
+                }
+            },
+        };
+    }
+    async generateObject(options) {
+        return this.withRetry(async () => {
+            const response = await this.client.chat.completions.create({
+                model: this.modelId,
+                messages: this.formatMessages(options.messages),
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.maxTokens,
+                response_format: {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'response',
+                        schema: this.normalizeSchema(options.schema),
+                        strict: true,
+                    },
+                },
+            });
+            const choice = response.choices[0];
+            const content = choice.message.content || '{}';
+            let parsed;
+            try {
+                parsed = JSON.parse(content);
+            }
+            catch (e) {
+                throw new Error(`Failed to parse JSON response: ${content}`);
+            }
+            return {
+                object: parsed,
+                usage: {
+                    promptTokens: response.usage?.prompt_tokens || 0,
+                    completionTokens: response.usage?.completion_tokens || 0,
+                    totalTokens: response.usage?.total_tokens || 0,
+                },
+                raw: response,
+            };
+        });
+    }
+    formatMessages(messages) {
+        return messages.map(msg => {
+            if (msg.role === 'tool') {
+                return {
+                    role: 'tool',
+                    content: msg.content || '',
+                    tool_call_id: msg.tool_call_id || '',
+                };
+            }
+            if (msg.role === 'assistant' && msg.tool_calls) {
+                return {
+                    role: 'assistant',
+                    content: msg.content,
+                    tool_calls: msg.tool_calls,
+                };
+            }
+            return {
+                role: msg.role,
+                content: msg.content || '',
+            };
+        });
+    }
+    formatTools(tools) {
+        return tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description || `Function ${tool.name}`,
+                parameters: tool.parameters || { type: 'object', properties: {} },
+            },
+        }));
+    }
+    mapFinishReason(reason) {
+        switch (reason) {
+            case 'stop': return 'stop';
+            case 'length': return 'length';
+            case 'tool_calls': return 'tool_calls';
+            case 'content_filter': return 'content_filter';
+            default: return 'stop';
+        }
+    }
+    normalizeSchema(schema) {
+        // If it's a Zod schema, convert to JSON schema
+        if (schema && typeof schema.parse === 'function' && typeof schema._def === 'object') {
+            // This is a Zod schema - we need zod-to-json-schema
+            // For now, throw an error suggesting to use JSON schema directly
+            throw new Error('Zod schemas require zod-to-json-schema. Please use JSON schema directly or install zod-to-json-schema.');
+        }
+        return schema;
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

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

@@ -0,0 +1,159 @@
+/**
+ * Provider Registry - Extensible provider registration system
+ *
+ * Fixes Issue #1095: Allows users to register custom providers
+ * that can be resolved by name via createProvider().
+ */
+import type { LLMProvider, ProviderConfig } from './types';
+/**
+ * Provider constructor type
+ */
+export type ProviderConstructor = new (modelId: string, config?: ProviderConfig) => LLMProvider;
+/**
+ * Lazy loader function that returns a provider constructor
+ * Used for tree-shaking and lazy loading of provider implementations
+ */
+export type ProviderLoader = () => ProviderConstructor;
+/**
+ * Options for registering a provider
+ */
+export interface RegisterOptions {
+    /** Allow overwriting an existing registration */
+    override?: boolean;
+    /** Additional names that resolve to this provider */
+    aliases?: string[];
+}
+/**
+ * Provider Registry Interface
+ */
+export interface IProviderRegistry {
+    register(name: string, provider: ProviderConstructor | ProviderLoader, options?: RegisterOptions): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    list(): string[];
+    resolve(name: string, modelId: string, config?: ProviderConfig): LLMProvider;
+    get(name: string): ProviderConstructor | ProviderLoader | undefined;
+}
+/**
+ * Provider Registry Implementation
+ *
+ * Manages registration and resolution of LLM providers by name.
+ * Supports lazy loading, aliases, and isolated instances.
+ */
+export declare class ProviderRegistry implements IProviderRegistry {
+    private entries;
+    private aliases;
+    /**
+     * Register a provider by name
+     *
+     * @param name - Provider name (e.g., 'cloudflare', 'ollama')
+     * @param provider - Provider constructor or lazy loader function
+     * @param options - Registration options
+     * @throws Error if name is already registered (unless override: true)
+     */
+    register(name: string, provider: ProviderConstructor | ProviderLoader, options?: RegisterOptions): void;
+    /**
+     * Unregister a provider by name
+     *
+     * @param name - Provider name to unregister
+     * @returns true if provider was unregistered, false if not found
+     */
+    unregister(name: string): boolean;
+    /**
+     * Check if a provider is registered
+     *
+     * @param name - Provider name to check
+     * @returns true if provider is registered
+     */
+    has(name: string): boolean;
+    /**
+     * List all registered provider names (canonical names only)
+     *
+     * @returns Array of provider names
+     */
+    list(): string[];
+    /**
+     * List all names including aliases
+     *
+     * @returns Array of all registered names and aliases
+     */
+    listAll(): string[];
+    /**
+     * Resolve a provider by name, creating an instance
+     *
+     * @param name - Provider name
+     * @param modelId - Model ID to pass to constructor
+     * @param config - Optional provider config
+     * @returns Provider instance
+     * @throws Error if provider not found
+     */
+    resolve(name: string, modelId: string, config?: ProviderConfig): LLMProvider;
+    /**
+     * Get the provider constructor/loader without instantiating
+     *
+     * @param name - Provider name
+     * @returns Provider constructor/loader or undefined
+     */
+    get(name: string): ProviderConstructor | ProviderLoader | undefined;
+    /**
+     * Get the resolved constructor for an entry
+     */
+    private getConstructor;
+    /**
+     * Determine if a value is a loader function vs a constructor
+     * Loaders are arrow functions or regular functions that return a class
+     * Constructors have a prototype with constructor
+     */
+    private isLoaderFunction;
+}
+/**
+ * Get the default global provider registry
+ *
+ * This is the registry used by createProvider() when no custom registry is specified.
+ * Built-in providers (OpenAI, Anthropic, Google) are registered here.
+ */
+export declare function getDefaultRegistry(): ProviderRegistry;
+/**
+ * Create a new isolated provider registry
+ *
+ * Use this when you need a separate registry that doesn't share
+ * registrations with the default global registry.
+ */
+export declare function createProviderRegistry(): ProviderRegistry;
+/**
+ * Register a provider to the default global registry
+ *
+ * @example
+ * ```typescript
+ * import { registerProvider } from 'praisonai';
+ * import { CloudflareProvider } from './my-cloudflare-provider';
+ *
+ * registerProvider('cloudflare', CloudflareProvider);
+ *
+ * // Now works:
+ * const agent = new Agent({ llm: 'cloudflare/workers-ai' });
+ * ```
+ */
+export declare function registerProvider(name: string, provider: ProviderConstructor | ProviderLoader, options?: RegisterOptions): void;
+/**
+ * Unregister a provider from the default global registry
+ */
+export declare function unregisterProvider(name: string): boolean;
+/**
+ * Check if a provider is registered in the default registry
+ */
+export declare function hasProvider(name: string): boolean;
+/**
+ * List all providers in the default registry
+ */
+export declare function listProviders(): string[];
+/**
+ * Register built-in providers to a registry
+ * Uses lazy loaders to avoid importing all providers at module load time
+ */
+export declare function registerBuiltinProviders(registry: ProviderRegistry): void;
+/**
+ * Reset the default registry (mainly for testing)
+ * @internal
+ */
+export declare function _resetDefaultRegistry(): void;

package/dist/llm/providers/registry.js

@@ -0,0 +1,279 @@
+"use strict";
+/**
+ * Provider Registry - Extensible provider registration system
+ *
+ * Fixes Issue #1095: Allows users to register custom providers
+ * that can be resolved by name via createProvider().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderRegistry = void 0;
+exports.getDefaultRegistry = getDefaultRegistry;
+exports.createProviderRegistry = createProviderRegistry;
+exports.registerProvider = registerProvider;
+exports.unregisterProvider = unregisterProvider;
+exports.hasProvider = hasProvider;
+exports.listProviders = listProviders;
+exports.registerBuiltinProviders = registerBuiltinProviders;
+exports._resetDefaultRegistry = _resetDefaultRegistry;
+/**
+ * Provider Registry Implementation
+ *
+ * Manages registration and resolution of LLM providers by name.
+ * Supports lazy loading, aliases, and isolated instances.
+ */
+class ProviderRegistry {
+    constructor() {
+        this.entries = new Map();
+        this.aliases = new Map(); // alias -> canonical name
+    }
+    /**
+     * Register a provider by name
+     *
+     * @param name - Provider name (e.g., 'cloudflare', 'ollama')
+     * @param provider - Provider constructor or lazy loader function
+     * @param options - Registration options
+     * @throws Error if name is already registered (unless override: true)
+     */
+    register(name, provider, options = {}) {
+        const normalizedName = name.toLowerCase();
+        // Check for existing registration
+        if (this.entries.has(normalizedName) && !options.override) {
+            throw new Error(`Provider '${name}' is already registered. ` +
+                `Use { override: true } to replace it.`);
+        }
+        // Determine if this is a loader function or direct constructor
+        const isLoader = this.isLoaderFunction(provider);
+        const entry = {
+            provider,
+            isLoader,
+            canonicalName: normalizedName,
+        };
+        this.entries.set(normalizedName, entry);
+        // Register aliases
+        if (options.aliases) {
+            for (const alias of options.aliases) {
+                const normalizedAlias = alias.toLowerCase();
+                if (this.entries.has(normalizedAlias) && !options.override) {
+                    throw new Error(`Alias '${alias}' conflicts with existing provider. ` +
+                        `Use { override: true } to replace it.`);
+                }
+                this.aliases.set(normalizedAlias, normalizedName);
+            }
+        }
+    }
+    /**
+     * Unregister a provider by name
+     *
+     * @param name - Provider name to unregister
+     * @returns true if provider was unregistered, false if not found
+     */
+    unregister(name) {
+        const normalizedName = name.toLowerCase();
+        // Check if it's an alias
+        if (this.aliases.has(normalizedName)) {
+            this.aliases.delete(normalizedName);
+            return true;
+        }
+        // Check if it's a canonical name
+        if (this.entries.has(normalizedName)) {
+            // Remove all aliases pointing to this provider
+            for (const [alias, canonical] of this.aliases.entries()) {
+                if (canonical === normalizedName) {
+                    this.aliases.delete(alias);
+                }
+            }
+            this.entries.delete(normalizedName);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if a provider is registered
+     *
+     * @param name - Provider name to check
+     * @returns true if provider is registered
+     */
+    has(name) {
+        const normalizedName = name.toLowerCase();
+        return this.entries.has(normalizedName) || this.aliases.has(normalizedName);
+    }
+    /**
+     * List all registered provider names (canonical names only)
+     *
+     * @returns Array of provider names
+     */
+    list() {
+        return Array.from(this.entries.keys());
+    }
+    /**
+     * List all names including aliases
+     *
+     * @returns Array of all registered names and aliases
+     */
+    listAll() {
+        return [...this.entries.keys(), ...this.aliases.keys()];
+    }
+    /**
+     * Resolve a provider by name, creating an instance
+     *
+     * @param name - Provider name
+     * @param modelId - Model ID to pass to constructor
+     * @param config - Optional provider config
+     * @returns Provider instance
+     * @throws Error if provider not found
+     */
+    resolve(name, modelId, config) {
+        const normalizedName = name.toLowerCase();
+        // Resolve alias to canonical name
+        const canonicalName = this.aliases.get(normalizedName) || normalizedName;
+        const entry = this.entries.get(canonicalName);
+        if (!entry) {
+            const available = this.list();
+            throw new Error(`Unknown provider: '${name}'. ` +
+                `Available providers: ${available.length > 0 ? available.join(', ') : 'none'}. ` +
+                `Register a custom provider with registerProvider('${name}', YourProviderClass).`);
+        }
+        // Get constructor (resolve loader if needed)
+        const Constructor = this.getConstructor(entry);
+        return new Constructor(modelId, config);
+    }
+    /**
+     * Get the provider constructor/loader without instantiating
+     *
+     * @param name - Provider name
+     * @returns Provider constructor/loader or undefined
+     */
+    get(name) {
+        const normalizedName = name.toLowerCase();
+        const canonicalName = this.aliases.get(normalizedName) || normalizedName;
+        return this.entries.get(canonicalName)?.provider;
+    }
+    /**
+     * Get the resolved constructor for an entry
+     */
+    getConstructor(entry) {
+        if (!entry.isLoader) {
+            return entry.provider;
+        }
+        // Lazy load and cache
+        if (!entry.cachedConstructor) {
+            const loader = entry.provider;
+            entry.cachedConstructor = loader();
+        }
+        return entry.cachedConstructor;
+    }
+    /**
+     * Determine if a value is a loader function vs a constructor
+     * Loaders are arrow functions or regular functions that return a class
+     * Constructors have a prototype with constructor
+     */
+    isLoaderFunction(value) {
+        // If it has a prototype with more than just constructor, it's likely a class
+        if (value.prototype && Object.getOwnPropertyNames(value.prototype).length > 1) {
+            return false;
+        }
+        // Check if it looks like a class (has 'prototype' that is an object with constructor)
+        if (value.prototype && value.prototype.constructor === value) {
+            // Additional check: classes typically have a name and their toString starts with 'class'
+            const str = value.toString();
+            if (str.startsWith('class ') || str.includes('function ')) {
+                return false;
+            }
+        }
+        // Arrow functions and simple functions are loaders
+        return typeof value === 'function' && !value.prototype?.constructor;
+    }
+}
+exports.ProviderRegistry = ProviderRegistry;
+// ============================================================================
+// Default Registry Singleton
+// ============================================================================
+let defaultRegistry = null;
+/**
+ * Get the default global provider registry
+ *
+ * This is the registry used by createProvider() when no custom registry is specified.
+ * Built-in providers (OpenAI, Anthropic, Google) are registered here.
+ */
+function getDefaultRegistry() {
+    if (!defaultRegistry) {
+        defaultRegistry = new ProviderRegistry();
+        registerBuiltinProviders(defaultRegistry);
+    }
+    return defaultRegistry;
+}
+/**
+ * Create a new isolated provider registry
+ *
+ * Use this when you need a separate registry that doesn't share
+ * registrations with the default global registry.
+ */
+function createProviderRegistry() {
+    return new ProviderRegistry();
+}
+/**
+ * Register a provider to the default global registry
+ *
+ * @example
+ * ```typescript
+ * import { registerProvider } from 'praisonai';
+ * import { CloudflareProvider } from './my-cloudflare-provider';
+ *
+ * registerProvider('cloudflare', CloudflareProvider);
+ *
+ * // Now works:
+ * const agent = new Agent({ llm: 'cloudflare/workers-ai' });
+ * ```
+ */
+function registerProvider(name, provider, options) {
+    getDefaultRegistry().register(name, provider, options);
+}
+/**
+ * Unregister a provider from the default global registry
+ */
+function unregisterProvider(name) {
+    return getDefaultRegistry().unregister(name);
+}
+/**
+ * Check if a provider is registered in the default registry
+ */
+function hasProvider(name) {
+    return getDefaultRegistry().has(name);
+}
+/**
+ * List all providers in the default registry
+ */
+function listProviders() {
+    return getDefaultRegistry().list();
+}
+// ============================================================================
+// Built-in Provider Registration
+// ============================================================================
+/**
+ * Register built-in providers to a registry
+ * Uses lazy loaders to avoid importing all providers at module load time
+ */
+function registerBuiltinProviders(registry) {
+    // OpenAI - lazy loaded
+    registry.register('openai', () => {
+        const { OpenAIProvider } = require('./openai');
+        return OpenAIProvider;
+    }, { aliases: ['oai'] });
+    // Anthropic - lazy loaded
+    registry.register('anthropic', () => {
+        const { AnthropicProvider } = require('./anthropic');
+        return AnthropicProvider;
+    }, { aliases: ['claude'] });
+    // Google - lazy loaded
+    registry.register('google', () => {
+        const { GoogleProvider } = require('./google');
+        return GoogleProvider;
+    }, { aliases: ['gemini'] });
+}
+/**
+ * Reset the default registry (mainly for testing)
+ * @internal
+ */
+function _resetDefaultRegistry() {
+    defaultRegistry = null;
+}