@mupt-ai/dari-gateway 0.2.0 → 0.3.0

package/dist/interaction/capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { HardCapability } from "@mupt-ai/dari-router/policy-engine";
+import type { InteractionRequest } from "./types.js";
+export declare function requiredCapabilitiesFor(request: Pick<InteractionRequest, "items" | "responseFormat" | "toolChoice" | "tools">): HardCapability[];

package/dist/interaction/capabilities.js

@@ -0,0 +1,24 @@
+export function requiredCapabilitiesFor(request) {
+    const capabilities = new Set();
+    if (request.items.some(itemHasImage))
+        capabilities.add("image_input");
+    if (request.items.some((item) => item.type === "reasoning_configuration")) {
+        capabilities.add("reasoning_configuration_update");
+    }
+    if (request.responseFormat !== undefined && request.responseFormat.type !== "text")
+        capabilities.add("structured_output");
+    if (request.tools.some((tool) => tool.kind === "hosted")
+        || request.items.some(requiresWebSearch)
+        || (typeof request.toolChoice === "object" && request.toolChoice.kind === "hosted")) {
+        capabilities.add("openai_hosted_web_search");
+    }
+    return [...capabilities];
+}
+function requiresWebSearch(item) {
+    return item.type === "hosted_tool_call" && item.tool === "web_search";
+}
+function itemHasImage(item) {
+    if (item.type === "message")
+        return item.content.some((part) => part.type === "image");
+    return item.type === "tool_result" && Array.isArray(item.output) && item.output.some((part) => part.type === "image");
+}

package/dist/interaction/image.d.ts

@@ -0,0 +1,4 @@
+export declare function parseDataImageUrl(url: string): {
+    mimeType: string;
+    data: string;
+} | undefined;

package/dist/interaction/image.js

@@ -0,0 +1,13 @@
+export function parseDataImageUrl(url) {
+    const commaIndex = url.indexOf(",");
+    if (!url.startsWith("data:") || commaIndex === -1)
+        return undefined;
+    const header = url.slice(5, commaIndex);
+    const segments = header.split(";");
+    const mimeType = segments.shift();
+    const data = url.slice(commaIndex + 1);
+    if (!mimeType?.toLowerCase().startsWith("image/") || segments.at(-1)?.toLowerCase() !== "base64" || !data) {
+        return undefined;
+    }
+    return { mimeType, data };
+}

package/dist/interaction/portable_reasoning_state.d.ts

@@ -0,0 +1,4 @@
+import { type PortableReasoningState } from "@mupt-ai/dari-router/protocols";
+export type { PortableReasoningState } from "@mupt-ai/dari-router/protocols";
+export declare function encodePortableReasoningState(state: PortableReasoningState): string;
+export declare function decodeUntrustedPortableReasoningState(value: string): PortableReasoningState | null;

package/dist/interaction/portable_reasoning_state.js

@@ -0,0 +1,18 @@
+import { decodeUntrustedPortableReasoningState as coreDecode, encodePortableReasoningState as coreEncode, } from "@mupt-ai/dari-router/protocols";
+import { rethrowFrameworkErrorAsHttp } from "../http/errors.js";
+export function encodePortableReasoningState(state) {
+    try {
+        return coreEncode(state);
+    }
+    catch (error) {
+        rethrowFrameworkErrorAsHttp(error, 500);
+    }
+}
+export function decodeUntrustedPortableReasoningState(value) {
+    try {
+        return coreDecode(value);
+    }
+    catch (error) {
+        rethrowFrameworkErrorAsHttp(error, 400);
+    }
+}

package/dist/interaction/provider_continuation_state.d.ts

@@ -0,0 +1,6 @@
+import { type ProviderContinuationState, type ProviderIdentity } from "@mupt-ai/dari-router/protocols";
+export type { ProviderContinuationState, ProviderIdentity } from "@mupt-ai/dari-router/protocols";
+export { compatibleProviderContinuation, isAnthropicEffort, sameProviderIdentity } from "@mupt-ai/dari-router/protocols";
+export declare function encodeProviderContinuationState(value: ProviderContinuationState): string;
+export declare function decodeUntrustedProviderContinuationState(value: string): ProviderContinuationState | null;
+export declare function providerIdentityFromModel(model: Record<string, unknown>): ProviderIdentity;

package/dist/interaction/provider_continuation_state.js

@@ -0,0 +1,27 @@
+import { decodeUntrustedProviderContinuationState as coreDecode, encodeProviderContinuationState as coreEncode, providerIdentityFromModel as coreProviderIdentityFromModel, } from "@mupt-ai/dari-router/protocols";
+import { rethrowFrameworkErrorAsHttp } from "../http/errors.js";
+export { compatibleProviderContinuation, isAnthropicEffort, sameProviderIdentity } from "@mupt-ai/dari-router/protocols";
+export function encodeProviderContinuationState(value) {
+    try {
+        return coreEncode(value);
+    }
+    catch (error) {
+        rethrowFrameworkErrorAsHttp(error, 500);
+    }
+}
+export function decodeUntrustedProviderContinuationState(value) {
+    try {
+        return coreDecode(value);
+    }
+    catch (error) {
+        rethrowFrameworkErrorAsHttp(error, 400);
+    }
+}
+export function providerIdentityFromModel(model) {
+    try {
+        return coreProviderIdentityFromModel(model);
+    }
+    catch (error) {
+        rethrowFrameworkErrorAsHttp(error, 502);
+    }
+}

package/dist/interaction/tool_identity.d.ts

@@ -0,0 +1,10 @@
+import type { InteractionTool, ProviderIdentity } from "./types.js";
+export declare const TOOL_CALL_ID_MAX_LENGTH = 512;
+export declare function isProtocolToolCallId(value: unknown): value is string;
+export declare function toolWireName(namespace: string | undefined, name: string): string;
+export declare function toolsByWireName(tools: InteractionTool[]): Map<string, InteractionTool>;
+export declare function providerToolCallId(callId: string, itemId: string | undefined, providerApi: string | null): string;
+export declare function providerToolCallIdentity(id: string, source: ProviderIdentity): {
+    callId: string;
+    itemId?: string;
+};

package/dist/interaction/tool_identity.js

@@ -0,0 +1,41 @@
+import { HttpError } from "../http/errors.js";
+export const TOOL_CALL_ID_MAX_LENGTH = 512;
+export function isProtocolToolCallId(value) {
+    return (typeof value === "string" &&
+        value.trim().length > 0 &&
+        value.length <= TOOL_CALL_ID_MAX_LENGTH);
+}
+export function toolWireName(namespace, name) {
+    return namespace ? `${namespace}__${name}` : name;
+}
+export function toolsByWireName(tools) {
+    const indexed = new Map();
+    for (const tool of tools) {
+        if (tool.kind === "hosted" || tool.kind === "server_tool")
+            continue;
+        const wireName = tool.kind === "client_tool" ? tool.name : toolWireName(tool.namespace, tool.name);
+        if (indexed.has(wireName)) {
+            throw new HttpError(400, `Tool names must remain unique after namespace encoding; '${wireName}' is ambiguous.`, "invalid_request_error", "tools");
+        }
+        indexed.set(wireName, tool);
+    }
+    return indexed;
+}
+export function providerToolCallId(callId, itemId, providerApi) {
+    if (!itemId || !usesResponsesToolCallIds(providerApi))
+        return callId;
+    return `${callId}|${itemId}`;
+}
+export function providerToolCallIdentity(id, source) {
+    const separator = usesResponsesToolCallIds(source.api) ? id.indexOf("|") : -1;
+    const identity = separator > 0 && separator < id.length - 1
+        ? { callId: id.slice(0, separator), itemId: id.slice(separator + 1) }
+        : { callId: id };
+    if (!isProtocolToolCallId(identity.callId)) {
+        throw new HttpError(502, `Provider output tool call ID must be a non-empty string no longer than ${TOOL_CALL_ID_MAX_LENGTH} characters.`, "provider_output_invalid");
+    }
+    return identity;
+}
+function usesResponsesToolCallIds(api) {
+    return api === "openai-responses" || api === "azure-openai-responses";
+}

package/dist/interaction/types.d.ts

@@ -0,0 +1,204 @@
+import type { ReasoningEffort } from "@mupt-ai/dari-router/policy-engine";
+export type { ProviderIdentity, ProviderContinuationState, } from "@mupt-ai/dari-router/protocols";
+import type { ProviderContinuationState, ProviderIdentity } from "@mupt-ai/dari-router/protocols";
+export type SourceProtocol = "anthropic_messages" | "openai_chat" | "openai_responses";
+export type AgentRequestClass = "main" | "subagent" | "workflow" | "auxiliary" | "compaction" | "side_reply" | "unknown";
+export type AgentRequestContext = {
+    requestClass: AgentRequestClass;
+    agentId?: string;
+    parentAgentId?: string;
+    agentType?: string;
+};
+export declare function isBackgroundRequest(request: InteractionRequest): boolean;
+export type InteractionRequestPurpose = "memory_extraction" | "tool_continuation";
+export type InteractionResponseFormat = {
+    type: "text";
+} | {
+    type: "json_object";
+} | {
+    type: "json_schema";
+    name: string;
+    schema: Record<string, unknown>;
+    strict?: boolean;
+    description?: string;
+};
+export type InteractionText = {
+    type: "text";
+    text: string;
+    annotations?: Array<Record<string, unknown>>;
+};
+export type InteractionImage = {
+    type: "image";
+    url: string;
+    detail?: "auto" | "low" | "high" | "original";
+};
+export type InteractionToolReference = {
+    type: "tool_reference";
+    toolName: string;
+};
+export type InteractionContent = InteractionText | InteractionImage | InteractionToolReference;
+export type InteractionMessage = {
+    type: "message";
+    id?: string;
+    clientTurnId?: string;
+    role: "system" | "developer" | "user" | "assistant";
+    content: InteractionContent[];
+    contentShape: "string" | "parts" | "null" | "absent";
+    phase?: "commentary" | "final_answer";
+    source?: ProviderIdentity;
+};
+export type InteractionReasoning = {
+    type: "reasoning";
+    id?: string;
+    summary: string[];
+    content: string[];
+    source?: ProviderIdentity;
+    continuation?: ProviderContinuationState;
+};
+export type ToolKind = "function" | "custom";
+export type InteractionToolCall = {
+    type: "tool_call";
+    id?: string;
+    callId: string;
+    kind: ToolKind;
+    name: string;
+    namespace?: string;
+    input?: string | Record<string, unknown>;
+    status?: "in_progress" | "completed" | "incomplete";
+};
+export type InteractionToolResult = {
+    type: "tool_result";
+    id?: string;
+    callId: string;
+    kind: ToolKind;
+    name?: string;
+    output: string | InteractionContent[] | null;
+    outputShape: "string" | "parts" | "null" | "absent";
+    isError?: boolean;
+    loadedTools?: string[];
+};
+export type InteractionReasoningConfiguration = {
+    type: "reasoning_configuration";
+    effort: ReasoningEffort;
+};
+export type InteractionHostedToolCall = {
+    type: "hosted_tool_call";
+    id: string;
+    tool: "web_search" | "server_tool_use" | "tool_search";
+    providerType: "web_search_call" | "server_tool_use" | "tool_search_result";
+    status?: "in_progress" | "searching" | "completed" | "incomplete" | "failed";
+    payload: Record<string, unknown>;
+    source?: ProviderIdentity;
+    serverToolUseId?: string;
+    serverToolName?: string;
+    serverToolInput?: Record<string, unknown>;
+    serverToolResult?: InteractionToolReference[];
+};
+export type InteractionItem = InteractionMessage | InteractionReasoning | InteractionToolCall | InteractionToolResult | InteractionReasoningConfiguration | InteractionHostedToolCall;
+export type InteractionOutputItem = InteractionMessage | InteractionReasoning | InteractionToolCall | InteractionHostedToolCall;
+export type ServerToolKind = "bash_20250124" | "text_editor_20250124" | "tool_search_tool_20250919" | "tool_search_tool_regex_20250919" | "tool_search_tool_regex" | "tool_search_tool_regex_20251119" | "tool_search_tool_bm25" | "tool_search_tool_bm25_20251119";
+export type ClientTool = {
+    kind: "client_tool";
+    name: string;
+    type: "bash_20250124" | "text_editor_20250124";
+    description?: string;
+};
+export type FunctionTool = {
+    kind: "function";
+    name: string;
+    namespace?: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    strict?: boolean;
+    deferLoading?: boolean;
+};
+export type CustomTool = {
+    kind: "custom";
+    name: string;
+    namespace?: string;
+    description?: string;
+    format?: Record<string, unknown>;
+};
+export type HostedTool = {
+    kind: "hosted";
+    type: "web_search" | "web_search_preview";
+    config: Record<string, unknown>;
+};
+export type ServerTool = {
+    kind: "server_tool";
+    name: string;
+    type: ServerToolKind;
+    description?: string;
+};
+export type InteractionTool = FunctionTool | CustomTool | HostedTool | ServerTool | ClientTool;
+export type InteractionToolChoice = "none" | "auto" | "required" | "any" | {
+    kind: ToolKind;
+    name: string;
+    namespace?: string;
+} | {
+    kind: "hosted";
+    type: HostedTool["type"];
+};
+export type GenerationControls = {
+    temperature?: number;
+    topP?: number;
+    maxOutputTokens?: number;
+    stop?: string | string[];
+};
+export type ReasoningControls = {
+    effort?: ReasoningEffort;
+    baseEffort?: ReasoningEffort;
+    hasConfigurationUpdate?: boolean;
+    enabled?: boolean;
+    budgetTokens?: number;
+};
+export type AnthropicSafeguards = {
+    safeguards: unknown[];
+    betas: string[];
+};
+export type InteractionRequest = {
+    sourceProtocol: SourceProtocol;
+    requestPurpose?: InteractionRequestPurpose;
+    agentContext?: AgentRequestContext;
+    claudeCodeUserAgent?: string;
+    museCodeClientId?: string;
+    anthropicSafeguards?: AnthropicSafeguards;
+    model?: string;
+    instructions?: string;
+    items: InteractionItem[];
+    tools: InteractionTool[];
+    toolChoice?: InteractionToolChoice;
+    parallelToolCalls?: boolean;
+    generation: GenerationControls;
+    reasoning?: ReasoningControls;
+    responseFormat?: InteractionResponseFormat;
+    promptCacheKey?: string;
+    stream: boolean;
+    metadata?: Record<string, unknown>;
+    user?: string;
+};
+export type InteractionUsage = {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    totalTokens: number;
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    costSource?: "provider";
+};
+export type InteractionOutput = {
+    responseId?: string;
+    createdAtMs: number;
+    source: ProviderIdentity;
+    items: InteractionOutputItem[];
+    usage: InteractionUsage;
+    stopReason: "stop" | "length" | "tool_use" | "error" | "aborted";
+    errorMessage?: string;
+    safeguardResults?: unknown[];
+};

package/dist/interaction/types.js

@@ -0,0 +1,5 @@
+export function isBackgroundRequest(request) {
+    return request.agentContext?.requestClass === "auxiliary"
+        || request.agentContext?.requestClass === "compaction"
+        || request.agentContext?.requestClass === "side_reply";
+}

package/dist/models/catalog.d.ts

@@ -0,0 +1,35 @@
+import { type ReasoningEffort } from "@mupt-ai/dari-router/policy-engine";
+export type CatalogModel = {
+    id: string;
+    provider: string;
+    native_model_id: string;
+    name: string;
+    context_window: number | null;
+    max_output_tokens: number | null;
+    input_modalities: string[];
+    thinking_levels: ReasoningEffort[];
+    price: CatalogModelPrice | null;
+    price_as_of: string;
+};
+export type CatalogModelPrice = {
+    input: number;
+    output: number;
+    cached_input: number | null;
+    cache_write: number | null;
+    tiers: CatalogPriceTier[];
+};
+export type CatalogPriceTier = {
+    input_tokens_above: number;
+    input: number;
+    output: number;
+    cached_input: number | null;
+    cache_write: number | null;
+};
+export type ModelCatalogOptions = {
+    providers?: readonly string[] | undefined;
+    fetch?: ((url: string, init?: RequestInit) => Promise<Response>) | undefined;
+    signal?: AbortSignal | undefined;
+};
+export declare const DEFAULT_CATALOG_PROVIDERS: readonly string[];
+/** List the agent-capable models of each requested provider. */
+export declare function listModelCatalog(options?: ModelCatalogOptions): Promise<CatalogModel[]>;

package/dist/models/catalog.js

@@ -0,0 +1,232 @@
+import { getSupportedThinkingLevels } from "@mupt-ai/pi-ai";
+import { getBuiltinModelDataGeneratedAt, getBuiltinModels, getBuiltinProviders, } from "@mupt-ai/pi-ai/providers/all";
+import { REASONING_EFFORTS, isReasoningEffort, isRecord, } from "@mupt-ai/dari-router/policy-engine";
+import { HttpError } from "../http/errors.js";
+export const DEFAULT_CATALOG_PROVIDERS = [
+    "openai",
+    "anthropic",
+    "meta",
+    "xai",
+    "fireworks",
+    "openrouter",
+    "vercel-ai-gateway",
+];
+const LIVE_LISTINGS = {
+    openrouter: { url: "https://openrouter.ai/api/v1/models", models: openRouterModels },
+    "vercel-ai-gateway": { url: "https://ai-gateway.vercel.sh/v1/models", models: vercelModels },
+};
+/** List the agent-capable models of each requested provider. */
+export async function listModelCatalog(options = {}) {
+    const providers = [...new Set(options.providers ?? DEFAULT_CATALOG_PROVIDERS)];
+    const builtin = new Set(getBuiltinProviders());
+    for (const provider of providers) {
+        if (LIVE_LISTINGS[provider] === undefined && !builtin.has(provider)) {
+            throw new HttpError(400, `Unknown catalog provider '${provider}'.`, "unknown_provider", "provider");
+        }
+    }
+    const lists = await Promise.all(providers.map(async (provider) => {
+        const listing = LIVE_LISTINGS[provider];
+        return listing === undefined
+            ? piModels(provider)
+            : listing.models(await fetchListing(listing.url, options), new Date().toISOString());
+    }));
+    return lists.flat();
+}
+async function fetchListing(url, options) {
+    let status;
+    let body = null;
+    // Network errors, aborts, and unparseable bodies are upstream failures
+    // too: all of them surface as catalog_unavailable rather than a raw 500.
+    try {
+        const response = await (options.fetch ?? fetch)(url, {
+            headers: { accept: "application/json" },
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        status = response.status;
+        body = response.ok ? await response.json() : null;
+    }
+    catch {
+        // Leaves body null.
+    }
+    if (!isRecord(body) || !Array.isArray(body.data)) {
+        const detail = status === undefined ? "could not be reached" : `returned no model list (HTTP ${status})`;
+        throw new HttpError(502, `${url} ${detail}.`, "catalog_unavailable");
+    }
+    return body.data;
+}
+function piModels(provider) {
+    const generatedAt = getBuiltinModelDataGeneratedAt();
+    const asOf = generatedAt === undefined ? "" : new Date(generatedAt).toISOString();
+    const models = getBuiltinModels(provider);
+    return models.map((model) => ({
+        id: `${provider}/${model.id}`,
+        provider,
+        native_model_id: model.id,
+        name: model.name,
+        context_window: model.contextWindow,
+        max_output_tokens: model.maxTokens,
+        input_modalities: [...model.input],
+        thinking_levels: orderedEfforts(getSupportedThinkingLevels(model)),
+        price: piPrice(model.cost),
+        price_as_of: asOf,
+    }));
+}
+function piPrice(cost) {
+    return {
+        input: cost.input,
+        output: cost.output,
+        cached_input: cost.cacheRead,
+        cache_write: cost.cacheWrite,
+        tiers: (cost.tiers ?? []).map((tier) => ({
+            input_tokens_above: tier.inputTokensAbove,
+            input: tier.input,
+            output: tier.output,
+            cached_input: tier.cacheRead,
+            cache_write: tier.cacheWrite,
+        })),
+    };
+}
+// https://openrouter.ai/docs/api/api-reference/models/get-models
+function openRouterModels(data, asOf) {
+    return data.filter(isRecord).flatMap((model) => {
+        const architecture = isRecord(model.architecture) ? model.architecture : {};
+        const parameters = stringList(model.supported_parameters);
+        if (typeof model.id !== "string" || !parameters.includes("tools"))
+            return [];
+        if (!stringList(architecture.output_modalities).includes("text"))
+            return [];
+        const reasoning = isRecord(model.reasoning) ? model.reasoning : {};
+        const topProvider = isRecord(model.top_provider) ? model.top_provider : {};
+        return [{
+                id: `openrouter/${model.id}`,
+                provider: "openrouter",
+                native_model_id: model.id,
+                name: typeof model.name === "string" ? model.name : model.id,
+                context_window: positiveInteger(model.context_length),
+                max_output_tokens: positiveInteger(topProvider.max_completion_tokens),
+                input_modalities: stringList(architecture.input_modalities),
+                thinking_levels: gatewayThinkingLevels({
+                    reasons: parameters.includes("reasoning"),
+                    efforts: Array.isArray(reasoning.supported_efforts) ? stringList(reasoning.supported_efforts) : null,
+                    canDisable: reasoning.mandatory !== true,
+                }),
+                price: isRecord(model.pricing) ? openRouterPrice(model.pricing) : null,
+                price_as_of: asOf,
+            }];
+    });
+}
+function openRouterPrice(pricing) {
+    const base = rates(pricing, "prompt", "completion");
+    if (base === null)
+        return null;
+    // Overrides restate only the rates they change; time-of-day overrides are
+    // not context tiers.
+    const tiers = (Array.isArray(pricing.overrides) ? pricing.overrides : [])
+        .filter(isRecord)
+        .flatMap((override) => {
+        const threshold = positiveInteger(override.min_prompt_tokens);
+        if (threshold === null || "utc_days" in override || "utc_start" in override || "utc_end" in override) {
+            return [];
+        }
+        const tier = rates({ ...pricing, ...override }, "prompt", "completion", override);
+        return tier === null ? [] : [{ input_tokens_above: threshold, ...tier }];
+    });
+    return { ...base, tiers };
+}
+// https://vercel.com/docs/ai-gateway/models-and-providers
+function vercelModels(data, asOf) {
+    return data.filter(isRecord).flatMap((model) => {
+        const modalities = isRecord(model.modalities) ? model.modalities : {};
+        const parameters = stringList(model.supported_parameters);
+        if (typeof model.id !== "string" || model.type !== "language" || !parameters.includes("tools"))
+            return [];
+        if (!stringList(modalities.output).includes("text"))
+            return [];
+        const options = Array.isArray(model.reasoning_options) ? model.reasoning_options.filter(isRecord) : [];
+        const effort = options.find((option) => option.type === "effort");
+        return [{
+                id: `vercel-ai-gateway/${model.id}`,
+                provider: "vercel-ai-gateway",
+                native_model_id: model.id,
+                name: typeof model.name === "string" ? model.name : model.id,
+                context_window: positiveInteger(model.context_window),
+                max_output_tokens: positiveInteger(model.max_tokens),
+                input_modalities: stringList(modalities.input),
+                thinking_levels: gatewayThinkingLevels({
+                    reasons: parameters.includes("reasoning") || options.length > 0,
+                    efforts: effort === undefined ? null : stringList(effort.values),
+                    canDisable: options.length === 0 || options.some((option) => option.type === "toggle"),
+                }),
+                price: isRecord(model.pricing) ? vercelPrice(model.pricing) : null,
+                price_as_of: asOf,
+            }];
+    });
+}
+function vercelPrice(pricing) {
+    const base = rates(pricing, "input", "output");
+    if (base === null)
+        return null;
+    // Each rate lists its own {cost, min, max} ranges; a range covers prompts of
+    // at least `min` tokens, so it is the tier above `min - 1`.
+    const ranged = new Map();
+    for (const key of ["input", "output", "input_cache_read", "input_cache_write"]) {
+        const ranges = Array.isArray(pricing[`${key}_tiers`]) ? pricing[`${key}_tiers`] : [];
+        for (const range of ranges.filter(isRecord)) {
+            const start = positiveInteger(range.min);
+            if (start === null || range.cost == null)
+                continue;
+            ranged.set(start - 1, { ...ranged.get(start - 1), [key]: range.cost });
+        }
+    }
+    const tiers = [...ranged.entries()]
+        .sort(([left], [right]) => left - right)
+        .flatMap(([threshold, stated]) => {
+        const tier = rates({ ...pricing, ...stated }, "input", "output", stated);
+        return tier === null ? [] : [{ input_tokens_above: threshold, ...tier }];
+    });
+    return { ...base, tiers };
+}
+// Base rates from per-token strings. A tier inherits input and output from
+// the base price but states its own cache rates, or has none.
+function rates(pricing, inputKey, outputKey, cacheRates = pricing) {
+    const input = perMillion(pricing[inputKey]);
+    const output = perMillion(pricing[outputKey]);
+    // Meta-routers with variable prices list negative rates.
+    if (input === null || output === null)
+        return null;
+    return {
+        input,
+        output,
+        cached_input: perMillion(cacheRates.input_cache_read),
+        cache_write: perMillion(cacheRates.input_cache_write),
+    };
+}
+// USD per token as a decimal string -> USD per million tokens. Shifting the
+// exponent in the string keeps "0.000001" exactly 1.
+function perMillion(value) {
+    const rate = typeof value === "string" ? Number(`${value.trim()}e6`)
+        : typeof value === "number" ? value * 1_000_000
+            : Number.NaN;
+    return Number.isFinite(rate) && rate >= 0 ? rate : null;
+}
+// Gateways forward `reasoning.effort`; models that reason without a stated
+// effort list take the standard low/medium/high levels.
+function gatewayThinkingLevels(args) {
+    if (!args.reasons)
+        return ["off"];
+    const efforts = args.efforts ?? ["low", "medium", "high"];
+    return orderedEfforts([
+        ...efforts.map((effort) => effort === "none" ? "off" : effort),
+        ...(args.canDisable ? ["off"] : []),
+    ]);
+}
+function orderedEfforts(levels) {
+    const accepted = new Set(levels.filter(isReasoningEffort));
+    return REASONING_EFFORTS.filter((effort) => accepted.has(effort));
+}
+function stringList(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : null;
+}

package/dist/models/context_limits.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedRouterModelConfig } from "../types.js";
+export declare function effectiveContextWindow(config: ResolvedRouterModelConfig | undefined, allowLongContext?: boolean): number | null;

package/dist/models/context_limits.js

@@ -0,0 +1,7 @@
+export function effectiveContextWindow(config, allowLongContext = false) {
+    const window = config?.context_window;
+    const limit = config?.standard_context_limit;
+    if (allowLongContext || limit == null)
+        return window ?? null;
+    return Math.min(window ?? limit, limit);
+}

package/dist/models/execution_provider.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderKeySource, ResolvedRouter } from "../types.js";
+/** Actual serving provider for a canonical model on a resolved managed router. */
+export declare function executionProviderForModel(credentials: ResolvedRouter, model: string): string;
+/**
+ * The key that serves a model on a resolved router: a platform-supplied
+ * credential first, then the resolved provider key. Missing declarations are
+ * user-owned so unknown platform data cannot trigger managed-key billing.
+ */
+export declare function keySourceForModel(credentials: ResolvedRouter, model: string): ProviderKeySource;