@mupt-ai/dari-gateway 0.1.0 → 0.2.1

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,203 @@
+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;
+    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/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,8 @@
+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. Missing declarations are
+ * user-owned so unknown platform data cannot trigger managed-key billing.
+ */
+export declare function keySourceForModel(credentials: ResolvedRouter, model: string): ProviderKeySource;

package/dist/models/execution_provider.js

@@ -0,0 +1,13 @@
+import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
+/** Actual serving provider for a canonical model on a resolved managed router. */
+export function executionProviderForModel(credentials, model) {
+    const configured = credentials.model_configs?.[model]?.provider?.trim();
+    return configured || providerForModel(model);
+}
+/**
+ * The key that serves a model on a resolved router. Missing declarations are
+ * user-owned so unknown platform data cannot trigger managed-key billing.
+ */
+export function keySourceForModel(credentials, model) {
+    return credentials.provider_key_sources?.[executionProviderForModel(credentials, model)] ?? "user";
+}

package/dist/models/gateways.d.ts

@@ -0,0 +1,11 @@
+export type Gateway = {
+    label: string;
+    baseUrl: string;
+    compat: Record<string, unknown>;
+    requestFields(options: {
+        zdr: boolean;
+    }): Record<string, unknown>;
+};
+export declare function gatewayFor(provider: unknown): Gateway | undefined;
+/** Deep-merges gateway routing fields into a provider request body. */
+export declare function payloadWithGatewayFields(payload: Record<string, unknown>, fields: Record<string, unknown>): Record<string, unknown>;

package/dist/models/gateways.js

@@ -0,0 +1,45 @@
+import { isRecord } from "@mupt-ai/dari-router/policy-engine";
+function gateway(spec) {
+    return { ...spec, compat: { thinkingFormat: "openrouter", ...spec.compat } };
+}
+const GATEWAYS = {
+    openrouter: gateway({
+        label: "OpenRouter",
+        baseUrl: "https://openrouter.ai/api/v1",
+        requestFields: ({ zdr }) => zdr ? { provider: { data_collection: "deny", zdr: true } } : {},
+    }),
+    // https://vercel.com/docs/ai-gateway/models-and-providers/provider-options
+    "vercel-ai-gateway": gateway({
+        label: "Vercel AI Gateway",
+        baseUrl: "https://ai-gateway.vercel.sh/v1",
+        // Pi detects OpenRouter's role, caching, and session conventions from its
+        // URL but not Vercel's: the system role reaches every upstream, and
+        // x-session-affinity keeps prompt-cache locality.
+        compat: {
+            supportsDeveloperRole: false,
+            sendSessionAffinityHeaders: true,
+            sessionAffinityFormat: "openai",
+        },
+        // Vercel passes requests through untouched unless asked to place the
+        // cache breakpoints Anthropic models need.
+        requestFields: ({ zdr }) => ({
+            providerOptions: {
+                gateway: { caching: "auto", ...(zdr ? { zeroDataRetention: true } : {}) },
+            },
+        }),
+    }),
+};
+export function gatewayFor(provider) {
+    return typeof provider === "string" ? GATEWAYS[provider.toLowerCase()] : undefined;
+}
+/** Deep-merges gateway routing fields into a provider request body. */
+export function payloadWithGatewayFields(payload, fields) {
+    const merged = { ...payload };
+    for (const [key, value] of Object.entries(fields)) {
+        const current = merged[key];
+        merged[key] = isRecord(current) && isRecord(value)
+            ? payloadWithGatewayFields(current, value)
+            : value;
+    }
+    return merged;
+}

package/dist/models/ids.d.ts

@@ -0,0 +1 @@
+export declare function requireCandidateModels(value: unknown): string[];

package/dist/models/ids.js

@@ -0,0 +1,15 @@
+import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
+import { HttpError } from "../http/errors.js";
+export function requireCandidateModels(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new HttpError(400, "routing.candidate_models must include at least one model.", "invalid_routing_request", "routing.candidate_models");
+    }
+    const candidates = value.map((item, index) => {
+        if (typeof item !== "string" || item.trim() === "") {
+            throw new HttpError(400, "routing.candidate_models must contain non-empty strings.", "invalid_routing_request", `routing.candidate_models[${index}]`);
+        }
+        providerForModel(item);
+        return item;
+    });
+    return [...new Set(candidates)];
+}

package/dist/models/provider_defaults.d.ts

@@ -0,0 +1,4 @@
+/** Display label for a provider slug; custom slugs title-case per segment. */
+export declare function providerLabel(provider: string): string;
+/** Endpoint fallback when neither the resolved config nor the registry has one. */
+export declare function defaultBaseUrl(provider: string): string | null;

package/dist/models/provider_defaults.js

@@ -0,0 +1,41 @@
+import { gatewayFor } from "./gateways.js";
+// Built-in model provider presentation and endpoint defaults; gateways carry
+// their own. Mirrors the hosted Dari model catalog's provider defaults; keep
+// the two in sync when adding a provider.
+const PROVIDER_LABELS = {
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    fireworks: "Fireworks",
+    meta: "Meta",
+    xai: "xAI",
+    dari: "Dari",
+    "amazon-bedrock": "Amazon Bedrock",
+    azure: "Microsoft Azure",
+};
+/** Display label for a provider slug; custom slugs title-case per segment. */
+export function providerLabel(provider) {
+    const known = PROVIDER_LABELS[provider.toLowerCase()] ?? gatewayFor(provider)?.label;
+    if (known)
+        return known;
+    return (provider
+        .split(/[._-]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ") || provider);
+}
+const PROVIDER_BASE_URLS = {
+    openai: "https://api.openai.com/v1",
+    anthropic: "https://api.anthropic.com",
+    fireworks: "https://api.fireworks.ai/inference/v1",
+    xai: "https://api.x.ai/v1",
+    // Pi-ai derives the effective AWS region from the endpoint unless the
+    // model config overrides base_url or the native id is an inference profile
+    // ARN, so this default only pins us-east-1 when nothing else is configured.
+    "amazon-bedrock": "https://bedrock-runtime.us-east-1.amazonaws.com",
+    // Microsoft Azure has no default: the platform derives each model's base
+    // URL from the credential's resource endpoint at resolve time.
+};
+/** Endpoint fallback when neither the resolved config nor the registry has one. */
+export function defaultBaseUrl(provider) {
+    return PROVIDER_BASE_URLS[provider.toLowerCase()] ?? gatewayFor(provider)?.baseUrl ?? null;
+}

package/dist/models/runtime_overrides.d.ts

@@ -0,0 +1,4 @@
+export declare function offRequiresWireNone(modelId: string): boolean;
+export declare function contextWindowOverride(modelId: string): number | undefined;
+export declare function inputModalitiesOverride(modelId: string): string[] | undefined;
+export declare function runtimeCompat(provider: string, registered: Record<string, unknown> | undefined, modelId?: string): unknown;

package/dist/models/runtime_overrides.js

@@ -0,0 +1,209 @@
+import { canonicalModelId, isRecord } from "@mupt-ai/dari-router/policy-engine";
+import { gatewayFor } from "./gateways.js";
+const MODEL_CONTEXT_OVERRIDES = {
+    // Selector and title models are not router candidate configs, so their
+    // context windows cannot depend on the Pi registry carrying them.
+    "openai/gpt-5.6-luna": 1_050_000,
+    "openai/gpt-6-luna": 1_050_000,
+};
+// Models whose true non-reasoning mode is the provider-literal effort "none"
+// rather than omitting the field. Live-validated: Fireworks DeepSeek thinks
+// by default when the request carries no reasoning_effort (and pi-ai's
+// completions path drops Dari's "off" before serializing), so a client's
+// explicit off must be injected into the provider payload as
+// reasoning_effort "none" (verified quiet: ~2 output tokens vs ~40 thinking).
+// OpenAI gpt-5.x models need no entry: the pi-ai registry already maps their
+// "off" to wire "none".
+// Models whose catalog metadata is not yet bundled in the installed Pi registry
+// but need explicit compat overrides to produce correct provider payloads.
+const MODEL_COMPAT_OVERRIDES = {
+    // The Pi registry does not carry Fable 5.1, Opus 5.5, Sonnet 5.5, and Opus 5's
+    // adaptive-thinking compatibility for every serving provider (OpenRouter,
+    // Bedrock), so it is declared here. Sonnet 5 is in the Pi
+    // registry (with forceAdaptiveThinking), but it's missing supportsTemperature
+    // (the Anthropic docs confirm non-default temperature returns 400).
+    "anthropic/claude-fable-5-1": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+    },
+    "anthropic/claude-opus-5-5": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+        supportsMidConvoEffort: true,
+    },
+    "anthropic/claude-opus-5": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+    },
+    "anthropic/claude-sonnet-5-5": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+        supportsMidConvoEffort: true,
+    },
+    "anthropic/claude-sonnet-5": {
+        supportsTemperature: false,
+    },
+    "anthropic/claude-haiku-5-5": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+    },
+    // GPT-6 Astra always reasons and OpenAI rejects temperature on it (400
+    // "Unsupported parameter: 'temperature'"), on api.openai.com and on Azure
+    // alike. The OpenAI transports do not read this flag themselves, so
+    // buildOptions drops the parameter. Live-validated 2026-09-15.
+    "openai/gpt-6-astra": {
+        supportsTemperature: false,
+    },
+    // GPT-6 Sol and Luna are newer than the installed Pi registry. They retain
+    // the GPT-5.6 Responses feature set, including explicit prompt caching and
+    // deferred tool loading. Keep this local until Pi ships their metadata.
+    "openai/gpt-6.1-sol": {
+        supportsStrictMode: true,
+        supportsOpenAIGrammarTools: true,
+        supportsAdditionalTools: true,
+        supportsToolSearch: true,
+        supportsExplicitPromptCacheMode: true,
+        supportsReasoningConfigurationUpdate: true,
+    },
+    "openai/gpt-6-sol": {
+        supportsStrictMode: true,
+        supportsOpenAIGrammarTools: true,
+        supportsAdditionalTools: true,
+        supportsToolSearch: true,
+        supportsExplicitPromptCacheMode: true,
+        supportsReasoningConfigurationUpdate: true,
+    },
+    "openai/gpt-6-luna": {
+        supportsStrictMode: true,
+        supportsOpenAIGrammarTools: true,
+        supportsAdditionalTools: true,
+        supportsToolSearch: true,
+        supportsExplicitPromptCacheMode: true,
+        supportsReasoningConfigurationUpdate: true,
+    },
+    // Kimi K3 is not in the installed Pi registry under the Fireworks provider.
+    // Fireworks returns preserved thinking in reasoning_content and accepts the
+    // model's documented low/high/max reasoning_effort values.
+    "moonshotai/Kimi-K3": {
+        thinkingFormat: "deepseek",
+        supportsReasoningEffort: true,
+        requiresReasoningContentOnAssistantMessages: true,
+    },
+    // DeepSeek V4 Flash 0731 is not in the installed Pi registry (new model),
+    // so it needs the same compat overrides as Kimi K3 for correct deepseek-
+    // format response parsing and multi-turn reasoning continuity.
+    "deepseek-ai/DeepSeek-V4-Flash-0731": {
+        thinkingFormat: "deepseek",
+        supportsReasoningEffort: true,
+        requiresReasoningContentOnAssistantMessages: true,
+    },
+    "deepseek-ai/DeepSeek-V4.1-Flash-1017": {
+        thinkingFormat: "deepseek",
+        supportsReasoningEffort: true,
+        requiresReasoningContentOnAssistantMessages: true,
+    },
+};
+// Serving-provider specific compat that replaces the model-level override
+// above. Microsoft Foundry serves DeepSeek through its own OpenAI-compatible
+// endpoint: the `thinking` parameter the deepseek thinking format sends is
+// rejected (400 unrecognized_request_argument), plain reasoning_effort
+// (none/low/high/max) is accepted, and reasoning comes back in
+// reasoning_content. Grok on Foundry takes reasoning_effort the same way.
+// Live-validated against a Foundry resource on 2026-09-15.
+const PROVIDER_MODEL_COMPAT_OVERRIDES = {
+    azure: {
+        "deepseek-ai/DeepSeek-V4-Flash-0731": {
+            supportsReasoningEffort: true,
+            requiresReasoningContentOnAssistantMessages: true,
+        },
+        "xai/grok-4.6": {
+            supportsReasoningEffort: true,
+        },
+        "xai/grok-4.7": {
+            supportsReasoningEffort: true,
+        },
+    },
+};
+// Compat keys that describe a model's native reasoning wire format, which a
+// gateway replaces with its own.
+const NATIVE_REASONING_COMPAT_KEYS = new Set([
+    "thinkingFormat",
+    "supportsReasoningEffort",
+    "requiresReasoningContentOnAssistantMessages",
+]);
+// Models whose input modalities are not detectable from the Pi registry.
+// GPT-5.6 is registered for Bedrock only under the unprefixed
+// "openai.gpt-5.6-*" ids; Dari executes the "us." inference profiles, which
+// miss the registry and would otherwise be pruned as text-only.
+const MODEL_INPUT_OVERRIDES = {
+    "anthropic/claude-haiku-5-5": ["text", "image"],
+    "anthropic/claude-sonnet-5-5": ["text", "image"],
+    "openai/gpt-6.1-sol": ["text", "image"],
+    "openai/gpt-6-sol": ["text", "image"],
+    "openai/gpt-6-luna": ["text", "image"],
+    "openai/gpt-5.6-luna": ["text", "image"],
+    "openai/gpt-5.6-sol": ["text", "image"],
+    "openai/gpt-5.6-terra": ["text", "image"],
+    "openai/gpt-6-astra": ["text", "image"],
+    "moonshotai/Kimi-K3": ["text", "image"],
+    "deepseek-ai/DeepSeek-V4.1-Flash-1017": ["text", "image"],
+    "zai-org/GLM-5.3-Flash": ["text", "image"],
+    // Grok 4.6 and 4.7 are registered for xAI's Responses API only; Foundry
+    // serves them through chat completions with the same text and image input.
+    "xai/grok-4.6": ["text", "image"],
+    "xai/grok-4.7": ["text", "image"],
+};
+const MODEL_OFF_WIRE_NONE = new Set([
+    // No longer bundled under Fireworks in Pi 1.1; preserve explicit off.
+    "zai-org/GLM-5.2",
+    "deepseek-ai/DeepSeek-V4-Pro-0813",
+    "fireworks/deepseek-ai/DeepSeek-V4-Flash",
+    "deepseek-ai/DeepSeek-V4-Flash-0731",
+    "deepseek-ai/DeepSeek-V4.1-Flash-1017",
+]);
+export function offRequiresWireNone(modelId) {
+    return MODEL_OFF_WIRE_NONE.has(canonicalModelId(modelId));
+}
+export function contextWindowOverride(modelId) {
+    return MODEL_CONTEXT_OVERRIDES[canonicalModelId(modelId)];
+}
+export function inputModalitiesOverride(modelId) {
+    return MODEL_INPUT_OVERRIDES[canonicalModelId(modelId)];
+}
+export function runtimeCompat(provider, registered, modelId) {
+    const canonical = modelId ? canonicalModelId(modelId) : undefined;
+    const compatOverride = canonical
+        ? PROVIDER_MODEL_COMPAT_OVERRIDES[provider]?.[canonical] ?? MODEL_COMPAT_OVERRIDES[canonical]
+        : undefined;
+    const gateway = gatewayFor(provider);
+    if (gateway) {
+        // A gateway's own dialect decides how reasoning goes over the wire, so
+        // the model overrides' native reasoning settings do not apply.
+        const modelOverride = Object.fromEntries(Object.entries(compatOverride ?? {}).filter(([key]) => !NATIVE_REASONING_COMPAT_KEYS.has(key)));
+        return {
+            ...(isRecord(registered?.compat) ? registered.compat : {}),
+            ...modelOverride,
+            ...gateway.compat,
+        };
+    }
+    if (provider !== "fireworks") {
+        if (compatOverride === undefined)
+            return registered?.compat;
+        return {
+            ...(isRecord(registered?.compat) ? registered.compat : {}),
+            ...compatOverride,
+        };
+    }
+    // Fireworks needs two compat defaults pi-ai does not detect for it:
+    // serverless cache hits ride on session-affinity headers pi-ai only sends
+    // when compat asks for them, and several Fireworks chat templates (e.g.
+    // DeepSeek) silently drop developer-role messages, so system prompts must
+    // go out under the system role. Registry-declared compat keys still win,
+    // and per-model overrides win over both for models the registry omits.
+    return {
+        sendSessionAffinityHeaders: true,
+        supportsDeveloperRole: false,
+        ...(isRecord(registered?.compat) ? registered.compat : {}),
+        ...compatOverride,
+    };
+}