@abot-ai/runtime 1.0.0

package/dist/src/model-gateway/providers/ollama/request-diagnostics.js

@@ -0,0 +1,98 @@
+import { traceDebug } from "../../../runtime/observability/debug-logger.js";
+import { readEffectiveOption } from "./options.js";
+function readRecord(value) {
+    const isRecord = value !== null && typeof value === "object" && !Array.isArray(value);
+    return isRecord ? value : undefined;
+}
+function resolveRequestedFormatKind(requestedFormat) {
+    if (requestedFormat === undefined) {
+        return "none";
+    }
+    if (requestedFormat === "json") {
+        return "json";
+    }
+    const formatRecord = readRecord(requestedFormat);
+    return formatRecord?.type === "json_schema" ? "json_schema" : "schema";
+}
+function resolveProviderFormatKind(projectedFormat) {
+    if (projectedFormat === undefined) {
+        return "none";
+    }
+    return projectedFormat === "json" ? "json" : "schema";
+}
+function countObjectProperties(value) {
+    const record = readRecord(value);
+    return record ? Object.keys(record).length : 0;
+}
+function countArrayItems(value) {
+    return Array.isArray(value) ? value.length : 0;
+}
+export function resolveOllamaBaseUrl(invocation, fallbackUrl) {
+    return invocation.profile.providerConfig?.baseUrl?.trim() || fallbackUrl;
+}
+export function emitOllamaSchemaDiagnostics(requestId, diagnostics) {
+    for (const diagnostic of diagnostics) {
+        traceDebug("model-gateway.server", "schema.projection.constraint_removed", {
+            requestId,
+            provider: "ollama",
+            action: diagnostic.action,
+            keyword: diagnostic.keyword,
+            path: diagnostic.path,
+            reason: diagnostic.reason,
+        });
+    }
+}
+export function emitOllamaRequestProjection(params) {
+    const { requestBody, invocation, endpoint } = params.invocationParams;
+    const projectedFormat = params.payload.format;
+    const projectedSchema = readRecord(projectedFormat);
+    traceDebug("model-gateway.server", "provider.request.projected", {
+        requestId: typeof requestBody.debugRequestId === "string"
+            ? requestBody.debugRequestId
+            : "",
+        endpoint,
+        modelStep: requestBody.modelStep,
+        profileId: invocation.profile.id,
+        providerId: invocation.profile.providerId,
+        provider: "ollama",
+        model: invocation.model,
+        requestedFormatKind: resolveRequestedFormatKind(requestBody.format),
+        providerFormatKind: resolveProviderFormatKind(projectedFormat),
+        providerSchemaCharacterCount: projectedSchema
+            ? JSON.stringify(projectedSchema).length
+            : 0,
+        providerSchemaRootType: typeof projectedSchema?.type === "string"
+            ? projectedSchema.type.slice(0, 64)
+            : "",
+        providerSchemaRootPropertyCount: countObjectProperties(projectedSchema?.properties),
+        providerSchemaRootOneOfVariantCount: countArrayItems(projectedSchema?.oneOf),
+        providerSchemaRootAnyOfVariantCount: countArrayItems(projectedSchema?.anyOf),
+        providerSchemaRootAllOfVariantCount: countArrayItems(projectedSchema?.allOf),
+        removedConstraintCount: params.removedConstraintCount,
+        providerContextTokenLimit: readEffectiveOption(params.payload, "num_ctx"),
+        providerOutputTokenLimit: readEffectiveOption(params.payload, "num_predict"),
+    });
+}
+export function emitOllamaTiming(params) {
+    const { requestBody, invocation, endpoint } = params.invocationParams;
+    const measuredDurationNs = (params.timing.loadDurationNs ?? 0) +
+        (params.timing.promptEvalDurationNs ?? 0) +
+        (params.timing.evalDurationNs ?? 0);
+    const remainingDurationNs = params.timing.totalDurationNs === undefined
+        ? undefined
+        : Math.max(0, params.timing.totalDurationNs - measuredDurationNs);
+    traceDebug("model-gateway.server", "ollama.invocation.timing", {
+        requestId: typeof requestBody.debugRequestId === "string"
+            ? requestBody.debugRequestId
+            : "",
+        endpoint,
+        modelStep: requestBody.modelStep,
+        profileId: invocation.profile.id,
+        providerId: invocation.profile.providerId,
+        model: invocation.model,
+        numCtx: readEffectiveOption(params.payload, "num_ctx"),
+        numPredict: readEffectiveOption(params.payload, "num_predict"),
+        ...params.timing,
+        ...(remainingDurationNs !== undefined ? { remainingDurationNs } : {}),
+    });
+}

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

@@ -0,0 +1,11 @@
+import type { ModelGatewayEvent } from "../../types.js";
+import type { ModelProviderInvocationParams } from "../contracts.js";
+export type StreamTerminationOutcome = "completed" | "aborted" | "failed";
+export declare function isAbortFailure(error: unknown): boolean;
+export declare function createOllamaStreamDiagnostics(params: {
+    invocationParams: ModelProviderInvocationParams;
+    payload: Record<string, unknown>;
+}): {
+    observe(event: ModelGatewayEvent): void;
+    terminate(outcome: StreamTerminationOutcome, error?: unknown): void;
+};

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

@@ -0,0 +1,137 @@
+import { traceDebug } from "../../../runtime/observability/debug-logger.js";
+import { readEffectiveOption } from "./options.js";
+const STREAM_PROGRESS_START_CHARACTER_COUNT = 4_096;
+const STREAM_DIAGNOSTIC_TAIL_CHARACTER_LIMIT = 8_192;
+const STREAM_REPETITION_MINIMUM_UNIT_CHARACTERS = 8;
+const STREAM_REPETITION_MAXIMUM_UNIT_CHARACTERS = 256;
+const STREAM_REPETITION_MINIMUM_COUNT = 6;
+function serializeDiagnosticError(error) {
+    return error instanceof Error
+        ? { name: error.name, message: error.message }
+        : { name: "Error", message: String(error) };
+}
+export function isAbortFailure(error) {
+    return (error !== null &&
+        typeof error === "object" &&
+        "name" in error &&
+        error.name === "AbortError");
+}
+function appendDiagnosticTail(current, next) {
+    const combined = current + next;
+    return combined.length <= STREAM_DIAGNOSTIC_TAIL_CHARACTER_LIMIT
+        ? combined
+        : combined.slice(-STREAM_DIAGNOSTIC_TAIL_CHARACTER_LIMIT);
+}
+function shouldReplaceBestRepetition(best, candidate) {
+    if (!best) {
+        return true;
+    }
+    if (candidate.coveredCharacterCount !== best.coveredCharacterCount) {
+        return candidate.coveredCharacterCount > best.coveredCharacterCount;
+    }
+    return candidate.unitCharacterCount < best.unitCharacterCount;
+}
+function detectRepeatedSuffix(value) {
+    const maximumUnitLength = Math.min(STREAM_REPETITION_MAXIMUM_UNIT_CHARACTERS, Math.floor(value.length / STREAM_REPETITION_MINIMUM_COUNT));
+    let best;
+    for (let unitCharacterCount = STREAM_REPETITION_MINIMUM_UNIT_CHARACTERS; unitCharacterCount <= maximumUnitLength; unitCharacterCount += 1) {
+        const unit = value.slice(-unitCharacterCount);
+        let repeatCount = 1;
+        while ((repeatCount + 1) * unitCharacterCount <= value.length &&
+            value.slice(-(repeatCount + 1) * unitCharacterCount, -repeatCount * unitCharacterCount) === unit) {
+            repeatCount += 1;
+        }
+        if (repeatCount < STREAM_REPETITION_MINIMUM_COUNT) {
+            continue;
+        }
+        const candidate = {
+            unitCharacterCount,
+            repeatCount,
+            coveredCharacterCount: repeatCount * unitCharacterCount,
+        };
+        if (shouldReplaceBestRepetition(best, candidate)) {
+            best = candidate;
+        }
+    }
+    return best;
+}
+function projectRepetition(prefix, value) {
+    const repetition = detectRepeatedSuffix(value);
+    if (!repetition) {
+        return {};
+    }
+    const label = prefix === "content" ? "content" : "thinking";
+    return {
+        [`${label}RepeatedSuffixUnitCharacterCount`]: repetition.unitCharacterCount,
+        [`${label}RepeatedSuffixCount`]: repetition.repeatCount,
+        [`${label}RepeatedSuffixCoveredCharacterCount`]: repetition.coveredCharacterCount,
+    };
+}
+export function createOllamaStreamDiagnostics(params) {
+    const { requestBody, invocation, endpoint } = params.invocationParams;
+    const startedAt = Date.now();
+    let eventCount = 0;
+    let contentCharacterCount = 0;
+    let thinkingCharacterCount = 0;
+    let contentTail = "";
+    let thinkingTail = "";
+    let nextProgressCharacterCount = STREAM_PROGRESS_START_CHARACTER_COUNT;
+    const base = {
+        requestId: typeof requestBody.debugRequestId === "string"
+            ? requestBody.debugRequestId
+            : "",
+        endpoint,
+        modelStep: typeof requestBody.modelStep === "string" ? requestBody.modelStep : "",
+        profileId: invocation.profile.id,
+        providerId: invocation.profile.providerId,
+        provider: "ollama",
+        model: invocation.model,
+        numCtx: readEffectiveOption(params.payload, "num_ctx"),
+        numPredict: readEffectiveOption(params.payload, "num_predict"),
+    };
+    const snapshot = () => ({
+        ...base,
+        elapsedMs: Date.now() - startedAt,
+        eventCount,
+        contentCharacterCount,
+        thinkingCharacterCount,
+        totalCharacterCount: contentCharacterCount + thinkingCharacterCount,
+        ...projectRepetition("content", contentTail),
+        ...projectRepetition("thinking", thinkingTail),
+    });
+    return {
+        observe(event) {
+            eventCount += 1;
+            if (event.type === "content") {
+                contentCharacterCount += event.text.length;
+                contentTail = appendDiagnosticTail(contentTail, event.text);
+            }
+            else if (event.type === "thinking") {
+                thinkingCharacterCount += event.text.length;
+                thinkingTail = appendDiagnosticTail(thinkingTail, event.text);
+            }
+            const totalCharacterCount = contentCharacterCount + thinkingCharacterCount;
+            if (totalCharacterCount < nextProgressCharacterCount) {
+                return;
+            }
+            while (nextProgressCharacterCount <= totalCharacterCount) {
+                nextProgressCharacterCount *= 2;
+            }
+            traceDebug("model-gateway.server", "ollama.stream.progress", snapshot());
+        },
+        terminate(outcome, error) {
+            const hasAbortReason = outcome === "aborted" && error !== undefined;
+            traceDebug("model-gateway.server", "ollama.stream.terminated", {
+                ...snapshot(),
+                outcome,
+                abortRequested: outcome === "aborted",
+                ...(hasAbortReason
+                    ? { abortReason: serializeDiagnosticError(error) }
+                    : {}),
+                ...(error !== undefined
+                    ? { error: serializeDiagnosticError(error) }
+                    : {}),
+            });
+        },
+    };
+}

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

@@ -0,0 +1,21 @@
+import type { ModelGatewayEvent, ModelTokenUsage } from "../../types.js";
+import type { ModelProviderEventSink } from "../contracts.js";
+export type OllamaProviderTiming = Readonly<{
+    loadDurationNs?: number;
+    promptEvalDurationNs?: number;
+    evalDurationNs?: number;
+    totalDurationNs?: number;
+}>;
+export type OllamaStreamOptions = Readonly<{
+    onTerminalTiming?: (timing: OllamaProviderTiming) => void;
+    onNormalizedEvent?: (event: ModelGatewayEvent) => void;
+}>;
+export declare function writeGatewayEvents(events: ModelProviderEventSink, json: unknown, options?: OllamaStreamOptions): void;
+export declare function flushNdjsonBuffer(buffer: string, events: ModelProviderEventSink, options?: OllamaStreamOptions): string;
+export declare function forwardOllamaStream(body: ReadableStream<Uint8Array>, events: ModelProviderEventSink, options?: OllamaStreamOptions): Promise<void>;
+export declare function collectOllamaStream(body: ReadableStream<Uint8Array>, options?: OllamaStreamOptions): Promise<{
+    text: string;
+    thinking: string;
+    usage?: ModelTokenUsage;
+    doneReason?: string | null;
+}>;

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

@@ -0,0 +1,201 @@
+import { buildModelTokenUsage } from "../../protocol/usage.js";
+function observeNormalizedEvent(options, event) {
+    try {
+        options.onNormalizedEvent?.(event);
+    }
+    catch {
+        // Diagnostics must never affect provider stream behavior.
+    }
+}
+function readOllamaEvent(json) {
+    const obj = json && typeof json === "object"
+        ? json
+        : {};
+    const thinking = obj.message?.thinking;
+    const content = obj.message?.content;
+    const doneFlag = obj.done === true;
+    const doneReason = obj.done_reason;
+    const events = [];
+    if (typeof thinking === "string" && thinking.length > 0) {
+        events.push({ type: "thinking", text: thinking });
+    }
+    if (typeof content === "string" && content.length > 0) {
+        events.push({ type: "content", text: content });
+    }
+    if (doneFlag) {
+        const usage = readOllamaUsage(obj);
+        events.push({
+            type: "done",
+            done: true,
+            doneReason: typeof doneReason === "string" ? doneReason : null,
+            ...(usage ? { usage } : {}),
+        });
+    }
+    return events;
+}
+function readOllamaUsage(json) {
+    const value = json && typeof json === "object" && !Array.isArray(json)
+        ? json
+        : {};
+    return buildModelTokenUsage({
+        inputTokens: value.prompt_eval_count,
+        outputTokens: value.eval_count,
+    });
+}
+function readOllamaProviderTiming(json) {
+    const value = json && typeof json === "object" && !Array.isArray(json)
+        ? json
+        : {};
+    if (value.done !== true) {
+        return undefined;
+    }
+    const readDuration = (field) => {
+        const duration = value[field];
+        return typeof duration === "number" &&
+            Number.isFinite(duration) &&
+            duration >= 0
+            ? duration
+            : undefined;
+    };
+    const loadDurationNs = readDuration("load_duration");
+    const promptEvalDurationNs = readDuration("prompt_eval_duration");
+    const evalDurationNs = readDuration("eval_duration");
+    const totalDurationNs = readDuration("total_duration");
+    const timing = {
+        ...(loadDurationNs !== undefined ? { loadDurationNs } : {}),
+        ...(promptEvalDurationNs !== undefined ? { promptEvalDurationNs } : {}),
+        ...(evalDurationNs !== undefined ? { evalDurationNs } : {}),
+        ...(totalDurationNs !== undefined ? { totalDurationNs } : {}),
+    };
+    return Object.keys(timing).length > 0 ? timing : undefined;
+}
+export function writeGatewayEvents(events, json, options = {}) {
+    const timing = readOllamaProviderTiming(json);
+    if (timing) {
+        options.onTerminalTiming?.(timing);
+    }
+    for (const event of readOllamaEvent(json)) {
+        observeNormalizedEvent(options, event);
+        events.emit(event);
+    }
+}
+export function flushNdjsonBuffer(buffer, events, options = {}) {
+    let remaining = buffer;
+    let newlineIndex;
+    while ((newlineIndex = remaining.indexOf("\n")) !== -1) {
+        const line = remaining.slice(0, newlineIndex).trim();
+        remaining = remaining.slice(newlineIndex + 1);
+        if (!line) {
+            continue;
+        }
+        try {
+            writeGatewayEvents(events, JSON.parse(line), options);
+        }
+        catch {
+            // Keep bridge behavior: ignore malformed upstream chunks.
+        }
+    }
+    return remaining;
+}
+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 });
+        }
+        buffer = flushNdjsonBuffer(buffer, events, options);
+        if (done) {
+            break;
+        }
+    }
+    if (buffer.trim()) {
+        try {
+            writeGatewayEvents(events, JSON.parse(buffer.trim()), options);
+        }
+        catch {
+            // Keep bridge behavior: ignore malformed trailing chunks.
+        }
+    }
+}
+export async function collectOllamaStream(body, options = {}) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let text = "";
+    let thinking = "";
+    let usage;
+    let doneReason;
+    const appendJson = (json) => {
+        const obj = json && typeof json === "object"
+            ? json
+            : {};
+        const nextThinking = obj.message?.thinking;
+        const nextContent = obj.message?.content;
+        const nextUsage = readOllamaUsage(json);
+        const timing = readOllamaProviderTiming(json);
+        if (typeof nextThinking === "string" && nextThinking.length > 0) {
+            thinking += nextThinking;
+        }
+        if (typeof nextContent === "string" && nextContent.length > 0) {
+            text += nextContent;
+        }
+        if (nextUsage) {
+            usage = nextUsage;
+        }
+        if (obj.done === true) {
+            doneReason = typeof obj.done_reason === "string" ? obj.done_reason : null;
+        }
+        if (timing) {
+            options.onTerminalTiming?.(timing);
+        }
+        for (const event of readOllamaEvent(json)) {
+            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 {
+                appendJson(JSON.parse(line));
+            }
+            catch {
+                // Keep bridge behavior: ignore malformed upstream chunks.
+            }
+        }
+        if (done) {
+            break;
+        }
+    }
+    if (buffer.trim()) {
+        try {
+            appendJson(JSON.parse(buffer.trim()));
+        }
+        catch {
+            // Keep bridge behavior: ignore malformed trailing chunks.
+        }
+    }
+    return {
+        text,
+        thinking,
+        ...(usage ? { usage } : {}),
+        ...(doneReason !== undefined ? { doneReason } : {}),
+    };
+}

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

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

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

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

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

@@ -0,0 +1 @@
+export * from "./ollama/payload.js";

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

@@ -0,0 +1 @@
+export * from "./ollama/payload.js";

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

@@ -0,0 +1,2 @@
+import type { ModelProviderAdapter } from "../contracts.js";
+export declare function createOpenAIProviderAdapter(): ModelProviderAdapter;

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

@@ -0,0 +1,114 @@
+import { fetchProviderWithTrace } from "../../model-io-trace.js";
+import { emitOpenAIMessageOutputDiagnostic, emitOpenAISchemaDiagnostics, emitOpenAIStreamTermination, hasStructuredTextFormat, resolveOpenAIStreamFailureOutcome, } from "./diagnostics.js";
+import { countOpenAIInputTokens } from "./input-token-count.js";
+import { buildOpenAIResponsesPayload, collectOpenAIResponsesStream, forwardOpenAIResponsesStream, resolveOpenAIProviderSettings, } from "./protocol.js";
+export function createOpenAIProviderAdapter() {
+    return Object.freeze({
+        type: "openai",
+        supportsImageInput: false,
+        countInputTokens: countOpenAIInputTokens,
+        async invoke(params) {
+            const settings = resolveOpenAIProviderSettings(params.requestBody);
+            if (!settings.apiKey) {
+                return {
+                    kind: "error",
+                    statusCode: 500,
+                    message: `missing OpenAI API key env: ${settings.apiKeyEnv}`,
+                };
+            }
+            const requestId = typeof params.requestBody.debugRequestId === "string"
+                ? params.requestBody.debugRequestId
+                : "";
+            const payload = buildOpenAIResponsesPayload(params.requestBody, {
+                onFormatProjection: (diagnostics) => emitOpenAISchemaDiagnostics(requestId, diagnostics),
+                ...(params.inputTokenMeasurement
+                    ? { inputTokenMeasurement: params.inputTokenMeasurement }
+                    : {}),
+            });
+            const streamOptions = {
+                structuredOutput: hasStructuredTextFormat(payload),
+                onMessageOutputDiagnostic: (diagnostic) => emitOpenAIMessageOutputDiagnostic(params, diagnostic),
+            };
+            const { response, responseTrace } = await fetchProviderWithTrace({
+                endpoint: params.endpoint,
+                requestBody: params.requestBody,
+                invocation: params.invocation,
+                fetchImpl: params.fetchImpl,
+                url: `${settings.baseUrl}/responses`,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${settings.apiKey}`,
+                },
+                payload,
+                decodeResponse: (body) => collectOpenAIResponsesStream(body),
+            });
+            if (!response.ok || !response.body) {
+                const message = await response.text();
+                await responseTrace;
+                return {
+                    kind: "error",
+                    statusCode: response.status || 502,
+                    message: message || "openai error",
+                };
+            }
+            const streamStartedAt = Date.now();
+            if (params.endpoint === "chat") {
+                const body = response.body;
+                return {
+                    kind: "chat",
+                    async stream(writer) {
+                        let outcome = "completed";
+                        let failure;
+                        try {
+                            await forwardOpenAIResponsesStream(body, writer, streamOptions);
+                        }
+                        catch (error) {
+                            outcome = resolveOpenAIStreamFailureOutcome(error);
+                            failure = error;
+                            throw error;
+                        }
+                        finally {
+                            emitOpenAIStreamTermination({
+                                invocationParams: params,
+                                startedAt: streamStartedAt,
+                                outcome,
+                                ...(failure !== undefined ? { error: failure } : {}),
+                            });
+                            await responseTrace;
+                        }
+                    },
+                };
+            }
+            let outcome = "completed";
+            let failure;
+            try {
+                const collected = await collectOpenAIResponsesStream(response.body, streamOptions);
+                return {
+                    kind: "raw",
+                    body: {
+                        text: collected.text,
+                        thinking: collected.thinking,
+                        ...(collected.usage ? { usage: collected.usage } : {}),
+                        ...(collected.doneReason
+                            ? { providerCompletionReason: collected.doneReason }
+                            : {}),
+                    },
+                };
+            }
+            catch (error) {
+                outcome = resolveOpenAIStreamFailureOutcome(error);
+                failure = error;
+                throw error;
+            }
+            finally {
+                emitOpenAIStreamTermination({
+                    invocationParams: params,
+                    startedAt: streamStartedAt,
+                    outcome,
+                    ...(failure !== undefined ? { error: failure } : {}),
+                });
+                await responseTrace;
+            }
+        },
+    });
+}

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

@@ -0,0 +1,14 @@
+import type { OpenAISchemaProjectionDiagnostic } from "../../structured-output/projection.js";
+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;
+export declare function emitOpenAIStreamTermination(params: {
+    invocationParams: ModelProviderInvocationParams;
+    startedAt: number;
+    outcome: OpenAIStreamTerminationOutcome;
+    error?: unknown;
+}): void;