@abot-ai/runtime 1.0.0

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

@@ -0,0 +1,71 @@
+import { traceDebug } from "../../../runtime/observability/debug-logger.js";
+function serializeDiagnosticError(error) {
+    return error instanceof 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", {
+            requestId,
+            provider: "openai",
+            action: diagnostic.action,
+            schemaName: diagnostic.schemaName,
+            reason: diagnostic.reason,
+            instructionCharacterCount: diagnostic.instructionCharacterCount,
+        });
+    }
+}
+export function emitOpenAIMessageOutputDiagnostic(params, diagnostic) {
+    traceDebug("model-gateway.server", "openai.message_outputs.normalized", {
+        requestId: typeof params.requestBody.debugRequestId === "string"
+            ? params.requestBody.debugRequestId
+            : "",
+        modelStep: typeof params.requestBody.modelStep === "string"
+            ? params.requestBody.modelStep
+            : "",
+        provider: "openai",
+        endpoint: params.endpoint,
+        ...diagnostic,
+    });
+}
+export function resolveOpenAIStreamFailureOutcome(error) {
+    const isAbort = error !== null &&
+        typeof error === "object" &&
+        "name" in error &&
+        error.name === "AbortError";
+    return isAbort ? "aborted" : "failed";
+}
+export function emitOpenAIStreamTermination(params) {
+    const { requestBody, invocation, endpoint } = params.invocationParams;
+    const hasAbortReason = params.outcome === "aborted" && params.error !== undefined;
+    traceDebug("model-gateway.server", "openai.stream.terminated", {
+        requestId: typeof requestBody.debugRequestId === "string"
+            ? requestBody.debugRequestId
+            : "",
+        endpoint,
+        modelStep: typeof requestBody.modelStep === "string" ? requestBody.modelStep : "",
+        profileId: invocation.profile.id,
+        providerId: invocation.profile.providerId,
+        provider: "openai",
+        model: invocation.model,
+        elapsedMs: Date.now() - params.startedAt,
+        outcome: params.outcome,
+        abortRequested: params.outcome === "aborted",
+        ...(hasAbortReason
+            ? { abortReason: serializeDiagnosticError(params.error) }
+            : {}),
+        ...(params.error !== undefined
+            ? { error: serializeDiagnosticError(params.error) }
+            : {}),
+    });
+}

package/dist/src/model-gateway/providers/openai/input-token-count.d.ts

@@ -0,0 +1,2 @@
+import type { ModelProviderInputTokenCountParams, ModelProviderInputTokenCountResult } from "../contracts.js";
+export declare function countOpenAIInputTokens(params: ModelProviderInputTokenCountParams): Promise<ModelProviderInputTokenCountResult>;

package/dist/src/model-gateway/providers/openai/input-token-count.js

@@ -0,0 +1,55 @@
+import { createProviderEnvelopeFingerprint } from "../envelope-budget.js";
+import { buildOpenAIInputTokenCountPayload } from "./payload.js";
+import { resolveOpenAIProviderSettings } from "./settings.js";
+function readInputTokenCount(body) {
+    const isRecord = body !== null && typeof body === "object" && !Array.isArray(body);
+    if (!isRecord) {
+        return undefined;
+    }
+    const inputTokens = body.input_tokens;
+    const isValidCount = typeof inputTokens === "number" &&
+        Number.isSafeInteger(inputTokens) &&
+        inputTokens >= 0;
+    return isValidCount ? inputTokens : undefined;
+}
+export async function countOpenAIInputTokens(params) {
+    const settings = resolveOpenAIProviderSettings(params.requestBody);
+    if (!settings.apiKey) {
+        return {
+            kind: "error",
+            statusCode: 500,
+            message: `missing OpenAI API key env: ${settings.apiKeyEnv}`,
+        };
+    }
+    const payload = buildOpenAIInputTokenCountPayload(params.requestBody);
+    const response = await params.fetchImpl(`${settings.baseUrl}/responses/input_tokens`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${settings.apiKey}`,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const message = await response.text().catch(() => "");
+        return {
+            kind: "error",
+            statusCode: response.status || 502,
+            message: message || "openai input token count error",
+        };
+    }
+    const body = await response.json().catch(() => undefined);
+    const inputTokens = readInputTokenCount(body);
+    if (inputTokens === undefined) {
+        return {
+            kind: "error",
+            statusCode: 502,
+            message: "openai input token count response invalid",
+        };
+    }
+    return {
+        kind: "counted",
+        inputTokens,
+        providerEnvelopeFingerprint: createProviderEnvelopeFingerprint(payload),
+    };
+}

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

@@ -0,0 +1,9 @@
+import { type OpenAISchemaProjectionDiagnostic } from "../../structured-output/projection.js";
+import type { ModelGatewayRequest } from "../../types.js";
+import type { ModelProviderInputTokenMeasurement } from "../contracts.js";
+export type OpenAIPayloadBuildOptions = Readonly<{
+    onFormatProjection?: (diagnostics: readonly OpenAISchemaProjectionDiagnostic[]) => void;
+    inputTokenMeasurement?: ModelProviderInputTokenMeasurement;
+}>;
+export declare function buildOpenAIResponsesPayload(requestBody: ModelGatewayRequest, payloadOptions?: OpenAIPayloadBuildOptions): Record<string, unknown>;
+export declare function buildOpenAIInputTokenCountPayload(requestBody: ModelGatewayRequest): Record<string, unknown>;

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

@@ -0,0 +1,127 @@
+import { resolveModelStepOutputTokenLimit } from "../../../shared/model-step-registry.js";
+import { isAssistantToolCallMessage, isToolResultMessage, validateModelGatewayMessages, } from "../../protocol/message-contract.js";
+import { normalizeReasoning, resolveModelInvocation, } from "../../policy/invocation-policy.js";
+import { projectOpenAIResponsesFormat, resolveModelGatewayFormat, } from "../../structured-output/projection.js";
+import { resolveProviderEnvelopeInputTokens } from "../envelope-budget.js";
+function prependInstructionInput(params) {
+    const instructions = (params.instructions ?? [])
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (instructions.length === 0) {
+        return params.input;
+    }
+    const systemMessage = {
+        role: "system",
+        content: instructions.join("\n"),
+    };
+    if (Array.isArray(params.input)) {
+        return [systemMessage, ...params.input];
+    }
+    const userContent = typeof params.input === "string" ? params.input : "";
+    return [systemMessage, { role: "user", content: userContent }];
+}
+function resolveUnprojectedInput(requestBody) {
+    const hasMessages = Array.isArray(requestBody.messages) && requestBody.messages.length > 0;
+    if (hasMessages) {
+        return requestBody.messages;
+    }
+    if (typeof requestBody.prompt === "string") {
+        return requestBody.prompt;
+    }
+    return typeof requestBody.text === "string" ? requestBody.text : "";
+}
+function projectOpenAIInputItems(input) {
+    if (!Array.isArray(input)) {
+        return input;
+    }
+    return input.flatMap((item) => {
+        if (isAssistantToolCallMessage(item)) {
+            return item.toolCalls.map((call) => ({
+                type: "function_call",
+                call_id: call.callId,
+                name: call.name,
+                arguments: call.arguments,
+            }));
+        }
+        if (isToolResultMessage(item)) {
+            return [
+                {
+                    type: "function_call_output",
+                    call_id: item.toolCallId,
+                    output: item.content,
+                },
+            ];
+        }
+        return [item];
+    });
+}
+function resolveInputWithProviderInstructions(requestBody, providerInstructions) {
+    const invocation = resolveModelInvocation(requestBody);
+    return prependInstructionInput({
+        input: projectOpenAIInputItems(resolveUnprojectedInput(requestBody)),
+        instructions: [...(invocation.instructions ?? []), ...providerInstructions],
+    });
+}
+function readFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
+    validateModelGatewayMessages(requestBody.messages);
+    const invocation = resolveModelInvocation(requestBody);
+    const generation = invocation.profile.generation;
+    const temperature = readFiniteNumber(generation.temperature);
+    const topP = readFiniteNumber(generation.topP);
+    const reasoningEffort = normalizeReasoning(requestBody.reasoningOverride) ??
+        generation.reasoningEffort ??
+        invocation.think;
+    const formatProjection = projectOpenAIResponsesFormat(resolveModelGatewayFormat(requestBody.format, invocation.format));
+    if (formatProjection.diagnostics.length > 0) {
+        payloadOptions.onFormatProjection?.(formatProjection.diagnostics);
+    }
+    const canUseSamplingControls = !invocation.profile.supportsThinking ||
+        reasoningEffort === undefined ||
+        reasoningEffort === "none";
+    const shouldSendReasoning = invocation.profile.supportsThinking &&
+        reasoningEffort !== undefined &&
+        reasoningEffort !== "none";
+    const payload = {
+        model: invocation.model,
+        input: resolveInputWithProviderInstructions(requestBody, formatProjection.instructions),
+        stream: true,
+    };
+    if (canUseSamplingControls && temperature !== undefined) {
+        payload.temperature = temperature;
+    }
+    if (canUseSamplingControls && topP !== undefined) {
+        payload.top_p = topP;
+    }
+    if (shouldSendReasoning) {
+        payload.reasoning = { effort: reasoningEffort };
+    }
+    if (formatProjection.format) {
+        payload.text = { format: formatProjection.format };
+    }
+    const outputTokenLimit = resolveModelStepOutputTokenLimit(requestBody.modelStep);
+    if (outputTokenLimit === undefined) {
+        return payload;
+    }
+    const { inputTokens } = resolveProviderEnvelopeInputTokens({
+        payload,
+        tokenEstimation: invocation.profile.context.tokenEstimation,
+        ...(payloadOptions.inputTokenMeasurement
+            ? { measurement: payloadOptions.inputTokenMeasurement }
+            : {}),
+    });
+    payload.max_output_tokens = Math.max(1, Math.min(outputTokenLimit, invocation.profile.contextWindowTokens - inputTokens));
+    return payload;
+}
+export function buildOpenAIInputTokenCountPayload(requestBody) {
+    const payload = { ...buildOpenAIResponsesPayload(requestBody) };
+    delete payload.stream;
+    delete payload.temperature;
+    delete payload.top_p;
+    delete payload.max_output_tokens;
+    return payload;
+}

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

@@ -0,0 +1,4 @@
+export { buildOpenAIInputTokenCountPayload, buildOpenAIResponsesPayload, type OpenAIPayloadBuildOptions, } from "./payload.js";
+export { resolveOpenAIProviderSettings } from "./settings.js";
+export { collectOpenAIResponsesStream, forwardOpenAIResponsesStream, } from "./stream.js";
+export type { OpenAIMessageOutputNormalizationDiagnostic, OpenAIResponsesStreamOptions, } from "./stream-normalizer.js";

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

@@ -0,0 +1,3 @@
+export { buildOpenAIInputTokenCountPayload, buildOpenAIResponsesPayload, } from "./payload.js";
+export { resolveOpenAIProviderSettings } from "./settings.js";
+export { collectOpenAIResponsesStream, forwardOpenAIResponsesStream, } from "./stream.js";

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

@@ -0,0 +1,6 @@
+import type { ModelGatewayRequest } from "../../types.js";
+export declare function resolveOpenAIProviderSettings(requestBody: ModelGatewayRequest): {
+    baseUrl: string;
+    apiKeyEnv: string;
+    apiKey?: string;
+};

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

@@ -0,0 +1,25 @@
+import { resolveModelInvocation } from "../../policy/invocation-policy.js";
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
+const ENV_VAR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function normalizeBaseUrl(value) {
+    return (value?.trim() || DEFAULT_OPENAI_BASE_URL).replace(/\/+$/, "");
+}
+function resolveApiKeyEnvironment(requestBody) {
+    const invocation = resolveModelInvocation(requestBody);
+    const configuredName = invocation.profile.providerConfig?.apiKeyEnv?.trim() ||
+        DEFAULT_OPENAI_API_KEY_ENV;
+    return ENV_VAR_NAME_PATTERN.test(configuredName)
+        ? configuredName
+        : DEFAULT_OPENAI_API_KEY_ENV;
+}
+export function resolveOpenAIProviderSettings(requestBody) {
+    const invocation = resolveModelInvocation(requestBody);
+    const apiKeyEnv = resolveApiKeyEnvironment(requestBody);
+    const apiKey = process.env[apiKeyEnv];
+    return {
+        baseUrl: normalizeBaseUrl(invocation.profile.providerConfig?.baseUrl ?? process.env.OPENAI_BASE_URL),
+        apiKeyEnv,
+        ...(apiKey ? { apiKey } : {}),
+    };
+}

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

@@ -0,0 +1,51 @@
+import type { ModelTokenUsage } from "../../types.js";
+import type { ModelProviderEventSink } from "../contracts.js";
+export type OpenAIMessageOutputNormalizationDiagnostic = Readonly<{
+    outcome: "additional_message_outputs_ignored";
+    outputCount: number;
+    selectedOutput: Readonly<{
+        itemId: string | null;
+        outputIndex: number | null;
+        arrivalOrder: number;
+        textByteCount: number;
+    }>;
+    ignoredOutputCount: number;
+    sampledIgnoredOutputs: readonly Readonly<{
+        itemId: string | null;
+        outputIndex: number | null;
+        arrivalOrder: number;
+        textByteCount: number;
+    }>[];
+    omittedIgnoredOutputCount: number;
+}>;
+export type OpenAIResponsesStreamOptions = Readonly<{
+    structuredOutput?: boolean;
+    onMessageOutputDiagnostic?: (diagnostic: OpenAIMessageOutputNormalizationDiagnostic) => void;
+}>;
+export type NormalizedOpenAIStreamEvent = {
+    type: "content";
+    text: string;
+} | {
+    type: "done";
+    done: true;
+    usage?: ModelTokenUsage;
+    doneReason?: string;
+} | {
+    type: "error";
+    error: string;
+};
+export declare class OpenAIResponsesStreamNormalizer {
+    private readonly options;
+    private readonly outputs;
+    private primaryOutputKey;
+    private terminal;
+    constructor(options: OpenAIResponsesStreamOptions);
+    consume(data: unknown): NormalizedOpenAIStreamEvent[];
+    finish(): NormalizedOpenAIStreamEvent[];
+    private consumeTextDelta;
+    private consumeIncompleteResponse;
+    private getMessageOutput;
+    private complete;
+    private emitAdditionalOutputDiagnostic;
+}
+export declare function writeNormalizedOpenAIEvents(events: readonly NormalizedOpenAIStreamEvent[], sink: ModelProviderEventSink): void;

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

@@ -0,0 +1,179 @@
+import { buildModelTokenUsage } from "../../protocol/usage.js";
+const OPENAI_IGNORED_MESSAGE_OUTPUT_DIAGNOSTIC_LIMIT = 8;
+function readRecord(value) {
+    const isRecord = value !== null && typeof value === "object" && !Array.isArray(value);
+    return isRecord ? value : {};
+}
+function resolveMessageOutputKey(params) {
+    if (params.itemId !== null) {
+        return `item:${params.itemId}`;
+    }
+    if (params.outputIndex !== null) {
+        return `output:${params.outputIndex}`;
+    }
+    return "unidentified-message-output";
+}
+function readOpenAIMessageOutputIdentity(event) {
+    const itemId = typeof event.item_id === "string" && event.item_id.length > 0
+        ? event.item_id
+        : null;
+    const outputIndex = typeof event.output_index === "number" &&
+        Number.isInteger(event.output_index) &&
+        event.output_index >= 0
+        ? event.output_index
+        : null;
+    return {
+        key: resolveMessageOutputKey({ itemId, outputIndex }),
+        itemId,
+        outputIndex,
+    };
+}
+function readOpenAIUsage(data) {
+    const event = readRecord(data);
+    const response = readRecord(event.response);
+    const usage = readRecord(response.usage);
+    const inputDetails = readRecord(usage.input_tokens_details);
+    const outputDetails = readRecord(usage.output_tokens_details);
+    return buildModelTokenUsage({
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        totalTokens: usage.total_tokens,
+        cachedInputTokens: inputDetails.cached_tokens,
+        reasoningTokens: outputDetails.reasoning_tokens,
+    });
+}
+function readOpenAIError(data) {
+    const event = readRecord(data);
+    const error = readRecord(event.error);
+    return ((typeof error.message === "string" && error.message.trim()) ||
+        (typeof event.message === "string" && event.message.trim()) ||
+        "openai stream error");
+}
+function readOpenAIIncompleteReason(data) {
+    const event = readRecord(data);
+    const response = readRecord(event.response);
+    const incompleteDetails = readRecord(response.incomplete_details);
+    const reason = incompleteDetails.reason;
+    return typeof reason === "string" && reason.trim().length > 0
+        ? reason.trim()
+        : "unknown_reason";
+}
+export class OpenAIResponsesStreamNormalizer {
+    options;
+    outputs = new Map();
+    primaryOutputKey;
+    terminal = false;
+    constructor(options) {
+        this.options = options;
+    }
+    consume(data) {
+        if (this.terminal) {
+            return [];
+        }
+        const event = readRecord(data);
+        if (event.type === "response.output_text.delta") {
+            return this.consumeTextDelta(event);
+        }
+        if (event.type === "response.completed") {
+            return this.complete(readOpenAIUsage(data));
+        }
+        if (event.type === "response.incomplete") {
+            return this.consumeIncompleteResponse(data);
+        }
+        if (event.type === "error") {
+            this.terminal = true;
+            return [{ type: "error", error: readOpenAIError(data) }];
+        }
+        return [];
+    }
+    finish() {
+        return this.complete(undefined);
+    }
+    consumeTextDelta(event) {
+        const delta = typeof event.delta === "string" ? event.delta : "";
+        if (!delta) {
+            return [];
+        }
+        if (!this.options.structuredOutput) {
+            return [{ type: "content", text: delta }];
+        }
+        const output = this.getMessageOutput(event);
+        output.textByteCount += Buffer.byteLength(delta, "utf8");
+        return output.key === this.primaryOutputKey
+            ? [{ type: "content", text: delta }]
+            : [];
+    }
+    consumeIncompleteResponse(data) {
+        const reason = readOpenAIIncompleteReason(data);
+        if (reason === "max_output_tokens") {
+            return this.complete(readOpenAIUsage(data), reason);
+        }
+        this.terminal = true;
+        return [{ type: "error", error: `openai response incomplete: ${reason}` }];
+    }
+    getMessageOutput(event) {
+        const identity = readOpenAIMessageOutputIdentity(event);
+        let output = this.outputs.get(identity.key);
+        if (!output) {
+            output = {
+                ...identity,
+                arrivalOrder: this.outputs.size + 1,
+                textByteCount: 0,
+            };
+            this.outputs.set(identity.key, output);
+            this.primaryOutputKey ??= identity.key;
+        }
+        return output;
+    }
+    complete(usage, doneReason) {
+        if (this.terminal) {
+            return [];
+        }
+        this.emitAdditionalOutputDiagnostic();
+        this.terminal = true;
+        return [
+            {
+                type: "done",
+                done: true,
+                ...(usage ? { usage } : {}),
+                ...(doneReason ? { doneReason } : {}),
+            },
+        ];
+    }
+    emitAdditionalOutputDiagnostic() {
+        const hasAdditionalStructuredOutputs = this.options.structuredOutput && this.outputs.size > 1;
+        if (!hasAdditionalStructuredOutputs) {
+            return;
+        }
+        const outputs = [...this.outputs.values()];
+        const selectedOutput = outputs[0];
+        const ignoredOutputs = outputs.slice(1);
+        this.options.onMessageOutputDiagnostic?.({
+            outcome: "additional_message_outputs_ignored",
+            outputCount: outputs.length,
+            selectedOutput: {
+                itemId: selectedOutput.itemId?.slice(0, 160) ?? null,
+                outputIndex: selectedOutput.outputIndex,
+                arrivalOrder: selectedOutput.arrivalOrder,
+                textByteCount: selectedOutput.textByteCount,
+            },
+            ignoredOutputCount: ignoredOutputs.length,
+            sampledIgnoredOutputs: ignoredOutputs
+                .slice(0, OPENAI_IGNORED_MESSAGE_OUTPUT_DIAGNOSTIC_LIMIT)
+                .map(({ itemId, outputIndex, arrivalOrder, textByteCount }) => ({
+                itemId: itemId?.slice(0, 160) ?? null,
+                outputIndex,
+                arrivalOrder,
+                textByteCount,
+            })),
+            omittedIgnoredOutputCount: Math.max(0, ignoredOutputs.length - OPENAI_IGNORED_MESSAGE_OUTPUT_DIAGNOSTIC_LIMIT),
+        });
+    }
+}
+export function writeNormalizedOpenAIEvents(events, sink) {
+    for (const event of events) {
+        sink.emit(event.type === "done"
+            ? { ...event, doneReason: event.doneReason ?? null }
+            : event);
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { ModelTokenUsage } from "../../types.js";
+import type { ModelProviderEventSink } from "../contracts.js";
+import { type OpenAIResponsesStreamOptions } from "./stream-normalizer.js";
+export declare function forwardOpenAIResponsesStream(body: ReadableStream<Uint8Array>, sink: ModelProviderEventSink, options?: OpenAIResponsesStreamOptions): Promise<void>;
+export declare function collectOpenAIResponsesStream(body: ReadableStream<Uint8Array>, options?: OpenAIResponsesStreamOptions): Promise<{
+    text: string;
+    thinking: string;
+    usage?: ModelTokenUsage;
+    doneReason?: string;
+}>;

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

@@ -0,0 +1,96 @@
+import { OpenAIResponsesStreamNormalizer, writeNormalizedOpenAIEvents, } from "./stream-normalizer.js";
+function parseSseEvents(buffer) {
+    const events = [];
+    let remaining = buffer;
+    let boundaryIndex;
+    while ((boundaryIndex = remaining.indexOf("\n\n")) !== -1) {
+        events.push(remaining.slice(0, boundaryIndex));
+        remaining = remaining.slice(boundaryIndex + 2);
+    }
+    return { events, rest: remaining };
+}
+function readSseData(eventBlock) {
+    return eventBlock
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trim())
+        .filter(Boolean);
+}
+async function* readOpenAIDataLines(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+        const parsed = parseSseEvents(buffer);
+        buffer = parsed.rest;
+        for (const eventBlock of parsed.events) {
+            for (const dataLine of readSseData(eventBlock)) {
+                yield dataLine;
+            }
+        }
+        if (done) {
+            break;
+        }
+    }
+}
+export async function forwardOpenAIResponsesStream(body, sink, options = {}) {
+    const normalizer = new OpenAIResponsesStreamNormalizer(options);
+    for await (const dataLine of readOpenAIDataLines(body)) {
+        if (dataLine === "[DONE]") {
+            writeNormalizedOpenAIEvents(normalizer.finish(), sink);
+            continue;
+        }
+        try {
+            const event = JSON.parse(dataLine);
+            writeNormalizedOpenAIEvents(normalizer.consume(event), sink);
+        }
+        catch {
+            // Keep gateway behavior: ignore malformed upstream stream chunks.
+        }
+    }
+}
+function applyCollectedEvent(collected, event) {
+    switch (event.type) {
+        case "content":
+            collected.text += event.text;
+            return;
+        case "done":
+            collected.usage = event.usage;
+            collected.doneReason = event.doneReason;
+            return;
+        case "error":
+            throw new Error(`openai_stream_error: ${event.error}`);
+    }
+}
+export async function collectOpenAIResponsesStream(body, options = {}) {
+    const normalizer = new OpenAIResponsesStreamNormalizer(options);
+    const collected = { text: "" };
+    for await (const dataLine of readOpenAIDataLines(body)) {
+        if (dataLine === "[DONE]") {
+            for (const event of normalizer.finish()) {
+                applyCollectedEvent(collected, event);
+            }
+            continue;
+        }
+        let event;
+        try {
+            event = JSON.parse(dataLine);
+        }
+        catch {
+            // Keep gateway behavior: ignore malformed upstream stream chunks.
+            continue;
+        }
+        for (const normalized of normalizer.consume(event)) {
+            applyCollectedEvent(collected, normalized);
+        }
+    }
+    return {
+        text: collected.text,
+        thinking: "",
+        ...(collected.usage ? { usage: collected.usage } : {}),
+        ...(collected.doneReason ? { doneReason: collected.doneReason } : {}),
+    };
+}

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

@@ -0,0 +1 @@
+export * from "./openai/adapter.js";

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

@@ -0,0 +1 @@
+export * from "./openai/adapter.js";

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

@@ -0,0 +1 @@
+export * from "./openai/protocol.js";

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

@@ -0,0 +1 @@
+export * from "./openai/protocol.js";

package/dist/src/model-gateway/providers/registry.d.ts

@@ -0,0 +1,5 @@
+import { type ModelProviderAdapter, type ModelProviderAdapterRegistry } from "./contracts.js";
+export declare function createBuiltInModelProviderAdapterRegistry(options: {
+    ollamaUrl: string;
+    additionalAdapters?: readonly ModelProviderAdapter[];
+}): ModelProviderAdapterRegistry;