cowork-os 0.3.21

package/dist/electron/electron/agent/llm/openai-provider.js

@@ -0,0 +1,657 @@
+"use strict";
+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 pi_ai_1 = require("@mariozechner/pi-ai");
+const openai_oauth_1 = require("./openai-oauth");
+// Default model for openai-codex (ChatGPT backend)
+const DEFAULT_CODEX_MODEL = 'gpt-5.1-codex-mini';
+/**
+ * OpenAI API provider implementation
+ * Supports both API key and OAuth token authentication
+ * - API Key: Uses OpenAI SDK directly with api.openai.com
+ * - OAuth: Uses pi-ai SDK with ChatGPT backend (chatgpt.com/backend-api/)
+ */
+class OpenAIProvider {
+    constructor(config) {
+        this.type = 'openai';
+        this.client = null;
+        const apiKey = config.openaiApiKey;
+        const accessToken = config.openaiAccessToken;
+        const refreshToken = config.openaiRefreshToken;
+        const tokenExpiresAt = config.openaiTokenExpiresAt;
+        this.model = config.model;
+        if (accessToken && refreshToken) {
+            // Use OAuth - will use pi-ai SDK for API calls
+            this.oauthTokens = {
+                access_token: accessToken,
+                refresh_token: refreshToken,
+                expires_at: tokenExpiresAt || 0, // Use stored expiry or 0 if not available
+            };
+            this.authMethod = 'oauth';
+            console.log(`[OpenAI] Using OAuth authentication with pi-ai SDK (token expires: ${tokenExpiresAt ? new Date(tokenExpiresAt).toISOString() : 'unknown'})`);
+        }
+        else if (apiKey) {
+            // Use API key - standard OpenAI SDK
+            this.client = new openai_1.default({ apiKey });
+            this.authMethod = 'api_key';
+            console.log('[OpenAI] Using API key authentication');
+        }
+        else {
+            throw new Error('OpenAI authentication required. Use API key or sign in with ChatGPT.');
+        }
+    }
+    async createMessage(request) {
+        if (this.authMethod === 'oauth') {
+            return this.createMessageWithOAuth(request);
+        }
+        else {
+            return this.createMessageWithApiKey(request);
+        }
+    }
+    /**
+     * Create message using API key (standard OpenAI SDK)
+     */
+    async createMessageWithApiKey(request) {
+        if (!this.client) {
+            throw new Error('OpenAI client not initialized');
+        }
+        const messages = this.convertMessages(request.messages, request.system);
+        const tools = request.tools ? this.convertTools(request.tools) : undefined;
+        try {
+            console.log(`[OpenAI] Calling API with model: ${request.model}`);
+            const response = await this.client.chat.completions.create({
+                model: request.model,
+                max_tokens: request.maxTokens,
+                messages,
+                ...(tools && tools.length > 0 && { tools }),
+            }, request.signal ? { signal: request.signal } : undefined);
+            return this.convertResponse(response);
+        }
+        catch (error) {
+            // Handle abort errors gracefully
+            if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+                console.log(`[OpenAI] Request aborted`);
+                throw new Error('Request cancelled');
+            }
+            console.error(`[OpenAI] API error:`, {
+                status: error.status,
+                message: error.message,
+                type: error.type || error.name,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Map public model names to openai-codex model IDs
+     */
+    mapToCodexModel(modelId) {
+        // Map common public model names to ChatGPT internal models
+        const modelMap = {
+            // Map gpt-4o models to gpt-5.1
+            'gpt-4o': 'gpt-5.1',
+            'gpt-4o-mini': 'gpt-5.1-codex-mini',
+            // Map o1/reasoning models to gpt-5.2
+            'o1': 'gpt-5.2',
+            'o1-mini': 'gpt-5.2-codex',
+            'o1-preview': 'gpt-5.2',
+            // Default mappings
+            'gpt-4-turbo': 'gpt-5.1',
+            'gpt-4': 'gpt-5.1',
+            'gpt-3.5-turbo': 'gpt-5.1-codex-mini',
+        };
+        return modelMap[modelId] || modelId;
+    }
+    /**
+     * Create message using OAuth (pi-ai SDK with ChatGPT backend)
+     */
+    async createMessageWithOAuth(request) {
+        if (!this.oauthTokens) {
+            throw new Error('OAuth tokens not available');
+        }
+        try {
+            // Map model ID to ChatGPT internal model
+            const codexModelId = this.mapToCodexModel(request.model);
+            console.log(`[OpenAI] Calling ChatGPT backend with model: ${codexModelId} (requested: ${request.model})`);
+            // Get the model object from pi-ai SDK
+            let model;
+            try {
+                // Get available models and find one that matches
+                const availableModels = (0, pi_ai_1.getModels)('openai-codex');
+                const found = availableModels.find(m => m.id === codexModelId);
+                if (found) {
+                    model = found;
+                }
+                else {
+                    // Use default if not found
+                    console.log(`[OpenAI] Model ${codexModelId} not found, using default: ${DEFAULT_CODEX_MODEL}`);
+                    model = availableModels.find(m => m.id === DEFAULT_CODEX_MODEL) || availableModels[0];
+                }
+            }
+            catch (e) {
+                console.error('[OpenAI] Failed to get model from pi-ai SDK:', e);
+                throw new Error(`Model not available: ${codexModelId}`);
+            }
+            // Convert messages to pi-ai format
+            const piAiMessages = this.convertMessagesToPiAi(request.messages);
+            // Convert tools to pi-ai format
+            const piAiTools = request.tools ? this.convertToolsToPiAi(request.tools) : undefined;
+            // Get API key from OAuth tokens (with auto-refresh)
+            const { apiKey, newTokens } = await openai_oauth_1.OpenAIOAuth.getApiKeyFromTokens(this.oauthTokens);
+            // Update tokens if they were refreshed
+            if (newTokens) {
+                this.oauthTokens = newTokens;
+            }
+            // Build context
+            const context = {
+                systemPrompt: request.system,
+                messages: piAiMessages,
+                tools: piAiTools,
+            };
+            // Make the API call using pi-ai SDK
+            const response = await (0, pi_ai_1.complete)(model, context, {
+                apiKey,
+                maxTokens: request.maxTokens,
+                signal: request.signal,
+            });
+            // Convert pi-ai response to our format
+            return this.convertPiAiResponse(response);
+        }
+        catch (error) {
+            // Handle abort errors gracefully
+            if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+                console.log(`[OpenAI] Request aborted`);
+                throw new Error('Request cancelled');
+            }
+            console.error(`[OpenAI] ChatGPT API error:`, {
+                message: error.message,
+                type: error.type || error.name,
+            });
+            throw error;
+        }
+    }
+    async testConnection() {
+        try {
+            if (this.authMethod === 'oauth') {
+                // For OAuth, try to get the API key and make a simple request
+                if (!this.oauthTokens) {
+                    return { success: false, error: 'OAuth tokens not available' };
+                }
+                const { apiKey } = await openai_oauth_1.OpenAIOAuth.getApiKeyFromTokens(this.oauthTokens);
+                // Get a model from the available models
+                const availableModels = (0, pi_ai_1.getModels)('openai-codex');
+                const model = availableModels.find(m => m.id === DEFAULT_CODEX_MODEL) || availableModels[0];
+                await (0, pi_ai_1.complete)(model, {
+                    messages: [{
+                            role: 'user',
+                            content: [{ type: 'text', text: 'Hi' }],
+                            timestamp: Date.now(),
+                        }],
+                }, { apiKey, maxTokens: 10 });
+                return { success: true };
+            }
+            else {
+                // For API key, use standard OpenAI SDK
+                if (!this.client) {
+                    return { success: false, error: 'OpenAI client not initialized' };
+                }
+                await this.client.chat.completions.create({
+                    model: 'gpt-4o-mini',
+                    max_tokens: 10,
+                    messages: [{ role: 'user', content: 'Hi' }],
+                });
+                return { success: true };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to OpenAI API',
+            };
+        }
+    }
+    /**
+     * Get available models
+     * For API key: uses the models.list API
+     * For OAuth: uses pi-ai SDK's model list for openai-codex provider
+     */
+    async getAvailableModels() {
+        // For OAuth authentication, use pi-ai SDK's model list
+        if (this.authMethod === 'oauth') {
+            console.log('[OpenAI] Using OAuth - fetching models from pi-ai SDK...');
+            try {
+                // Get models from pi-ai SDK for openai-codex provider
+                const piAiModels = (0, pi_ai_1.getModels)('openai-codex');
+                const models = piAiModels.map((m) => ({
+                    id: m.id,
+                    name: m.name || this.formatModelName(m.id),
+                    description: this.getModelDescription(m.id),
+                }));
+                // Sort by priority
+                models.sort((a, b) => {
+                    const priority = (id) => {
+                        if (id.includes('5.1-codex-mini'))
+                            return 0;
+                        if (id.includes('5.1-codex-max'))
+                            return 1;
+                        if (id === 'gpt-5.1')
+                            return 2;
+                        if (id.includes('5.2-codex'))
+                            return 3;
+                        if (id === 'gpt-5.2')
+                            return 4;
+                        return 5;
+                    };
+                    return priority(a.id) - priority(b.id);
+                });
+                console.log(`[OpenAI] Found ${models.length} models via pi-ai SDK`);
+                return models;
+            }
+            catch (error) {
+                console.error('[OpenAI] Failed to get models from pi-ai SDK:', error);
+                // Return defaults on error
+                return this.getDefaultCodexModels();
+            }
+        }
+        // For API key authentication, use the standard models list API
+        if (this.client) {
+            try {
+                const response = await this.client.models.list();
+                const models = response.data
+                    .filter((m) => m.id.startsWith('gpt-') || m.id.startsWith('o1') || m.id.startsWith('o3'))
+                    .map((m) => ({
+                    id: m.id,
+                    name: this.formatModelName(m.id),
+                    description: this.getModelDescription(m.id),
+                }))
+                    .sort((a, b) => {
+                    const priority = (id) => {
+                        if (id.includes('gpt-4o'))
+                            return 0;
+                        if (id.includes('gpt-4'))
+                            return 1;
+                        if (id.includes('gpt-3.5'))
+                            return 2;
+                        if (id.includes('o1'))
+                            return 3;
+                        if (id.includes('o3'))
+                            return 4;
+                        return 5;
+                    };
+                    return priority(a.id) - priority(b.id);
+                });
+                return models;
+            }
+            catch (error) {
+                console.error('Failed to fetch OpenAI models:', error);
+            }
+        }
+        // Return defaults if nothing else works
+        return this.getDefaultModels();
+    }
+    getDefaultModels() {
+        return [
+            { id: 'gpt-4o', name: 'GPT-4o', description: 'Most capable model for complex tasks' },
+            { id: 'gpt-4o-mini', name: 'GPT-4o Mini', description: 'Fast and affordable for most tasks' },
+            { id: 'o1', name: 'o1', description: 'Advanced reasoning model' },
+            { id: 'o1-mini', name: 'o1 Mini', description: 'Fast reasoning model' },
+            { id: 'gpt-4-turbo', name: 'GPT-4 Turbo', description: 'Previous generation flagship' },
+            { id: 'gpt-3.5-turbo', name: 'GPT-3.5 Turbo', description: 'Fast and cost-effective' },
+        ];
+    }
+    getDefaultCodexModels() {
+        return [
+            { id: 'gpt-5.1-codex-mini', name: 'GPT-5.1 Codex Mini', description: 'Fast and efficient for most tasks' },
+            { id: 'gpt-5.1-codex-max', name: 'GPT-5.1 Codex Max', description: 'Maximum capability for complex tasks' },
+            { id: 'gpt-5.1', name: 'GPT-5.1', description: 'Balanced performance and capability' },
+            { id: 'gpt-5.2-codex', name: 'GPT-5.2 Codex', description: 'Advanced reasoning model' },
+            { id: 'gpt-5.2', name: 'GPT-5.2', description: 'Most advanced reasoning' },
+        ];
+    }
+    formatModelName(modelId) {
+        // Format model ID to display name
+        if (modelId === 'gpt-4o')
+            return 'GPT-4o';
+        if (modelId === 'gpt-4o-mini')
+            return 'GPT-4o Mini';
+        if (modelId.includes('gpt-4o-'))
+            return `GPT-4o (${modelId.replace('gpt-4o-', '')})`;
+        if (modelId === 'gpt-4-turbo')
+            return 'GPT-4 Turbo';
+        if (modelId.includes('gpt-4-turbo-'))
+            return `GPT-4 Turbo (${modelId.replace('gpt-4-turbo-', '')})`;
+        if (modelId === 'gpt-4')
+            return 'GPT-4';
+        if (modelId.includes('gpt-4-'))
+            return `GPT-4 (${modelId.replace('gpt-4-', '')})`;
+        if (modelId === 'gpt-3.5-turbo')
+            return 'GPT-3.5 Turbo';
+        if (modelId.includes('gpt-3.5-turbo-'))
+            return `GPT-3.5 Turbo (${modelId.replace('gpt-3.5-turbo-', '')})`;
+        if (modelId === 'o1')
+            return 'o1';
+        if (modelId === 'o1-mini')
+            return 'o1 Mini';
+        if (modelId === 'o1-preview')
+            return 'o1 Preview';
+        if (modelId === 'o3-mini')
+            return 'o3 Mini';
+        // ChatGPT internal models
+        if (modelId === 'gpt-5.1')
+            return 'GPT-5.1';
+        if (modelId === 'gpt-5.1-codex-mini')
+            return 'GPT-5.1 Codex Mini';
+        if (modelId === 'gpt-5.1-codex-max')
+            return 'GPT-5.1 Codex Max';
+        if (modelId === 'gpt-5.2')
+            return 'GPT-5.2';
+        if (modelId === 'gpt-5.2-codex')
+            return 'GPT-5.2 Codex';
+        return modelId;
+    }
+    getModelDescription(modelId) {
+        if (modelId.includes('gpt-4o') && !modelId.includes('mini'))
+            return 'Most capable model for complex tasks';
+        if (modelId.includes('gpt-4o-mini'))
+            return 'Fast and affordable for most tasks';
+        if (modelId.includes('gpt-4-turbo'))
+            return 'Previous generation flagship';
+        if (modelId.includes('gpt-4'))
+            return 'High capability model';
+        if (modelId.includes('gpt-3.5'))
+            return 'Fast and cost-effective';
+        if (modelId === 'o1' || modelId === 'o1-preview')
+            return 'Advanced reasoning model';
+        if (modelId === 'o1-mini')
+            return 'Fast reasoning model';
+        if (modelId.includes('o3'))
+            return 'Next generation reasoning';
+        // ChatGPT internal models
+        if (modelId === 'gpt-5.1')
+            return 'Balanced performance and capability';
+        if (modelId === 'gpt-5.1-codex-mini')
+            return 'Fast and efficient for most tasks';
+        if (modelId === 'gpt-5.1-codex-max')
+            return 'Maximum capability for complex tasks';
+        if (modelId === 'gpt-5.2')
+            return 'Most advanced reasoning';
+        if (modelId === 'gpt-5.2-codex')
+            return 'Advanced reasoning model';
+        return 'OpenAI model';
+    }
+    /**
+     * Convert messages to pi-ai SDK format
+     */
+    convertMessagesToPiAi(messages) {
+        const result = [];
+        const now = Date.now();
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                if (msg.role === 'user') {
+                    result.push({
+                        role: 'user',
+                        content: [{ type: 'text', text: msg.content }],
+                        timestamp: now,
+                    });
+                }
+                else {
+                    // Assistant message
+                    result.push({
+                        role: 'assistant',
+                        content: [{ type: 'text', text: msg.content }],
+                        api: 'openai-codex-responses',
+                        provider: 'openai-codex',
+                        model: this.model,
+                        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+                        stopReason: 'stop',
+                        timestamp: now,
+                    });
+                }
+            }
+            else if (Array.isArray(msg.content)) {
+                // Check if this is a tool result array
+                const toolResults = msg.content.filter((item) => item.type === 'tool_result');
+                if (toolResults.length > 0) {
+                    // Convert tool results to pi-ai format
+                    for (const toolResult of toolResults) {
+                        result.push({
+                            role: 'toolResult',
+                            toolCallId: toolResult.tool_use_id,
+                            toolName: '', // Will be filled by the SDK
+                            content: [{ type: 'text', text: toolResult.content }],
+                            isError: toolResult.is_error || false,
+                            timestamp: now,
+                        });
+                    }
+                }
+                else {
+                    // Handle mixed content (text and tool_use)
+                    if (msg.role === 'user') {
+                        const textContent = msg.content
+                            .filter((item) => item.type === 'text')
+                            .map((item) => ({ type: 'text', text: item.text }));
+                        if (textContent.length > 0) {
+                            result.push({
+                                role: 'user',
+                                content: textContent,
+                                timestamp: now,
+                            });
+                        }
+                    }
+                    else {
+                        // Assistant message with tool calls
+                        const content = [];
+                        for (const item of msg.content) {
+                            if (item.type === 'text') {
+                                content.push({ type: 'text', text: item.text });
+                            }
+                            else if (item.type === 'tool_use') {
+                                content.push({
+                                    type: 'toolCall',
+                                    id: item.id,
+                                    name: item.name,
+                                    arguments: item.input,
+                                });
+                            }
+                        }
+                        if (content.length > 0) {
+                            result.push({
+                                role: 'assistant',
+                                content,
+                                api: 'openai-codex-responses',
+                                provider: 'openai-codex',
+                                model: this.model,
+                                usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+                                stopReason: 'stop',
+                                timestamp: now,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Convert tools to pi-ai SDK format
+     */
+    convertToolsToPiAi(tools) {
+        return tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema,
+        }));
+    }
+    /**
+     * Convert pi-ai response to our format
+     */
+    convertPiAiResponse(response) {
+        const content = [];
+        if (response.content) {
+            for (const block of response.content) {
+                if (block.type === 'text') {
+                    content.push({
+                        type: 'text',
+                        text: block.text,
+                    });
+                }
+                else if (block.type === 'toolCall') {
+                    content.push({
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: block.arguments || {},
+                    });
+                }
+            }
+        }
+        // Map stop reason
+        let stopReason = 'end_turn';
+        if (response.stopReason === 'toolUse') {
+            stopReason = 'tool_use';
+        }
+        else if (response.stopReason === 'length') {
+            stopReason = 'max_tokens';
+        }
+        return {
+            content,
+            stopReason,
+            usage: response.usage
+                ? {
+                    inputTokens: response.usage.input || 0,
+                    outputTokens: response.usage.output || 0,
+                }
+                : undefined,
+        };
+    }
+    /**
+     * Convert messages to OpenAI format (for API key auth)
+     */
+    convertMessages(messages, system) {
+        const result = [];
+        // Add system message first if provided
+        if (system) {
+            result.push({
+                role: 'system',
+                content: system,
+            });
+        }
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                result.push({
+                    role: msg.role,
+                    content: msg.content,
+                });
+            }
+            else if (Array.isArray(msg.content)) {
+                // Check if this is a tool result array
+                const toolResults = msg.content.filter((item) => item.type === 'tool_result');
+                if (toolResults.length > 0) {
+                    // Convert tool results to OpenAI format
+                    for (const toolResult of toolResults) {
+                        result.push({
+                            role: 'tool',
+                            tool_call_id: toolResult.tool_use_id,
+                            content: toolResult.content,
+                        });
+                    }
+                }
+                else {
+                    // Handle mixed content (text and tool_use)
+                    const textContent = msg.content
+                        .filter((item) => item.type === 'text')
+                        .map((item) => item.text)
+                        .join('\n');
+                    const toolUses = msg.content.filter((item) => item.type === 'tool_use');
+                    if (msg.role === 'assistant') {
+                        const assistantMsg = {
+                            role: 'assistant',
+                            content: textContent || null,
+                        };
+                        if (toolUses.length > 0) {
+                            assistantMsg.tool_calls = toolUses.map((tool) => ({
+                                id: tool.id,
+                                type: 'function',
+                                function: {
+                                    name: tool.name,
+                                    arguments: JSON.stringify(tool.input),
+                                },
+                            }));
+                        }
+                        result.push(assistantMsg);
+                    }
+                    else {
+                        result.push({
+                            role: msg.role,
+                            content: textContent,
+                        });
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    convertTools(tools) {
+        return tools.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema,
+            },
+        }));
+    }
+    convertResponse(response) {
+        const choice = response.choices[0];
+        const content = [];
+        // Add text content if present
+        if (choice.message.content) {
+            content.push({
+                type: 'text',
+                text: choice.message.content,
+            });
+        }
+        // Add tool calls if present
+        if (choice.message.tool_calls) {
+            for (const toolCall of choice.message.tool_calls) {
+                // Only handle function-type tool calls
+                if (toolCall.type === 'function') {
+                    content.push({
+                        type: 'tool_use',
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        input: JSON.parse(toolCall.function.arguments || '{}'),
+                    });
+                }
+            }
+        }
+        return {
+            content,
+            stopReason: this.mapStopReason(choice.finish_reason),
+            usage: response.usage
+                ? {
+                    inputTokens: response.usage.prompt_tokens,
+                    outputTokens: response.usage.completion_tokens,
+                }
+                : undefined,
+        };
+    }
+    mapStopReason(reason) {
+        switch (reason) {
+            case 'stop':
+                return 'end_turn';
+            case 'tool_calls':
+                return 'tool_use';
+            case 'length':
+                return 'max_tokens';
+            case 'content_filter':
+                return 'stop_sequence';
+            default:
+                return 'end_turn';
+        }
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;