dominds 1.13.2 → 1.15.2

package/dist/llm/gen/openai.js

@@ -2,7 +2,9 @@
 /**
  * Module: llm/gen/openai
  *
- * OpenAI-compatible Responses API integration implementing streaming and batch generation.
+ * OpenAI Responses API integration implementing streaming and batch generation.
+ * Isolation principle: this wrapper owns OpenAI Responses request/stream semantics and must not
+ * inherit Codex-specific abstractions or parameter aliases.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -19,6 +21,19 @@ const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
 const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/openai');
+const OPENAI_API_QUIRK_VENDOR_HEARTBEAT_EVENT_TYPES = {
+    'xcode.best': ['keepalive'],
+};
+const OPENAI_NATIVE_TOOL_ITEM_TYPES = new Set([
+    'file_search_call',
+    'code_interpreter_call',
+    'image_generation_call',
+    'mcp_call',
+    'mcp_list_tools',
+    'mcp_approval_request',
+    'custom_tool_call',
+]);
+const OPENAI_MALFORMED_BATCH_OUTPUT_ITEM_ERROR_CODE = 'OPENAI_MALFORMED_BATCH_OUTPUT_ITEM';
 function limitOpenAiToolOutputText(text, msg, limitChars) {
     const limited = (0, tool_output_limit_1.truncateProviderToolOutputText)(text, limitChars);
     if (limited.truncated) {
@@ -65,6 +80,59 @@ function limitOpenAiToolOutputItems(output, msg, limitChars) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function readEventType(value) {
+    if (!isRecord(value) || typeof value.type !== 'string') {
+        return null;
+    }
+    return value.type;
+}
+function normalizeProviderApiQuirks(providerConfig) {
+    const raw = providerConfig.apiQuirks;
+    if (typeof raw === 'string') {
+        return raw.trim().length > 0 ? new Set([raw.trim()]) : new Set();
+    }
+    if (Array.isArray(raw)) {
+        return new Set(raw.filter((entry) => typeof entry === 'string' && entry.trim() !== ''));
+    }
+    return new Set();
+}
+function resolveOpenAiVendorHeartbeatEventTypes(providerConfig) {
+    const eventTypes = new Set();
+    for (const quirk of normalizeProviderApiQuirks(providerConfig)) {
+        const vendorEventTypes = OPENAI_API_QUIRK_VENDOR_HEARTBEAT_EVENT_TYPES[quirk];
+        if (!vendorEventTypes)
+            continue;
+        for (const eventType of vendorEventTypes) {
+            eventTypes.add(eventType);
+        }
+    }
+    return eventTypes;
+}
+function maybeAnnotateOpenAiQuirkFailure(providerConfig, error) {
+    const quirks = normalizeProviderApiQuirks(providerConfig);
+    const message = error instanceof Error
+        ? error.message
+        : typeof error === 'string'
+            ? error
+            : isRecord(error) && typeof error.message === 'string'
+                ? error.message
+                : '';
+    const lowerMessage = message.toLowerCase();
+    if (quirks.has('xcode.best') &&
+        lowerMessage.includes('stream error:') &&
+        lowerMessage.includes('internal_error') &&
+        lowerMessage.includes('received from peer')) {
+        if (error instanceof Error) {
+            const out = error;
+            out.code = 'XCODE_BEST_STREAM_INTERNAL_ERROR';
+            return out;
+        }
+        const out = new Error(message.length > 0 ? message : 'xcode.best stream internal error');
+        out.code = 'XCODE_BEST_STREAM_INTERNAL_ERROR';
+        return out;
+    }
+    return error;
+}
 function tryExtractApiReturnedModel(value) {
     // NOTE: External API payload; a runtime check is unavoidable.
     if (!isRecord(value))
@@ -116,7 +184,6 @@ function chatMessageToOpenAiInputItem(msg) {
             };
         case 'transient_guide_msg':
         case 'saying_msg':
-        case 'ui_only_markdown_msg':
             return {
                 type: 'message',
                 role: 'assistant',
@@ -125,7 +192,7 @@ function chatMessageToOpenAiInputItem(msg) {
         case 'thinking_msg':
             return thinkingMessageToOpenAiReasoningItem(msg);
         case 'tellask_result_msg':
-        case 'tellask_carryover_result_msg':
+        case 'tellask_carryover_msg':
             return {
                 type: 'message',
                 role: 'user',
@@ -157,24 +224,15 @@ function buildReasoningPayloadFromText(text) {
         summary: [{ type: 'summary_text', text }],
     };
 }
-function buildReasoningItemId(genseq, text) {
-    let hash = 0;
-    for (let i = 0; i < text.length; i += 1) {
-        hash = (hash * 31 + text.charCodeAt(i)) >>> 0;
-    }
-    return `dominds_reasoning_${genseq}_${hash.toString(16)}`;
-}
 function thinkingMessageToOpenAiReasoningItem(msg) {
     const reasoning = msg.reasoning ?? buildReasoningPayloadFromText(msg.content);
     if (!reasoning) {
-        return {
-            id: buildReasoningItemId(msg.genseq, msg.content),
-            type: 'reasoning',
-            summary: [],
-        };
+        return { type: 'reasoning', summary: [] };
     }
+    // Some Responses-compatible gateways reject client-fabricated reasoning IDs and only accept
+    // provider-issued IDs (for example `rs_*`). We therefore omit `id` when replaying persisted
+    // reasoning and rely on encrypted_content when available.
     const out = {
-        id: buildReasoningItemId(msg.genseq, `${msg.content}\n${reasoning.encrypted_content ?? ''}`),
         type: 'reasoning',
         summary: reasoning.summary.map((part) => ({ type: 'summary_text', text: part.text })),
     };
@@ -271,6 +329,11 @@ function mergeAdjacentOpenAiMessages(input) {
     }
     return merged;
 }
+function shouldIncludeOpenAiEncryptedReasoning(input, reasoning) {
+    if (reasoning !== undefined)
+        return true;
+    return input.some((item) => isRecord(item) && item.type === 'reasoning');
+}
 async function buildOpenAiRequestInput(context, providerConfig) {
     const normalized = (0, tool_call_context_1.normalizeToolCallPairs)(context);
     const violation = (0, tool_call_context_1.findFirstToolCallAdjacencyViolation)(normalized);
@@ -308,13 +371,40 @@ function parseOpenAiUsage(usage) {
         totalTokens: typeof totalTokens === 'number' ? totalTokens : inputTokens + outputTokens,
     };
 }
-function buildOpenAiTextConfig(openAiParams, jsonResponseEnabled) {
+function buildOpenAiTextConfig(openAiParams) {
     const textConfig = {};
     if (openAiParams.verbosity !== undefined) {
         textConfig.verbosity = openAiParams.verbosity;
     }
-    if (jsonResponseEnabled) {
-        textConfig.format = { type: 'json_object' };
+    const textFormat = openAiParams.text_format;
+    if (textFormat === 'text' || textFormat === 'json_object') {
+        textConfig.format = { type: textFormat };
+    }
+    else if (textFormat === 'json_schema') {
+        const schemaName = openAiParams.text_format_json_schema_name?.trim();
+        const rawSchema = openAiParams.text_format_json_schema?.trim();
+        if (!schemaName || !rawSchema) {
+            throw new Error('Invalid openai text_format=json_schema: text_format_json_schema_name and text_format_json_schema are required.');
+        }
+        let parsedSchema;
+        try {
+            parsedSchema = JSON.parse(rawSchema);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid openai text_format_json_schema: ${message}`);
+        }
+        if (!isRecord(parsedSchema)) {
+            throw new Error('Invalid openai text_format_json_schema: expected a JSON object at the top level.');
+        }
+        textConfig.format = {
+            type: 'json_schema',
+            name: schemaName,
+            schema: parsedSchema,
+            ...(openAiParams.text_format_json_schema_strict !== undefined
+                ? { strict: openAiParams.text_format_json_schema_strict }
+                : {}),
+        };
     }
     return textConfig.verbosity !== undefined || textConfig.format !== undefined
         ? textConfig
@@ -332,10 +422,389 @@ function buildOpenAiReasoning(openAiParams) {
         ...(summary !== undefined ? { summary } : {}),
     };
 }
-function resolveOpenAiJsonResponseEnabled(agent, openAiParams) {
-    if (openAiParams.json_response !== undefined)
-        return openAiParams.json_response;
-    return agent.model_params?.json_response === true;
+function buildOpenAiNativeTools(openAiParams) {
+    const enabled = openAiParams.web_search_tool === true ||
+        openAiParams.web_search_context_size !== undefined ||
+        (Array.isArray(openAiParams.web_search_allowed_domains) &&
+            openAiParams.web_search_allowed_domains.length > 0);
+    if (!enabled)
+        return [];
+    const webSearchTool = {
+        type: 'web_search',
+        ...(openAiParams.web_search_context_size !== undefined
+            ? { search_context_size: openAiParams.web_search_context_size }
+            : {}),
+        ...(Array.isArray(openAiParams.web_search_allowed_domains) &&
+            openAiParams.web_search_allowed_domains.length > 0
+            ? { filters: { allowed_domains: openAiParams.web_search_allowed_domains } }
+            : {}),
+    };
+    return [webSearchTool];
+}
+function buildOpenAiInclude(input, reasoning, openAiParams) {
+    const include = new Set();
+    if (shouldIncludeOpenAiEncryptedReasoning(input, reasoning)) {
+        include.add('reasoning.encrypted_content');
+    }
+    if (openAiParams.web_search_include_sources === true) {
+        include.add('web_search_call.action.sources');
+    }
+    return include.size > 0 ? Array.from(include) : undefined;
+}
+function toOpenAiLlmWebSearchCall(item, itemId, phase) {
+    const rawAction = isRecord(item.action) ? item.action : null;
+    let action;
+    if (rawAction?.type === 'search') {
+        const queries = Array.isArray(rawAction.queries) &&
+            rawAction.queries.every((entry) => typeof entry === 'string')
+            ? rawAction.queries
+            : undefined;
+        action = {
+            type: 'search',
+            ...(typeof rawAction.query === 'string' ? { query: rawAction.query } : {}),
+            ...(queries && queries.length > 0 ? { queries } : {}),
+        };
+    }
+    else if (rawAction?.type === 'open_page') {
+        action = {
+            type: 'open_page',
+            ...(typeof rawAction.url === 'string' ? { url: rawAction.url } : {}),
+        };
+    }
+    else if (rawAction?.type === 'find_in_page') {
+        action = {
+            type: 'find_in_page',
+            ...(typeof rawAction.url === 'string' ? { url: rawAction.url } : {}),
+            ...(typeof rawAction.pattern === 'string' ? { pattern: rawAction.pattern } : {}),
+        };
+    }
+    else {
+        action = undefined;
+    }
+    return {
+        source: 'openai_responses',
+        phase,
+        itemId,
+        ...(typeof item.status === 'string' ? { status: item.status } : {}),
+        ...(action !== undefined ? { action } : {}),
+    };
+}
+function buildOpenAiWebSearchProgressCall(itemId, phase, status, action) {
+    return {
+        source: 'openai_responses',
+        phase,
+        itemId,
+        status,
+        ...(action !== undefined ? { action } : {}),
+    };
+}
+function throwOpenAiMalformedBatchOutputItem(itemType, detail) {
+    const message = `OPENAI malformed batch output item ${itemType}: ${detail}`;
+    const error = new Error(message);
+    error.code = OPENAI_MALFORMED_BATCH_OUTPUT_ITEM_ERROR_CODE;
+    log.error(message, error);
+    throw error;
+}
+async function throwOpenAiMalformedStreamEvent(receiver, eventType, detail) {
+    const message = `OPENAI malformed stream event ${eventType}: ${detail}`;
+    log.error(message, new Error('openai_malformed_stream_event'));
+    if (receiver.streamError) {
+        await receiver.streamError(message);
+    }
+    throw new Error(message);
+}
+function buildOpenAiNativeToolCallFromState(state, phase) {
+    if (state.itemType === 'custom_tool_call') {
+        return {
+            source: 'openai_responses',
+            itemType: state.itemType,
+            phase,
+            callId: state.callId,
+            ...(state.itemId !== undefined ? { itemId: state.itemId } : {}),
+            ...(state.status !== undefined ? { status: state.status } : {}),
+            ...(state.title !== undefined ? { title: state.title } : {}),
+            ...(state.summary !== undefined ? { summary: state.summary } : {}),
+            ...(state.detail !== undefined ? { detail: state.detail } : {}),
+        };
+    }
+    return {
+        source: 'openai_responses',
+        itemType: state.itemType,
+        phase,
+        itemId: state.itemId,
+        ...(state.status !== undefined ? { status: state.status } : {}),
+        ...(state.title !== undefined ? { title: state.title } : {}),
+        ...(state.summary !== undefined ? { summary: state.summary } : {}),
+        ...(state.detail !== undefined ? { detail: state.detail } : {}),
+    };
+}
+function mergeOpenAiNativeToolSeedIntoState(state, seed) {
+    if (state.itemType !== seed.itemType) {
+        throw new Error(`OPENAI native tool tracker invariant violation: itemType mismatch (${state.itemType} !== ${seed.itemType})`);
+    }
+    if (state.itemType === 'custom_tool_call' && seed.itemType === 'custom_tool_call') {
+        if (state.callId !== seed.callId) {
+            throw new Error(`OPENAI native tool tracker invariant violation: custom callId mismatch (${state.callId} !== ${seed.callId})`);
+        }
+        if (seed.itemId !== undefined && seed.itemId.trim() !== '') {
+            const normalizedItemId = seed.itemId.trim();
+            if (state.itemId !== undefined && state.itemId !== normalizedItemId) {
+                throw new Error(`OPENAI native tool tracker invariant violation: custom itemId mismatch (${state.itemId} !== ${normalizedItemId})`);
+            }
+            state.itemId = normalizedItemId;
+        }
+    }
+    else if (state.itemType !== 'custom_tool_call' && seed.itemType !== 'custom_tool_call') {
+        if (state.itemId !== seed.itemId) {
+            throw new Error(`OPENAI native tool tracker invariant violation: item tool itemId mismatch (${state.itemId} !== ${seed.itemId})`);
+        }
+    }
+    if (seed.status !== undefined) {
+        state.status = seed.status;
+    }
+    if (seed.title !== undefined) {
+        state.title = seed.title;
+    }
+    if (seed.summary !== undefined) {
+        state.summary = seed.summary;
+    }
+    if (seed.detail !== undefined) {
+        state.detail = seed.detail;
+    }
+    return state;
+}
+class OpenAiNativeToolTracker {
+    constructor() {
+        this.itemToolByItemId = new Map();
+        this.customToolByCallId = new Map();
+        this.customCallIdByItemId = new Map();
+    }
+    upsertItemTool(seed) {
+        const existing = this.itemToolByItemId.get(seed.itemId);
+        const state = existing ??
+            {
+                itemType: seed.itemType,
+                itemId: seed.itemId,
+            };
+        mergeOpenAiNativeToolSeedIntoState(state, seed);
+        if (!existing) {
+            this.itemToolByItemId.set(seed.itemId, state);
+        }
+        return state;
+    }
+    upsertCustomTool(seed) {
+        const existing = this.customToolByCallId.get(seed.callId);
+        const state = existing ??
+            {
+                itemType: 'custom_tool_call',
+                callId: seed.callId,
+            };
+        if (seed.itemId !== undefined && seed.itemId.trim() !== '') {
+            const normalizedItemId = seed.itemId.trim();
+            const existingCallId = this.customCallIdByItemId.get(normalizedItemId);
+            if (existingCallId !== undefined && existingCallId !== seed.callId) {
+                throw new Error(`OPENAI native tool tracker invariant violation: custom itemId ${normalizedItemId} already bound to a different callId`);
+            }
+        }
+        mergeOpenAiNativeToolSeedIntoState(state, seed);
+        if (!existing) {
+            this.customToolByCallId.set(seed.callId, state);
+        }
+        if (state.itemId !== undefined) {
+            this.customCallIdByItemId.set(state.itemId, state.callId);
+        }
+        return state;
+    }
+    claimCustomToolByItemId(itemId) {
+        const mappedCallId = this.customCallIdByItemId.get(itemId);
+        if (mappedCallId !== undefined) {
+            const existing = this.customToolByCallId.get(mappedCallId);
+            if (!existing) {
+                throw new Error(`OPENAI native tool tracker invariant violation: missing custom tool state for mapped itemId=${itemId}`);
+            }
+            return existing;
+        }
+        const unresolved = Array.from(this.customToolByCallId.values()).filter((state) => state.itemId === undefined);
+        if (unresolved.length === 1) {
+            const claimed = unresolved[0];
+            claimed.itemId = itemId;
+            this.customCallIdByItemId.set(itemId, claimed.callId);
+            return claimed;
+        }
+        if (unresolved.length === 0) {
+            throw new Error(`OPENAI native tool tracker invariant violation: missing unresolved custom tool state for itemId=${itemId}`);
+        }
+        throw new Error(`OPENAI native tool tracker invariant violation: ambiguous custom tool itemId correlation for itemId=${itemId}`);
+    }
+    upsert(seed) {
+        return seed.itemType === 'custom_tool_call'
+            ? this.upsertCustomTool(seed)
+            : this.upsertItemTool(seed);
+    }
+}
+function summarizeCodeInterpreterOutputs(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const parts = [];
+    let imageCount = 0;
+    for (const output of value) {
+        if (!isRecord(output) || typeof output.type !== 'string')
+            continue;
+        if (output.type === 'logs' && typeof output.logs === 'string' && output.logs.trim() !== '') {
+            parts.push(output.logs.trim());
+            continue;
+        }
+        if (output.type === 'image') {
+            imageCount += 1;
+        }
+    }
+    if (imageCount > 0) {
+        parts.push(`images=${String(imageCount)}`);
+    }
+    return parts.length > 0 ? parts.join('\n') : undefined;
+}
+function buildOpenAiNativeToolSeed(item, itemId) {
+    if (typeof item.type !== 'string' ||
+        !OPENAI_NATIVE_TOOL_ITEM_TYPES.has(item.type)) {
+        return null;
+    }
+    const itemType = item.type;
+    if (itemType === 'custom_tool_call') {
+        const callId = typeof item.call_id === 'string' ? item.call_id.trim() : '';
+        if (callId === '') {
+            throwOpenAiMalformedBatchOutputItem(itemType, 'missing call_id');
+        }
+        const base = {
+            itemType,
+            callId,
+            ...(typeof itemId === 'string' && itemId.trim() !== '' ? { itemId: itemId.trim() } : {}),
+        };
+        const namespace = typeof item.namespace === 'string' ? item.namespace.trim() : '';
+        const name = typeof item.name === 'string' ? item.name.trim() : '';
+        const summary = namespace !== '' && name !== ''
+            ? `${namespace}:${name}`
+            : namespace !== ''
+                ? namespace
+                : name;
+        return {
+            ...base,
+            title: 'Custom Tool Call',
+            ...(summary !== '' ? { summary } : {}),
+            ...(typeof item.input === 'string' && item.input.trim() !== ''
+                ? { detail: item.input.trim() }
+                : {}),
+        };
+    }
+    if (typeof itemId !== 'string' || itemId.trim() === '') {
+        throwOpenAiMalformedBatchOutputItem(itemType, 'missing itemId');
+    }
+    const base = {
+        itemType,
+        itemId: itemId.trim(),
+    };
+    switch (itemType) {
+        case 'file_search_call': {
+            const queries = Array.isArray(item.queries) && item.queries.every((entry) => typeof entry === 'string')
+                ? item.queries
+                : [];
+            const results = Array.isArray(item.results) ? item.results.length : 0;
+            return {
+                ...base,
+                ...(typeof item.status === 'string' ? { status: item.status } : {}),
+                title: 'File Search',
+                ...(queries.length > 0 ? { summary: queries.join('\n') } : {}),
+                ...(results > 0 ? { detail: `results=${String(results)}` } : {}),
+            };
+        }
+        case 'code_interpreter_call': {
+            return {
+                ...base,
+                ...(typeof item.status === 'string' ? { status: item.status } : {}),
+                title: 'Code Interpreter',
+                ...(typeof item.code === 'string' && item.code.trim() !== ''
+                    ? { summary: item.code.trim() }
+                    : {}),
+                ...(typeof item.container_id === 'string' && item.container_id.trim() !== ''
+                    ? {
+                        detail: `container=${item.container_id.trim()}${summarizeCodeInterpreterOutputs(item.outputs) ? `\n${summarizeCodeInterpreterOutputs(item.outputs)}` : ''}`,
+                    }
+                    : summarizeCodeInterpreterOutputs(item.outputs)
+                        ? { detail: summarizeCodeInterpreterOutputs(item.outputs) }
+                        : {}),
+            };
+        }
+        case 'image_generation_call': {
+            return {
+                ...base,
+                ...(typeof item.status === 'string' ? { status: item.status } : {}),
+                title: 'Image Generation',
+                summary: typeof item.result === 'string' && item.result.length > 0
+                    ? 'image_ready'
+                    : 'image_pending',
+            };
+        }
+        case 'mcp_call': {
+            const serverLabel = typeof item.server_label === 'string' ? item.server_label.trim() : '';
+            const name = typeof item.name === 'string' ? item.name.trim() : '';
+            const summary = serverLabel !== '' && name !== ''
+                ? `${serverLabel}: ${name}`
+                : serverLabel !== ''
+                    ? serverLabel
+                    : name;
+            const detailParts = [
+                typeof item.arguments === 'string' && item.arguments.trim() !== ''
+                    ? item.arguments.trim()
+                    : '',
+                typeof item.output === 'string' && item.output.trim() !== '' ? item.output.trim() : '',
+                typeof item.error === 'string' && item.error.trim() !== ''
+                    ? `error=${item.error.trim()}`
+                    : '',
+            ].filter((part) => part.length > 0);
+            return {
+                ...base,
+                ...(typeof item.status === 'string' ? { status: item.status } : {}),
+                title: 'MCP Tool Call',
+                ...(summary !== '' ? { summary } : {}),
+                ...(detailParts.length > 0 ? { detail: detailParts.join('\n') } : {}),
+            };
+        }
+        case 'mcp_list_tools': {
+            const serverLabel = typeof item.server_label === 'string' ? item.server_label.trim() : '';
+            const toolNames = Array.isArray(item.tools)
+                ? item.tools
+                    .filter((entry) => isRecord(entry))
+                    .map((entry) => (typeof entry.name === 'string' ? entry.name.trim() : ''))
+                    .filter((entry) => entry.length > 0)
+                : [];
+            const error = typeof item.error === 'string' ? item.error.trim() : '';
+            return {
+                ...base,
+                title: 'MCP Tool Discovery',
+                ...(serverLabel !== '' ? { summary: serverLabel } : {}),
+                ...(toolNames.length > 0 || error !== ''
+                    ? { detail: [...toolNames, ...(error !== '' ? [`error=${error}`] : [])].join('\n') }
+                    : {}),
+            };
+        }
+        case 'mcp_approval_request': {
+            const serverLabel = typeof item.server_label === 'string' ? item.server_label.trim() : '';
+            const name = typeof item.name === 'string' ? item.name.trim() : '';
+            return {
+                ...base,
+                title: 'MCP Approval Request',
+                ...(serverLabel !== '' || name !== ''
+                    ? { summary: [serverLabel, name].filter(Boolean).join(': ') }
+                    : {}),
+                ...(typeof item.arguments === 'string' && item.arguments.trim() !== ''
+                    ? { detail: item.arguments.trim() }
+                    : {}),
+            };
+        }
+        default: {
+            const _exhaustive = itemType;
+            return _exhaustive;
+        }
+    }
 }
 async function buildOpenAiRequestInputWrapper(context, providerConfig) {
     return await buildOpenAiRequestInput(context, providerConfig);
@@ -347,16 +816,27 @@ function extractOutputMessageText(item) {
     if (!Array.isArray(content))
         return '';
     let text = '';
-    for (const part of content) {
-        if (!isRecord(part) || typeof part.type !== 'string')
+    let transcript = '';
+    let sawOutputText = false;
+    for (const rawPart of content) {
+        if (!isRecord(rawPart) || typeof rawPart.type !== 'string')
             continue;
-        if (part.type === 'output_text' && typeof part.text === 'string') {
-            text += part.text;
+        if (rawPart.type === 'output_text' && typeof rawPart.text === 'string') {
+            sawOutputText = true;
+            text += rawPart.text;
+        }
+        if (rawPart.type === 'output_audio' && typeof rawPart.transcript === 'string') {
+            transcript += rawPart.transcript;
         }
-        if (part.type === 'refusal' && typeof part.refusal === 'string') {
-            text += part.refusal;
+        if (rawPart.type === 'refusal' && typeof rawPart.refusal === 'string') {
+            text += rawPart.refusal;
         }
     }
+    // Keep batch-mode message extraction aligned with streaming semantics: transcript text is only a
+    // fallback when the response item did not already carry canonical output_text content.
+    if (!sawOutputText && transcript.length > 0) {
+        text += transcript;
+    }
     return text;
 }
 function extractReasoningText(item) {
@@ -407,11 +887,12 @@ function extractReasoningPayload(item) {
         out.encrypted_content = encrypted;
     return out;
 }
-function openAiResponseToChatMessages(response, genseq) {
-    const messages = [];
+function openAiResponseToBatchOutputs(response, genseq) {
+    const outputs = [];
     const output = response.output;
     if (!Array.isArray(output))
-        return messages;
+        return outputs;
+    const nativeToolTracker = new OpenAiNativeToolTracker();
     for (const item of output) {
         if (!isRecord(item) || typeof item.type !== 'string')
             continue;
@@ -419,12 +900,15 @@ function openAiResponseToChatMessages(response, genseq) {
             const reasoning = extractReasoningPayload(item);
             const content = extractReasoningText(item);
             if (content.length > 0 || reasoning !== null) {
-                messages.push({
-                    type: 'thinking_msg',
-                    role: 'assistant',
-                    genseq,
-                    content,
-                    reasoning: reasoning ?? undefined,
+                outputs.push({
+                    kind: 'message',
+                    message: {
+                        type: 'thinking_msg',
+                        role: 'assistant',
+                        genseq,
+                        content,
+                        reasoning: reasoning ?? undefined,
+                    },
                 });
             }
             continue;
@@ -432,11 +916,14 @@ function openAiResponseToChatMessages(response, genseq) {
         if (item.type === 'message') {
             const content = extractOutputMessageText(item);
             if (content.length > 0) {
-                messages.push({
-                    type: 'saying_msg',
-                    role: 'assistant',
-                    genseq,
-                    content,
+                outputs.push({
+                    kind: 'message',
+                    message: {
+                        type: 'saying_msg',
+                        role: 'assistant',
+                        genseq,
+                        content,
+                    },
                 });
             }
             continue;
@@ -446,19 +933,44 @@ function openAiResponseToChatMessages(response, genseq) {
             const name = typeof item.name === 'string' ? item.name : '';
             const args = typeof item.arguments === 'string' ? item.arguments : '';
             if (callId.length > 0 && name.length > 0) {
-                messages.push({
-                    type: 'func_call_msg',
-                    role: 'assistant',
-                    genseq,
-                    id: callId,
-                    name,
-                    arguments: args,
+                outputs.push({
+                    kind: 'message',
+                    message: {
+                        type: 'func_call_msg',
+                        role: 'assistant',
+                        genseq,
+                        id: callId,
+                        name,
+                        arguments: args,
+                    },
                 });
             }
             continue;
         }
+        if (item.type === 'web_search_call') {
+            const itemId = typeof item.id === 'string' ? item.id.trim() : '';
+            if (itemId.length === 0) {
+                throwOpenAiMalformedBatchOutputItem(item.type, 'missing itemId');
+            }
+            outputs.push({
+                kind: 'web_search_call',
+                call: toOpenAiLlmWebSearchCall(item, itemId, 'done'),
+            });
+            continue;
+        }
+        if (OPENAI_NATIVE_TOOL_ITEM_TYPES.has(item.type)) {
+            const itemId = typeof item.id === 'string' ? item.id.trim() : undefined;
+            const seed = buildOpenAiNativeToolSeed(item, itemId);
+            if (seed) {
+                const state = nativeToolTracker.upsert(seed);
+                outputs.push({
+                    kind: 'native_tool_call',
+                    call: buildOpenAiNativeToolCallFromState(state, 'done'),
+                });
+            }
+        }
     }
-    return messages;
+    return outputs;
 }
 class OpenAiGen {
     get apiType() {
@@ -478,13 +990,16 @@ class OpenAiGen {
         const requestInput = await buildOpenAiRequestInput(context, providerConfig);
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
-        const jsonResponseEnabled = resolveOpenAiJsonResponseEnabled(agent, openAiParams);
         const modelInfo = providerConfig.models[agent.model];
         const outputLength = modelInfo?.output_length;
         const maxOutputTokens = maxTokens ?? openAiParams.max_tokens ?? outputLength ?? 1024;
         const parallelToolCalls = openAiParams.parallel_tool_calls ?? true;
-        const textConfig = buildOpenAiTextConfig(openAiParams, jsonResponseEnabled);
+        const textConfig = buildOpenAiTextConfig(openAiParams);
         const reasoning = buildOpenAiReasoning(openAiParams);
+        const nativeTools = buildOpenAiNativeTools(openAiParams);
+        const include = buildOpenAiInclude(requestInput, reasoning, openAiParams);
+        const tools = [...funcTools.map(funcToolToOpenAiTool), ...nativeTools];
+        const vendorHeartbeatEventTypes = resolveOpenAiVendorHeartbeatEventTypes(providerConfig);
         const payload = {
             model: agent.model,
             input: requestInput,
@@ -494,12 +1009,16 @@ class OpenAiGen {
             store: false,
             stream: true,
             ...(openAiParams.service_tier !== undefined && { service_tier: openAiParams.service_tier }),
+            ...(openAiParams.safety_identifier !== undefined && {
+                safety_identifier: openAiParams.safety_identifier,
+            }),
             ...(openAiParams.temperature !== undefined && { temperature: openAiParams.temperature }),
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...(reasoning !== undefined && { reasoning }),
+            ...(include !== undefined ? { include } : {}),
             ...(textConfig !== undefined && { text: textConfig }),
-            ...(funcTools.length > 0
-                ? { tools: funcTools.map(funcToolToOpenAiTool), tool_choice: 'auto' }
+            ...(tools.length > 0
+                ? { tools, tool_choice: 'auto' }
                 : { tool_choice: 'none' }),
         };
         let sayingStarted = false;
@@ -507,9 +1026,33 @@ class OpenAiGen {
         let currentThinkingContent = '';
         let finishedThinkingFromDelta = false;
         let sawOutputText = false;
+        let currentAudioTranscript = '';
         let activeStream = 'idle';
         let usage = { kind: 'unavailable' };
         let returnedModel;
+        const nativeToolTracker = new OpenAiNativeToolTracker();
+        function claimNativeToolStateByEventItemId(itemId, itemType, title) {
+            try {
+                if (itemType === 'custom_tool_call') {
+                    const existing = nativeToolTracker.claimCustomToolByItemId(itemId);
+                    if (existing.title === undefined || existing.title.trim() === '') {
+                        existing.title = title;
+                    }
+                    return existing;
+                }
+                return nativeToolTracker.upsert({
+                    itemType,
+                    itemId,
+                    title,
+                });
+            }
+            catch (error) {
+                const detail = error instanceof Error && error.message.trim().length > 0
+                    ? error.message
+                    : `failed to resolve native tool state for ${itemType}`;
+                return throwOpenAiMalformedStreamEvent(receiver, itemType, detail);
+            }
+        }
         function applyArgsDelta(state, chunk) {
             if (chunk.length === 0)
                 return;
@@ -538,7 +1081,28 @@ class OpenAiGen {
             state.emitted = true;
             await receiver_.funcCall(state.callId, state.name, args);
         }
+        async function emitNativeToolCall(state, phase) {
+            if (!receiver.nativeToolCall)
+                return;
+            await receiver.nativeToolCall(buildOpenAiNativeToolCallFromState(state, phase));
+        }
         const activeFuncCallsByItemId = new Map();
+        const activeWebSearchCallsByItemId = new Map();
+        function readOptionalEventString(value) {
+            return typeof value === 'string' ? value : '';
+        }
+        async function requireEventString(value, eventType, field) {
+            if (typeof value === 'string')
+                return value;
+            return await throwOpenAiMalformedStreamEvent(receiver, eventType, `missing string ${field}`);
+        }
+        async function requireNonEmptyEventItemId(value, eventType) {
+            const itemId = (await requireEventString(value, eventType, 'item_id')).trim();
+            if (itemId.length === 0) {
+                await throwOpenAiMalformedStreamEvent(receiver, eventType, 'empty item_id');
+            }
+            return itemId;
+        }
         try {
             const stream = await client.responses.create(payload, {
                 ...(abortSignal ? { signal: abortSignal } : {}),
@@ -547,6 +1111,14 @@ class OpenAiGen {
                 if (abortSignal?.aborted) {
                     throw new Error('AbortError');
                 }
+                const providerEvent = event;
+                const providerEventType = readEventType(providerEvent);
+                if (providerEventType !== null && vendorHeartbeatEventTypes.has(providerEventType)) {
+                    // Some Responses-compatible gateways emit out-of-band heartbeat frames to keep idle
+                    // streams alive. They are not part of the official OpenAI event taxonomy and carry no
+                    // model semantics, so the OpenAI wrapper ignores them locally.
+                    continue;
+                }
                 switch (event.type) {
                     case 'response.created':
                     case 'response.in_progress':
@@ -556,6 +1128,15 @@ class OpenAiGen {
                             returnedModel = tryExtractApiReturnedModel(event.response);
                         }
                         if (event.type === 'response.completed') {
+                            if (!sawOutputText && currentAudioTranscript.trim().length > 0) {
+                                if (!sayingStarted) {
+                                    await receiver.sayingStart();
+                                }
+                                await receiver.sayingChunk(currentAudioTranscript);
+                                await receiver.sayingFinish();
+                                sayingStarted = false;
+                                sawOutputText = true;
+                            }
                             if (thinkingStarted) {
                                 await receiver.thinkingFinish(buildReasoningPayloadFromText(currentThinkingContent));
                                 thinkingStarted = false;
@@ -598,7 +1179,7 @@ class OpenAiGen {
                         throw new Error(message);
                     }
                     case 'response.output_text.delta': {
-                        const delta = event.delta;
+                        const delta = await requireEventString(event.delta, event.type, 'delta');
                         if (delta.length > 0) {
                             if (activeStream === 'thinking') {
                                 const detail = 'OPENAI stream overlap violation: received output_text while thinking stream still active';
@@ -624,7 +1205,8 @@ class OpenAiGen {
                         break;
                     }
                     case 'response.output_text.done': {
-                        if (!sawOutputText && event.text.length > 0) {
+                        const text = await requireEventString(event.text, event.type, 'text');
+                        if (!sawOutputText && text.length > 0) {
                             if (activeStream === 'thinking') {
                                 const detail = 'OPENAI stream overlap violation: received output_text while thinking stream still active';
                                 log.error(detail, new Error('openai_stream_overlap_violation'));
@@ -643,7 +1225,7 @@ class OpenAiGen {
                                 await receiver.sayingStart();
                                 activeStream = 'saying';
                             }
-                            await receiver.sayingChunk(event.text);
+                            await receiver.sayingChunk(text);
                             sawOutputText = true;
                         }
                         if (sayingStarted) {
@@ -656,7 +1238,7 @@ class OpenAiGen {
                     }
                     case 'response.reasoning_text.delta':
                     case 'response.reasoning_summary_text.delta': {
-                        const delta = event.delta;
+                        const delta = await requireEventString(event.delta, event.type, 'delta');
                         if (delta.length > 0) {
                             if (activeStream === 'saying') {
                                 const detail = 'OPENAI stream overlap violation: received reasoning while saying stream still active';
@@ -715,6 +1297,15 @@ class OpenAiGen {
                         }
                         break;
                     }
+                    case 'response.audio.delta':
+                    case 'response.audio.done':
+                        break;
+                    case 'response.audio.transcript.delta': {
+                        currentAudioTranscript += await requireEventString(event.delta, event.type, 'delta');
+                        break;
+                    }
+                    case 'response.audio.transcript.done':
+                        break;
                     case 'response.output_item.done': {
                         const item = event.item;
                         if (isRecord(item) && item.type === 'function_call') {
@@ -747,6 +1338,37 @@ class OpenAiGen {
                             }
                             break;
                         }
+                        if (isRecord(item) && item.type === 'web_search_call' && receiver.webSearchCall) {
+                            const itemId = typeof item.id === 'string' ? item.id.trim() : '';
+                            if (itemId.length === 0) {
+                                await throwOpenAiMalformedStreamEvent(receiver, item.type, 'missing itemId');
+                            }
+                            const call = toOpenAiLlmWebSearchCall(item, itemId, 'done');
+                            activeWebSearchCallsByItemId.set(itemId, {
+                                itemId,
+                                action: call.action,
+                            });
+                            await receiver.webSearchCall(call);
+                            break;
+                        }
+                        if (isRecord(item) &&
+                            typeof item.type === 'string' &&
+                            OPENAI_NATIVE_TOOL_ITEM_TYPES.has(item.type)) {
+                            const itemId = typeof item.id === 'string' ? item.id.trim() : '';
+                            if (item.type !== 'custom_tool_call' && itemId.length === 0) {
+                                await throwOpenAiMalformedStreamEvent(receiver, item.type, 'missing itemId');
+                            }
+                            if (item.type === 'custom_tool_call' &&
+                                !(typeof item.call_id === 'string' && item.call_id.trim().length > 0)) {
+                                await throwOpenAiMalformedStreamEvent(receiver, item.type, 'missing call_id');
+                            }
+                            const seed = buildOpenAiNativeToolSeed(item, itemId.length > 0 ? itemId : undefined);
+                            if (seed) {
+                                const state = nativeToolTracker.upsert(seed);
+                                await emitNativeToolCall(state, 'done');
+                            }
+                            break;
+                        }
                         if (isRecord(item) && item.type === 'message' && !sawOutputText) {
                             const text = extractOutputMessageText(item);
                             if (text.length > 0) {
@@ -841,14 +1463,182 @@ class OpenAiGen {
                                 activeFuncCallsByItemId.set(itemId, state);
                             }
                         }
+                        if (isRecord(item) && item.type === 'web_search_call' && receiver.webSearchCall) {
+                            const itemId = typeof item.id === 'string' ? item.id.trim() : '';
+                            if (itemId.length === 0) {
+                                await throwOpenAiMalformedStreamEvent(receiver, item.type, 'missing itemId');
+                            }
+                            const call = toOpenAiLlmWebSearchCall(item, itemId, 'added');
+                            activeWebSearchCallsByItemId.set(itemId, {
+                                itemId,
+                                action: call.action,
+                            });
+                            await receiver.webSearchCall(call);
+                        }
+                        if (isRecord(item) &&
+                            typeof item.type === 'string' &&
+                            OPENAI_NATIVE_TOOL_ITEM_TYPES.has(item.type)) {
+                            const itemId = typeof item.id === 'string' ? item.id.trim() : '';
+                            if (item.type !== 'custom_tool_call' && itemId.length === 0) {
+                                await throwOpenAiMalformedStreamEvent(receiver, item.type, 'missing itemId');
+                            }
+                            if (item.type === 'custom_tool_call' &&
+                                !(typeof item.call_id === 'string' && item.call_id.trim().length > 0)) {
+                                await throwOpenAiMalformedStreamEvent(receiver, item.type, 'missing call_id');
+                            }
+                            const seed = buildOpenAiNativeToolSeed(item, itemId.length > 0 ? itemId : undefined);
+                            if (seed) {
+                                const state = nativeToolTracker.upsert(seed);
+                                await emitNativeToolCall(state, 'added');
+                            }
+                        }
+                        break;
+                    }
+                    case 'response.web_search_call.in_progress':
+                    case 'response.web_search_call.searching':
+                    case 'response.web_search_call.completed': {
+                        if (!receiver.webSearchCall) {
+                            break;
+                        }
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const existing = activeWebSearchCallsByItemId.get(itemId);
+                        const status = event.type === 'response.web_search_call.in_progress'
+                            ? 'in_progress'
+                            : event.type === 'response.web_search_call.searching'
+                                ? 'searching'
+                                : 'completed';
+                        const phase = event.type === 'response.web_search_call.completed' ? 'done' : 'added';
+                        await receiver.webSearchCall(buildOpenAiWebSearchProgressCall(itemId, phase, status, existing?.action));
+                        break;
+                    }
+                    case 'response.file_search_call.in_progress':
+                    case 'response.file_search_call.searching':
+                    case 'response.file_search_call.completed': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'file_search_call', 'File Search');
+                        existing.status =
+                            event.type === 'response.file_search_call.in_progress'
+                                ? 'in_progress'
+                                : event.type === 'response.file_search_call.searching'
+                                    ? 'searching'
+                                    : 'completed';
+                        await emitNativeToolCall(existing, event.type === 'response.file_search_call.completed' ? 'done' : 'added');
+                        break;
+                    }
+                    case 'response.code_interpreter_call.in_progress':
+                    case 'response.code_interpreter_call.interpreting':
+                    case 'response.code_interpreter_call.completed': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'code_interpreter_call', 'Code Interpreter');
+                        existing.status =
+                            event.type === 'response.code_interpreter_call.in_progress'
+                                ? 'in_progress'
+                                : event.type === 'response.code_interpreter_call.interpreting'
+                                    ? 'interpreting'
+                                    : 'completed';
+                        await emitNativeToolCall(existing, event.type === 'response.code_interpreter_call.completed' ? 'done' : 'added');
+                        break;
+                    }
+                    case 'response.code_interpreter_call_code.delta': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const delta = await requireEventString(event.delta, event.type, 'delta');
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'code_interpreter_call', 'Code Interpreter');
+                        existing.summary = `${existing.summary ?? ''}${delta}`;
+                        break;
+                    }
+                    case 'response.code_interpreter_call_code.done': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const code = await requireEventString(event.code, event.type, 'code');
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'code_interpreter_call', 'Code Interpreter');
+                        existing.summary = code;
+                        await emitNativeToolCall(existing, 'added');
+                        break;
+                    }
+                    case 'response.image_generation_call.in_progress':
+                    case 'response.image_generation_call.generating':
+                    case 'response.image_generation_call.completed': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'image_generation_call', 'Image Generation');
+                        existing.status =
+                            event.type === 'response.image_generation_call.in_progress'
+                                ? 'in_progress'
+                                : event.type === 'response.image_generation_call.generating'
+                                    ? 'generating'
+                                    : 'completed';
+                        await emitNativeToolCall(existing, event.type === 'response.image_generation_call.completed' ? 'done' : 'added');
+                        break;
+                    }
+                    case 'response.image_generation_call.partial_image': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'image_generation_call', 'Image Generation');
+                        const currentIndex = typeof event.partial_image_index === 'number' ? event.partial_image_index + 1 : 1;
+                        existing.detail = `partial_images=${String(currentIndex)}`;
+                        break;
+                    }
+                    case 'response.mcp_call.in_progress':
+                    case 'response.mcp_call.failed':
+                    case 'response.mcp_call.completed': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'mcp_call', 'MCP Tool Call');
+                        existing.status =
+                            event.type === 'response.mcp_call.in_progress'
+                                ? 'in_progress'
+                                : event.type === 'response.mcp_call.failed'
+                                    ? 'failed'
+                                    : 'completed';
+                        await emitNativeToolCall(existing, event.type === 'response.mcp_call.completed' ? 'done' : 'added');
+                        break;
+                    }
+                    case 'response.mcp_call_arguments.delta': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const delta = await requireEventString(event.delta, event.type, 'delta');
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'mcp_call', 'MCP Tool Call');
+                        existing.detail = `${existing.detail ?? ''}${delta}`;
+                        break;
+                    }
+                    case 'response.mcp_call_arguments.done': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const args = await requireEventString(event.arguments, event.type, 'arguments');
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'mcp_call', 'MCP Tool Call');
+                        existing.detail = args;
+                        await emitNativeToolCall(existing, 'added');
+                        break;
+                    }
+                    case 'response.mcp_list_tools.in_progress':
+                    case 'response.mcp_list_tools.failed':
+                    case 'response.mcp_list_tools.completed': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'mcp_list_tools', 'MCP Tool Discovery');
+                        existing.status =
+                            event.type === 'response.mcp_list_tools.in_progress'
+                                ? 'in_progress'
+                                : event.type === 'response.mcp_list_tools.failed'
+                                    ? 'failed'
+                                    : 'completed';
+                        await emitNativeToolCall(existing, event.type === 'response.mcp_list_tools.completed' ? 'done' : 'added');
+                        break;
+                    }
+                    case 'response.custom_tool_call_input.delta': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const delta = await requireEventString(event.delta, event.type, 'delta');
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'custom_tool_call', 'Custom Tool Call');
+                        existing.detail = `${existing.detail ?? ''}${delta}`;
+                        break;
+                    }
+                    case 'response.custom_tool_call_input.done': {
+                        const itemId = await requireNonEmptyEventItemId(event.item_id, event.type);
+                        const input = await requireEventString(event.input, event.type, 'input');
+                        const existing = await claimNativeToolStateByEventItemId(itemId, 'custom_tool_call', 'Custom Tool Call');
+                        existing.detail = input;
+                        await emitNativeToolCall(existing, 'added');
                         break;
                     }
                     case 'response.content_part.added':
                     case 'response.content_part.done':
                         break;
                     case 'response.function_call_arguments.delta': {
-                        const itemId = event.item_id;
-                        const delta = event.delta;
+                        const itemId = await requireEventString(event.item_id, event.type, 'item_id');
+                        const delta = await requireEventString(event.delta, event.type, 'delta');
                         if (itemId.length > 0 && delta.length > 0) {
                             const existing = activeFuncCallsByItemId.get(itemId);
                             const state = existing ??
@@ -865,9 +1655,9 @@ class OpenAiGen {
                         break;
                     }
                     case 'response.function_call_arguments.done': {
-                        const itemId = event.item_id;
-                        const name = event.name;
-                        const args = event.arguments;
+                        const itemId = await requireEventString(event.item_id, event.type, 'item_id');
+                        const name = readOptionalEventString(event.name);
+                        const args = readOptionalEventString(event.arguments);
                         if (itemId.length > 0) {
                             const existing = activeFuncCallsByItemId.get(itemId);
                             const state = existing ??
@@ -906,10 +1696,27 @@ class OpenAiGen {
                     }
                 }
             }
+            for (const state of activeFuncCallsByItemId.values()) {
+                await maybeEmitFuncCall(state, receiver);
+            }
+            const unresolvedFuncCalls = Array.from(activeFuncCallsByItemId.values()).filter((state) => !state.emitted &&
+                (state.callId.length > 0 || state.name.length > 0 || state.argsJson.length > 0));
+            if (unresolvedFuncCalls.length > 0) {
+                const detail = 'OPENAI incomplete function-call stream state: ' +
+                    unresolvedFuncCalls
+                        .map((state) => `itemId=${state.itemId},callId=${state.callId || '<missing>'},name=${state.name || '<missing>'}`)
+                        .join('; ');
+                log.error(detail, new Error('openai_incomplete_function_call_stream_state'));
+                if (receiver.streamError) {
+                    await receiver.streamError(detail);
+                }
+                throw new Error(detail);
+            }
         }
         catch (error) {
-            log.warn('OPENAI streaming error', error);
-            throw error;
+            const annotatedError = maybeAnnotateOpenAiQuirkFailure(providerConfig, error);
+            log.warn('OPENAI streaming error', annotatedError);
+            throw annotatedError;
         }
         finally {
             if (thinkingStarted) {
@@ -932,13 +1739,15 @@ class OpenAiGen {
         const requestInput = await buildOpenAiRequestInput(context, providerConfig);
         const openAiParams = agent.model_params?.openai || {};
         const maxTokens = agent.model_params?.max_tokens;
-        const jsonResponseEnabled = resolveOpenAiJsonResponseEnabled(agent, openAiParams);
         const modelInfo = providerConfig.models[agent.model];
         const outputLength = modelInfo?.output_length;
         const maxOutputTokens = maxTokens ?? openAiParams.max_tokens ?? outputLength ?? 1024;
         const parallelToolCalls = openAiParams.parallel_tool_calls ?? true;
-        const textConfig = buildOpenAiTextConfig(openAiParams, jsonResponseEnabled);
+        const textConfig = buildOpenAiTextConfig(openAiParams);
         const reasoning = buildOpenAiReasoning(openAiParams);
+        const nativeTools = buildOpenAiNativeTools(openAiParams);
+        const include = buildOpenAiInclude(requestInput, reasoning, openAiParams);
+        const tools = [...funcTools.map(funcToolToOpenAiTool), ...nativeTools];
         const payload = {
             model: agent.model,
             input: requestInput,
@@ -948,12 +1757,16 @@ class OpenAiGen {
             store: false,
             stream: false,
             ...(openAiParams.service_tier !== undefined && { service_tier: openAiParams.service_tier }),
+            ...(openAiParams.safety_identifier !== undefined && {
+                safety_identifier: openAiParams.safety_identifier,
+            }),
             ...(openAiParams.temperature !== undefined && { temperature: openAiParams.temperature }),
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...(reasoning !== undefined && { reasoning }),
+            ...(include !== undefined ? { include } : {}),
             ...(textConfig !== undefined && { text: textConfig }),
-            ...(funcTools.length > 0
-                ? { tools: funcTools.map(funcToolToOpenAiTool), tool_choice: 'auto' }
+            ...(tools.length > 0
+                ? { tools, tool_choice: 'auto' }
                 : { tool_choice: 'none' }),
         };
         const response = await client.responses.create(payload, {
@@ -964,8 +1777,12 @@ class OpenAiGen {
         }
         const returnedModel = typeof response.model === 'string' ? response.model : undefined;
         const usage = parseOpenAiUsage(response.usage);
+        const outputs = openAiResponseToBatchOutputs(response, genseq);
         return {
-            messages: openAiResponseToChatMessages(response, genseq),
+            messages: outputs
+                .filter((entry) => entry.kind === 'message')
+                .map((entry) => entry.message),
+            outputs,
             usage,
             llmGenModel: returnedModel,
         };