@tpitre/story-ui 2.2.0 → 2.3.0

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

@@ -0,0 +1,458 @@
+/**
+ * OpenAI LLM Provider
+ *
+ * Implementation of the LLM provider interface for OpenAI's GPT models.
+ */
+import { BaseLLMProvider } from './base-provider.js';
+import { logger } from '../logger.js';
+// OpenAI model definitions - Updated November 2025
+// Reference: https://openai.com/index/introducing-gpt-5/
+const OPENAI_MODELS = [
+    // GPT-5.1 Series - Latest (November 2025)
+    {
+        id: 'gpt-5.1',
+        name: 'GPT-5.1',
+        provider: 'openai',
+        contextWindow: 256000,
+        maxOutputTokens: 32768,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        supportsReasoning: true, // Adaptive reasoning with reasoning_effort parameter
+        inputPricePer1kTokens: 0.005,
+        outputPricePer1kTokens: 0.015,
+        description: 'Latest GPT-5 series. 76.3% on SWE-bench. Adaptive reasoning capability.',
+    },
+    {
+        id: 'gpt-5.1-chat-latest',
+        name: 'GPT-5.1 Instant',
+        provider: 'openai',
+        contextWindow: 256000,
+        maxOutputTokens: 32768,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        supportsReasoning: true,
+        inputPricePer1kTokens: 0.003,
+        outputPricePer1kTokens: 0.012,
+        description: 'More conversational GPT-5.1 with improved instruction following.',
+    },
+    {
+        id: 'gpt-5.1-thinking',
+        name: 'GPT-5.1 Thinking',
+        provider: 'openai',
+        contextWindow: 256000,
+        maxOutputTokens: 65536,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        supportsReasoning: true,
+        inputPricePer1kTokens: 0.008,
+        outputPricePer1kTokens: 0.024,
+        description: 'Extended thinking mode for complex reasoning tasks.',
+    },
+    // GPT-5 Original (August 2025)
+    {
+        id: 'gpt-5',
+        name: 'GPT-5',
+        provider: 'openai',
+        contextWindow: 200000,
+        maxOutputTokens: 32768,
+        supportsVision: true,
+        supportsDocuments: true,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        supportsReasoning: true,
+        inputPricePer1kTokens: 0.005,
+        outputPricePer1kTokens: 0.015,
+        description: 'Multimodal foundation model combining reasoning and general capabilities.',
+    },
+    // GPT-4o Series
+    {
+        id: 'gpt-4o',
+        name: 'GPT-4o',
+        provider: 'openai',
+        contextWindow: 128000,
+        maxOutputTokens: 16384,
+        supportsVision: true,
+        supportsDocuments: false,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.0025,
+        outputPricePer1kTokens: 0.01,
+    },
+    {
+        id: 'gpt-4o-mini',
+        name: 'GPT-4o Mini',
+        provider: 'openai',
+        contextWindow: 128000,
+        maxOutputTokens: 16384,
+        supportsVision: true,
+        supportsDocuments: false,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.00015,
+        outputPricePer1kTokens: 0.0006,
+    },
+    // o1 Reasoning Series
+    {
+        id: 'o1',
+        name: 'o1 (Reasoning)',
+        provider: 'openai',
+        contextWindow: 200000,
+        maxOutputTokens: 100000,
+        supportsVision: true,
+        supportsDocuments: false,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.015,
+        outputPricePer1kTokens: 0.06,
+    },
+    {
+        id: 'o1-mini',
+        name: 'o1 Mini (Reasoning)',
+        provider: 'openai',
+        contextWindow: 128000,
+        maxOutputTokens: 65536,
+        supportsVision: false,
+        supportsDocuments: false,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.003,
+        outputPricePer1kTokens: 0.012,
+    },
+    // Legacy GPT-4 Series
+    {
+        id: 'gpt-4-turbo',
+        name: 'GPT-4 Turbo',
+        provider: 'openai',
+        contextWindow: 128000,
+        maxOutputTokens: 4096,
+        supportsVision: true,
+        supportsDocuments: false,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.01,
+        outputPricePer1kTokens: 0.03,
+    },
+    {
+        id: 'gpt-3.5-turbo',
+        name: 'GPT-3.5 Turbo (Legacy)',
+        provider: 'openai',
+        contextWindow: 16385,
+        maxOutputTokens: 4096,
+        supportsVision: false,
+        supportsDocuments: false,
+        supportsFunctionCalling: true,
+        supportsStreaming: true,
+        inputPricePer1kTokens: 0.0005,
+        outputPricePer1kTokens: 0.0015,
+    },
+];
+// Default model
+const DEFAULT_MODEL = 'gpt-4o';
+// API configuration
+const OPENAI_API_URL = 'https://api.openai.com/v1/chat/completions';
+export class OpenAIProvider extends BaseLLMProvider {
+    constructor(config) {
+        super(config);
+        this.name = 'OpenAI';
+        this.type = 'openai';
+        this.supportedModels = OPENAI_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;
+        }
+    }
+    async chat(messages, options) {
+        this.validateMessages(messages);
+        this.logRequest(messages, options);
+        const apiKey = this.config.apiKey;
+        if (!apiKey) {
+            throw new Error('OpenAI API key not configured');
+        }
+        const model = options?.model || this.config.model;
+        const openaiMessages = this.convertMessages(messages, options?.systemPrompt);
+        const requestBody = {
+            model,
+            messages: openaiMessages,
+            max_tokens: options?.maxTokens || this.getSelectedModel()?.maxOutputTokens || 4096,
+        };
+        // Add optional parameters
+        if (options?.temperature !== undefined) {
+            requestBody.temperature = options.temperature;
+        }
+        if (options?.topP !== undefined) {
+            requestBody.top_p = options.topP;
+        }
+        if (options?.stopSequences?.length) {
+            requestBody.stop = options.stopSequences;
+        }
+        try {
+            const response = await fetch(this.config.baseUrl || OPENAI_API_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`,
+                    ...(this.config.organizationId && { 'OpenAI-Organization': this.config.organizationId }),
+                },
+                body: JSON.stringify(requestBody),
+                signal: AbortSignal.timeout(this.config.timeout || 120000),
+            });
+            if (!response.ok) {
+                const errorBody = await response.text();
+                logger.error('OpenAI API error response', { status: response.status, body: errorBody });
+                throw new Error(`OpenAI API error: ${response.status} - ${errorBody}`);
+            }
+            const data = (await response.json());
+            const chatResponse = this.convertResponse(data);
+            this.logResponse(chatResponse);
+            return chatResponse;
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'TimeoutError') {
+                throw new Error(`OpenAI 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: 'OpenAI API key not configured' };
+            return;
+        }
+        const model = options?.model || this.config.model;
+        const openaiMessages = this.convertMessages(messages, options?.systemPrompt);
+        const requestBody = {
+            model,
+            messages: openaiMessages,
+            max_tokens: options?.maxTokens || this.getSelectedModel()?.maxOutputTokens || 4096,
+            stream: true,
+        };
+        if (options?.temperature !== undefined) {
+            requestBody.temperature = options.temperature;
+        }
+        try {
+            const response = await fetch(this.config.baseUrl || OPENAI_API_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`,
+                    ...(this.config.organizationId && { 'OpenAI-Organization': this.config.organizationId }),
+                },
+                body: JSON.stringify(requestBody),
+                signal: AbortSignal.timeout(this.config.timeout || 120000),
+            });
+            if (!response.ok) {
+                const errorBody = await response.text();
+                yield { type: 'error', error: `OpenAI 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 === '[DONE]')
+                            continue;
+                        try {
+                            const event = JSON.parse(data);
+                            if (event.choices?.[0]?.delta?.content) {
+                                yield { type: 'text', content: event.choices[0].delta.content };
+                            }
+                            // Usage may be included in the final message
+                            if (event.usage) {
+                                promptTokens = event.usage.prompt_tokens || 0;
+                                completionTokens = event.usage.completion_tokens || 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 response = await fetch(OPENAI_API_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify({
+                    model: 'gpt-3.5-turbo',
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'Hi' }],
+                }),
+                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 === 401) {
+                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 OpenAI format
+    convertMessages(messages, systemPrompt) {
+        const result = [];
+        // Add system prompt if provided
+        if (systemPrompt) {
+            result.push({ role: 'system', content: systemPrompt });
+        }
+        // Convert remaining messages
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                // Add system messages directly
+                result.push({
+                    role: 'system',
+                    content: typeof msg.content === 'string' ? msg.content : this.extractTextContent(msg.content),
+                });
+            }
+            else {
+                result.push({
+                    role: msg.role,
+                    content: this.convertContent(msg.content),
+                });
+            }
+        }
+        return result;
+    }
+    extractTextContent(content) {
+        return content
+            .filter(item => item.type === 'text')
+            .map(item => item.text)
+            .join('\n');
+    }
+    convertContent(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return content.map(item => {
+            if (item.type === 'text') {
+                return { type: 'text', text: item.text };
+            }
+            if (item.type === 'image') {
+                const imageContent = item;
+                // OpenAI expects either a URL or a base64 data URL
+                const imageUrl = imageContent.source.url ||
+                    `data:${imageContent.source.mediaType || 'image/png'};base64,${imageContent.source.data}`;
+                return {
+                    type: 'image_url',
+                    image_url: {
+                        url: imageUrl,
+                        detail: 'auto',
+                    },
+                };
+            }
+            // Document type - convert to text representation
+            if (item.type === 'document') {
+                return {
+                    type: 'text',
+                    text: `[Document: ${item.source.name || 'unnamed'}]`,
+                };
+            }
+            return { type: 'text', text: '' };
+        });
+    }
+    convertResponse(data) {
+        const choice = data.choices[0];
+        const content = choice?.message?.content || '';
+        return {
+            id: data.id,
+            model: data.model,
+            content,
+            finishReason: this.mapFinishReason(choice?.finish_reason),
+            usage: {
+                promptTokens: data.usage.prompt_tokens,
+                completionTokens: data.usage.completion_tokens,
+                totalTokens: data.usage.total_tokens,
+            },
+            raw: data,
+        };
+    }
+    mapFinishReason(finishReason) {
+        switch (finishReason) {
+            case 'stop':
+                return 'stop';
+            case 'length':
+                return 'length';
+            case 'tool_calls':
+            case 'function_call':
+                return 'tool_calls';
+            case 'content_filter':
+                return 'content_filter';
+            default:
+                return 'stop';
+        }
+    }
+    // Token estimation using tiktoken approximation
+    estimateTokens(text) {
+        // Rough estimate: ~4 characters per token for English text
+        // OpenAI uses cl100k_base encoding for newer models
+        return Math.ceil(text.length / 4);
+    }
+}
+// Factory function
+export function createOpenAIProvider(config) {
+    return new OpenAIProvider(config);
+}

package/dist/story-generator/llm-providers/settings-manager.d.ts

@@ -0,0 +1,75 @@
+/**
+ * LLM Settings Manager
+ *
+ * Manages hybrid configuration for LLM provider/model selection.
+ * Combines environment variables (DevOps guardrails) with user preferences.
+ *
+ * Environment Variables:
+ * - DEFAULT_PROVIDER: Default provider (claude, openai, gemini)
+ * - DEFAULT_MODEL: Default model ID
+ * - ALLOWED_MODELS: Comma-separated list of allowed model IDs (optional)
+ * - ALLOWED_PROVIDERS: Comma-separated list of allowed providers (optional)
+ * - SINGLE_PROVIDER_MODE: Hide provider selection (true/false)
+ */
+import { ProviderType } from './types.js';
+export interface UserSettings {
+    selectedProvider?: ProviderType;
+    selectedModel?: string;
+}
+export interface SettingsConfig {
+    defaultProvider: ProviderType;
+    defaultModel: string;
+    allowedProviders: ProviderType[];
+    allowedModels: string[];
+    singleProviderMode: boolean;
+}
+export interface AvailableOption {
+    id: string;
+    name: string;
+    description?: string;
+    isDefault?: boolean;
+    isRecommended?: boolean;
+}
+export interface SettingsResponse {
+    providers: AvailableOption[];
+    models: AvailableOption[];
+    currentProvider: ProviderType;
+    currentModel: string;
+    config: {
+        singleProviderMode: boolean;
+        hasRestrictions: boolean;
+    };
+}
+/**
+ * Load settings configuration from environment
+ */
+export declare function loadSettingsConfig(): SettingsConfig;
+/**
+ * Get available providers for UI selection
+ */
+export declare function getAvailableProviders(config: SettingsConfig): AvailableOption[];
+/**
+ * Get available models for a provider
+ */
+export declare function getAvailableModels(provider: ProviderType, config: SettingsConfig): AvailableOption[];
+/**
+ * Validate user's model selection against configuration
+ */
+export declare function validateSelection(provider: ProviderType, model: string, config: SettingsConfig): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Get complete settings response for UI
+ */
+export declare function getSettingsForUI(currentProvider?: ProviderType, currentModel?: string): SettingsResponse;
+/**
+ * Apply user settings and return effective provider/model
+ */
+export declare function applyUserSettings(settings: UserSettings): {
+    provider: ProviderType;
+    model: string;
+    applied: boolean;
+    fallbackReason?: string;
+};
+//# sourceMappingURL=settings-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"settings-manager.d.ts","sourceRoot":"","sources":["../../../story-generator/llm-providers/settings-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAA0B,MAAM,YAAY,CAAC;AAIlE,MAAM,WAAW,YAAY;IAC3B,gBAAgB,CAAC,EAAE,YAAY,CAAC;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;CAExB;AAED,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,YAAY,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,eAAe,EAAE,YAAY,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE;QACN,kBAAkB,EAAE,OAAO,CAAC;QAC5B,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;CACH;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,cAAc,CA0BnD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,GAAG,eAAe,EAAE,CAyB/E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,cAAc,GACrB,eAAe,EAAE,CAmCnB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,cAAc,GACrB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CA4BpC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,eAAe,CAAC,EAAE,YAAY,EAC9B,YAAY,CAAC,EAAE,MAAM,GACpB,gBAAgB,CAuBlB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG;IACzD,QAAQ,EAAE,YAAY,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAuBA"}