@abot-ai/runtime 1.7.0 → 1.8.0

package/dist/src/model-gateway/observability/provider-response-tail.js

@@ -0,0 +1,28 @@
+const MAX_PARTIAL_BODY_BYTES = 16_384;
+/** Fixed storage: appending copies only incoming bytes, never the retained tail. */
+export class ProviderResponseTail {
+    bytes = Buffer.alloc(MAX_PARTIAL_BODY_BYTES);
+    writeOffset = 0;
+    usedBytes = 0;
+    append(chunk) {
+        if (chunk.byteLength >= this.bytes.length) {
+            this.bytes.set(chunk.subarray(chunk.byteLength - this.bytes.length));
+            this.writeOffset = 0;
+            this.usedBytes = this.bytes.length;
+            return;
+        }
+        const firstLength = Math.min(chunk.byteLength, this.bytes.length - this.writeOffset);
+        this.bytes.set(chunk.subarray(0, firstLength), this.writeOffset);
+        this.bytes.set(chunk.subarray(firstLength), 0);
+        this.writeOffset = (this.writeOffset + chunk.byteLength) % this.bytes.length;
+        this.usedBytes = Math.min(this.usedBytes + chunk.byteLength, this.bytes.length);
+    }
+    snapshot() {
+        const result = Buffer.alloc(this.usedBytes);
+        const start = (this.writeOffset - this.usedBytes + this.bytes.length) % this.bytes.length;
+        const firstLength = Math.min(this.usedBytes, this.bytes.length - start);
+        result.set(this.bytes.subarray(start, start + firstLength));
+        result.set(this.bytes.subarray(0, this.usedBytes - firstLength), firstLength);
+        return result;
+    }
+}

package/dist/src/model-gateway/observability/provider-sse-diagnostics.d.ts

@@ -0,0 +1,30 @@
+/** Bounded SSE metadata only; never selects or forwards model output. */
+export declare class ProviderSseDiagnostics {
+    private pendingLine;
+    private droppingLine;
+    private afterCarriageReturn;
+    private eventType;
+    private hasData;
+    private data;
+    private dataTruncated;
+    private eventCount;
+    private oversizedLineCount;
+    private readonly counts;
+    private readonly recentEvents;
+    observe(text: string, afterMs: number): void;
+    snapshot(): {
+        eventCount: number;
+        eventTypes: {
+            [k: string]: number;
+        };
+        recentEvents: {
+            type: string;
+            afterMs: number;
+        }[];
+        oversizedLineCount: number;
+    };
+    private appendLinePart;
+    private finishLine;
+    private appendData;
+    private finishEvent;
+}

package/dist/src/model-gateway/observability/provider-sse-diagnostics.js

@@ -0,0 +1,119 @@
+const MAX_LINE_CHARACTERS = 32_768;
+const MAX_DATA_CHARACTERS = 32_768;
+const MAX_EVENT_TYPE_CHARACTERS = 128;
+const MAX_EVENT_TYPES = 32;
+const MAX_RECENT_EVENTS = 32;
+/** Bounded SSE metadata only; never selects or forwards model output. */
+export class ProviderSseDiagnostics {
+    pendingLine = "";
+    droppingLine = false;
+    afterCarriageReturn = false;
+    eventType;
+    hasData = false;
+    data = "";
+    dataTruncated = false;
+    eventCount = 0;
+    oversizedLineCount = 0;
+    counts = new Map();
+    recentEvents = [];
+    observe(text, afterMs) {
+        if (text.length === 0)
+            return;
+        let start = this.afterCarriageReturn && text.startsWith("\n") ? 1 : 0;
+        this.afterCarriageReturn = text.endsWith("\r");
+        const lineEndings = /\r\n|\r|\n/gu;
+        while (start < text.length) {
+            lineEndings.lastIndex = start;
+            const ending = lineEndings.exec(text);
+            this.appendLinePart(text.slice(start, ending?.index));
+            if (!ending)
+                return;
+            this.finishLine(afterMs);
+            start = ending.index + ending[0].length;
+        }
+    }
+    snapshot() {
+        return {
+            eventCount: this.eventCount,
+            eventTypes: Object.fromEntries(this.counts),
+            recentEvents: [...this.recentEvents],
+            oversizedLineCount: this.oversizedLineCount,
+        };
+    }
+    appendLinePart(part) {
+        if (this.droppingLine)
+            return;
+        const remaining = MAX_LINE_CHARACTERS - this.pendingLine.length;
+        this.pendingLine += part.slice(0, remaining);
+        if (part.length <= remaining)
+            return;
+        this.droppingLine = true;
+        this.oversizedLineCount += 1;
+    }
+    finishLine(afterMs) {
+        const line = this.pendingLine;
+        const truncated = this.droppingLine;
+        this.pendingLine = "";
+        this.droppingLine = false;
+        if (line === "") {
+            this.finishEvent(afterMs);
+            return;
+        }
+        const colon = line.indexOf(":");
+        const field = colon < 0 ? line : line.slice(0, colon);
+        let value = colon < 0 ? "" : line.slice(colon + 1);
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        if (field === "event") {
+            this.eventType = value.slice(0, MAX_EVENT_TYPE_CHARACTERS);
+            return;
+        }
+        if (field !== "data")
+            return;
+        this.hasData = true;
+        this.appendData(value, truncated);
+    }
+    appendData(value, truncated) {
+        if (this.dataTruncated)
+            return;
+        if (truncated || this.data.length + value.length + 1 > MAX_DATA_CHARACTERS) {
+            this.dataTruncated = true;
+            this.data = "";
+            return;
+        }
+        this.data += value + "\n";
+    }
+    finishEvent(afterMs) {
+        const hasData = this.hasData;
+        const type = this.eventType ?? readDataEventType(this.data.slice(0, -1));
+        this.eventType = undefined;
+        this.hasData = false;
+        this.data = "";
+        this.dataTruncated = false;
+        if (!hasData)
+            return;
+        const recordedType = type || "message";
+        const countKey = this.counts.has(recordedType) || this.counts.size < MAX_EVENT_TYPES
+            ? recordedType : "(other)";
+        this.counts.set(countKey, (this.counts.get(countKey) ?? 0) + 1);
+        this.eventCount += 1;
+        this.recentEvents.push({ type: recordedType, afterMs });
+        if (this.recentEvents.length > MAX_RECENT_EVENTS)
+            this.recentEvents.shift();
+    }
+}
+function readDataEventType(data) {
+    if (data === "")
+        return "";
+    if (data === "[DONE]")
+        return "[DONE]";
+    try {
+        const value = JSON.parse(data);
+        if (value === null || typeof value !== "object" || !("type" in value))
+            return "";
+        return typeof value.type === "string" ? value.type.slice(0, MAX_EVENT_TYPE_CHARACTERS) : "";
+    }
+    catch {
+        return "";
+    }
+}

package/dist/src/model-gateway/observability/provider-trace.js

@@ -2,6 +2,7 @@ import { createProviderTraceContext, serializeProviderError, } from "./provider-
 import { isModelIoTraceEnabled, traceModelIo } from "./trace-store.js";
 import { permitsModelContentTrace } from "./content-trace-policy.js";
 import { toolMediaSafeError } from "./tool-media-privacy.js";
+import { captureProviderResponseBody } from "./provider-response-capture.js";
 function sanitizeProviderHeaders(headers) {
     const credentialHeaders = new Set([
         "authorization",
@@ -21,22 +22,42 @@ async function decodeProviderResponse(response, decodeResponse) {
         return { decodeError: serializeProviderError(error) };
     }
 }
-async function captureProviderResponse(context, response, decodeResponse) {
+async function captureProviderResponse(context, response, decodeResponse, startedAt) {
     try {
         const rawResponse = response.clone();
         const decodedResponse = response.clone();
-        const [body, decodedCapture] = await Promise.all([
-            rawResponse.text(),
-            decodeProviderResponse(decodedResponse, decodeResponse),
-        ]);
+        const rawCapture = captureProviderResponseBody(rawResponse, startedAt);
+        const decodedCapture = decodeProviderResponse(decodedResponse, decodeResponse);
+        const capture = await rawCapture;
+        if (capture.outcome === "failed") {
+            await traceModelIo({
+                event: "provider.failure",
+                ...context,
+                stage: "response.capture",
+                error: serializeProviderError(capture.error),
+                response: {
+                    status: response.status,
+                    statusText: response.statusText,
+                    partialBodyPrefix: capture.partialBodyPrefix,
+                    partialBodyPrefixBytes: capture.partialBodyPrefixBytes,
+                    partialBodyPrefixTruncated: capture.partialBodyPrefixTruncated,
+                    partialBody: capture.partialBody,
+                    partialBodyBytes: capture.partialBodyBytes,
+                    bodyTruncated: capture.bodyTruncated,
+                    stream: capture.stream,
+                },
+            });
+            return;
+        }
         await traceModelIo({
             event: "provider.response",
             ...context,
             response: {
                 status: response.status,
                 statusText: response.statusText,
-                ...decodedCapture,
-                body,
+                ...await decodedCapture,
+                body: capture.body,
+                stream: capture.stream,
             },
         });
     }
@@ -71,6 +92,7 @@ export async function fetchProviderWithTrace(params) {
             },
         });
     }
+    const startedAt = Date.now();
     try {
         const response = await params.fetchImpl(params.url, {
             method: "POST",
@@ -80,7 +102,7 @@ export async function fetchProviderWithTrace(params) {
         return {
             response,
             responseTrace: traceEnabled && contentTraceEnabled
-                ? captureProviderResponse(context, response, params.decodeResponse)
+                ? captureProviderResponse(context, response, params.decodeResponse, startedAt)
                 : Promise.resolve(),
         };
     }

package/dist/src/model-gateway/providers/ollama/adapter.js

@@ -1,9 +1,10 @@
 import { fetchProviderWithTrace } from "../../model-io-trace.js";
-import { toolMediaSafeError, toolMediaSafeMessage } from "../../observability/tool-media-privacy.js";
+import { toolMediaSafeError, toolMediaSafeMessage, } from "../../observability/tool-media-privacy.js";
 import { buildOllamaPayload, buildOllamaRawPayload, } from "./payload.js";
 import { emitOllamaRequestProjection, emitOllamaSchemaDiagnostics, emitOllamaTiming, resolveOllamaBaseUrl, } from "./request-diagnostics.js";
 import { createOllamaStreamDiagnostics, isAbortFailure, } from "./stream-diagnostics.js";
 import { collectOllamaStream, forwardOllamaStream, } from "./stream-normalizer.js";
+import { OllamaStreamTerminationError } from "./stream-termination.js";
 import { embedWithOllama } from "./embeddings.js";
 import { listOllamaEmbeddingModels } from "./embedding-models.js";
 function readRequestId(params) {
@@ -81,7 +82,12 @@ export function createOllamaProviderAdapter(options) {
                         catch (error) {
                             outcome = resolveFailureOutcome(error);
                             failure = toolMediaSafeError(error, params.requestBody);
-                            throw failure;
+                            if (!(error instanceof OllamaStreamTerminationError))
+                                throw failure;
+                            writer.emit({
+                                type: "error",
+                                error: toolMediaSafeMessage(error.message, params.requestBody),
+                            });
                         }
                         finally {
                             streamDiagnostics.terminate(outcome, failure);

package/dist/src/model-gateway/providers/ollama/stream-normalizer.js

@@ -1,4 +1,5 @@
 import { buildModelTokenUsage } from "../../protocol/usage.js";
+import { assertOllamaFrameSucceeded, assertOllamaStreamCompleted, } from "./stream-termination.js";
 function observeNormalizedEvent(options, event) {
     try {
         options.onNormalizedEvent?.(event);
@@ -8,6 +9,7 @@ function observeNormalizedEvent(options, event) {
     }
 }
 function readOllamaEvent(json) {
+    assertOllamaFrameSucceeded(json);
     const obj = json && typeof json === "object"
         ? json
         : {};
@@ -88,12 +90,7 @@ export function flushNdjsonBuffer(buffer, events, options = {}) {
         if (!line) {
             continue;
         }
-        try {
-            writeGatewayEvents(events, JSON.parse(line), options);
-        }
-        catch {
-            // Keep bridge behavior: ignore malformed upstream chunks.
-        }
+        writeGatewayEvents(events, parseOllamaStreamLine(line), options);
     }
     return remaining;
 }
@@ -101,26 +98,39 @@ export async function forwardOllamaStream(body, events, options = {}) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            buffer += decoder.decode();
-        }
-        else {
-            buffer += decoder.decode(value, { stream: true });
+    let terminalReceived = false;
+    const terminalTrackingEvents = {
+        emit(event) {
+            if (event.type === "done")
+                terminalReceived = true;
+            events.emit(event);
+        },
+    };
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                buffer += decoder.decode();
+            }
+            else {
+                buffer += decoder.decode(value, { stream: true });
+            }
+            buffer = flushNdjsonBuffer(buffer, terminalTrackingEvents, options);
+            if (done) {
+                break;
+            }
         }
-        buffer = flushNdjsonBuffer(buffer, events, options);
-        if (done) {
-            break;
+        if (buffer.trim()) {
+            writeGatewayEvents(terminalTrackingEvents, parseOllamaStreamLine(buffer.trim()), options);
         }
+        assertOllamaStreamCompleted(terminalReceived);
     }
-    if (buffer.trim()) {
-        try {
-            writeGatewayEvents(events, JSON.parse(buffer.trim()), options);
-        }
-        catch {
-            // Keep bridge behavior: ignore malformed trailing chunks.
-        }
+    catch (error) {
+        void reader.cancel(error).catch(() => { });
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
     }
 }
 export async function collectOllamaStream(body, options = {}) {
@@ -132,6 +142,7 @@ export async function collectOllamaStream(body, options = {}) {
     let usage;
     let doneReason;
     const appendJson = (json) => {
+        assertOllamaFrameSucceeded(json);
         const obj = json && typeof json === "object"
             ? json
             : {};
@@ -158,39 +169,39 @@ export async function collectOllamaStream(body, options = {}) {
             observeNormalizedEvent(options, event);
         }
     };
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            buffer += decoder.decode();
-        }
-        else {
-            buffer += decoder.decode(value, { stream: true });
-        }
-        let newlineIndex;
-        while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
-            const line = buffer.slice(0, newlineIndex).trim();
-            buffer = buffer.slice(newlineIndex + 1);
-            if (!line) {
-                continue;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                buffer += decoder.decode();
+            }
+            else {
+                buffer += decoder.decode(value, { stream: true });
             }
-            try {
-                appendJson(JSON.parse(line));
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                if (!line) {
+                    continue;
+                }
+                appendJson(parseOllamaStreamLine(line));
             }
-            catch {
-                // Keep bridge behavior: ignore malformed upstream chunks.
+            if (done) {
+                break;
             }
         }
-        if (done) {
-            break;
+        if (buffer.trim()) {
+            appendJson(parseOllamaStreamLine(buffer.trim()));
         }
+        assertOllamaStreamCompleted(doneReason !== undefined);
     }
-    if (buffer.trim()) {
-        try {
-            appendJson(JSON.parse(buffer.trim()));
-        }
-        catch {
-            // Keep bridge behavior: ignore malformed trailing chunks.
-        }
+    catch (error) {
+        void reader.cancel(error).catch(() => { });
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
     }
     return {
         text,
@@ -199,3 +210,12 @@ export async function collectOllamaStream(body, options = {}) {
         ...(doneReason !== undefined ? { doneReason } : {}),
     };
 }
+function parseOllamaStreamLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        // Preserve tolerance for malformed chunks without swallowing provider errors.
+        return undefined;
+    }
+}

package/dist/src/model-gateway/providers/ollama/stream-termination.d.ts

@@ -0,0 +1,6 @@
+/** A provider stream failed instead of completing its output. */
+export declare class OllamaStreamTerminationError extends Error {
+    constructor(message: string);
+}
+export declare function assertOllamaFrameSucceeded(json: unknown): void;
+export declare function assertOllamaStreamCompleted(terminalReceived: boolean): void;

package/dist/src/model-gateway/providers/ollama/stream-termination.js

@@ -0,0 +1,20 @@
+/** A provider stream failed instead of completing its output. */
+export class OllamaStreamTerminationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OllamaStreamTerminationError";
+    }
+}
+export function assertOllamaFrameSucceeded(json) {
+    if (!json || typeof json !== "object" || Array.isArray(json))
+        return;
+    const error = json.error;
+    if (typeof error !== "string")
+        return;
+    throw new OllamaStreamTerminationError(`ollama_stream_error: ${error || "provider generation failed"}`);
+}
+export function assertOllamaStreamCompleted(terminalReceived) {
+    if (terminalReceived)
+        return;
+    throw new OllamaStreamTerminationError("ollama_stream_missing_terminal");
+}

package/dist/src/model-gateway/providers/openai/adapter.js

@@ -1,9 +1,12 @@
 import { fetchProviderWithTrace } from "../../model-io-trace.js";
 import { toolMediaSafeError, toolMediaSafeEvent, toolMediaSafeMessage } from "../../observability/tool-media-privacy.js";
-import { emitOpenAIMessageOutputDiagnostic, emitOpenAISchemaDiagnostics, emitOpenAIStreamTermination, hasStructuredTextFormat, resolveOpenAIStreamFailureOutcome, } from "./diagnostics.js";
+import { emitOpenAIMessageOutputDiagnostic, emitOpenAISchemaDiagnostics, emitOpenAIStreamTermination, resolveOpenAIStreamFailureOutcome, } from "./diagnostics.js";
 import { countOpenAIInputTokens } from "./input-token-count.js";
 import { buildOpenAIResponsesPayload, collectOpenAIResponsesStream, forwardOpenAIResponsesStream, resolveOpenAIProviderSettings, } from "./protocol.js";
 import { embedWithOpenAI } from "./embeddings.js";
+import { bindOpenAIResponseLifetime } from "./response-lifetime.js";
+import { resolveOpenAIFunctionOutputName } from "./function-output.js";
+import { requiresSingleMessageOutput } from "./message-output-policy.js";
 export function createOpenAIProviderAdapter() {
     return Object.freeze({
         type: "openai",
@@ -24,26 +27,25 @@ export function createOpenAIProviderAdapter() {
                 : "";
             const payload = buildOpenAIResponsesPayload(params.requestBody, {
                 onFormatProjection: (diagnostics) => emitOpenAISchemaDiagnostics(requestId, diagnostics),
-                ...(params.inputTokenMeasurement
-                    ? { inputTokenMeasurement: params.inputTokenMeasurement }
-                    : {}),
             });
+            const functionOutputName = resolveOpenAIFunctionOutputName(payload);
             const streamOptions = {
-                structuredOutput: hasStructuredTextFormat(payload),
+                functionOutputName,
+                structuredOutput: requiresSingleMessageOutput(params.requestBody, payload),
                 onMessageOutputDiagnostic: (diagnostic) => emitOpenAIMessageOutputDiagnostic(params, diagnostic),
             };
             const { response, responseTrace } = await fetchProviderWithTrace({
                 endpoint: params.endpoint,
                 requestBody: params.requestBody,
                 invocation: params.invocation,
-                fetchImpl: params.fetchImpl,
+                fetchImpl: async (input, init) => bindOpenAIResponseLifetime(await params.fetchImpl(input, init), { functionOutputName }),
                 url: `${settings.baseUrl}/responses`,
                 headers: {
                     "Content-Type": "application/json",
                     Authorization: `Bearer ${settings.apiKey}`,
                 },
                 payload,
-                decodeResponse: (body) => collectOpenAIResponsesStream(body),
+                decodeResponse: (body) => collectOpenAIResponsesStream(body, { functionOutputName }),
             });
             if (!response.ok || !response.body) {
                 const message = await response.text();

package/dist/src/model-gateway/providers/openai/diagnostics.d.ts

@@ -2,7 +2,6 @@ import type { OpenAISchemaProjectionDiagnostic } from "../../structured-output/p
 import type { ModelProviderInvocationParams } from "../contracts.js";
 import type { OpenAIMessageOutputNormalizationDiagnostic } from "./stream-normalizer.js";
 export type OpenAIStreamTerminationOutcome = "completed" | "aborted" | "failed";
-export declare function hasStructuredTextFormat(payload: Record<string, unknown>): boolean;
 export declare function emitOpenAISchemaDiagnostics(requestId: string, diagnostics: readonly OpenAISchemaProjectionDiagnostic[]): void;
 export declare function emitOpenAIMessageOutputDiagnostic(params: ModelProviderInvocationParams, diagnostic: OpenAIMessageOutputNormalizationDiagnostic): void;
 export declare function resolveOpenAIStreamFailureOutcome(error: unknown): OpenAIStreamTerminationOutcome;

package/dist/src/model-gateway/providers/openai/diagnostics.js

@@ -4,15 +4,6 @@ function serializeDiagnosticError(error) {
         ? { name: error.name, message: error.message }
         : { name: "Error", message: String(error) };
 }
-function readRecord(value) {
-    const isRecord = value !== null && typeof value === "object" && !Array.isArray(value);
-    return isRecord ? value : undefined;
-}
-export function hasStructuredTextFormat(payload) {
-    const text = readRecord(payload.text);
-    const format = readRecord(text?.format);
-    return format?.type === "json_schema" || format?.type === "json_object";
-}
 export function emitOpenAISchemaDiagnostics(requestId, diagnostics) {
     for (const diagnostic of diagnostics) {
         traceDebug("model-gateway.server", "schema.projection.instruction_injected", {

package/dist/src/model-gateway/providers/openai/function-output.d.ts

@@ -0,0 +1,11 @@
+type OpenAIFunctionOutput = Readonly<{
+    tools: readonly Record<string, unknown>[];
+    tool_choice: Readonly<{
+        type: "function";
+        name: string;
+    }>;
+    parallel_tool_calls: false;
+}>;
+export declare function projectOpenAIFunctionOutput(modelStep: unknown, format: unknown): OpenAIFunctionOutput | undefined;
+export declare function resolveOpenAIFunctionOutputName(payload: Record<string, unknown>): string | undefined;
+export {};

package/dist/src/model-gateway/providers/openai/function-output.js

@@ -0,0 +1,37 @@
+import { resolveModelInvocationStep } from "../../../shared/model-step-registry.js";
+import { isModelGatewayJsonSchemaFormat, isPlainObject, } from "../../structured-output/format-contract.js";
+function isCapabilityControlsStep(modelStep) {
+    return resolveModelInvocationStep(modelStep)?.outputContract === "capability_controls";
+}
+function hasFunctionParametersSchema(format) {
+    if (!isModelGatewayJsonSchemaFormat(format))
+        return false;
+    return format.schema.type === "object";
+}
+// Transport the existing controls envelope as one function's arguments. The
+// Runtime still owns validation, frozen-control merging and execution authority.
+export function projectOpenAIFunctionOutput(modelStep, format) {
+    if (!isCapabilityControlsStep(modelStep))
+        return undefined;
+    if (!hasFunctionParametersSchema(format))
+        return undefined;
+    return {
+        tools: [{
+                type: "function",
+                name: format.name,
+                parameters: format.schema,
+                ...(format.description === undefined ? {} : { description: format.description }),
+                ...(format.strict === undefined ? {} : { strict: format.strict }),
+            }],
+        tool_choice: { type: "function", name: format.name },
+        parallel_tool_calls: false,
+    };
+}
+export function resolveOpenAIFunctionOutputName(payload) {
+    const choice = payload.tool_choice;
+    if (!isPlainObject(choice))
+        return undefined;
+    if (choice.type !== "function")
+        return undefined;
+    return typeof choice.name === "string" ? choice.name : undefined;
+}

package/dist/src/model-gateway/providers/openai/function-result.d.ts

@@ -0,0 +1,7 @@
+type OpenAIFunctionResult = Readonly<{
+    text: string;
+} | {
+    error: string;
+}>;
+export declare function readOpenAIFunctionResult(response: unknown, expectedName: string): OpenAIFunctionResult;
+export {};

package/dist/src/model-gateway/providers/openai/function-result.js

@@ -0,0 +1,35 @@
+import { isModelGatewayToolCall } from "../../protocol/message-contract.js";
+import { isPlainObject } from "../../structured-output/format-contract.js";
+function isFunctionCall(value) {
+    return isPlainObject(value) && value.type === "function_call";
+}
+function hasCompletedResponseOutput(response) {
+    if (!isPlainObject(response))
+        return false;
+    if (response.status !== "completed")
+        return false;
+    return Array.isArray(response.output);
+}
+// Only the terminal response snapshot is authoritative. Argument deltas and
+// output_item.done may precede refusal, truncation or a failed response.
+export function readOpenAIFunctionResult(response, expectedName) {
+    if (!hasCompletedResponseOutput(response)) {
+        return { error: "openai function response not completed" };
+    }
+    const calls = response.output.filter(isFunctionCall);
+    if (calls.length !== 1) {
+        return { error: "openai function response requires exactly one call" };
+    }
+    const call = calls[0];
+    if (call.name !== expectedName) {
+        return { error: "openai function response name mismatch" };
+    }
+    if (call.status !== undefined && call.status !== "completed") {
+        return { error: "openai function call not completed" };
+    }
+    const projected = { callId: call.call_id, name: call.name, arguments: call.arguments };
+    if (!isModelGatewayToolCall(projected)) {
+        return { error: "openai function call arguments or identity invalid" };
+    }
+    return { text: projected.arguments };
+}

package/dist/src/model-gateway/providers/openai/message-output-policy.d.ts

@@ -0,0 +1,3 @@
+import type { ModelGatewayRequest } from "../../types.js";
+/** Content authoring consumes one message even when its wire format is plain text. */
+export declare function requiresSingleMessageOutput(request: ModelGatewayRequest, payload: Record<string, unknown>): boolean;