@llumiverse/drivers 0.23.0 → 0.24.0-dev.202601221707

package/src/openai/index.ts

@@ -19,15 +19,21 @@ import {
     TrainingJobStatus,
     TrainingOptions,
     TrainingPromptOptions,
+    getConversationMeta,
     getModelCapabilities,
+    incrementConversationTurn,
     modelModalitiesToArray,
+    stripBase64ImagesFromConversation,
     supportsToolUse,
+    truncateLargeTextInConversation,
+    unwrapConversationArray,
 } from "@llumiverse/core";
-import { asyncMap } from "@llumiverse/core/async";
-import { formatOpenAILikeMultimodalPrompt } from "./openai_format.js";
 import OpenAI, { AzureOpenAI } from "openai";
-import { ChatCompletionMessageParam } from "openai/resources/chat/completions";
-import { Stream } from "openai/streaming";
+import { formatOpenAILikeMultimodalPrompt } from "./openai_format.js";
+
+// Response API types
+type ResponseInputItem = OpenAI.Responses.ResponseInputItem;
+type EasyInputMessage = OpenAI.Responses.EasyInputMessage;
 
 // Helper function to convert string to CompletionResult[]
 function textToCompletionResult(text: string): CompletionResult[] {
@@ -48,32 +54,24 @@ export interface BaseOpenAIDriverOptions extends DriverOptions {
 
 export abstract class BaseOpenAIDriver extends AbstractDriver<
     BaseOpenAIDriverOptions,
-    ChatCompletionMessageParam[]
+    ResponseInputItem[]
 > {
-    //abstract provider: "azure_openai" | "openai" | "xai" | "azure_foundry";
-    abstract provider: Providers.openai | Providers.azure_openai | "xai" | Providers.azure_foundry;
+    abstract provider: Providers.openai | Providers.azure_openai | Providers.xai | Providers.azure_foundry | Providers.openai_compatible;
     abstract service: OpenAI | AzureOpenAI;
 
     constructor(opts: BaseOpenAIDriverOptions) {
         super(opts);
-        this.formatPrompt = formatOpenAILikeMultimodalPrompt
-        //TODO: better type, we send back OpenAI.Chat.Completions.ChatCompletionMessageParam[] but just not compatible with Function call that we don't use here
+        this.formatPrompt = formatOpenAILikeMultimodalPrompt;
     }
 
     extractDataFromResponse(
         _options: ExecutionOptions,
-        result: OpenAI.Chat.Completions.ChatCompletion
+        result: OpenAI.Responses.Response
     ): Completion {
-        const tokenInfo: ExecutionTokenUsage = {
-            prompt: result.usage?.prompt_tokens,
-            result: result.usage?.completion_tokens,
-            total: result.usage?.total_tokens,
-        };
-
-        const choice = result.choices[0];
+        const tokenInfo = mapUsage(result.usage);
 
-        const tools = collectTools(choice.message.tool_calls);
-        const data = choice.message.content ?? undefined;
+        const tools = collectTools(result.output);
+        const data = extractTextFromResponse(result);
 
         if (!data && !tools) {
             this.logger.error({ result }, "[OpenAI] Response is not valid");
@@ -83,37 +81,21 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
         return {
             result: textToCompletionResult(data || ''),
             token_usage: tokenInfo,
-            finish_reason: openAiFinishReason(choice.finish_reason),
+            finish_reason: responseFinishReason(result, tools),
             tool_use: tools,
         };
     }
 
-    async requestTextCompletionStream(prompt: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
+    async requestTextCompletionStream(prompt: ResponseInputItem[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
         if (options.model_options?._option_id !== "openai-text" && options.model_options?._option_id !== "openai-thinking") {
             this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
 
-        const toolDefs = getToolDefinitions(options.tools);
-        const useTools: boolean = toolDefs ? supportsToolUse(options.model, "openai", true) : false;
-
-        const mapFn = (chunk: OpenAI.Chat.Completions.ChatCompletionChunk) => {
-            let result = undefined
-            if (useTools && this.provider !== "xai" && options.result_schema) {
-                result = chunk.choices[0]?.delta?.tool_calls?.[0].function?.arguments ?? "";
-            } else {
-                result = chunk.choices[0]?.delta.content ?? "";
-            }
+        // Include conversation history (same as non-streaming)
+        const conversation = updateConversation(options.conversation, prompt);
 
-            return {
-                result: textToCompletionResult(result),
-                finish_reason: openAiFinishReason(chunk.choices[0]?.finish_reason ?? undefined),         //Uses expected "stop" , "length" format
-                token_usage: {
-                    prompt: chunk.usage?.prompt_tokens,
-                    result: chunk.usage?.completion_tokens,
-                    total: (chunk.usage?.prompt_tokens ?? 0) + (chunk.usage?.completion_tokens ?? 0),
-                }
-            } satisfies CompletionChunkObject;
-        };
+        const toolDefs = getToolDefinitions(options.tools);
+        const useTools: boolean = toolDefs ? supportsToolUse(options.model, this.provider, true) : false;
 
         convertRoles(prompt, options.model);
 
@@ -133,35 +115,31 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
             }
         }
 
-        const stream = await this.service.chat.completions.create({
+        const reasoning = model_options?.reasoning_effort ? { effort: model_options.reasoning_effort } : undefined;
+
+        const stream = await this.service.responses.create({
             stream: true,
-            stream_options: { include_usage: true },
             model: options.model,
-            messages: prompt,
-            reasoning_effort: model_options?.reasoning_effort,
+            input: conversation,
+            reasoning,
             temperature: model_options?.temperature,
             top_p: model_options?.top_p,
-            presence_penalty: model_options?.presence_penalty,
-            frequency_penalty: model_options?.frequency_penalty,
-            n: 1,
-            max_completion_tokens: model_options?.max_tokens, //TODO: use max_tokens for older models, currently relying on OpenAI to handle it
+            max_output_tokens: model_options?.max_tokens,
             tools: useTools ? toolDefs : undefined,
-            stop: model_options?.stop_sequence,
-            response_format: parsedSchema ? {
-                type: "json_schema",
-                json_schema: {
+            text: parsedSchema ? {
+                format: {
+                    type: "json_schema",
                     name: "format_output",
                     schema: parsedSchema,
                     strict: strictMode,
                 }
             } : undefined,
-        } satisfies OpenAI.Chat.ChatCompletionCreateParamsStreaming
-        ) satisfies Stream<OpenAI.Chat.Completions.ChatCompletionChunk>;
+        });
 
-        return asyncMap(stream, mapFn);
+        return mapResponseStream(stream);
     }
 
-    async requestTextCompletion(prompt: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<Completion> {
+    async requestTextCompletion(prompt: ResponseInputItem[], options: ExecutionOptions): Promise<Completion> {
         if (options.model_options?._option_id !== "openai-text" && options.model_options?._option_id !== "openai-thinking") {
             this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
@@ -172,9 +150,9 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
         insert_image_detail(prompt, model_options?.image_detail ?? "auto");
 
         const toolDefs = getToolDefinitions(options.tools);
-        const useTools: boolean = toolDefs ? supportsToolUse(options.model, "openai") : false;
+        const useTools: boolean = toolDefs ? supportsToolUse(options.model, this.provider) : false;
 
-        let conversation = updateConversation(options.conversation as ChatCompletionMessageParam[], prompt);
+        let conversation = updateConversation(options.conversation, prompt);
 
         let parsedSchema: JSONSchema | undefined = undefined;
         let strictMode = false;
@@ -189,22 +167,20 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
             }
         }
 
-        const res = await this.service.chat.completions.create({
+        const reasoning = model_options?.reasoning_effort ? { effort: model_options.reasoning_effort } : undefined;
+
+        const res = await this.service.responses.create({
             stream: false,
             model: options.model,
-            messages: conversation,
-            reasoning_effort: model_options?.reasoning_effort,
+            input: conversation,
+            reasoning,
             temperature: model_options?.temperature,
             top_p: model_options?.top_p,
-            presence_penalty: model_options?.presence_penalty,
-            frequency_penalty: model_options?.frequency_penalty,
-            n: 1,
-            max_completion_tokens: model_options?.max_tokens, //TODO: use max_tokens for older models, currently relying on OpenAI to handle it
+            max_output_tokens: model_options?.max_tokens, //TODO: use max_tokens for older models, currently relying on OpenAI to handle it
             tools: useTools ? toolDefs : undefined,
-            stop: model_options?.stop_sequence,
-            response_format: parsedSchema ? {
-                type: "json_schema",
-                json_schema: {
+            text: parsedSchema ? {
+                format: {
+                    type: "json_schema",
                     name: "format_output",
                     schema: parsedSchema,
                     strict: strictMode,
@@ -217,8 +193,24 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
             completion.original_response = res;
         }
 
-        conversation = updateConversation(conversation, createPromptFromResponse(res.choices[0].message));
-        completion.conversation = conversation;
+        conversation = updateConversation(conversation, createAssistantMessageFromCompletion(completion));
+
+        // Increment turn counter for deferred stripping
+        conversation = incrementConversationTurn(conversation) as ResponseInputItem[];
+
+        // Strip large base64 image data based on options.stripImagesAfterTurns
+        const currentTurn = getConversationMeta(conversation).turnNumber;
+        const stripOptions = {
+            keepForTurns: options.stripImagesAfterTurns ?? Infinity,
+            currentTurn,
+            textMaxTokens: options.stripTextMaxTokens
+        };
+        let processedConversation = stripBase64ImagesFromConversation(conversation, stripOptions);
+
+        // Truncate large text content if configured
+        processedConversation = truncateLargeTextInConversation(processedConversation, stripOptions);
+
+        completion.conversation = processedConversation;
 
         return completion;
     }
@@ -233,6 +225,60 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
         return Promise.resolve(true);
     }
 
+    /**
+     * Build conversation context after streaming completion.
+     * Reconstructs the assistant message from accumulated results and applies stripping.
+     */
+    buildStreamingConversation(
+        prompt: ResponseInputItem[],
+        result: unknown[],
+        toolUse: unknown[] | undefined,
+        options: ExecutionOptions
+    ): ResponseInputItem[] | undefined {
+        // Build assistant message from accumulated CompletionResult[]
+        const completionResults = result as CompletionResult[];
+
+        const textContent = completionResultsToText(completionResults);
+
+        // Start with the conversation from options or the prompt
+        let conversation = updateConversation(options.conversation, prompt);
+
+        // Add assistant message as EasyInputMessage
+        if (textContent) {
+            const assistantMessage: EasyInputMessage = {
+                role: 'assistant',
+                content: textContent,
+            };
+            conversation = updateConversation(conversation, [assistantMessage]);
+        }
+
+        // Add function calls as separate items (Response API format)
+        if (toolUse && toolUse.length > 0) {
+            const functionCalls: OpenAI.Responses.ResponseFunctionToolCall[] = (toolUse as ToolUse[]).map(t => ({
+                type: 'function_call' as const,
+                call_id: t.id,
+                name: t.tool_name,
+                arguments: typeof t.tool_input === 'string' ? t.tool_input : JSON.stringify(t.tool_input ?? {}),
+            }));
+            conversation = updateConversation(conversation, functionCalls);
+        }
+
+        // Increment turn counter
+        conversation = incrementConversationTurn(conversation) as ResponseInputItem[];
+
+        // Apply stripping based on options
+        const currentTurn = getConversationMeta(conversation).turnNumber;
+        const stripOptions = {
+            keepForTurns: options.stripImagesAfterTurns ?? Infinity,
+            currentTurn,
+            textMaxTokens: options.stripTextMaxTokens
+        };
+        let processedConversation = stripBase64ImagesFromConversation(conversation, stripOptions);
+        processedConversation = truncateLargeTextInConversation(processedConversation, stripOptions);
+
+        return processedConversation as ResponseInputItem[];
+    }
+
     createTrainingPrompt(options: TrainingPromptOptions): Promise<string> {
         if (options.model.includes("gpt")) {
             return super.createTrainingPrompt(options);
@@ -377,44 +423,175 @@ function jobInfo(job: OpenAI.FineTuning.Jobs.FineTuningJob): TrainingJob {
     }
 }
 
-function insert_image_detail(messages: ChatCompletionMessageParam[], detail_level: string): ChatCompletionMessageParam[] {
-    if (detail_level == "auto" || detail_level == "low" || detail_level == "high") {
-        for (const message of messages) {
-            if (message.role !== 'assistant' && message.content) {
-                for (const part of message.content) {
-                    if (typeof part === "string") {
-                        continue;
+function mapUsage(usage?: OpenAI.Responses.ResponseUsage | null): ExecutionTokenUsage | undefined {
+    if (!usage) {
+        return undefined;
+    }
+    return {
+        prompt: usage.input_tokens,
+        result: usage.output_tokens,
+        total: usage.total_tokens,
+    };
+}
+
+function completionResultsToText(completionResults: CompletionResult[] | undefined): string {
+    if (!completionResults) {
+        return '';
+    }
+    return completionResults
+        .map(r => {
+            switch (r.type) {
+                case 'text':
+                    return r.value;
+                case 'json':
+                    return typeof r.value === 'string' ? r.value : JSON.stringify(r.value);
+                case 'image':
+                    // Skip images in conversation - they're in the result
+                    return '';
+                default:
+                    return String((r as any).value || '');
+            }
+        })
+        .join('');
+}
+
+function createAssistantMessageFromCompletion(completion: Completion): ResponseInputItem[] {
+    const textContent = completionResultsToText(completion.result);
+    const result: ResponseInputItem[] = [];
+
+    // Add assistant text message if present
+    if (textContent) {
+        const assistantMessage: EasyInputMessage = {
+            role: 'assistant',
+            content: textContent,
+        };
+        result.push(assistantMessage);
+    }
+
+    // Add function calls as separate items (Response API format)
+    if (completion.tool_use && completion.tool_use.length > 0) {
+        for (const t of completion.tool_use) {
+            const functionCall: OpenAI.Responses.ResponseFunctionToolCall = {
+                type: 'function_call',
+                call_id: t.id,
+                name: t.tool_name,
+                arguments: typeof t.tool_input === 'string'
+                    ? t.tool_input
+                    : JSON.stringify(t.tool_input ?? {}),
+            };
+            result.push(functionCall);
+        }
+    }
+
+    return result;
+}
+
+function mapResponseStream(stream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>): AsyncIterable<CompletionChunkObject> {
+    const toolCallMetadata = new Map<string, { syntheticId: string, name?: string }>();
+
+    return {
+        async *[Symbol.asyncIterator]() {
+            for await (const event of stream) {
+                if (event.type === 'response.output_item.added' && event.item.type === 'function_call') {
+                    const syntheticId = `tool_${event.output_index}`;
+                    const actualId = event.item.id ?? event.item.call_id;
+                    if (actualId) {
+                        toolCallMetadata.set(actualId, { syntheticId, name: event.item.name });
+                    }
+                    const toolUse: ToolUse & { _actual_id?: string } = {
+                        id: syntheticId,
+                        _actual_id: actualId,
+                        tool_name: event.item.name,
+                        tool_input: '' as any,
+                    };
+                    yield {
+                        result: [],
+                        tool_use: [toolUse],
+                    } satisfies CompletionChunkObject;
+                } else if (event.type === 'response.function_call_arguments.delta') {
+                    const metadata = toolCallMetadata.get(event.item_id);
+                    const syntheticId = metadata?.syntheticId ?? `tool_${event.output_index}`;
+                    const toolUse: ToolUse & { _actual_id?: string } = {
+                        id: syntheticId,
+                        _actual_id: event.item_id,
+                        tool_name: metadata?.name ?? '',
+                        tool_input: event.delta as any,
+                    };
+                    yield {
+                        result: [],
+                        tool_use: [toolUse],
+                    } satisfies CompletionChunkObject;
+                }
+                // Note: We don't emit response.function_call_arguments.done because the arguments were already
+                // streamed via delta events. Emitting it again would duplicate the tool_input content.
+                // We only update the metadata to ensure the tool name is captured.
+                else if (event.type === 'response.function_call_arguments.done') {
+                    // Just update metadata, don't yield (arguments already accumulated from delta events)
+                    const metadata = toolCallMetadata.get(event.item_id);
+                    const syntheticId = metadata?.syntheticId ?? `tool_${event.output_index}`;
+                    const tool_name = metadata?.name ?? event.name ?? '';
+                    if (event.item_id) {
+                        toolCallMetadata.set(event.item_id, { syntheticId, name: tool_name });
                     }
-                    if (part.type === 'image_url') {
-                        part.image_url = { ...part.image_url, detail: detail_level };
+                } else if (event.type === 'response.output_text.delta') {
+                    yield {
+                        result: textToCompletionResult(event.delta),
+                    } satisfies CompletionChunkObject;
+                }
+                // Note: We don't emit response.output_text.done because the text was already
+                // streamed via delta events. Emitting it again would duplicate the content.
+                else if (event.type === 'response.completed' || event.type === 'response.incomplete' || event.type === 'response.failed') {
+                    const finalTools = collectTools(event.response.output);
+                    yield {
+                        result: [],
+                        finish_reason: responseFinishReason(event.response, finalTools),
+                        token_usage: mapUsage(event.response.usage),
+                    } satisfies CompletionChunkObject;
+                }
+            }
+        }
+    };
+}
+
+function insert_image_detail(items: ResponseInputItem[], detail_level: string): ResponseInputItem[] {
+    if (detail_level === "auto" || detail_level === "low" || detail_level === "high") {
+        for (const item of items) {
+            // Check if it's an EasyInputMessage or Message with content array
+            if ('role' in item && 'content' in item && item.role !== 'assistant') {
+                const content = (item as EasyInputMessage).content;
+                if (Array.isArray(content)) {
+                    for (const part of content) {
+                        if (typeof part === 'object' && part.type === 'input_image') {
+                            (part as any).detail = detail_level;
+                        }
                     }
                 }
             }
         }
     }
-    return messages;
+    return items;
 }
 
-function convertRoles(messages: ChatCompletionMessageParam[], model: string): ChatCompletionMessageParam[] {
+function convertRoles(items: ResponseInputItem[], model: string): ResponseInputItem[] {
     //New openai models use developer role instead of system
     if (model.includes("o1") || model.includes("o3")) {
         if (model.includes("o1-mini") || model.includes("o1-preview")) {
             //o1-mini and o1-preview support neither system nor developer
-            for (const message of messages) {
-                if (message.role === 'system') {
-                    (message.role as any) = 'user';
+            for (const item of items) {
+                if ('role' in item && (item as EasyInputMessage).role === 'system') {
+                    (item as any).role = 'user';
                 }
             }
         } else {
             //Models newer than o1 use developer role
-            for (const message of messages) {
-                if (message.role === 'system') {
-                    (message.role as any) = 'developer';
+            for (const item of items) {
+                if ('role' in item && (item as EasyInputMessage).role === 'system') {
+                    (item as any).role = 'developer';
                 }
             }
         }
     }
-    return messages
+    return items;
 }
 
 //Structured output support is typically aligned with tool use support
@@ -427,10 +604,10 @@ function supportsSchema(model: string): boolean {
     return supportsToolUse(model, "openai");
 }
 
-function getToolDefinitions(tools: ToolDefinition[] | undefined | null): OpenAI.ChatCompletionTool[] | undefined {
+function getToolDefinitions(tools: ToolDefinition[] | undefined | null): OpenAI.Responses.Tool[] | undefined {
     return tools ? tools.map(getToolDefinition) : undefined;
 }
-function getToolDefinition(toolDef: ToolDefinition): OpenAI.ChatCompletionTool {
+function getToolDefinition(toolDef: ToolDefinition): OpenAI.Responses.FunctionTool {
     let parsedSchema: JSONSchema | undefined = undefined;
     let strictMode = false;
     if (toolDef.input_schema) {
@@ -446,64 +623,50 @@ function getToolDefinition(toolDef: ToolDefinition): OpenAI.ChatCompletionTool {
 
     return {
         type: "function",
-        function: {
-            name: toolDef.name,
-            description: toolDef.description,
-            parameters: parsedSchema,
-            strict: strictMode,
-        },
-    } satisfies OpenAI.ChatCompletionTool;
-}
-
-function openAiFinishReason(finish_reason?: string): string | undefined {
-    if (finish_reason === "tool_calls") {
-        return "tool_use";
-    }
-    return finish_reason;
+        name: toolDef.name,
+        description: toolDef.description,
+        parameters: parsedSchema ?? null,
+        strict: strictMode,
+    };
 }
 
-function updateConversation(conversation: ChatCompletionMessageParam[], message: ChatCompletionMessageParam[]): ChatCompletionMessageParam[] {
-    if (!message) {
-        return conversation;
+function updateConversation(conversation: unknown, items: ResponseInputItem[]): ResponseInputItem[] {
+    if (!items) {
+        // Unwrap array if wrapped, otherwise treat as array
+        const unwrapped = unwrapConversationArray<ResponseInputItem>(conversation);
+        return unwrapped ?? (conversation as ResponseInputItem[] || []);
     }
     if (!conversation) {
-        return message;
+        return items;
     }
-    return [...conversation, ...message];
+    // Unwrap array if wrapped, otherwise treat as array
+    const unwrapped = unwrapConversationArray<ResponseInputItem>(conversation);
+    const convArray = unwrapped ?? (conversation as ResponseInputItem[]);
+    return [...convArray, ...items];
 }
 
-export function collectTools(toolCalls?: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[]): ToolUse[] | undefined {
-    if (!toolCalls) {
+export function collectTools(output?: OpenAI.Responses.ResponseOutputItem[]): ToolUse[] | undefined {
+    if (!output) {
         return undefined;
     }
 
     const tools: ToolUse[] = [];
-    for (const call of toolCalls) {
-        tools.push({
-            id: call.id,
-            tool_name: call.function.name,
-            tool_input: JSON.parse(call.function.arguments),
-        });
-
+    for (const item of output) {
+        if (item.type === 'function_call') {
+            const id = item.call_id || item.id;
+            if (!id) {
+                continue;
+            }
+            tools.push({
+                id,
+                tool_name: item.name ?? '',
+                tool_input: safeJsonParse(item.arguments),
+            });
+        }
     }
     return tools.length > 0 ? tools : undefined;
 }
 
-function createPromptFromResponse(response: OpenAI.Chat.Completions.ChatCompletionMessage): ChatCompletionMessageParam[] {
-    const messages: ChatCompletionMessageParam[] = [];
-    if (response) {
-        messages.push({
-            role: response.role,
-            content: [{
-                type: "text",
-                text: response.content ?? ""
-            }],
-            tool_calls: response.tool_calls,
-        });
-    }
-    return messages;
-}
-
 //For strict mode false
 function limitedSchemaFormat(schema: JSONSchema): JSONSchema {
     const formattedSchema = { ...schema };
@@ -511,6 +674,18 @@ function limitedSchemaFormat(schema: JSONSchema): JSONSchema {
     // Defaults not supported
     delete formattedSchema.default;
 
+    // OpenAI requires type field even in non-strict mode
+    // If no type is specified, default to 'object' for properties with format/editor hints,
+    // otherwise 'string' as a safe fallback
+    if (!formattedSchema.type && formattedSchema.description) {
+        // Properties with format: "document" or editor hints are typically objects
+        if (formattedSchema.format === 'document' || formattedSchema.editor) {
+            formattedSchema.type = 'object';
+        } else {
+            formattedSchema.type = 'string';
+        }
+    }
+
     if (formattedSchema?.properties) {
         // Process each property recursively
         for (const propName of Object.keys(formattedSchema.properties)) {
@@ -556,6 +731,11 @@ function openAISchemaFormat(schema: JSONSchema, nesting: number = 0): JSONSchema
         for (const propName of Object.keys(formattedSchema.properties)) {
             const property = formattedSchema.properties[propName];
 
+            // OpenAI strict mode requires all properties to have a type
+            if (!property?.type) {
+                throw new Error(`Property '${propName}' is missing required 'type' field for OpenAI strict mode`);
+            }
+
             // Recursively process properties
             formattedSchema.properties[propName] = openAISchemaFormat(property, nesting + 1);
 
@@ -575,4 +755,51 @@ function openAISchemaFormat(schema: JSONSchema, nesting: number = 0): JSONSchema
     }
 
     return formattedSchema
-}
+}
+
+function extractTextFromResponse(response: OpenAI.Responses.Response): string {
+    if (response.output_text) {
+        return response.output_text;
+    }
+
+    const collected: string[] = [];
+    for (const item of response.output ?? []) {
+        if (item.type === 'message') {
+            const text = item.content
+                .map(part => part.type === 'output_text' ? part.text : '')
+                .join('');
+            if (text) {
+                collected.push(text);
+            }
+        }
+    }
+
+    return collected.join("\n");
+}
+
+function responseFinishReason(response: OpenAI.Responses.Response, tools?: ToolUse[] | undefined): string | undefined {
+    if (tools && tools.length > 0) {
+        return "tool_use";
+    }
+    if (response.status === 'incomplete') {
+        if (response.incomplete_details?.reason === 'max_output_tokens') {
+            return 'length';
+        }
+        return response.incomplete_details?.reason ?? 'incomplete';
+    }
+    if (response.status && response.status !== 'completed') {
+        return response.status;
+    }
+    return 'stop';
+}
+
+function safeJsonParse(value: unknown): any {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    try {
+        return JSON.parse(value);
+    } catch {
+        return value;
+    }
+}