@llumiverse/drivers 1.2.0 → 1.4.0-dev.20260629.090753Z

package/lib/{esm/openai → openai}/index.js

@@ -1,16 +1,20 @@
-import { AbstractDriver, getConversationMeta, getModelCapabilities, incrementConversationTurn, LlumiverseError, modelModalitiesToArray, ModelType, stripBase64ImagesFromConversation, stripHeartbeatsFromConversation, supportsToolUse, TrainingJobStatus, truncateLargeTextInConversation, unwrapConversationArray, } from "@llumiverse/core";
+import { getConversationMeta, getModelCapabilities, incrementConversationTurn, LlumiverseError, ModelType, modelModalitiesToArray, normalizeEmbeddingsOptions, OPENAI_DEFAULT_EMBEDDING_MODEL, stripBase64ImagesFromConversation, stripHeartbeatsFromConversation, supportsToolUse, TrainingJobStatus, truncateLargeTextInConversation, unwrapConversationArray, } from '@llumiverse/core';
+import { AbstractDriver } from '@llumiverse/core/driver';
 import { APIConnectionError, APIConnectionTimeoutError, APIError, AuthenticationError, BadRequestError, ConflictError, ContentFilterFinishReasonError, InternalServerError, LengthFinishReasonError, NotFoundError, OpenAIError, PermissionDeniedError, RateLimitError, UnprocessableEntityError, } from 'openai/error';
-import { formatOpenAILikeMultimodalPrompt } from "./openai_format.js";
+import { formatOpenAILikeMultimodalPrompt } from './openai_format.js';
 // Helper function to convert string to CompletionResult[]
 function textToCompletionResult(text) {
-    return text ? [{ type: "text", value: text }] : [];
+    return text ? [{ type: 'text', value: text }] : [];
+}
+function hasNumericStatus(error) {
+    return error instanceof Error && typeof error.status === 'number';
 }
 function isOpenAIReasoningModel(model) {
     const normalized = model.toLowerCase();
-    return normalized.includes("o1")
-        || normalized.includes("o3")
-        || normalized.includes("o4")
-        || normalized.includes("gpt-5");
+    return (normalized.includes('o1') ||
+        normalized.includes('o3') ||
+        normalized.includes('o4') ||
+        normalized.includes('gpt-5'));
 }
 function isGpt5ProModel(model) {
     const modelName = model.toLowerCase().split('/').pop() ?? model.toLowerCase();
@@ -21,17 +25,17 @@ function openAIReasoningEffort(model, effort) {
         return undefined;
     }
     if (isGpt5ProModel(model)) {
-        return "high";
+        return 'high';
     }
-    return effort === "low" || effort === "medium" || effort === "high" ? effort : undefined;
+    return effort === 'low' || effort === 'medium' || effort === 'high' ? effort : undefined;
 }
 //TODO: Do we need a list?, replace with if statements and modernize?
 const supportFineTunning = new Set([
-    "gpt-3.5-turbo-1106",
-    "gpt-3.5-turbo-0613",
-    "babbage-002",
-    "davinci-002",
-    "gpt-4-0613"
+    'gpt-3.5-turbo-1106',
+    'gpt-3.5-turbo-0613',
+    'babbage-002',
+    'davinci-002',
+    'gpt-4-0613',
 ]);
 export class BaseOpenAIDriver extends AbstractDriver {
     constructor(opts) {
@@ -44,8 +48,8 @@ export class BaseOpenAIDriver extends AbstractDriver {
         // Collect all parts in order (text and images)
         const allResults = extractCompletionResults(result.output);
         if (allResults.length === 0 && !tools) {
-            this.logger.error({ result }, "[OpenAI] Response is not valid");
-            throw new Error("Response is not valid: no data");
+            this.logger.error({ result }, '[OpenAI] Response is not valid');
+            throw new Error('Response is not valid: no data');
         }
         return {
             result: allResults,
@@ -56,14 +60,14 @@ export class BaseOpenAIDriver extends AbstractDriver {
     }
     async requestTextCompletionStream(prompt, options) {
         if (options.model_options?._option_id !== undefined &&
-            options.model_options?._option_id !== "openai-text" &&
-            options.model_options?._option_id !== "openai-thinking" &&
-            options.model_options?._option_id !== "text-fallback") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+            options.model_options?._option_id !== 'openai-text' &&
+            options.model_options?._option_id !== 'openai-thinking' &&
+            options.model_options?._option_id !== 'text-fallback') {
+            this.logger.debug({ options: options.model_options }, 'Unexpected option id');
         }
         // Include conversation history (same as non-streaming)
         // Fix orphaned function_call items (can occur when agent is stopped mid-tool-execution)
-        let conversation = fixOrphanedToolUse(updateConversation(options.conversation, prompt));
+        let conversation = fixOrphanedToolResults(fixOrphanedToolUse(updateConversation(options.conversation, prompt)));
         const toolDefs = getToolDefinitions(options.tools);
         const useTools = toolDefs ? supportsToolUse(options.model, this.provider, true) : false;
         // When no tools are provided but conversation contains function_call/function_call_output
@@ -73,15 +77,15 @@ export class BaseOpenAIDriver extends AbstractDriver {
         }
         convertRoles(prompt, options.model);
         const model_options = options.model_options;
-        insert_image_detail(prompt, model_options?.image_detail ?? "auto");
-        let parsedSchema = undefined;
+        insert_image_detail(prompt, model_options?.image_detail ?? 'auto');
+        let parsedSchema;
         let strictMode = false;
-        if (options.result_schema && supportsSchema(options.model)) {
+        if (options.result_schema && supportsSchema(options.model, this.provider)) {
             try {
                 parsedSchema = openAISchemaFormat(options.result_schema);
                 strictMode = true;
             }
-            catch (e) {
+            catch {
                 parsedSchema = limitedSchemaFormat(options.result_schema);
                 strictMode = false;
             }
@@ -98,43 +102,46 @@ export class BaseOpenAIDriver extends AbstractDriver {
             top_p: isReasoningModel ? undefined : model_options?.top_p,
             max_output_tokens: model_options?.max_tokens,
             tools: useTools ? toolDefs : undefined,
-            text: parsedSchema ? {
-                format: {
-                    type: "json_schema",
-                    name: "format_output",
-                    schema: parsedSchema,
-                    strict: strictMode,
+            text: parsedSchema
+                ? {
+                    format: {
+                        type: 'json_schema',
+                        name: 'format_output',
+                        schema: parsedSchema,
+                        strict: strictMode,
+                    },
                 }
-            } : undefined,
+                : undefined,
         });
         return mapResponseStream(stream);
     }
     async requestTextCompletion(prompt, options) {
         if (options.model_options?._option_id !== undefined &&
-            options.model_options?._option_id !== "openai-text" &&
-            options.model_options?._option_id !== "openai-thinking") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+            options.model_options?._option_id !== 'openai-text' &&
+            options.model_options?._option_id !== 'openai-thinking' &&
+            options.model_options?._option_id !== 'text-fallback') {
+            this.logger.debug({ options: options.model_options }, 'Unexpected option id');
         }
         convertRoles(prompt, options.model);
         const model_options = options.model_options;
-        insert_image_detail(prompt, model_options?.image_detail ?? "auto");
+        insert_image_detail(prompt, model_options?.image_detail ?? 'auto');
         const toolDefs = getToolDefinitions(options.tools);
         const useTools = toolDefs ? supportsToolUse(options.model, this.provider) : false;
         // Fix orphaned function_call items (can occur when agent is stopped mid-tool-execution)
-        let conversation = fixOrphanedToolUse(updateConversation(options.conversation, prompt));
+        let conversation = fixOrphanedToolResults(fixOrphanedToolUse(updateConversation(options.conversation, prompt)));
         // When no tools are provided but conversation contains function_call/function_call_output
         // items (e.g. checkpoint summary calls), convert them to text to avoid API errors
         if (!useTools) {
             conversation = convertOpenAIFunctionItemsToText(conversation);
         }
-        let parsedSchema = undefined;
+        let parsedSchema;
         let strictMode = false;
-        if (options.result_schema && supportsSchema(options.model)) {
+        if (options.result_schema && supportsSchema(options.model, this.provider)) {
             try {
                 parsedSchema = openAISchemaFormat(options.result_schema);
                 strictMode = true;
             }
-            catch (e) {
+            catch {
                 parsedSchema = limitedSchemaFormat(options.result_schema);
                 strictMode = false;
             }
@@ -151,14 +158,16 @@ export class BaseOpenAIDriver extends AbstractDriver {
             top_p: isReasoningModel ? undefined : model_options?.top_p,
             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,
-            text: parsedSchema ? {
-                format: {
-                    type: "json_schema",
-                    name: "format_output",
-                    schema: parsedSchema,
-                    strict: strictMode,
+            text: parsedSchema
+                ? {
+                    format: {
+                        type: 'json_schema',
+                        name: 'format_output',
+                        schema: parsedSchema,
+                        strict: strictMode,
+                    },
                 }
-            } : undefined,
+                : undefined,
         });
         const completion = this.extractDataFromResponse(options, res);
         if (options.include_original_response) {
@@ -172,7 +181,7 @@ export class BaseOpenAIDriver extends AbstractDriver {
         const stripOptions = {
             keepForTurns: options.stripImagesAfterTurns ?? Infinity,
             currentTurn,
-            textMaxTokens: options.stripTextMaxTokens
+            textMaxTokens: options.stripTextMaxTokens,
         };
         let processedConversation = stripBase64ImagesFromConversation(conversation, stripOptions);
         // Truncate large text content if configured
@@ -187,13 +196,12 @@ export class BaseOpenAIDriver extends AbstractDriver {
     }
     canStream(_options) {
         // Image generation models don't support streaming
-        if (_options.model.includes("dall-e")
-            || _options.model.includes("gpt-image")
-            || _options.model.includes("chatgpt-image")) {
+        if (_options.model.includes('dall-e') ||
+            _options.model.includes('gpt-image') ||
+            _options.model.includes('chatgpt-image')) {
             return Promise.resolve(false);
         }
-        if (_options.model.includes("o1")
-            && !(_options.model.includes("mini") || _options.model.includes("preview"))) {
+        if (_options.model.includes('o1') && !(_options.model.includes('mini') || _options.model.includes('preview'))) {
             //o1 full does not support streaming
             //TODO: Update when OpenAI adds support for streaming, last check 16/02/2025
             return Promise.resolve(false);
@@ -213,6 +221,7 @@ export class BaseOpenAIDriver extends AbstractDriver {
         // Add assistant message as EasyInputMessage
         if (textContent) {
             const assistantMessage = {
+                type: 'message',
                 role: 'assistant',
                 content: textContent,
             };
@@ -220,7 +229,7 @@ export class BaseOpenAIDriver extends AbstractDriver {
         }
         // Add function calls as separate items (Response API format)
         if (toolUse && toolUse.length > 0) {
-            const functionCalls = toolUse.map(t => ({
+            const functionCalls = toolUse.map((t) => ({
                 type: 'function_call',
                 call_id: t.id,
                 name: t.tool_name,
@@ -235,7 +244,7 @@ export class BaseOpenAIDriver extends AbstractDriver {
         const stripOptions = {
             keepForTurns: options.stripImagesAfterTurns ?? Infinity,
             currentTurn,
-            textMaxTokens: options.stripTextMaxTokens
+            textMaxTokens: options.stripTextMaxTokens,
         };
         let processedConversation = stripBase64ImagesFromConversation(conversation, stripOptions);
         processedConversation = truncateLargeTextInConversation(processedConversation, stripOptions);
@@ -246,24 +255,24 @@ export class BaseOpenAIDriver extends AbstractDriver {
         return processedConversation;
     }
     createTrainingPrompt(options) {
-        if (options.model.includes("gpt")) {
+        if (options.model.includes('gpt')) {
             return super.createTrainingPrompt(options);
         }
         else {
             // babbage, davinci not yet implemented
-            throw new Error("Unsupported model for training: " + options.model);
+            throw new Error(`Unsupported model for training: ${options.model}`);
         }
     }
     async startTraining(dataset, options) {
         const url = await dataset.getURL();
         const file = await this.service.files.create({
             file: await fetch(url),
-            purpose: "fine-tune",
+            purpose: 'fine-tune',
         });
         const job = await this.service.fineTuning.jobs.create({
             training_file: file.id,
             model: options.model,
-            hyperparameters: options.params
+            hyperparameters: options.params,
         });
         return jobInfo(job);
     }
@@ -281,7 +290,7 @@ export class BaseOpenAIDriver extends AbstractDriver {
             await this.service.models.list();
             return true;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -295,22 +304,36 @@ export class BaseOpenAIDriver extends AbstractDriver {
         let result = (await this.service.models.list()).data;
         //Some of these use the completions API instead of the chat completions API.
         //Others are for non-text input modalities. Therefore common to both.
-        const wordBlacklist = ["embed", "whisper", "transcribe", "audio", "moderation", "tts",
-            "realtime", "babbage", "davinci", "codex", "o1-pro", "computer-use", "sora"];
+        const wordBlacklist = [
+            'embed',
+            'whisper',
+            'transcribe',
+            'audio',
+            'moderation',
+            'tts',
+            'realtime',
+            'babbage',
+            'davinci',
+            'codex',
+            'o1-pro',
+            'computer-use',
+            'sora',
+        ];
         //OpenAI has very little information, filtering based on name.
         result = result.filter((m) => {
             return !wordBlacklist.some((word) => m.id.includes(word));
         });
         const models = filter ? result.filter(filter) : result;
-        const aiModels = models.map((m) => {
-            const modelCapability = getModelCapabilities(m.id, "openai");
+        const aiModels = models
+            .map((m) => {
+            const modelCapability = getModelCapabilities(m.id, this.provider);
             let owner = m.owned_by;
-            if (owner == "system") {
-                owner = "openai";
+            if (owner === 'system') {
+                owner = 'openai';
             }
             // Determine model type based on capabilities
             let modelType = ModelType.Text;
-            if (m.id.includes("dall-e") || m.id.includes("gpt-image")) {
+            if (m.id.includes('dall-e') || m.id.includes('gpt-image')) {
                 modelType = ModelType.Image;
             }
             return {
@@ -323,34 +346,60 @@ export class BaseOpenAIDriver extends AbstractDriver {
                 output_modalities: modelModalitiesToArray(modelCapability.output),
                 tool_support: modelCapability.tool_support,
             };
-        }).sort((a, b) => a.id.localeCompare(b.id));
+        })
+            .sort((a, b) => a.id.localeCompare(b.id));
         return aiModels;
     }
-    async generateEmbeddings({ text, image, model = "text-embedding-3-small" }) {
-        if (image) {
-            throw new Error("Image embeddings not supported by OpenAI");
-        }
-        if (!text) {
-            throw new Error("No text provided");
-        }
-        const res = await this.service.embeddings.create({
-            input: text,
-            model: model,
+    async generateEmbeddings(options) {
+        const normalized = normalizeEmbeddingsOptions(options);
+        const model = normalized.model ?? OPENAI_DEFAULT_EMBEDDING_MODEL;
+        const texts = normalized.inputs.map((input) => {
+            if (input.type !== 'text') {
+                throw new Error(`Provider 'openai' does not support '${input.type}' embeddings; only 'text' is supported.`);
+            }
+            return input.text;
         });
-        const embeddings = res.data[0].embedding;
-        if (!embeddings || embeddings.length === 0) {
-            throw new Error("No embedding found");
+        try {
+            const res = await this.service.embeddings.create({
+                input: texts,
+                model,
+                ...(normalized.dimensions ? { dimensions: normalized.dimensions } : {}),
+                encoding_format: 'float',
+            });
+            // OpenAI does not guarantee data is returned in the same order as the input,
+            // but does return a stable `index` per item. Sort by index to align with inputs.
+            const ordered = [...res.data].sort((a, b) => a.index - b.index);
+            const items = ordered.map((entry) => {
+                if (!entry.embedding || entry.embedding.length === 0) {
+                    throw new Error(`OpenAI embedding empty for input index ${entry.index}`);
+                }
+                return { outputs: [{ values: entry.embedding, modality: 'text' }] };
+            });
+            const usage = res.usage
+                ? { input_tokens: res.usage.prompt_tokens, input_text_tokens: res.usage.prompt_tokens }
+                : undefined;
+            return { model, results: items, usage };
+        }
+        catch (error) {
+            if (LlumiverseError.isLlumiverseError(error))
+                throw error;
+            if (error instanceof Error && !hasNumericStatus(error))
+                throw error;
+            throw this.formatLlumiverseError(error, {
+                provider: this.provider,
+                model,
+                operation: 'execute',
+            });
         }
-        return { values: embeddings, model };
     }
-    imageModels = ["dall-e", "gpt-image", "chatgpt-image"];
+    imageModels = ['dall-e', 'gpt-image', 'chatgpt-image'];
     /**
      * Determine if a model is specifically an image generation model (not conversational image model)
      */
     isImageModel(model) {
         // DALL-E models are standalone image generation
         // gpt-image models can generate images in conversations, not standalone
-        return this.imageModels.some(imageModel => model.includes(imageModel));
+        return this.imageModels.some((imageModel) => model.includes(imageModel));
     }
     /**
      * Request image generation from standalone Images API
@@ -360,16 +409,16 @@ export class BaseOpenAIDriver extends AbstractDriver {
         this.logger.debug(`[${this.provider}] Generating image with model ${options.model}`);
         const model_options = options.model_options;
         // Extract prompt text from ResponseInputItem[]
-        let promptText = "";
+        let promptText = '';
         for (const item of prompt) {
             if ('content' in item && typeof item.content === 'string') {
-                promptText += item.content + "\\n";
+                promptText += `${item.content}\\n`;
             }
             else if ('content' in item && Array.isArray(item.content)) {
                 // Extract text from content array
                 for (const part of item.content) {
                     if ('type' in part && part.type === 'input_text' && 'text' in part) {
-                        promptText += part.text + "\\n";
+                        promptText += `${part.text}\\n`;
                     }
                 }
             }
@@ -379,15 +428,15 @@ export class BaseOpenAIDriver extends AbstractDriver {
             const generateParams = {
                 model: options.model,
                 prompt: promptText,
-                size: model_options?.size || "1024x1024",
+                size: model_options?.size || '1024x1024',
             };
             // Add DALL-E specific options
-            if (options.model.includes("dall-e") || model_options?._option_id === "openai-dalle") {
+            if (options.model.includes('dall-e') || model_options?._option_id === 'openai-dalle') {
                 const dalleOptions = model_options;
                 generateParams.n = dalleOptions?.n || 1;
-                generateParams.response_format = dalleOptions?.response_format || "b64_json";
-                if (options.model.includes("dall-e-3")) {
-                    generateParams.quality = dalleOptions?.image_quality || "standard";
+                generateParams.response_format = dalleOptions?.response_format || 'b64_json';
+                if (options.model.includes('dall-e-3')) {
+                    generateParams.quality = dalleOptions?.image_quality || 'standard';
                     if (dalleOptions?.style) {
                         generateParams.style = dalleOptions.style;
                     }
@@ -415,23 +464,27 @@ export class BaseOpenAIDriver extends AbstractDriver {
                         continue;
                     }
                     results.push({
-                        type: "image",
-                        value: imageValue
+                        type: 'image',
+                        value: imageValue,
                     });
                 }
             }
             return {
-                result: results
+                result: results,
             };
         }
         catch (error) {
             this.logger.error({ error }, `[${this.provider}] Image generation failed`);
+            const generationError = error instanceof Error ? error : new Error(String(error));
+            const errorCode = error?.code === 'content_policy_violation'
+                ? 'content_policy_violation'
+                : 'validation_error';
             return {
                 result: [],
                 error: {
-                    message: error.message,
-                    code: error.code || 'GENERATION_FAILED'
-                }
+                    message: generationError.message,
+                    code: errorCode,
+                },
             };
         }
     }
@@ -512,9 +565,7 @@ export class BaseOpenAIDriver extends AbstractDriver {
      * Type guard to check if error is an OpenAI API error or OpenAI-specific error.
      */
     isOpenAIApiError(error) {
-        return (error !== null &&
-            typeof error === 'object' &&
-            (error instanceof APIError || error instanceof OpenAIError));
+        return (error !== null && typeof error === 'object' && (error instanceof APIError || error instanceof OpenAIError));
     }
     /**
      * Determine if an OpenAI API error is retryable.
@@ -591,7 +642,7 @@ export class BaseOpenAIDriver extends AbstractDriver {
                 return false;
             if (errorCode === 'invalid_model')
                 return false;
-            if (errorCode.includes('invalid_'))
+            if (typeof errorCode === 'string' && errorCode.includes('invalid_'))
                 return false;
         }
         // Check error type
@@ -637,7 +688,9 @@ function jobInfo(job) {
     }
     else if (jobStatus === 'failed') {
         status = TrainingJobStatus.failed;
-        details = job.error ? `${job.error.code} - ${job.error.message} ${job.error.param ? " [" + job.error.param + "]" : ""}` : "error";
+        details = job.error
+            ? `${job.error.code} - ${job.error.message} ${job.error.param ? ` [${job.error.param}]` : ''}`
+            : 'error';
     }
     else if (jobStatus === 'cancelled') {
         status = TrainingJobStatus.cancelled;
@@ -650,19 +703,20 @@ function jobInfo(job) {
         id: job.id,
         model: job.fine_tuned_model || undefined,
         status,
-        details
+        details,
     };
 }
 function mapUsage(usage) {
     if (!usage) {
         return undefined;
     }
+    const cachedTokens = usage.input_tokens_details?.cached_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? usage.cached_tokens;
     return {
         prompt: usage.input_tokens,
         result: usage.output_tokens,
         total: usage.total_tokens,
-        prompt_cached: usage.input_tokens_details?.cached_tokens ?? undefined,
-        prompt_new: usage.input_tokens - (usage.input_tokens_details?.cached_tokens ?? 0),
+        prompt_cached: cachedTokens ?? undefined,
+        prompt_new: usage.input_tokens - (cachedTokens ?? 0),
     };
 }
 function completionResultsToText(completionResults) {
@@ -670,7 +724,7 @@ function completionResultsToText(completionResults) {
         return '';
     }
     return completionResults
-        .map(r => {
+        .map((r) => {
         switch (r.type) {
             case 'text':
                 return r.value;
@@ -679,8 +733,10 @@ function completionResultsToText(completionResults) {
             case 'image':
                 // Skip images in conversation - they're in the result
                 return '';
-            default:
-                return String(r.value || '');
+            default: {
+                const _exhaustive = r;
+                return String(_exhaustive);
+            }
         }
     })
         .join('');
@@ -691,6 +747,7 @@ function createAssistantMessageFromCompletion(completion) {
     // Add assistant text message if present
     if (textContent) {
         const assistantMessage = {
+            type: 'message',
             role: 'assistant',
             content: textContent,
         };
@@ -703,29 +760,33 @@ function createAssistantMessageFromCompletion(completion) {
                 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 ?? {}),
+                arguments: typeof t.tool_input === 'string' ? t.tool_input : JSON.stringify(t.tool_input ?? {}),
             };
             result.push(functionCall);
         }
     }
     return result;
 }
-function mapResponseStream(stream) {
+export function mapResponseStream(stream) {
     const toolCallMetadata = new Map();
     return {
         async *[Symbol.asyncIterator]() {
+            let hasTextDeltas = false;
+            let refusalText = '';
             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 callId = event.item.call_id ?? event.item.id;
+                    const metadata = { syntheticId, callId, name: event.item.name };
+                    if (event.item.id) {
+                        toolCallMetadata.set(event.item.id, metadata);
+                    }
+                    if (event.item.call_id) {
+                        toolCallMetadata.set(event.item.call_id, metadata);
                     }
                     const toolUse = {
                         id: syntheticId,
-                        _actual_id: actualId,
+                        _actual_id: callId,
                         tool_name: event.item.name,
                         tool_input: '',
                     };
@@ -737,9 +798,10 @@ function mapResponseStream(stream) {
                 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 callId = metadata?.callId ?? event.item_id;
                     const toolUse = {
                         id: syntheticId,
-                        _actual_id: event.item_id,
+                        _actual_id: callId,
                         tool_name: metadata?.name ?? '',
                         tool_input: event.delta,
                     };
@@ -757,17 +819,38 @@ function mapResponseStream(stream) {
                     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 });
+                        toolCallMetadata.set(event.item_id, { syntheticId, callId: metadata?.callId, name: tool_name });
                     }
                 }
                 else if (event.type === 'response.output_text.delta') {
+                    hasTextDeltas = true;
                     yield {
                         result: textToCompletionResult(event.delta),
                     };
                 }
-                // 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') {
+                else if (event.type === 'response.output_text.done') {
+                    // Fallback: some models (e.g. gpt-5 with json_schema structured output) buffer
+                    // the entire output and never emit delta events — only the done event with the
+                    // full text. Emit it here only when no deltas arrived to avoid duplication.
+                    if (!hasTextDeltas && event.text) {
+                        yield {
+                            result: textToCompletionResult(event.text),
+                        };
+                    }
+                }
+                else if (event.type === 'response.refusal.delta') {
+                    refusalText += event.delta;
+                }
+                else if (event.type === 'response.refusal.done') {
+                    throw new Error(`[OpenAI] Model refused: ${event.refusal || refusalText}`);
+                }
+                else if (event.type === 'response.error') {
+                    const errEvent = event;
+                    throw new Error(`[OpenAI Responses API] ${errEvent.message}${errEvent.code ? ` (${errEvent.code})` : ''}`);
+                }
+                else if (event.type === 'response.completed' ||
+                    event.type === 'response.incomplete' ||
+                    event.type === 'response.failed') {
                     const finalTools = collectTools(event.response.output);
                     yield {
                         result: [],
@@ -776,11 +859,11 @@ function mapResponseStream(stream) {
                     };
                 }
             }
-        }
+        },
     };
 }
 function insert_image_detail(items, detail_level) {
-    if (detail_level === "auto" || detail_level === "low" || detail_level === "high") {
+    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') {
@@ -799,8 +882,8 @@ function insert_image_detail(items, detail_level) {
 }
 function convertRoles(items, model) {
     //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")) {
+    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 item of items) {
                 if ('role' in item && item.role === 'system') {
@@ -821,12 +904,12 @@ function convertRoles(items, model) {
 }
 //Structured output support is typically aligned with tool use support
 //Not true for realtime models, which do not support structured output, but do support tool use.
-function supportsSchema(model) {
-    const realtimeModel = model.includes("realtime");
+function supportsSchema(model, provider) {
+    const realtimeModel = model.includes('realtime');
     if (realtimeModel) {
         return false;
     }
-    return supportsToolUse(model, "openai");
+    return supportsToolUse(model, provider);
 }
 /**
  * Converts function_call and function_call_output items to text messages in OpenAI conversation.
@@ -834,17 +917,17 @@ function supportsSchema(model) {
  * tools to be defined in the API request.
  */
 export function convertOpenAIFunctionItemsToText(items) {
-    const hasFunctionItems = items.some(item => {
+    const hasFunctionItems = items.some((item) => {
         const type = item.type;
         return type === 'function_call' || type === 'function_call_output';
     });
     if (!hasFunctionItems)
         return items;
-    return items.map(item => {
+    return items.map((item) => {
         const typed = item;
         if (typed.type === 'function_call') {
             const argsStr = typed.arguments || '';
-            const truncated = argsStr.length > 500 ? argsStr.substring(0, 500) + '...' : argsStr;
+            const truncated = argsStr.length > 500 ? `${argsStr.substring(0, 500)}...` : argsStr;
             return {
                 role: 'assistant',
                 content: `[Tool call: ${typed.name}(${truncated})]`,
@@ -852,7 +935,7 @@ export function convertOpenAIFunctionItemsToText(items) {
         }
         if (typed.type === 'function_call_output') {
             const output = typed.output || 'No output';
-            const truncated = output.length > 500 ? output.substring(0, 500) + '...' : output;
+            const truncated = output.length > 500 ? `${output.substring(0, 500)}...` : output;
             return {
                 role: 'user',
                 content: `[Tool result: ${truncated}]`,
@@ -865,7 +948,7 @@ function getToolDefinitions(tools) {
     return tools ? tools.map(getToolDefinition) : undefined;
 }
 function getToolDefinition(toolDef) {
-    let parsedSchema = undefined;
+    let parsedSchema;
     let strictMode = false;
     if (toolDef.input_schema) {
         try {
@@ -873,14 +956,14 @@ function getToolDefinition(toolDef) {
             parsedSchema = openAISchemaFormat(toolDef.input_schema);
             strictMode = true;
         }
-        catch (e) {
+        catch {
             //TODO: type assertion here is not safe, does not work with satisfies
             parsedSchema = limitedSchemaFormat(toolDef.input_schema);
             strictMode = false;
         }
     }
     return {
-        type: "function",
+        type: 'function',
         name: toolDef.name,
         description: toolDef.description,
         parameters: parsedSchema ?? null,
@@ -936,8 +1019,8 @@ function extractCompletionResults(output) {
             for (const part of item.content) {
                 if (part.type === 'output_text' && part.text) {
                     results.push({
-                        type: "text",
-                        value: part.text
+                        type: 'text',
+                        value: part.text,
                     });
                 }
             }
@@ -946,12 +1029,10 @@ function extractCompletionResults(output) {
             // GPT-image models return base64 encoded images in result field
             const base64Data = item.result;
             // Format as data URL for consistency with other image outputs
-            const imageUrl = base64Data.startsWith('data:')
-                ? base64Data
-                : `data:image/png;base64,${base64Data}`;
+            const imageUrl = base64Data.startsWith('data:') ? base64Data : `data:image/png;base64,${base64Data}`;
             results.push({
-                type: "image",
-                value: imageUrl
+                type: 'image',
+                value: imageUrl,
             });
         }
     }
@@ -994,13 +1075,13 @@ function limitedSchemaFormat(schema) {
 //For strict mode true
 function openAISchemaFormat(schema, nesting = 0) {
     if (nesting > 5) {
-        throw new Error("OpenAI schema nesting too deep");
+        throw new Error('OpenAI schema nesting too deep');
     }
     const formattedSchema = { ...schema };
     // Defaults not supported
     delete formattedSchema.default;
     // Additional properties not supported, required to be set.
-    if (formattedSchema?.type === "object") {
+    if (formattedSchema?.type === 'object') {
         formattedSchema.additionalProperties = false;
     }
     if (formattedSchema?.properties) {
@@ -1024,16 +1105,17 @@ function openAISchemaFormat(schema, nesting = 0) {
             }
         }
     }
-    if (formattedSchema?.type === 'object' && (!formattedSchema?.properties || Object.keys(formattedSchema?.properties ?? {}).length == 0)) {
+    if (formattedSchema?.type === 'object' &&
+        (!formattedSchema?.properties || Object.keys(formattedSchema?.properties ?? {}).length === 0)) {
         //If no properties are defined, then additionalProperties: true was set or the object would be empty.
         //OpenAI does not support this on structured output/ strict mode.
-        throw new Error("OpenAI does not support empty objects or objects with additionalProperties set to true");
+        throw new Error('OpenAI does not support empty objects or objects with additionalProperties set to true');
     }
     return formattedSchema;
 }
 function responseFinishReason(response, tools) {
     if (tools && tools.length > 0) {
-        return "tool_use";
+        return 'tool_use';
     }
     if (response.status === 'incomplete') {
         if (response.incomplete_details?.reason === 'max_output_tokens') {
@@ -1108,6 +1190,30 @@ export function fixOrphanedToolUse(items) {
     }
     return result;
 }
+/**
+ * Drop function_call_output items whose call_id has no matching function_call
+ * item anywhere in the input. Mirror of {@link fixOrphanedToolUse}: that
+ * synthesizes outputs for calls left unanswered (e.g. a cancelled run); this
+ * removes outputs left dangling after their function_call was dropped (e.g. by
+ * conversation compaction/trimming). The OpenAI Responses API requires every
+ * function_call_output to reference a prior function_call's call_id.
+ */
+export function fixOrphanedToolResults(items) {
+    if (items.length === 0)
+        return items;
+    const callIds = new Set();
+    for (const item of items) {
+        if ('type' in item && item.type === 'function_call') {
+            callIds.add(item.call_id);
+        }
+    }
+    return items.filter((item) => {
+        if ('type' in item && item.type === 'function_call_output') {
+            return callIds.has(item.call_id);
+        }
+        return true;
+    });
+}
 function safeJsonParse(value) {
     if (typeof value !== 'string') {
         return value;