@tpitre/story-ui 2.2.0 → 2.3.1

package/dist/story-generator/llm-providers/gemini-provider.js

@@ -0,0 +1,406 @@
+/**
+ * Gemini LLM Provider
+ *
+ * Implementation of the LLM provider interface for Google's Gemini models.
+ */
+import { BaseLLMProvider } from './base-provider.js';
+import { logger } from '../logger.js';
+// Gemini model definitions - Updated November 2025
+// Reference: https://ai.google.dev/gemini-api/docs/gemini-3
+const GEMINI_MODELS = [
+    // Gemini 3 Series - Latest (November 2025)
+    {
+        id: 'gemini-3-pro',
+        name: 'Gemini 3 Pro',
+        provider: 'gemini',
+        contextWindow: 1000000, // 1M tokens input
+        maxOutputTokens: 64000,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        supportsReasoning: true, // Native reasoning with thinking_level parameter
+        inputPricePer1kTokens: 0.002, // $2/million for <=200k context
+        outputPricePer1kTokens: 0.012, // $12/million output
+        description: 'Most intelligent Gemini model. PhD-level reasoning, 1501 Elo on LMArena.',
+    },
+    {
+        id: 'gemini-3-pro-preview',
+        name: 'Gemini 3 Pro (Preview)',
+        provider: 'gemini',
+        contextWindow: 1000000,
+        maxOutputTokens: 64000,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        supportsReasoning: true,
+        inputPricePer1kTokens: 0.002,
+        outputPricePer1kTokens: 0.012,
+        description: 'Preview version of Gemini 3 Pro with latest experimental features.',
+    },
+    // Gemini 2.0 Series
+    {
+        id: 'gemini-2.0-flash-exp',
+        name: 'Gemini 2.0 Flash Experimental',
+        provider: 'gemini',
+        contextWindow: 1048576,
+        maxOutputTokens: 8192,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.00,
+        outputPricePer1kTokens: 0.00,
+    },
+    {
+        id: 'gemini-2.0-flash',
+        name: 'Gemini 2.0 Flash',
+        provider: 'gemini',
+        contextWindow: 1048576,
+        maxOutputTokens: 8192,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.00,
+        outputPricePer1kTokens: 0.00,
+    },
+    // Gemini 1.5 Series (Legacy)
+    {
+        id: 'gemini-1.5-pro',
+        name: 'Gemini 1.5 Pro',
+        provider: 'gemini',
+        contextWindow: 2097152,
+        maxOutputTokens: 8192,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.00125,
+        outputPricePer1kTokens: 0.005,
+    },
+    {
+        id: 'gemini-1.5-flash',
+        name: 'Gemini 1.5 Flash',
+        provider: 'gemini',
+        contextWindow: 1048576,
+        maxOutputTokens: 8192,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.000075,
+        outputPricePer1kTokens: 0.0003,
+    },
+    {
+        id: 'gemini-1.5-flash-8b',
+        name: 'Gemini 1.5 Flash 8B',
+        provider: 'gemini',
+        contextWindow: 1048576,
+        maxOutputTokens: 8192,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.0000375,
+        outputPricePer1kTokens: 0.00015,
+    },
+];
+// Default model
+const DEFAULT_MODEL = 'gemini-2.0-flash';
+// API configuration
+const GEMINI_API_BASE = 'https://generativelanguage.googleapis.com/v1beta/models';
+export class GeminiProvider extends BaseLLMProvider {
+    constructor(config) {
+        super(config);
+        this.name = 'Gemini';
+        this.type = 'gemini';
+        this.supportedModels = GEMINI_MODELS;
+        // Set the provider type after base constructor
+        this.setProviderType();
+        // Set default model if not provided
+        if (!this.config.model) {
+            this.config.model = DEFAULT_MODEL;
+        }
+    }
+    getApiUrl(model, stream = false) {
+        const method = stream ? 'streamGenerateContent' : 'generateContent';
+        return `${GEMINI_API_BASE}/${model}:${method}`;
+    }
+    async chat(messages, options) {
+        this.validateMessages(messages);
+        this.logRequest(messages, options);
+        const apiKey = this.config.apiKey;
+        if (!apiKey) {
+            throw new Error('Gemini API key not configured');
+        }
+        const model = options?.model || this.config.model;
+        const geminiContents = this.convertMessages(messages);
+        const systemPrompt = this.buildSystemPrompt(options);
+        const requestBody = {
+            contents: geminiContents,
+            generationConfig: {
+                maxOutputTokens: options?.maxTokens || this.getSelectedModel()?.maxOutputTokens || 8192,
+                ...(options?.temperature !== undefined && { temperature: options.temperature }),
+                ...(options?.topP !== undefined && { topP: options.topP }),
+                ...(options?.topK !== undefined && { topK: options.topK }),
+                ...(options?.stopSequences?.length && { stopSequences: options.stopSequences }),
+            },
+        };
+        // Add system instruction if provided
+        if (systemPrompt) {
+            requestBody.systemInstruction = {
+                parts: [{ text: systemPrompt }],
+            };
+        }
+        const url = `${this.getApiUrl(model)}?key=${apiKey}`;
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody),
+                signal: AbortSignal.timeout(this.config.timeout || 120000),
+            });
+            if (!response.ok) {
+                const errorBody = await response.text();
+                logger.error('Gemini API error response', { status: response.status, body: errorBody });
+                throw new Error(`Gemini API error: ${response.status} - ${errorBody}`);
+            }
+            const data = (await response.json());
+            const chatResponse = this.convertResponse(data, model);
+            this.logResponse(chatResponse);
+            return chatResponse;
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'TimeoutError') {
+                throw new Error(`Gemini API request timed out after ${this.config.timeout}ms`);
+            }
+            throw error;
+        }
+    }
+    async *chatStream(messages, options) {
+        this.validateMessages(messages);
+        this.logRequest(messages, options);
+        const apiKey = this.config.apiKey;
+        if (!apiKey) {
+            yield { type: 'error', error: 'Gemini API key not configured' };
+            return;
+        }
+        const model = options?.model || this.config.model;
+        const geminiContents = this.convertMessages(messages);
+        const systemPrompt = this.buildSystemPrompt(options);
+        const requestBody = {
+            contents: geminiContents,
+            generationConfig: {
+                maxOutputTokens: options?.maxTokens || this.getSelectedModel()?.maxOutputTokens || 8192,
+                ...(options?.temperature !== undefined && { temperature: options.temperature }),
+            },
+        };
+        if (systemPrompt) {
+            requestBody.systemInstruction = {
+                parts: [{ text: systemPrompt }],
+            };
+        }
+        const url = `${this.getApiUrl(model, true)}?key=${apiKey}&alt=sse`;
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody),
+                signal: AbortSignal.timeout(this.config.timeout || 120000),
+            });
+            if (!response.ok) {
+                const errorBody = await response.text();
+                yield { type: 'error', error: `Gemini API error: ${response.status} - ${errorBody}` };
+                return;
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                yield { type: 'error', error: 'No response body' };
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let promptTokens = 0;
+            let completionTokens = 0;
+            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: ')) {
+                        const data = line.slice(6);
+                        if (!data || data === '[DONE]')
+                            continue;
+                        try {
+                            const event = JSON.parse(data);
+                            // Extract text from candidates
+                            const text = event.candidates?.[0]?.content?.parts
+                                ?.map(p => p.text)
+                                .filter(Boolean)
+                                .join('');
+                            if (text) {
+                                yield { type: 'text', content: text };
+                            }
+                            // Extract usage metadata
+                            if (event.usageMetadata) {
+                                promptTokens = event.usageMetadata.promptTokenCount || 0;
+                                completionTokens = event.usageMetadata.candidatesTokenCount || 0;
+                            }
+                        }
+                        catch {
+                            // Skip malformed JSON
+                        }
+                    }
+                }
+            }
+            yield {
+                type: 'done',
+                usage: {
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: promptTokens + completionTokens,
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'error',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async validateApiKey(apiKey) {
+        try {
+            // Make a minimal API call to validate the key
+            const url = `${this.getApiUrl('gemini-1.5-flash')}?key=${apiKey}`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    contents: [{ parts: [{ text: 'Hi' }] }],
+                    generationConfig: { maxOutputTokens: 1 },
+                }),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (response.ok) {
+                return {
+                    valid: true,
+                    models: this.supportedModels,
+                };
+            }
+            const errorBody = await response.text();
+            // Check for specific error types
+            if (response.status === 400 && errorBody.includes('API_KEY_INVALID')) {
+                return {
+                    valid: false,
+                    error: 'Invalid API key',
+                };
+            }
+            return {
+                valid: false,
+                error: `API validation failed: ${errorBody}`,
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: error instanceof Error ? error.message : 'Validation failed',
+            };
+        }
+    }
+    // Convert our message format to Gemini format
+    convertMessages(messages) {
+        return messages
+            .filter(msg => msg.role !== 'system') // System messages handled separately
+            .map(msg => ({
+            role: msg.role === 'assistant' ? 'model' : 'user',
+            parts: this.convertContent(msg.content),
+        }));
+    }
+    convertContent(content) {
+        if (typeof content === 'string') {
+            return [{ text: content }];
+        }
+        return content.map(item => {
+            if (item.type === 'text') {
+                return { text: item.text };
+            }
+            if (item.type === 'image') {
+                const imageContent = item;
+                if (imageContent.source.type === 'base64' && imageContent.source.data) {
+                    return {
+                        inlineData: {
+                            mimeType: imageContent.source.mediaType || 'image/png',
+                            data: imageContent.source.data,
+                        },
+                    };
+                }
+                // URL images - Gemini requires base64, so we store for async processing
+                // NOTE: For Gemini, URL images should be pre-converted to base64 using imageProcessor.ts
+                // If a URL image reaches here, it means it wasn't pre-processed
+                if (imageContent.source.url) {
+                    logger.warn(`Gemini provider received URL image that wasn't pre-converted to base64. URL: ${imageContent.source.url}`);
+                    logger.warn('For best results, use imageProcessor.processImageInputs() to convert URL images before sending to Gemini.');
+                    return { text: `[Image URL - requires base64 conversion: ${imageContent.source.url}]` };
+                }
+                return { text: '[Invalid image content]' };
+            }
+            // Document type
+            if (item.type === 'document') {
+                return { text: `[Document: ${item.source.name || 'unnamed'}]` };
+            }
+            return { text: '' };
+        });
+    }
+    convertResponse(data, model) {
+        const candidate = data.candidates?.[0];
+        const textParts = candidate?.content?.parts || [];
+        const content = textParts.map(p => p.text || '').join('');
+        return {
+            id: `gemini-${Date.now()}`, // Gemini doesn't return an ID
+            model,
+            content,
+            finishReason: this.mapFinishReason(candidate?.finishReason),
+            usage: {
+                promptTokens: data.usageMetadata?.promptTokenCount || 0,
+                completionTokens: data.usageMetadata?.candidatesTokenCount || 0,
+                totalTokens: data.usageMetadata?.totalTokenCount || 0,
+            },
+            raw: data,
+        };
+    }
+    mapFinishReason(finishReason) {
+        switch (finishReason) {
+            case 'STOP':
+                return 'stop';
+            case 'MAX_TOKENS':
+                return 'length';
+            case 'SAFETY':
+            case 'RECITATION':
+                return 'content_filter';
+            default:
+                return 'stop';
+        }
+    }
+    // Token estimation for Gemini
+    estimateTokens(text) {
+        // Gemini uses a similar tokenization to other LLMs
+        // Rough estimate: ~4 characters per token
+        return Math.ceil(text.length / 4);
+    }
+}
+// Factory function
+export function createGeminiProvider(config) {
+    return new GeminiProvider(config);
+}

package/dist/story-generator/llm-providers/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * LLM Providers Module
+ *
+ * Exports all LLM providers and the provider registry for managing them.
+ */
+export * from './types.js';
+export { BaseLLMProvider } from './base-provider.js';
+export { ClaudeProvider, createClaudeProvider } from './claude-provider.js';
+export { OpenAIProvider, createOpenAIProvider } from './openai-provider.js';
+export { GeminiProvider, createGeminiProvider } from './gemini-provider.js';
+import { LLMProvider, ProviderType, ProviderRegistry, ModelInfo, ProviderConfig } from './types.js';
+/**
+ * Default Provider Registry Implementation
+ */
+declare class DefaultProviderRegistry implements ProviderRegistry {
+    private providers;
+    private defaultProviderType;
+    constructor();
+    private registerBuiltInProviders;
+    register(provider: LLMProvider): void;
+    get(type: ProviderType): LLMProvider | undefined;
+    getAll(): LLMProvider[];
+    getAvailableModels(): ModelInfo[];
+    getDefault(): LLMProvider | undefined;
+    setDefault(type: ProviderType): void;
+    /**
+     * Configure a provider with API key and settings
+     */
+    configureProvider(type: ProviderType, config: Partial<ProviderConfig>): void;
+    /**
+     * Get a provider that supports a specific model
+     */
+    getProviderForModel(modelId: string): LLMProvider | undefined;
+    /**
+     * Check if any provider is configured and ready to use
+     */
+    hasConfiguredProvider(): boolean;
+    /**
+     * Get all configured providers
+     */
+    getConfiguredProviders(): LLMProvider[];
+}
+/**
+ * Get the global provider registry instance
+ */
+export declare function getProviderRegistry(): DefaultProviderRegistry;
+/**
+ * Convenience function to get a provider by type
+ */
+export declare function getProvider(type: ProviderType): LLMProvider | undefined;
+/**
+ * Convenience function to get the default provider
+ */
+export declare function getDefaultProvider(): LLMProvider | undefined;
+/**
+ * Convenience function to configure a provider
+ */
+export declare function configureProvider(type: ProviderType, config: Partial<ProviderConfig>): void;
+/**
+ * Initialize providers from environment variables
+ */
+export declare function initializeFromEnv(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/story-generator/llm-providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../story-generator/llm-providers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5E,OAAO,EACL,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,cAAc,EACf,MAAM,YAAY,CAAC;AAMpB;;GAEG;AACH,cAAM,uBAAwB,YAAW,gBAAgB;IACvD,OAAO,CAAC,SAAS,CAA6C;IAC9D,OAAO,CAAC,mBAAmB,CAA6B;;IAOxD,OAAO,CAAC,wBAAwB;IAQhC,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI;IAUrC,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,GAAG,SAAS;IAIhD,MAAM,IAAI,WAAW,EAAE;IAIvB,kBAAkB,IAAI,SAAS,EAAE;IAQjC,UAAU,IAAI,WAAW,GAAG,SAAS;IAKrC,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAQpC;;OAEG;IACH,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI;IAQ5E;;OAEG;IACH,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAS7D;;OAEG;IACH,qBAAqB,IAAI,OAAO;IAShC;;OAEG;IACH,sBAAsB,IAAI,WAAW,EAAE;CAGxC;AAKD;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,uBAAuB,CAK7D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,GAAG,SAAS,CAEvE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,WAAW,GAAG,SAAS,CAE5D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,GAC9B,IAAI,CAEN;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAiCxC"}

package/dist/story-generator/llm-providers/index.js

@@ -0,0 +1,169 @@
+/**
+ * LLM Providers Module
+ *
+ * Exports all LLM providers and the provider registry for managing them.
+ */
+// Types
+export * from './types.js';
+// Base provider
+export { BaseLLMProvider } from './base-provider.js';
+// Provider implementations
+export { ClaudeProvider, createClaudeProvider } from './claude-provider.js';
+export { OpenAIProvider, createOpenAIProvider } from './openai-provider.js';
+export { GeminiProvider, createGeminiProvider } from './gemini-provider.js';
+import { ClaudeProvider } from './claude-provider.js';
+import { OpenAIProvider } from './openai-provider.js';
+import { GeminiProvider } from './gemini-provider.js';
+import { logger } from '../logger.js';
+/**
+ * Default Provider Registry Implementation
+ */
+class DefaultProviderRegistry {
+    constructor() {
+        this.providers = new Map();
+        this.defaultProviderType = null;
+        // Register built-in providers
+        this.registerBuiltInProviders();
+    }
+    registerBuiltInProviders() {
+        // Register all built-in providers
+        this.register(new ClaudeProvider());
+        this.register(new OpenAIProvider());
+        this.register(new GeminiProvider());
+        logger.debug('Registered built-in providers: Claude, OpenAI, Gemini');
+    }
+    register(provider) {
+        this.providers.set(provider.type, provider);
+        logger.debug(`Registered provider: ${provider.name} (${provider.type})`);
+        // Set as default if it's the first provider
+        if (!this.defaultProviderType) {
+            this.defaultProviderType = provider.type;
+        }
+    }
+    get(type) {
+        return this.providers.get(type);
+    }
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    getAvailableModels() {
+        const models = [];
+        for (const provider of this.providers.values()) {
+            models.push(...provider.supportedModels);
+        }
+        return models;
+    }
+    getDefault() {
+        if (!this.defaultProviderType)
+            return undefined;
+        return this.providers.get(this.defaultProviderType);
+    }
+    setDefault(type) {
+        if (!this.providers.has(type)) {
+            throw new Error(`Provider type '${type}' is not registered`);
+        }
+        this.defaultProviderType = type;
+        logger.debug(`Set default provider to: ${type}`);
+    }
+    /**
+     * Configure a provider with API key and settings
+     */
+    configureProvider(type, config) {
+        const provider = this.providers.get(type);
+        if (!provider) {
+            throw new Error(`Provider type '${type}' is not registered`);
+        }
+        provider.configure({ ...config, provider: type });
+    }
+    /**
+     * Get a provider that supports a specific model
+     */
+    getProviderForModel(modelId) {
+        for (const provider of this.providers.values()) {
+            if (provider.supportedModels.some(m => m.id === modelId)) {
+                return provider;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Check if any provider is configured and ready to use
+     */
+    hasConfiguredProvider() {
+        for (const provider of this.providers.values()) {
+            if (provider.isConfigured()) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get all configured providers
+     */
+    getConfiguredProviders() {
+        return this.getAll().filter(p => p.isConfigured());
+    }
+}
+// Singleton registry instance
+let registryInstance = null;
+/**
+ * Get the global provider registry instance
+ */
+export function getProviderRegistry() {
+    if (!registryInstance) {
+        registryInstance = new DefaultProviderRegistry();
+    }
+    return registryInstance;
+}
+/**
+ * Convenience function to get a provider by type
+ */
+export function getProvider(type) {
+    return getProviderRegistry().get(type);
+}
+/**
+ * Convenience function to get the default provider
+ */
+export function getDefaultProvider() {
+    return getProviderRegistry().getDefault();
+}
+/**
+ * Convenience function to configure a provider
+ */
+export function configureProvider(type, config) {
+    getProviderRegistry().configureProvider(type, config);
+}
+/**
+ * Initialize providers from environment variables
+ */
+export function initializeFromEnv() {
+    const registry = getProviderRegistry();
+    // Configure Claude if API key is present
+    const claudeKey = process.env.CLAUDE_API_KEY || process.env.ANTHROPIC_API_KEY;
+    if (claudeKey) {
+        registry.configureProvider('claude', {
+            apiKey: claudeKey,
+            model: process.env.CLAUDE_MODEL || 'claude-sonnet-4-5-20250929',
+        });
+        logger.info('Claude provider configured from environment');
+    }
+    // Configure OpenAI if API key is present
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (openaiKey) {
+        registry.configureProvider('openai', {
+            apiKey: openaiKey,
+            model: process.env.OPENAI_MODEL || 'gpt-4o',
+            organizationId: process.env.OPENAI_ORG_ID,
+        });
+        logger.info('OpenAI provider configured from environment');
+    }
+    // Configure Gemini if API key is present
+    const geminiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+    if (geminiKey) {
+        registry.configureProvider('gemini', {
+            apiKey: geminiKey,
+            model: process.env.GEMINI_MODEL || 'gemini-2.0-flash',
+        });
+        logger.info('Gemini provider configured from environment');
+    }
+}

package/dist/story-generator/llm-providers/openai-provider.d.ts

@@ -0,0 +1,24 @@
+/**
+ * OpenAI LLM Provider
+ *
+ * Implementation of the LLM provider interface for OpenAI's GPT models.
+ */
+import { ProviderType, ProviderConfig, ModelInfo, ChatMessage, ChatOptions, ChatResponse, StreamChunk, ValidationResult } from './types.js';
+import { BaseLLMProvider } from './base-provider.js';
+export declare class OpenAIProvider extends BaseLLMProvider {
+    readonly name = "OpenAI";
+    readonly type: ProviderType;
+    readonly supportedModels: ModelInfo[];
+    constructor(config?: Partial<ProviderConfig>);
+    chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>;
+    chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncIterable<StreamChunk>;
+    validateApiKey(apiKey: string): Promise<ValidationResult>;
+    private convertMessages;
+    private extractTextContent;
+    private convertContent;
+    private convertResponse;
+    private mapFinishReason;
+    estimateTokens(text: string): number;
+}
+export declare function createOpenAIProvider(config?: Partial<ProviderConfig>): OpenAIProvider;
+//# sourceMappingURL=openai-provider.d.ts.map

package/dist/story-generator/llm-providers/openai-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-provider.d.ts","sourceRoot":"","sources":["../../../story-generator/llm-providers/openai-provider.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,YAAY,EACZ,cAAc,EACd,SAAS,EACT,WAAW,EACX,WAAW,EACX,YAAY,EACZ,WAAW,EACX,gBAAgB,EAGjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AA+LrD,qBAAa,cAAe,SAAQ,eAAe;IACjD,QAAQ,CAAC,IAAI,YAAY;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAY;IACvC,QAAQ,CAAC,eAAe,cAAiB;gBAE7B,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAUtC,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IA2D1E,UAAU,CACf,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,CAAC,WAAW,CAAC;IAqGvB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA+C/D,OAAO,CAAC,eAAe;IA8BvB,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,cAAc;IAiCtB,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,eAAe;IAmBvB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAKrC;AAGD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc,CAErF"}