@abot-ai/runtime 1.0.0

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

@@ -0,0 +1,178 @@
+import { normalizeModelPreference, resolveClientPreferenceProfile, resolveConfiguredInvocationProfile, resolveProfileById, } from "./invocation-profile-policy.js";
+export class ModelInvocationResolutionError extends Error {
+    code;
+    statusCode = 400;
+    constructor(code, detail) {
+        super(`${code}: ${detail}`);
+        this.code = code;
+        this.name = "ModelInvocationResolutionError";
+    }
+}
+export function resolveThink(agentMode) {
+    const mode = String(agentMode || "reasoning").toLowerCase();
+    if (mode === "deep")
+        return "high";
+    if (mode === "fast")
+        return "none";
+    return "medium";
+}
+export function normalizeReasoning(value) {
+    const normalized = String(value || "")
+        .trim()
+        .toLowerCase();
+    if (normalized === "none")
+        return "none";
+    if (normalized === "minimal")
+        return "minimal";
+    if (normalized === "low")
+        return "low";
+    if (normalized === "medium")
+        return "medium";
+    if (normalized === "high")
+        return "high";
+    if (normalized === "xhigh")
+        return "xhigh";
+    return undefined;
+}
+function applyInvocationProfileOverlay(candidate) {
+    const overlay = candidate.invocationProfile;
+    if (!overlay) {
+        return candidate.profile;
+    }
+    return {
+        ...candidate.profile,
+        generation: {
+            ...candidate.profile.generation,
+            ...(overlay.generation ?? {}),
+        },
+        context: {
+            ...candidate.profile.context,
+            ...(overlay.context ?? {}),
+        },
+    };
+}
+function resolveModelStepCalibrationSlot(params) {
+    const step = typeof params.modelStep === "string" ? params.modelStep.trim() : "";
+    const mapped = step ? params.modelPolicy?.defaults?.steps?.[step] : undefined;
+    if (!mapped) {
+        return undefined;
+    }
+    if (params.modelPolicy?.invocationProfiles?.[mapped] ||
+        resolveProfileById(mapped, params.modelPolicy)) {
+        return undefined;
+    }
+    return mapped;
+}
+function applyModelStepCalibration(params) {
+    if (!params.slotId) {
+        return { profile: params.profile };
+    }
+    const calibration = params.profile.calibration?.[params.slotId];
+    if (!calibration) {
+        return { profile: params.profile };
+    }
+    const targetProfileId = calibration.profileId?.trim();
+    const targetProfile = targetProfileId
+        ? resolveProfileById(targetProfileId, params.modelPolicy)
+        : params.profile;
+    if (!targetProfile) {
+        throw new ModelInvocationResolutionError("unknown_model_profile", `calibration ${params.slotId} references unavailable profile ${targetProfileId}`);
+    }
+    const invocationProfile = {
+        profileId: targetProfile.id,
+        ...(calibration.generation ? { generation: calibration.generation } : {}),
+        ...(calibration.context ? { context: calibration.context } : {}),
+        ...((calibration.format ?? params.fallbackFormat)
+            ? { format: calibration.format ?? params.fallbackFormat }
+            : {}),
+    };
+    return {
+        profile: applyInvocationProfileOverlay({
+            profileId: targetProfile.id,
+            profile: targetProfile,
+            source: "modelStep",
+            invocationProfileId: params.slotId,
+            invocationProfile,
+        }),
+        invocationProfile,
+        ...(calibration.instructions && calibration.instructions.length > 0
+            ? { instructions: calibration.instructions }
+            : {}),
+    };
+}
+function validateExplicitModelPreference(requestBody) {
+    if (requestBody.modelPreference === undefined) {
+        return;
+    }
+    const normalized = normalizeModelPreference(requestBody.modelPreference, requestBody.modelPolicy);
+    if (normalized) {
+        return;
+    }
+    const rawProfileId = requestBody.modelPreference &&
+        typeof requestBody.modelPreference === "object" &&
+        !Array.isArray(requestBody.modelPreference) &&
+        typeof requestBody.modelPreference
+            .profileId === "string"
+        ? requestBody.modelPreference.profileId.trim()
+        : "";
+    if (rawProfileId) {
+        throw new ModelInvocationResolutionError("unknown_model_profile", `requested profile ${rawProfileId} is not available in model policy`);
+    }
+    throw new ModelInvocationResolutionError("invalid_model_preference", "modelPreference.profileId must identify a configured profile");
+}
+export function resolveModelInvocation(requestBody) {
+    validateExplicitModelPreference(requestBody);
+    const overrideModel = typeof requestBody?.modelOverride === "string" &&
+        requestBody.modelOverride.trim().length > 0
+        ? requestBody.modelOverride.trim()
+        : "";
+    const configuredProfile = resolveConfiguredInvocationProfile({
+        taskType: typeof requestBody?.taskType === "string" ? requestBody.taskType : "",
+        modelStep: requestBody?.modelStep,
+        modelPolicy: requestBody?.modelPolicy,
+        includeStepFallback: true,
+    });
+    const clientPreferenceProfile = resolveClientPreferenceProfile({
+        modelPreference: requestBody?.modelPreference,
+        modelPolicy: requestBody?.modelPolicy,
+        modelStep: requestBody?.modelStep,
+    });
+    const configOverridesClient = requestBody?.modelPolicy?.defaults?.overrideClientPreference === true;
+    const selectedCandidate = configOverridesClient
+        ? (configuredProfile ?? clientPreferenceProfile)
+        : (clientPreferenceProfile ?? configuredProfile);
+    if (!selectedCandidate) {
+        const configuredDefault = requestBody.modelPolicy?.defaults?.profileId?.trim();
+        throw new ModelInvocationResolutionError("model_profile_required", configuredDefault
+            ? `effective profile ${configuredDefault} is not available in model policy`
+            : "model policy must resolve an effective configured profile");
+    }
+    const baseProfile = applyInvocationProfileOverlay(selectedCandidate);
+    const calibration = applyModelStepCalibration({
+        profile: baseProfile,
+        slotId: resolveModelStepCalibrationSlot({
+            modelPolicy: requestBody?.modelPolicy,
+            modelStep: requestBody?.modelStep,
+        }),
+        modelPolicy: requestBody?.modelPolicy,
+        fallbackFormat: selectedCandidate.invocationProfile?.format,
+    });
+    const profile = overrideModel.length > 0
+        ? { ...calibration.profile, model: overrideModel }
+        : calibration.profile;
+    const selectedInvocationProfile = calibration.invocationProfile ?? selectedCandidate.invocationProfile;
+    const think = normalizeReasoning(requestBody?.reasoningOverride) ??
+        profile.generation.reasoningEffort ??
+        resolveThink(requestBody?.agentMode);
+    return {
+        model: profile.model,
+        profile,
+        think: profile.supportsThinking ? think : undefined,
+        ...(selectedInvocationProfile?.format
+            ? { format: selectedInvocationProfile.format }
+            : {}),
+        ...(calibration.instructions
+            ? { instructions: calibration.instructions }
+            : {}),
+    };
+}

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

@@ -0,0 +1,25 @@
+import type { ModelStep } from "../../shared/types.js";
+import { normalizeProfileId, type InvocationProfileCandidate as SharedInvocationProfileCandidate, type InvocationProfileSource } from "../../shared/invocation-profile-selection.js";
+import type { ModelGatewayPolicyConfig, ModelPreference, ModelProfile } from "../types.js";
+export { normalizeProfileId, type InvocationProfileSource };
+export type InvocationProfileCandidate = SharedInvocationProfileCandidate<ModelProfile>;
+export declare function resolveProfileById(profileId: unknown, policy?: ModelGatewayPolicyConfig): ModelProfile | undefined;
+export declare function normalizeModelPreference(value: unknown, policy?: ModelGatewayPolicyConfig): ModelPreference | undefined;
+export declare function resolveClientPreferenceProfile(params: {
+    modelPreference?: unknown;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    modelStep?: ModelStep | string;
+}): InvocationProfileCandidate | undefined;
+export declare function resolveConfiguredInvocationProfile(params: {
+    taskType?: string;
+    modelStep?: ModelStep | string;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    includeStepFallback?: boolean;
+}): InvocationProfileCandidate | undefined;
+export declare function resolveEffectiveInvocationProfile(params: {
+    taskType?: string;
+    modelStep?: ModelStep | string;
+    modelPreference?: unknown;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    includeStepFallback?: boolean;
+}): InvocationProfileCandidate | undefined;

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

@@ -0,0 +1,28 @@
+import { normalizeModelPreference as normalizeSharedModelPreference, normalizeProfileId, resolveClientPreferenceProfile as resolveSharedClientPreferenceProfile, resolveConfiguredInvocationProfile as resolveSharedConfiguredInvocationProfile, resolveEffectiveInvocationProfile as resolveSharedEffectiveInvocationProfile, } from "../../shared/invocation-profile-selection.js";
+import { getModelProfile } from "./model-registry.js";
+export { normalizeProfileId };
+export function resolveProfileById(profileId, policy) {
+    const normalized = normalizeProfileId(profileId);
+    return normalized ? getModelProfile(normalized, policy) : undefined;
+}
+export function normalizeModelPreference(value, policy) {
+    return normalizeSharedModelPreference(value, policy, getModelProfile);
+}
+export function resolveClientPreferenceProfile(params) {
+    return resolveSharedClientPreferenceProfile({
+        ...params,
+        resolveProfile: getModelProfile,
+    });
+}
+export function resolveConfiguredInvocationProfile(params) {
+    return resolveSharedConfiguredInvocationProfile({
+        ...params,
+        resolveProfile: getModelProfile,
+    });
+}
+export function resolveEffectiveInvocationProfile(params) {
+    return resolveSharedEffectiveInvocationProfile({
+        ...params,
+        resolveProfile: getModelProfile,
+    });
+}

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

@@ -0,0 +1,9 @@
+import type { ModelContextConfig, ModelGatewayPolicyConfig, ModelProfile } from "../types.js";
+export declare function getModelProfile(profileId: string, policy?: ModelGatewayPolicyConfig): ModelProfile | undefined;
+export declare function listModelProfiles(policy?: ModelGatewayPolicyConfig): ModelProfile[];
+export declare function resolveModelContextConfig(params: {
+    agentMode?: unknown;
+    taskType?: string;
+    modelPreference?: unknown;
+    modelPolicy?: ModelGatewayPolicyConfig;
+}): ModelContextConfig;

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

@@ -0,0 +1,164 @@
+const TEXT_MODEL_CAPABILITIES = {
+    inputModalities: ["text"],
+    outputModalities: ["text"],
+};
+function normalizeConfiguredProfile(profileId, config, policy) {
+    const model = config.model.trim();
+    if (model.length === 0) {
+        return undefined;
+    }
+    const providerId = config.provider?.trim();
+    if (!providerId) {
+        return undefined;
+    }
+    const providerConfig = policy?.providers?.[providerId];
+    if (!providerConfig) {
+        return undefined;
+    }
+    const declaredContextWindowTokens = normalizePositiveInteger(config.contextWindowTokens);
+    if (declaredContextWindowTokens === undefined) {
+        return undefined;
+    }
+    const providerAllocatedContextWindowTokens = providerConfig.type === "ollama"
+        ? normalizePositiveInteger(config.options?.num_ctx)
+        : undefined;
+    const contextWindowTokens = Math.min(declaredContextWindowTokens, providerAllocatedContextWindowTokens ?? declaredContextWindowTokens);
+    const context = mergeContextConfig(policy?.defaults?.context, config.context);
+    const generation = mergeGenerationConfig(config.generation);
+    const capabilities = mergeProfileCapabilities(config.capabilities);
+    return {
+        id: profileId,
+        label: config.label?.trim() || profileId,
+        providerId,
+        provider: providerConfig.type,
+        providerConfig,
+        model,
+        contextWindowTokens,
+        supportsThinking: config.supportsThinking === true,
+        options: config.options ?? {},
+        generation,
+        context,
+        capabilities,
+        ...(config.calibration ? { calibration: config.calibration } : {}),
+    };
+}
+function normalizeModalities(values, fallback) {
+    if (!Array.isArray(values)) {
+        return [...fallback];
+    }
+    const modalities = values.filter((value) => value === "text" || value === "image" || value === "audio");
+    return modalities.length > 0 ? [...new Set(modalities)] : [...fallback];
+}
+function mergeProfileCapabilities(config) {
+    return {
+        inputModalities: normalizeModalities(config?.inputModalities, TEXT_MODEL_CAPABILITIES.inputModalities),
+        outputModalities: normalizeModalities(config?.outputModalities, TEXT_MODEL_CAPABILITIES.outputModalities),
+    };
+}
+function mergeGenerationConfig(...configs) {
+    return Object.assign({}, ...configs.filter(Boolean));
+}
+function mergeContextConfig(...configs) {
+    return Object.assign({}, ...configs.filter(Boolean));
+}
+function buildProfileMap(policy) {
+    const profiles = {};
+    for (const [profileId, config] of Object.entries(policy?.profiles ?? {})) {
+        const normalized = normalizeConfiguredProfile(profileId, config, policy);
+        if (normalized) {
+            profiles[profileId] = normalized;
+        }
+    }
+    return profiles;
+}
+export function getModelProfile(profileId, policy) {
+    return buildProfileMap(policy)[profileId];
+}
+export function listModelProfiles(policy) {
+    return Object.values(buildProfileMap(policy));
+}
+function normalizePositiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0
+        ? value
+        : undefined;
+}
+function normalizePositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? value
+        : undefined;
+}
+function normalizeNonNegativeInteger(value) {
+    return typeof value === "number" &&
+        Number.isFinite(value) &&
+        value >= 0 &&
+        Number.isInteger(value)
+        ? value
+        : undefined;
+}
+export function resolveModelContextConfig(params) {
+    const preferredProfileId = readPreferredProfileId(params.modelPreference);
+    const profileId = preferredProfileId ?? params.modelPolicy?.defaults?.profileId;
+    const profile = profileId
+        ? getModelProfile(profileId, params.modelPolicy)
+        : undefined;
+    const defaults = params.modelPolicy?.defaults?.context ?? {};
+    return normalizeContextConfig({
+        ...defaults,
+        ...(profile?.context ?? {}),
+    });
+}
+function readPreferredProfileId(modelPreference) {
+    const isPreferenceObject = modelPreference !== null &&
+        typeof modelPreference === "object" &&
+        !Array.isArray(modelPreference);
+    if (!isPreferenceObject) {
+        return undefined;
+    }
+    const profileId = modelPreference.profileId;
+    return typeof profileId === "string" ? profileId : undefined;
+}
+function normalizeFormatTokenAccounting(formatTokenAccounting) {
+    const hasSupportedMode = formatTokenAccounting?.mode === "none" ||
+        formatTokenAccounting?.mode === "estimate";
+    if (!hasSupportedMode) {
+        return undefined;
+    }
+    const normalizedFixedFormatOverheadTokens = normalizeNonNegativeInteger(formatTokenAccounting?.fixedOverheadTokens);
+    return {
+        mode: formatTokenAccounting.mode,
+        ...(normalizedFixedFormatOverheadTokens !== undefined
+            ? { fixedOverheadTokens: normalizedFixedFormatOverheadTokens }
+            : {}),
+    };
+}
+function normalizeTokenEstimation(tokenEstimation) {
+    if (!tokenEstimation) {
+        return undefined;
+    }
+    const normalized = {};
+    const asciiCharactersPerToken = normalizePositiveNumber(tokenEstimation.asciiCharactersPerToken);
+    const nonAsciiBytesPerToken = normalizePositiveNumber(tokenEstimation.nonAsciiBytesPerToken);
+    const messageOverheadTokens = normalizePositiveNumber(tokenEstimation.messageOverheadTokens);
+    if (asciiCharactersPerToken !== undefined) {
+        normalized.asciiCharactersPerToken = asciiCharactersPerToken;
+    }
+    if (nonAsciiBytesPerToken !== undefined) {
+        normalized.nonAsciiBytesPerToken = nonAsciiBytesPerToken;
+    }
+    if (messageOverheadTokens !== undefined) {
+        normalized.messageOverheadTokens = messageOverheadTokens;
+    }
+    return normalized;
+}
+function normalizeContextConfig(context) {
+    const normalized = {};
+    const formatTokenAccounting = normalizeFormatTokenAccounting(context.formatTokenAccounting);
+    const tokenEstimation = normalizeTokenEstimation(context.tokenEstimation);
+    if (formatTokenAccounting) {
+        normalized.formatTokenAccounting = formatTokenAccounting;
+    }
+    if (tokenEstimation) {
+        normalized.tokenEstimation = tokenEstimation;
+    }
+    return normalized;
+}

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

@@ -0,0 +1,15 @@
+import type { ChatAssistantToolCallMessage, ChatTextMessage, ChatToolResultMessage, ModelGatewayToolCall } from "../types.js";
+export declare class ModelGatewayMessageValidationError extends Error {
+    constructor(code: string);
+}
+export declare function isModelGatewayToolCall(value: unknown): value is ModelGatewayToolCall;
+export declare function isAssistantToolCallMessage(value: unknown): value is ChatAssistantToolCallMessage;
+export declare function isToolResultMessage(value: unknown): value is ChatToolResultMessage;
+export declare function isTextChatMessage(value: unknown): value is ChatTextMessage;
+export declare function hasModelGatewayToolInteractionLane(value: unknown): boolean;
+/**
+ * Enforces the native tool-call continuation protocol whenever any tool-lane
+ * marker is present. Text-only arrays intentionally keep their legacy,
+ * permissive normalization behavior in the client and provider projectors.
+ */
+export declare function validateModelGatewayMessages(value: unknown): void;

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

@@ -0,0 +1,181 @@
+const MODEL_GATEWAY_TOOL_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+const TEXT_MESSAGE_KEYS = new Set(["role", "content", "attachments"]);
+const TOOL_CALL_MESSAGE_KEYS = new Set(["role", "content", "toolCalls"]);
+const TOOL_CALL_KEYS = new Set(["callId", "name", "arguments"]);
+const TOOL_RESULT_MESSAGE_KEYS = new Set([
+    "role",
+    "content",
+    "toolCallId",
+    "toolName",
+]);
+const ATTACHMENT_KEYS = new Set([
+    "id",
+    "kind",
+    "mimeType",
+    "storageRef",
+    "name",
+    "size",
+    "data",
+]);
+export class ModelGatewayMessageValidationError extends Error {
+    constructor(code) {
+        super(code);
+        this.name = "ModelGatewayMessageValidationError";
+    }
+}
+function fail(code) {
+    throw new ModelGatewayMessageValidationError(code);
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowedKeys) {
+    return Object.keys(value).every((key) => allowedKeys.has(key));
+}
+function isJsonObjectString(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed);
+    }
+    catch {
+        return false;
+    }
+}
+function isStrictAttachment(value) {
+    if (!isRecord(value) || !hasOnlyKeys(value, ATTACHMENT_KEYS)) {
+        return false;
+    }
+    return (typeof value.id === "string" &&
+        value.id.trim().length > 0 &&
+        value.kind === "image" &&
+        typeof value.mimeType === "string" &&
+        value.mimeType.trim().length > 0 &&
+        typeof value.storageRef === "string" &&
+        value.storageRef.trim().length > 0 &&
+        (value.name === undefined || typeof value.name === "string") &&
+        (value.size === undefined ||
+            (typeof value.size === "number" &&
+                Number.isFinite(value.size) &&
+                value.size >= 0)) &&
+        (value.data === undefined || typeof value.data === "string"));
+}
+export function isModelGatewayToolCall(value) {
+    if (!isRecord(value) || !hasOnlyKeys(value, TOOL_CALL_KEYS)) {
+        return false;
+    }
+    return (typeof value.callId === "string" &&
+        value.callId.trim().length > 0 &&
+        typeof value.name === "string" &&
+        MODEL_GATEWAY_TOOL_NAME_PATTERN.test(value.name) &&
+        typeof value.arguments === "string" &&
+        isJsonObjectString(value.arguments));
+}
+export function isAssistantToolCallMessage(value) {
+    if (!isRecord(value) || !hasOnlyKeys(value, TOOL_CALL_MESSAGE_KEYS)) {
+        return false;
+    }
+    return (value.role === "assistant" &&
+        value.content === "" &&
+        Array.isArray(value.toolCalls) &&
+        value.toolCalls.length > 0 &&
+        value.toolCalls.every(isModelGatewayToolCall));
+}
+export function isToolResultMessage(value) {
+    if (!isRecord(value) || !hasOnlyKeys(value, TOOL_RESULT_MESSAGE_KEYS)) {
+        return false;
+    }
+    return (value.role === "tool" &&
+        typeof value.content === "string" &&
+        typeof value.toolCallId === "string" &&
+        value.toolCallId.trim().length > 0 &&
+        typeof value.toolName === "string" &&
+        MODEL_GATEWAY_TOOL_NAME_PATTERN.test(value.toolName));
+}
+export function isTextChatMessage(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return ((value.role === "system" ||
+        value.role === "user" ||
+        value.role === "assistant") &&
+        typeof value.content === "string" &&
+        !Object.prototype.hasOwnProperty.call(value, "toolCalls"));
+}
+function isStrictTextChatMessage(value) {
+    if (!isRecord(value) ||
+        !hasOnlyKeys(value, TEXT_MESSAGE_KEYS) ||
+        !isTextChatMessage(value)) {
+        return false;
+    }
+    return (value.attachments === undefined ||
+        (Array.isArray(value.attachments) &&
+            value.attachments.every(isStrictAttachment)));
+}
+export function hasModelGatewayToolInteractionLane(value) {
+    const hasMarker = (message) => isRecord(message) &&
+        (message.role === "tool" ||
+            Object.prototype.hasOwnProperty.call(message, "toolCalls"));
+    return Array.isArray(value) ? value.some(hasMarker) : hasMarker(value);
+}
+/**
+ * Enforces the native tool-call continuation protocol whenever any tool-lane
+ * marker is present. Text-only arrays intentionally keep their legacy,
+ * permissive normalization behavior in the client and provider projectors.
+ */
+export function validateModelGatewayMessages(value) {
+    if (!hasModelGatewayToolInteractionLane(value)) {
+        return;
+    }
+    if (!Array.isArray(value)) {
+        fail("model_gateway_tool_interaction_invalid");
+    }
+    const messages = value.map((message) => {
+        if (isAssistantToolCallMessage(message)) {
+            return message;
+        }
+        if (isToolResultMessage(message)) {
+            return message;
+        }
+        if (isStrictTextChatMessage(message)) {
+            return message;
+        }
+        return fail("model_gateway_tool_interaction_invalid");
+    });
+    const seenCallIds = new Set();
+    const settledCallIds = new Set();
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (isAssistantToolCallMessage(message)) {
+            for (const call of message.toolCalls) {
+                if (seenCallIds.has(call.callId)) {
+                    fail("model_gateway_tool_call_id_duplicate");
+                }
+                seenCallIds.add(call.callId);
+            }
+            for (const [resultOffset, call] of message.toolCalls.entries()) {
+                const result = messages[index + resultOffset + 1];
+                if (!result) {
+                    fail("model_gateway_tool_result_missing");
+                }
+                if (!isToolResultMessage(result)) {
+                    fail("model_gateway_tool_result_order_invalid");
+                }
+                if (result.toolCallId !== call.callId) {
+                    fail("model_gateway_tool_result_order_invalid");
+                }
+                if (result.toolName !== call.name) {
+                    fail("model_gateway_tool_result_name_mismatch");
+                }
+                settledCallIds.add(call.callId);
+            }
+            index += message.toolCalls.length;
+            continue;
+        }
+        if (isToolResultMessage(message)) {
+            if (settledCallIds.has(message.toolCallId)) {
+                fail("model_gateway_tool_result_duplicate");
+            }
+            fail("model_gateway_tool_result_unmatched");
+        }
+    }
+}

package/dist/src/model-gateway/protocol/usage.d.ts

@@ -0,0 +1,9 @@
+import type { ModelTokenUsage } from "../types.js";
+export declare function buildModelTokenUsage(params: {
+    inputTokens: unknown;
+    outputTokens: unknown;
+    totalTokens?: unknown;
+    cachedInputTokens?: unknown;
+    reasoningTokens?: unknown;
+}): ModelTokenUsage | undefined;
+export declare function normalizeModelTokenUsage(value: unknown): ModelTokenUsage | undefined;

package/dist/src/model-gateway/protocol/usage.js

@@ -0,0 +1,39 @@
+function readNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? Math.trunc(value)
+        : undefined;
+}
+export function buildModelTokenUsage(params) {
+    const inputTokens = readNonNegativeInteger(params.inputTokens);
+    const outputTokens = readNonNegativeInteger(params.outputTokens);
+    if (inputTokens === undefined || outputTokens === undefined) {
+        return undefined;
+    }
+    const reportedTotal = readNonNegativeInteger(params.totalTokens);
+    const cachedInputTokens = readNonNegativeInteger(params.cachedInputTokens);
+    const reasoningTokens = readNonNegativeInteger(params.reasoningTokens);
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: reportedTotal ?? inputTokens + outputTokens,
+        ...(cachedInputTokens !== undefined && cachedInputTokens <= inputTokens
+            ? { cachedInputTokens }
+            : {}),
+        ...(reasoningTokens !== undefined && reasoningTokens <= outputTokens
+            ? { reasoningTokens }
+            : {}),
+    };
+}
+export function normalizeModelTokenUsage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const usage = value;
+    return buildModelTokenUsage({
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens,
+        cachedInputTokens: usage.cachedInputTokens,
+        reasoningTokens: usage.reasoningTokens,
+    });
+}

package/dist/src/model-gateway/provider-adapter.d.ts

@@ -0,0 +1 @@
+export * from "./providers/contracts.js";

package/dist/src/model-gateway/provider-adapter.js

@@ -0,0 +1 @@
+export * from "./providers/contracts.js";

package/dist/src/model-gateway/provider-envelope-budget.d.ts

@@ -0,0 +1 @@
+export * from "./providers/envelope-budget.js";

package/dist/src/model-gateway/provider-envelope-budget.js

@@ -0,0 +1 @@
+export * from "./providers/envelope-budget.js";