@abot-ai/runtime 1.0.0

package/dist/src/model-gateway/client/stream-parser.js

@@ -0,0 +1,129 @@
+import { normalizeModelTokenUsage } from "../protocol/usage.js";
+function readText(value) {
+    return typeof value === "string" ? value : "";
+}
+function readObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function parseStreamEvent(line, callbacks) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        callbacks.onStreamEvent?.({
+            kind: "invalid_json",
+            raw: line.slice(0, 300),
+        });
+        return undefined;
+    }
+}
+function emitContent(token, callbacks, currentText) {
+    if (token) {
+        callbacks.onToken?.(token);
+        callbacks.onStreamEvent?.({
+            kind: "content",
+            text: token,
+        });
+        return currentText + token;
+    }
+    callbacks.onStreamEvent?.({
+        kind: "content_empty",
+    });
+    return currentText;
+}
+function isErrorEvent(messageType, stream) {
+    return messageType === "error" || stream === "error";
+}
+function readErrorMessage(message, data) {
+    const errorObject = readObject(message.error);
+    return (readText(message.error) ||
+        readText(errorObject.message) ||
+        readText(message.message) ||
+        readText(data.error) ||
+        readText(data.message) ||
+        "model stream error");
+}
+function throwStreamError(message, data, callbacks) {
+    const errorText = readErrorMessage(message, data);
+    callbacks.onStreamEvent?.({
+        kind: "error",
+        text: errorText,
+    });
+    throw new Error(`model_stream_error: ${errorText}`);
+}
+function readContentText(message, data) {
+    return (readText(message.text) ||
+        readText(message.delta) ||
+        readText(data.delta) ||
+        readText(data.text));
+}
+function emitThinking(thinkingText, callbacks, currentText) {
+    if (thinkingText) {
+        callbacks.onThinking?.(thinkingText);
+    }
+    callbacks.onStreamEvent?.({
+        kind: "thinking",
+        text: thinkingText,
+    });
+    return currentText;
+}
+function emitTerminal(message, callbacks) {
+    const usage = normalizeModelTokenUsage(message.usage);
+    if (usage) {
+        callbacks.onUsage?.(usage);
+    }
+    callbacks.onTerminal?.({
+        providerCompletionReason: typeof message.doneReason === "string"
+            ? message.doneReason.slice(0, 160)
+            : null,
+    });
+}
+function isThinkingEvent(messageType, stream) {
+    return messageType === "thinking" || stream === "thinking";
+}
+function isContentEvent(messageType) {
+    return (messageType === "content" ||
+        messageType === "final" ||
+        messageType === "done");
+}
+function readAssistantStreamContent(message, data) {
+    return (readText(data.delta) ||
+        readText(data.text) ||
+        readText(message.text) ||
+        readText(message.delta));
+}
+export function applyStreamLine(line, callbacks, currentText) {
+    if (!line.trim()) {
+        return currentText;
+    }
+    const message = parseStreamEvent(line, callbacks);
+    if (!message) {
+        return currentText;
+    }
+    const messageType = typeof message.type === "string" ? message.type : "";
+    const stream = typeof message.stream === "string" ? message.stream : "";
+    const data = readObject(message.data);
+    if (isErrorEvent(messageType, stream)) {
+        return throwStreamError(message, data, callbacks);
+    }
+    const contentText = readContentText(message, data);
+    if (isThinkingEvent(messageType, stream)) {
+        return emitThinking(contentText, callbacks, currentText);
+    }
+    if (messageType === "done") {
+        emitTerminal(message, callbacks);
+    }
+    if (isContentEvent(messageType)) {
+        return emitContent(contentText, callbacks, currentText);
+    }
+    if (stream === "assistant") {
+        return emitContent(readAssistantStreamContent(message, data), callbacks, currentText);
+    }
+    callbacks.onStreamEvent?.({
+        kind: "unknown_type",
+        type: messageType || stream || "missing",
+    });
+    return currentText;
+}

package/dist/src/model-gateway/client-stream-parser.d.ts

@@ -0,0 +1 @@
+export { applyStreamLine, type StreamCallbacks, } from "./client/stream-parser.js";

package/dist/src/model-gateway/client-stream-parser.js

@@ -0,0 +1 @@
+export { applyStreamLine, } from "./client/stream-parser.js";

package/dist/src/model-gateway/client.d.ts

@@ -0,0 +1,19 @@
+import type { InvokeModelGatewayParams, InvokeRawModelGatewayParams, ModelGatewayClientOptions, ModelMetricMessage, RawModelGatewayResult, StreamMeta } from "./client/contracts.js";
+import { buildModelInvocationMetrics } from "./client/invocation-metrics.js";
+import { projectModelGatewayMetricMessages } from "./client/message-projection.js";
+import { getModelGatewayStreamInactivityTimeoutMs } from "./client/options.js";
+import { classifyEmptyResponse } from "./client/stream-consumer.js";
+import type { ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult } from "./types.js";
+export type { ModelGatewayClientOptions, ModelMetricMessage };
+export { buildModelInvocationMetrics, classifyEmptyResponse, getModelGatewayStreamInactivityTimeoutMs, projectModelGatewayMetricMessages, };
+export declare function invokeModelGateway(params: InvokeModelGatewayParams): Promise<{
+    text: string;
+    meta: StreamMeta;
+}>;
+export declare function countModelGatewayInputTokens(params: ModelGatewayInputTokenCountParams): Promise<ModelGatewayInputTokenCountResult | undefined>;
+export declare function invokeRawModelGateway(params: InvokeRawModelGatewayParams): Promise<RawModelGatewayResult>;
+export declare function createModelGatewayClient(options?: ModelGatewayClientOptions): {
+    invoke: typeof invokeModelGateway;
+    invokeRaw: typeof invokeRawModelGateway;
+    countInputTokens: typeof countModelGatewayInputTokens;
+};

package/dist/src/model-gateway/client.js

@@ -0,0 +1,25 @@
+import { invokeModelGatewayWithOptions } from "./client/chat.js";
+import { countModelGatewayInputTokensWithOptions, } from "./client/input-token-count.js";
+import { buildModelInvocationMetrics } from "./client/invocation-metrics.js";
+import { projectModelGatewayMetricMessages } from "./client/message-projection.js";
+import { getModelGatewayStreamInactivityTimeoutMs } from "./client/options.js";
+import { invokeRawModelGatewayWithOptions } from "./client/raw.js";
+import { classifyEmptyResponse } from "./client/stream-consumer.js";
+export { buildModelInvocationMetrics, classifyEmptyResponse, getModelGatewayStreamInactivityTimeoutMs, projectModelGatewayMetricMessages, };
+export async function invokeModelGateway(params) {
+    return invokeModelGatewayWithOptions(params);
+}
+export async function countModelGatewayInputTokens(params) {
+    return countModelGatewayInputTokensWithOptions(params);
+}
+export async function invokeRawModelGateway(params) {
+    return invokeRawModelGatewayWithOptions(params);
+}
+export function createModelGatewayClient(options = {}) {
+    const inputTokenCountCache = new Map();
+    return {
+        invoke: (params) => invokeModelGatewayWithOptions(params, options),
+        invokeRaw: (params) => invokeRawModelGatewayWithOptions(params, options),
+        countInputTokens: (params) => countModelGatewayInputTokensWithOptions(params, options, inputTokenCountCache),
+    };
+}

package/dist/src/model-gateway/index.d.ts

@@ -0,0 +1,3 @@
+export { createModelProviderAdapterRegistry, ModelProviderAdapterResolutionError, type ModelProviderAdapter, type ModelProviderAdapterRegistry, type ModelProviderChatInvocation, type ModelProviderEventSink, type ModelProviderInvocationError, type ModelProviderInputTokenCount, type ModelProviderInputTokenCountParams, type ModelProviderInputTokenCountResult, type ModelProviderInvocationParams, type ModelProviderInvocationResult, type ModelProviderRawInvocation, } from "./provider-adapter.js";
+export { createChatHandler, createInputTokenCountHandler, createModelGatewayServer, createRawHandler, type GatewayFetch, type GatewayResponse, type ModelGatewayHandlerOptions, } from "./server.js";
+export type { ModelContextConfig, ModelFormatTokenAccountingConfig, ModelGatewayPolicyConfig, ModelGatewayProviderConfig, ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult, ModelGatewayRequest, ModelProfile, ResolvedModelInvocation, } from "./types.js";

package/dist/src/model-gateway/index.js

@@ -0,0 +1,2 @@
+export { createModelProviderAdapterRegistry, ModelProviderAdapterResolutionError, } from "./provider-adapter.js";
+export { createChatHandler, createInputTokenCountHandler, createModelGatewayServer, createRawHandler, } from "./server.js";

package/dist/src/model-gateway/invocation-policy.d.ts

@@ -0,0 +1 @@
+export * from "./policy/invocation-policy.js";

package/dist/src/model-gateway/invocation-policy.js

@@ -0,0 +1 @@
+export * from "./policy/invocation-policy.js";

package/dist/src/model-gateway/invocation-profile-policy.d.ts

@@ -0,0 +1 @@
+export * from "./policy/invocation-profile-policy.js";

package/dist/src/model-gateway/invocation-profile-policy.js

@@ -0,0 +1 @@
+export * from "./policy/invocation-profile-policy.js";

package/dist/src/model-gateway/message-contract.d.ts

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

package/dist/src/model-gateway/message-contract.js

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

package/dist/src/model-gateway/model-io-trace.d.ts

@@ -0,0 +1,3 @@
+export { createContextWindowGuardedProviderFetch, ModelProviderContextWindowExceededError, ModelProviderEnvelopeInspectionError, } from "./observability/context-window-guard.js";
+export { fetchProviderWithTrace, type ProviderResponseDecoder, } from "./observability/provider-trace.js";
+export { configureModelIoTrace, ProcessModelIoTrace, processModelIoTrace, resetModelIoTraceConfig, traceModelIo, type ModelIoTraceConfig, type ModelIoTraceEvent, } from "./observability/trace-store.js";

package/dist/src/model-gateway/model-io-trace.js

@@ -0,0 +1,3 @@
+export { createContextWindowGuardedProviderFetch, ModelProviderContextWindowExceededError, ModelProviderEnvelopeInspectionError, } from "./observability/context-window-guard.js";
+export { fetchProviderWithTrace, } from "./observability/provider-trace.js";
+export { configureModelIoTrace, ProcessModelIoTrace, processModelIoTrace, resetModelIoTraceConfig, traceModelIo, } from "./observability/trace-store.js";

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

@@ -0,0 +1 @@
+export * from "./policy/model-registry.js";

package/dist/src/model-gateway/model-registry.js

@@ -0,0 +1 @@
+export * from "./policy/model-registry.js";

package/dist/src/model-gateway/observability/context-window-guard.d.ts

@@ -0,0 +1,27 @@
+import type { ModelProviderInputTokenMeasurement } from "../providers/contracts.js";
+import type { ModelGatewayRequest, ResolvedModelInvocation } from "../types.js";
+import { type ProviderTraceContext } from "./provider-trace-context.js";
+export declare class ModelProviderContextWindowExceededError extends Error {
+    readonly statusCode = 400;
+    readonly code = "model_context_window_exceeded";
+    constructor();
+}
+export declare class ModelProviderEnvelopeInspectionError extends Error {
+    readonly statusCode = 400;
+    readonly code = "model_provider_envelope_uninspectable";
+    constructor();
+}
+export declare function assertFinalProviderEnvelopeFits(params: {
+    context: ProviderTraceContext;
+    invocation: ResolvedModelInvocation;
+    payload: Record<string, unknown>;
+    inputTokenMeasurement?: ModelProviderInputTokenMeasurement;
+}): void;
+/** Guards the fetch capability supplied to every provider adapter. */
+export declare function createContextWindowGuardedProviderFetch(params: {
+    endpoint: "chat" | "raw";
+    requestBody: ModelGatewayRequest;
+    invocation: ResolvedModelInvocation;
+    fetchImpl: typeof fetch;
+    inputTokenMeasurement?: ModelProviderInputTokenMeasurement;
+}): typeof fetch;

package/dist/src/model-gateway/observability/context-window-guard.js

@@ -0,0 +1,81 @@
+import { traceDebug } from "../../runtime/observability/debug-logger.js";
+import { resolveProviderEnvelopeInputTokens } from "../providers/envelope-budget.js";
+import { createProviderTraceContext, } from "./provider-trace-context.js";
+export class ModelProviderContextWindowExceededError extends Error {
+    statusCode = 400;
+    code = "model_context_window_exceeded";
+    constructor() {
+        super("model_context_window_exceeded");
+        this.name = "ModelProviderContextWindowExceededError";
+    }
+}
+export class ModelProviderEnvelopeInspectionError extends Error {
+    statusCode = 400;
+    code = "model_provider_envelope_uninspectable";
+    constructor() {
+        super("model_provider_envelope_uninspectable");
+        this.name = "ModelProviderEnvelopeInspectionError";
+    }
+}
+function parseProviderFetchPayload(body) {
+    if (typeof body !== "string") {
+        throw new ModelProviderEnvelopeInspectionError();
+    }
+    try {
+        const decoded = JSON.parse(body);
+        const isObjectPayload = decoded !== null &&
+            typeof decoded === "object" &&
+            !Array.isArray(decoded);
+        if (isObjectPayload) {
+            return decoded;
+        }
+    }
+    catch {
+        // A provider dispatch without inspectable JSON cannot prove admission.
+    }
+    throw new ModelProviderEnvelopeInspectionError();
+}
+export function assertFinalProviderEnvelopeFits(params) {
+    const assessment = resolveProviderEnvelopeInputTokens({
+        payload: params.payload,
+        tokenEstimation: params.invocation.profile.context.tokenEstimation,
+        ...(params.inputTokenMeasurement
+            ? { measurement: params.inputTokenMeasurement }
+            : {}),
+    });
+    const contextWindowTokens = params.invocation.profile.contextWindowTokens;
+    const fitsContextWindow = assessment.inputTokens < contextWindowTokens;
+    traceDebug("model-gateway.server", "provider.envelope.assessed", {
+        ...params.context,
+        phase: "final_provider_envelope",
+        outcome: fitsContextWindow ? "accepted" : "rejected",
+        inputTokens: assessment.inputTokens,
+        measurement: assessment.measurement,
+        source: assessment.source,
+        measurementBinding: assessment.measurementBinding,
+        ...(assessment.measurement === "actual"
+            ? { measuredInputTokens: assessment.inputTokens }
+            : { estimatedInputTokens: assessment.inputTokens }),
+        contextWindowTokens,
+        remainingContextTokens: Math.max(0, contextWindowTokens - assessment.inputTokens),
+    });
+    if (!fitsContextWindow) {
+        throw new ModelProviderContextWindowExceededError();
+    }
+}
+/** Guards the fetch capability supplied to every provider adapter. */
+export function createContextWindowGuardedProviderFetch(params) {
+    const context = createProviderTraceContext(params);
+    return async (input, init) => {
+        const payload = parseProviderFetchPayload(init?.body);
+        assertFinalProviderEnvelopeFits({
+            context,
+            invocation: params.invocation,
+            payload,
+            ...(params.inputTokenMeasurement
+                ? { inputTokenMeasurement: params.inputTokenMeasurement }
+                : {}),
+        });
+        return params.fetchImpl(input, init);
+    };
+}

package/dist/src/model-gateway/observability/provider-trace-context.d.ts

@@ -0,0 +1,12 @@
+import type { ModelGatewayRequest, ResolvedModelInvocation } from "../types.js";
+import type { ModelIoTraceEvent } from "./trace-store.js";
+export type ProviderTraceContext = Pick<ModelIoTraceEvent, "invocationId" | "requestId" | "endpoint" | "modelStep" | "profileId" | "providerId" | "provider" | "model">;
+export declare function createProviderTraceContext(params: {
+    endpoint: "chat" | "raw";
+    requestBody: ModelGatewayRequest;
+    invocation: ResolvedModelInvocation;
+}): ProviderTraceContext;
+export declare function serializeProviderError(error: unknown): {
+    name: string;
+    message: string;
+};

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

@@ -0,0 +1,22 @@
+import { randomUUID } from "node:crypto";
+export function createProviderTraceContext(params) {
+    return {
+        invocationId: randomUUID(),
+        requestId: typeof params.requestBody.debugRequestId === "string"
+            ? params.requestBody.debugRequestId
+            : "",
+        endpoint: params.endpoint,
+        modelStep: typeof params.requestBody.modelStep === "string"
+            ? params.requestBody.modelStep
+            : "",
+        profileId: params.invocation.profile.id,
+        providerId: params.invocation.profile.providerId,
+        provider: params.invocation.profile.provider,
+        model: params.invocation.model,
+    };
+}
+export function serializeProviderError(error) {
+    return error instanceof Error
+        ? { name: error.name, message: error.message }
+        : { name: "Error", message: String(error) };
+}

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

@@ -0,0 +1,19 @@
+import type { ModelGatewayRequest, ResolvedModelInvocation } from "../types.js";
+export type ProviderResponseDecoder = (body: ReadableStream<Uint8Array>) => Promise<{
+    text: string;
+    thinking: string;
+    usage?: unknown;
+}>;
+export declare function fetchProviderWithTrace(params: {
+    endpoint: "chat" | "raw";
+    requestBody: ModelGatewayRequest;
+    invocation: ResolvedModelInvocation;
+    fetchImpl: typeof fetch;
+    url: string;
+    headers: Record<string, string>;
+    payload: Record<string, unknown>;
+    decodeResponse: ProviderResponseDecoder;
+}): Promise<{
+    response: Response;
+    responseTrace: Promise<void>;
+}>;

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

@@ -0,0 +1,90 @@
+import { createProviderTraceContext, serializeProviderError, } from "./provider-trace-context.js";
+import { isModelIoTraceEnabled, traceModelIo } from "./trace-store.js";
+function sanitizeProviderHeaders(headers) {
+    const credentialHeaders = new Set([
+        "authorization",
+        "proxy-authorization",
+        "x-api-key",
+    ]);
+    return Object.fromEntries(Object.entries(headers).filter(([name]) => !credentialHeaders.has(name.toLowerCase())));
+}
+async function decodeProviderResponse(response, decodeResponse) {
+    if (!response.body) {
+        return { decoded: { text: "", thinking: "" } };
+    }
+    try {
+        return { decoded: await decodeResponse(response.body) };
+    }
+    catch (error) {
+        return { decodeError: serializeProviderError(error) };
+    }
+}
+async function captureProviderResponse(context, response, decodeResponse) {
+    try {
+        const rawResponse = response.clone();
+        const decodedResponse = response.clone();
+        const [body, decodedCapture] = await Promise.all([
+            rawResponse.text(),
+            decodeProviderResponse(decodedResponse, decodeResponse),
+        ]);
+        await traceModelIo({
+            event: "provider.response",
+            ...context,
+            response: {
+                status: response.status,
+                statusText: response.statusText,
+                ...decodedCapture,
+                body,
+            },
+        });
+    }
+    catch (error) {
+        await traceModelIo({
+            event: "provider.failure",
+            ...context,
+            stage: "response.capture",
+            error: serializeProviderError(error),
+        });
+    }
+}
+export async function fetchProviderWithTrace(params) {
+    const traceEnabled = isModelIoTraceEnabled();
+    const context = createProviderTraceContext(params);
+    const serializedBody = JSON.stringify(params.payload);
+    if (traceEnabled) {
+        await traceModelIo({
+            event: "provider.request",
+            ...context,
+            request: {
+                url: params.url,
+                method: "POST",
+                headers: sanitizeProviderHeaders(params.headers),
+                body: params.payload,
+            },
+        });
+    }
+    try {
+        const response = await params.fetchImpl(params.url, {
+            method: "POST",
+            headers: params.headers,
+            body: serializedBody,
+        });
+        return {
+            response,
+            responseTrace: traceEnabled
+                ? captureProviderResponse(context, response, params.decodeResponse)
+                : Promise.resolve(),
+        };
+    }
+    catch (error) {
+        if (traceEnabled) {
+            await traceModelIo({
+                event: "provider.failure",
+                ...context,
+                stage: "request.fetch",
+                error: serializeProviderError(error),
+            });
+        }
+        throw error;
+    }
+}

package/dist/src/model-gateway/observability/trace-store.d.ts

@@ -0,0 +1,32 @@
+import type { RuntimeLogRotationConfig } from "../../runtime/ports.js";
+export type ModelIoTraceConfig = {
+    traceFile?: string;
+    enabled?: boolean;
+    rotation?: RuntimeLogRotationConfig;
+};
+export type ModelIoTraceEvent = {
+    event: "provider.request" | "provider.response" | "provider.failure";
+    invocationId: string;
+    requestId: string;
+    endpoint: "chat" | "raw";
+    modelStep: string;
+    profileId: string;
+    providerId: string;
+    provider: string;
+    model: string;
+    [key: string]: unknown;
+};
+/** Owns the gateway process trace configuration and serialized write queue. */
+export declare class ProcessModelIoTrace {
+    private config;
+    private writeQueue;
+    configure(config?: ModelIoTraceConfig): void;
+    reset(): void;
+    isEnabled(): boolean;
+    trace(event: ModelIoTraceEvent): Promise<void>;
+}
+export declare const processModelIoTrace: ProcessModelIoTrace;
+export declare function configureModelIoTrace(config?: ModelIoTraceConfig): void;
+export declare function resetModelIoTraceConfig(): void;
+export declare function isModelIoTraceEnabled(): boolean;
+export declare function traceModelIo(event: ModelIoTraceEvent): Promise<void>;

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

@@ -0,0 +1,74 @@
+import { DEFAULT_RUNTIME_LOGGING_ENABLED, DEFAULT_RUNTIME_LOG_ROTATION_CONFIG, } from "../../runtime/config/constants.js";
+import { appendTraceLineWithRotation, } from "../../runtime/observability/log-rotation.js";
+function warnCleanupFailure(warning) {
+    console.warn(JSON.stringify({
+        scope: "model-gateway.model-io-trace",
+        event: warning.event,
+        ts: new Date().toISOString(),
+        traceFile: warning.traceFile,
+        error: warning.error,
+        paths: warning.paths,
+    }));
+}
+function reportWriteFailure(error) {
+    console.error(JSON.stringify({
+        scope: "model-gateway.model-io-trace",
+        event: "write.failed",
+        ts: new Date().toISOString(),
+        error: error instanceof Error ? error.message : String(error),
+    }));
+}
+/** Owns the gateway process trace configuration and serialized write queue. */
+export class ProcessModelIoTrace {
+    config = {};
+    writeQueue = Promise.resolve();
+    configure(config = {}) {
+        this.config = { ...this.config, ...config };
+    }
+    reset() {
+        this.config = {};
+        this.writeQueue = Promise.resolve();
+    }
+    isEnabled() {
+        const enabled = this.config.enabled ?? DEFAULT_RUNTIME_LOGGING_ENABLED;
+        return enabled && Boolean(this.config.traceFile);
+    }
+    async trace(event) {
+        const traceFile = this.config.traceFile;
+        if (!this.isEnabled() || !traceFile) {
+            return;
+        }
+        const line = JSON.stringify({
+            version: 1,
+            ts: new Date().toISOString(),
+            ...event,
+        });
+        this.writeQueue = this.writeQueue
+            .catch(() => undefined)
+            .then(() => appendTraceLineWithRotation({
+            traceFile,
+            line,
+            rotation: this.config.rotation ?? DEFAULT_RUNTIME_LOG_ROTATION_CONFIG,
+            onWarning: warnCleanupFailure,
+        }));
+        try {
+            await this.writeQueue;
+        }
+        catch (error) {
+            reportWriteFailure(error);
+        }
+    }
+}
+export const processModelIoTrace = new ProcessModelIoTrace();
+export function configureModelIoTrace(config = {}) {
+    processModelIoTrace.configure(config);
+}
+export function resetModelIoTraceConfig() {
+    processModelIoTrace.reset();
+}
+export function isModelIoTraceEnabled() {
+    return processModelIoTrace.isEnabled();
+}
+export async function traceModelIo(event) {
+    return processModelIoTrace.trace(event);
+}

package/dist/src/model-gateway/policy/invocation-policy.d.ts

@@ -0,0 +1,11 @@
+import type { ModelReasoningLevel } from "../../shared/types.js";
+import type { ModelGatewayRequest, ResolvedModelInvocation } from "../types.js";
+export type ModelInvocationResolutionErrorCode = "invalid_model_preference" | "model_profile_required" | "unknown_model_profile";
+export declare class ModelInvocationResolutionError extends Error {
+    readonly code: ModelInvocationResolutionErrorCode;
+    readonly statusCode = 400;
+    constructor(code: ModelInvocationResolutionErrorCode, detail: string);
+}
+export declare function resolveThink(agentMode: unknown): ModelReasoningLevel;
+export declare function normalizeReasoning(value: unknown): ModelReasoningLevel | undefined;
+export declare function resolveModelInvocation(requestBody: ModelGatewayRequest): ResolvedModelInvocation;