@theia/ai-openai 1.66.0-next.73 → 1.66.0-next.80

package/lib/node/openai-response-api-utils.js

@@ -0,0 +1,677 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSystemMessages = exports.OpenAiResponseApiUtils = void 0;
+const tslib_1 = require("tslib");
+const ai_core_1 = require("@theia/ai-core");
+const core_1 = require("@theia/core");
+const promise_util_1 = require("@theia/core/lib/common/promise-util");
+const inversify_1 = require("@theia/core/shared/inversify");
+/**
+ * Utility class for handling OpenAI Response API requests and tool calling cycles.
+ *
+ * This class encapsulates the complexity of the Response API's multi-turn conversation
+ * patterns for tool calling, keeping the main language model class clean and focused.
+ */
+let OpenAiResponseApiUtils = class OpenAiResponseApiUtils {
+    /**
+     * Handles Response API requests with proper tool calling cycles.
+     * Works for both streaming and non-streaming cases.
+     */
+    async handleRequest(openai, request, settings, model, modelUtils, developerMessageSettings, runnerOptions, modelId, isStreaming, tokenUsageService, cancellationToken) {
+        if (cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.isCancellationRequested) {
+            return { text: '' };
+        }
+        const { instructions, input } = this.processMessages(request.messages, developerMessageSettings, model);
+        const tools = this.convertToolsForResponseApi(request.tools);
+        // If no tools are provided, use simple response handling
+        if (!tools || tools.length === 0) {
+            if (isStreaming) {
+                const stream = openai.responses.stream({
+                    model: model,
+                    instructions,
+                    input,
+                    ...settings
+                });
+                return { stream: this.createSimpleResponseApiStreamIterator(stream, request.requestId, modelId, tokenUsageService, cancellationToken) };
+            }
+            else {
+                const response = await openai.responses.create({
+                    model: model,
+                    instructions,
+                    input,
+                    ...settings
+                });
+                // Record token usage if available
+                if (tokenUsageService && response.usage) {
+                    await tokenUsageService.recordTokenUsage(modelId, {
+                        inputTokens: response.usage.input_tokens,
+                        outputTokens: response.usage.output_tokens,
+                        requestId: request.requestId
+                    });
+                }
+                return { text: response.output_text || '' };
+            }
+        }
+        // Handle tool calling with multi-turn conversation using the unified iterator
+        const iterator = new ResponseApiToolCallIterator(openai, request, settings, model, modelUtils, developerMessageSettings, runnerOptions, modelId, this, isStreaming, tokenUsageService, cancellationToken);
+        return { stream: iterator };
+    }
+    /**
+     * Converts ToolRequest objects to the format expected by the Response API.
+     */
+    convertToolsForResponseApi(tools) {
+        if (!tools || tools.length === 0) {
+            return undefined;
+        }
+        const converted = tools.map(tool => ({
+            type: 'function',
+            name: tool.name,
+            description: tool.description || '',
+            // The Response API is very strict re: JSON schema: all properties must be listed as required,
+            // and additional properties must be disallowed.
+            // https://platform.openai.com/docs/guides/function-calling#strict-mode
+            parameters: {
+                ...tool.parameters,
+                additionalProperties: false,
+                required: tool.parameters.properties ? Object.keys(tool.parameters.properties) : []
+            },
+            strict: true
+        }));
+        console.debug(`Converted ${tools.length} tools for Response API:`, converted.map(t => t.name));
+        return converted;
+    }
+    createSimpleResponseApiStreamIterator(stream, requestId, modelId, tokenUsageService, cancellationToken) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                var _a;
+                try {
+                    for await (const event of stream) {
+                        if (cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.isCancellationRequested) {
+                            break;
+                        }
+                        if (event.type === 'response.output_text.delta') {
+                            yield {
+                                content: event.delta
+                            };
+                        }
+                        else if (event.type === 'response.completed') {
+                            if (tokenUsageService && ((_a = event.response) === null || _a === void 0 ? void 0 : _a.usage)) {
+                                await tokenUsageService.recordTokenUsage(modelId, {
+                                    inputTokens: event.response.usage.input_tokens,
+                                    outputTokens: event.response.usage.output_tokens,
+                                    requestId
+                                });
+                            }
+                        }
+                        else if (event.type === 'error') {
+                            console.error('Response API error:', event.message);
+                            throw new Error(`Response API error: ${event.message}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('Error in Response API stream:', error);
+                    throw error;
+                }
+            }
+        };
+    }
+    /**
+     * Processes the provided list of messages by applying system message adjustments and converting
+     * them directly to the format expected by the OpenAI Response API.
+     *
+     * This method converts messages directly without going through ChatCompletionMessageParam types.
+     *
+     * @param messages the list of messages to process.
+     * @param developerMessageSettings how system and developer messages are handled during processing.
+     * @param model the OpenAI model identifier. Currently not used, but allows subclasses to implement model-specific behavior.
+     * @returns an object containing instructions and input formatted for the Response API.
+     */
+    processMessages(messages, developerMessageSettings, model) {
+        const processed = this.processSystemMessages(messages, developerMessageSettings)
+            .filter(m => m.type !== 'thinking');
+        // Extract system/developer messages for instructions
+        const systemMessages = processed.filter((m) => m.type === 'text' && m.actor === 'system');
+        const instructions = systemMessages.length > 0
+            ? systemMessages.map(m => m.text).join('\n')
+            : undefined;
+        // Convert non-system messages to Response API input items
+        const nonSystemMessages = processed.filter(m => m.actor !== 'system');
+        const input = [];
+        for (const message of nonSystemMessages) {
+            if (ai_core_1.LanguageModelMessage.isTextMessage(message)) {
+                if (message.actor === 'ai') {
+                    // Assistant messages use ResponseOutputMessage format
+                    input.push({
+                        id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+                        type: 'message',
+                        role: 'assistant',
+                        status: 'completed',
+                        content: [{
+                                type: 'output_text',
+                                text: message.text,
+                                annotations: []
+                            }]
+                    });
+                }
+                else {
+                    // User messages use input format
+                    input.push({
+                        type: 'message',
+                        role: 'user',
+                        content: [{
+                                type: 'input_text',
+                                text: message.text
+                            }]
+                    });
+                }
+            }
+            else if (ai_core_1.LanguageModelMessage.isToolUseMessage(message)) {
+                input.push({
+                    type: 'function_call',
+                    call_id: message.id,
+                    name: message.name,
+                    arguments: JSON.stringify(message.input)
+                });
+            }
+            else if (ai_core_1.LanguageModelMessage.isToolResultMessage(message)) {
+                const content = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
+                input.push({
+                    type: 'function_call_output',
+                    call_id: message.tool_use_id,
+                    output: content
+                });
+            }
+            else if (ai_core_1.LanguageModelMessage.isImageMessage(message)) {
+                input.push({
+                    type: 'message',
+                    role: 'user',
+                    content: [{
+                            type: 'input_image',
+                            detail: 'auto',
+                            image_url: ai_core_1.ImageContent.isBase64(message.image) ?
+                                `data:${message.image.mimeType};base64,${message.image.base64data}` :
+                                message.image.url
+                        }]
+                });
+            }
+            else if (ai_core_1.LanguageModelMessage.isThinkingMessage(message)) {
+                // Pass
+            }
+            else {
+                (0, core_1.unreachable)(message);
+            }
+        }
+        return { instructions, input };
+    }
+    processSystemMessages(messages, developerMessageSettings) {
+        return processSystemMessages(messages, developerMessageSettings);
+    }
+};
+exports.OpenAiResponseApiUtils = OpenAiResponseApiUtils;
+exports.OpenAiResponseApiUtils = OpenAiResponseApiUtils = tslib_1.__decorate([
+    (0, inversify_1.injectable)()
+], OpenAiResponseApiUtils);
+/**
+ * Iterator for handling Response API streaming with tool calls.
+ * Based on the pattern from openai-streaming-iterator.ts but adapted for Response API.
+ */
+class ResponseApiToolCallIterator {
+    constructor(openai, request, settings, model, modelUtils, developerMessageSettings, runnerOptions, modelId, utils, isStreaming, tokenUsageService, cancellationToken) {
+        this.openai = openai;
+        this.request = request;
+        this.settings = settings;
+        this.model = model;
+        this.modelUtils = modelUtils;
+        this.developerMessageSettings = developerMessageSettings;
+        this.runnerOptions = runnerOptions;
+        this.modelId = modelId;
+        this.utils = utils;
+        this.isStreaming = isStreaming;
+        this.tokenUsageService = tokenUsageService;
+        this.cancellationToken = cancellationToken;
+        this.requestQueue = new Array();
+        this.messageCache = new Array();
+        this.done = false;
+        this.terminalError = undefined;
+        this.currentToolCalls = new Map();
+        this.totalInputTokens = 0;
+        this.totalOutputTokens = 0;
+        this.iteration = 0;
+        this.currentResponseText = '';
+        const { instructions, input } = utils.processMessages(request.messages, developerMessageSettings, model);
+        this.instructions = instructions;
+        this.currentInput = input;
+        this.tools = utils.convertToolsForResponseApi(request.tools);
+        this.maxIterations = runnerOptions.maxChatCompletions || 100;
+        // Start the first iteration
+        this.startIteration();
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    async next() {
+        if (this.messageCache.length && this.requestQueue.length) {
+            throw new Error('Assertion error: cache and queue should not both be populated.');
+        }
+        // Deliver all the messages we got, even if we've since terminated.
+        if (this.messageCache.length) {
+            return {
+                done: false,
+                value: this.messageCache.shift()
+            };
+        }
+        else if (this.terminalError) {
+            throw this.terminalError;
+        }
+        else if (this.done) {
+            return {
+                done: true,
+                value: undefined
+            };
+        }
+        else {
+            const deferred = new promise_util_1.Deferred();
+            this.requestQueue.push(deferred);
+            return deferred.promise;
+        }
+    }
+    async startIteration() {
+        var _a;
+        try {
+            while (this.iteration < this.maxIterations && !((_a = this.cancellationToken) === null || _a === void 0 ? void 0 : _a.isCancellationRequested)) {
+                console.debug(`Starting Response API iteration ${this.iteration} with ${this.currentInput.length} input messages`);
+                await this.processStream();
+                // Check if we have tool calls that need execution
+                if (this.currentToolCalls.size === 0) {
+                    // No tool calls, we're done
+                    this.finalize();
+                    return;
+                }
+                // Execute all tool calls
+                await this.executeToolCalls();
+                // Prepare for next iteration
+                this.prepareNextIteration();
+                this.iteration++;
+            }
+            // Max iterations reached
+            this.finalize();
+        }
+        catch (error) {
+            this.terminalError = error instanceof Error ? error : new Error(String(error));
+            this.finalize();
+        }
+    }
+    async processStream() {
+        var _a;
+        this.currentToolCalls.clear();
+        this.currentResponseText = '';
+        if (this.isStreaming) {
+            // Use streaming API
+            const stream = this.openai.responses.stream({
+                model: this.model,
+                instructions: this.instructions,
+                input: this.currentInput,
+                tools: this.tools,
+                ...this.settings
+            });
+            for await (const event of stream) {
+                if ((_a = this.cancellationToken) === null || _a === void 0 ? void 0 : _a.isCancellationRequested) {
+                    break;
+                }
+                await this.handleStreamEvent(event);
+            }
+        }
+        else {
+            // Use non-streaming API but yield results incrementally
+            await this.processNonStreamingResponse();
+        }
+    }
+    async processNonStreamingResponse() {
+        var _a;
+        const response = await this.openai.responses.create({
+            model: this.model,
+            instructions: this.instructions,
+            input: this.currentInput,
+            tools: this.tools,
+            ...this.settings
+        });
+        // Record token usage
+        if (response.usage) {
+            this.totalInputTokens += response.usage.input_tokens;
+            this.totalOutputTokens += response.usage.output_tokens;
+        }
+        // First, yield any text content from the response
+        this.currentResponseText = response.output_text || '';
+        if (this.currentResponseText) {
+            this.handleIncoming({ content: this.currentResponseText });
+        }
+        // Find function calls in the response
+        const functionCalls = ((_a = response.output) === null || _a === void 0 ? void 0 : _a.filter((item) => item.type === 'function_call')) || [];
+        // Process each function call
+        for (const functionCall of functionCalls) {
+            if (functionCall.id && functionCall.name) {
+                const toolCall = {
+                    id: functionCall.id,
+                    call_id: functionCall.call_id || functionCall.id,
+                    name: functionCall.name,
+                    arguments: functionCall.arguments || '',
+                    executed: false
+                };
+                this.currentToolCalls.set(functionCall.id, toolCall);
+                // Yield the tool call initiation
+                this.handleIncoming({
+                    tool_calls: [{
+                            id: functionCall.id,
+                            finished: false,
+                            function: {
+                                name: functionCall.name,
+                                arguments: functionCall.arguments || ''
+                            }
+                        }]
+                });
+            }
+        }
+    }
+    async handleStreamEvent(event) {
+        var _a, _b, _c;
+        switch (event.type) {
+            case 'response.output_text.delta':
+                this.currentResponseText += event.delta;
+                this.handleIncoming({ content: event.delta });
+                break;
+            case 'response.output_item.added':
+                if (((_a = event.item) === null || _a === void 0 ? void 0 : _a.type) === 'function_call') {
+                    this.handleFunctionCallAdded(event.item);
+                }
+                break;
+            case 'response.function_call_arguments.delta':
+                this.handleFunctionCallArgsDelta(event);
+                break;
+            case 'response.function_call_arguments.done':
+                await this.handleFunctionCallArgsDone(event);
+                break;
+            case 'response.output_item.done':
+                if (((_b = event.item) === null || _b === void 0 ? void 0 : _b.type) === 'function_call') {
+                    this.handleFunctionCallDone(event.item);
+                }
+                break;
+            case 'response.completed':
+                if ((_c = event.response) === null || _c === void 0 ? void 0 : _c.usage) {
+                    this.totalInputTokens += event.response.usage.input_tokens;
+                    this.totalOutputTokens += event.response.usage.output_tokens;
+                }
+                break;
+            case 'error':
+                console.error('Response API error:', event.message);
+                throw new Error(`Response API error: ${event.message}`);
+        }
+    }
+    handleFunctionCallAdded(functionCall) {
+        if (functionCall.id && functionCall.call_id) {
+            console.debug(`Function call added: ${functionCall.name} with id ${functionCall.id} and call_id ${functionCall.call_id}`);
+            const toolCall = {
+                id: functionCall.id,
+                call_id: functionCall.call_id,
+                name: functionCall.name || '',
+                arguments: functionCall.arguments || '',
+                executed: false
+            };
+            this.currentToolCalls.set(functionCall.id, toolCall);
+            this.handleIncoming({
+                tool_calls: [{
+                        id: functionCall.id,
+                        finished: false,
+                        function: {
+                            name: functionCall.name || '',
+                            arguments: functionCall.arguments || ''
+                        }
+                    }]
+            });
+        }
+    }
+    handleFunctionCallArgsDelta(event) {
+        const toolCall = this.currentToolCalls.get(event.item_id);
+        if (toolCall) {
+            toolCall.arguments += event.delta;
+            if (event.delta) {
+                this.handleIncoming({
+                    tool_calls: [{
+                            id: event.item_id,
+                            function: {
+                                arguments: event.delta
+                            }
+                        }]
+                });
+            }
+        }
+    }
+    async handleFunctionCallArgsDone(event) {
+        let toolCall = this.currentToolCalls.get(event.item_id);
+        if (!toolCall) {
+            // Create if we didn't see the added event
+            toolCall = {
+                id: event.item_id,
+                name: event.name || '',
+                arguments: event.arguments || '',
+                executed: false
+            };
+            this.currentToolCalls.set(event.item_id, toolCall);
+            this.handleIncoming({
+                tool_calls: [{
+                        id: event.item_id,
+                        finished: false,
+                        function: {
+                            name: event.name || '',
+                            arguments: event.arguments || ''
+                        }
+                    }]
+            });
+        }
+        else {
+            // Update with final values
+            toolCall.name = event.name || toolCall.name;
+            toolCall.arguments = event.arguments || toolCall.arguments;
+        }
+    }
+    handleFunctionCallDone(functionCall) {
+        if (!functionCall.id) {
+            console.warn('Unexpected absence of ID for call ID', functionCall.call_id);
+            return;
+        }
+        const toolCall = this.currentToolCalls.get(functionCall.id);
+        if (toolCall && !toolCall.call_id && functionCall.call_id) {
+            toolCall.call_id = functionCall.call_id;
+        }
+    }
+    async executeToolCalls() {
+        var _a;
+        for (const [itemId, toolCall] of this.currentToolCalls) {
+            if (toolCall.executed) {
+                continue;
+            }
+            const tool = (_a = this.request.tools) === null || _a === void 0 ? void 0 : _a.find(t => t.name === toolCall.name);
+            if (tool) {
+                try {
+                    const result = await tool.handler(toolCall.arguments);
+                    toolCall.result = result;
+                    // Yield the tool call completion
+                    this.handleIncoming({
+                        tool_calls: [{
+                                id: itemId,
+                                finished: true,
+                                function: {
+                                    name: toolCall.name,
+                                    arguments: toolCall.arguments
+                                },
+                                result
+                            }]
+                    });
+                }
+                catch (error) {
+                    console.error(`Error executing tool ${toolCall.name}:`, error);
+                    toolCall.error = error instanceof Error ? error : new Error(String(error));
+                    const errorResult = {
+                        type: 'error',
+                        data: error instanceof Error ? error.message : String(error)
+                    };
+                    // Yield the tool call error
+                    this.handleIncoming({
+                        tool_calls: [{
+                                id: itemId,
+                                finished: true,
+                                function: {
+                                    name: toolCall.name,
+                                    arguments: toolCall.arguments
+                                },
+                                result: errorResult
+                            }]
+                    });
+                }
+            }
+            else {
+                console.warn(`Tool ${toolCall.name} not found in request tools`);
+                toolCall.error = new Error(`Tool ${toolCall.name} not found`);
+                const errorResult = {
+                    type: 'error',
+                    data: `Tool ${toolCall.name} not found`
+                };
+                // Yield the tool call error
+                this.handleIncoming({
+                    tool_calls: [{
+                            id: itemId,
+                            finished: true,
+                            function: {
+                                name: toolCall.name,
+                                arguments: toolCall.arguments
+                            },
+                            result: errorResult
+                        }]
+                });
+            }
+            toolCall.executed = true;
+        }
+    }
+    prepareNextIteration() {
+        // Add assistant response with the actual text that was streamed
+        const assistantMessage = {
+            role: 'assistant',
+            content: this.currentResponseText
+        };
+        // Add the function calls that were made by the assistant
+        const functionCalls = [];
+        for (const [itemId, toolCall] of this.currentToolCalls) {
+            functionCalls.push({
+                type: 'function_call',
+                call_id: toolCall.call_id || itemId,
+                name: toolCall.name,
+                arguments: toolCall.arguments
+            });
+        }
+        // Add tool results
+        const toolResults = [];
+        for (const [itemId, toolCall] of this.currentToolCalls) {
+            const callId = toolCall.call_id || itemId;
+            if (toolCall.result !== undefined) {
+                const resultContent = typeof toolCall.result === 'string' ? toolCall.result : JSON.stringify(toolCall.result);
+                toolResults.push({
+                    type: 'function_call_output',
+                    call_id: callId,
+                    output: resultContent
+                });
+            }
+            else if (toolCall.error) {
+                toolResults.push({
+                    type: 'function_call_output',
+                    call_id: callId,
+                    output: `Error: ${toolCall.error.message}`
+                });
+            }
+        }
+        this.currentInput = [...this.currentInput, assistantMessage, ...functionCalls, ...toolResults];
+    }
+    handleIncoming(message) {
+        if (this.messageCache.length && this.requestQueue.length) {
+            throw new Error('Assertion error: cache and queue should not both be populated.');
+        }
+        if (this.requestQueue.length) {
+            this.requestQueue.shift().resolve({
+                done: false,
+                value: message
+            });
+        }
+        else {
+            this.messageCache.push(message);
+        }
+    }
+    async finalize() {
+        this.done = true;
+        // Record final token usage
+        if (this.tokenUsageService && (this.totalInputTokens > 0 || this.totalOutputTokens > 0)) {
+            try {
+                await this.tokenUsageService.recordTokenUsage(this.modelId, {
+                    inputTokens: this.totalInputTokens,
+                    outputTokens: this.totalOutputTokens,
+                    requestId: this.request.requestId
+                });
+            }
+            catch (error) {
+                console.error('Error recording token usage:', error);
+            }
+        }
+        // Resolve any outstanding requests
+        if (this.terminalError) {
+            this.requestQueue.forEach(request => request.reject(this.terminalError));
+        }
+        else {
+            this.requestQueue.forEach(request => request.resolve({ done: true, value: undefined }));
+        }
+        this.requestQueue.length = 0;
+    }
+}
+function processSystemMessages(messages, developerMessageSettings) {
+    if (developerMessageSettings === 'skip') {
+        return messages.filter(message => message.actor !== 'system');
+    }
+    else if (developerMessageSettings === 'mergeWithFollowingUserMessage') {
+        const updated = messages.slice();
+        for (let i = updated.length - 1; i >= 0; i--) {
+            if (updated[i].actor === 'system') {
+                const systemMessage = updated[i];
+                if (i + 1 < updated.length && updated[i + 1].actor === 'user') {
+                    // Merge system message with the next user message
+                    const userMessage = updated[i + 1];
+                    updated[i + 1] = {
+                        ...updated[i + 1],
+                        text: systemMessage.text + '\n' + userMessage.text
+                    };
+                    updated.splice(i, 1);
+                }
+                else {
+                    // The message directly after is not a user message (or none exists), so create a new user message right after
+                    updated.splice(i + 1, 0, { actor: 'user', type: 'text', text: systemMessage.text });
+                    updated.splice(i, 1);
+                }
+            }
+        }
+        return updated;
+    }
+    return messages;
+}
+exports.processSystemMessages = processSystemMessages;
+//# sourceMappingURL=openai-response-api-utils.js.map