@velum-labs/routekit-gateway 0.13.0 → 0.15.0

package/README.md

@@ -24,5 +24,4 @@ import {
 API-key providers use registry-defined credentials and URLs. Multi-account
 subscription providers and relays are in `@velum-labs/routekit-accounts`; they expose the
 same source interface with per-model account eligibility and quota-aware
-selection.
-Product-specific orchestration is in `@fusionkit/gateway`.
+selection. RouteKit hosts wire this package into the singleton daemon gateway.

package/dist/bedrock-source.d.ts

@@ -0,0 +1,22 @@
+import { BedrockClient } from "@aws-sdk/client-bedrock";
+import { BedrockRuntimeClient, type ConverseCommandInput, type ConverseCommandOutput } from "@aws-sdk/client-bedrock-runtime";
+import type { BackendRequestOptions } from "./backend.js";
+import type { DiscoveredModel, ProviderSource } from "./provider-source.js";
+export type BedrockControlClient = Pick<BedrockClient, "send">;
+export type BedrockRuntime = Pick<BedrockRuntimeClient, "send">;
+export type BedrockProviderSourceOptions = {
+    controlClient?: BedrockControlClient;
+    runtimeClient?: BedrockRuntime;
+};
+export declare function toBedrockConverseInput(body: unknown): ConverseCommandInput;
+export declare function fromBedrockConverseOutput(output: ConverseCommandOutput, model: string): Record<string, unknown>;
+export declare class BedrockProviderSource implements ProviderSource {
+    #private;
+    readonly sourceId: "bedrock";
+    constructor(options?: BedrockProviderSourceOptions);
+    discoverModels(signal?: AbortSignal): Promise<readonly DiscoveredModel[]>;
+    chat(body: unknown, signal?: AbortSignal, _options?: BackendRequestOptions): Promise<Response>;
+    embeddings(): Promise<Response>;
+    reasoningCapabilities(): DiscoveredModel["reasoning"];
+    close(): void;
+}

package/dist/bedrock-source.js

@@ -0,0 +1,429 @@
+import { BedrockClient, ListFoundationModelsCommand, ListInferenceProfilesCommand } from "@aws-sdk/client-bedrock";
+import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
+import { randomId } from "@velum-labs/routekit-runtime";
+import { anthropicReasoningDetailsOf, reasoningSelectionOf, withoutRouteKitExtensions } from "./adapters/openai-chat-wire.js";
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function anthropicFoundationModel(model) {
+    return model.providerName?.toLowerCase() === "anthropic" &&
+        model.modelLifecycle?.status === "ACTIVE" &&
+        typeof model.modelId === "string" && model.modelId.length > 0;
+}
+function foundationIdFromArn(arn) {
+    if (arn === undefined)
+        return undefined;
+    const marker = ":foundation-model/";
+    const index = arn.indexOf(marker);
+    return index < 0 ? undefined : arn.slice(index + marker.length);
+}
+function activeAnthropicProfile(profile, anthropicModels) {
+    return profile.status === "ACTIVE" &&
+        typeof profile.inferenceProfileId === "string" && profile.inferenceProfileId.length > 0 &&
+        (profile.models ?? []).some((model) => {
+            const id = foundationIdFromArn(model.modelArn);
+            return id !== undefined && anthropicModels.has(id);
+        });
+}
+function textParts(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.flatMap((part) => {
+        const item = record(part);
+        return typeof item?.text === "string" ? [item.text] : [];
+    }).join("");
+}
+function imageBlock(part) {
+    const imageUrl = typeof part.image_url === "string" ? part.image_url : record(part.image_url)?.url;
+    if (typeof imageUrl !== "string")
+        return undefined;
+    const match = /^data:image\/(png|jpeg|gif|webp);base64,(.+)$/s.exec(imageUrl);
+    if (match === null)
+        return undefined;
+    return {
+        image: {
+            format: match[1],
+            source: { bytes: Uint8Array.from(Buffer.from(match[2], "base64")) }
+        }
+    };
+}
+function bedrockReasoningBlocks(details) {
+    return anthropicReasoningDetailsOf(details, "message")
+        .sort((left, right) => left.index - right.index)
+        .map((detail) => detail.type === "redacted_thinking"
+        ? { reasoningContent: { redactedContent: Uint8Array.from(Buffer.from(detail.data, "base64")) } }
+        : { reasoningContent: { reasoningText: {
+                    text: detail.thinking ?? "",
+                    ...(detail.signature !== undefined ? { signature: detail.signature } : {})
+                } } });
+}
+function messageContent(message) {
+    const blocks = message.role === "assistant"
+        ? bedrockReasoningBlocks(message.reasoning_details)
+        : [];
+    if (typeof message.content === "string") {
+        if (message.content.length > 0)
+            blocks.push({ text: message.content });
+    }
+    else if (Array.isArray(message.content)) {
+        for (const value of message.content) {
+            const part = record(value);
+            if (part === undefined)
+                continue;
+            if (part.type === "image_url") {
+                const image = imageBlock(part);
+                if (image !== undefined)
+                    blocks.push(image);
+            }
+            else if (typeof part.text === "string" && part.text.length > 0) {
+                blocks.push({ text: part.text });
+            }
+        }
+    }
+    for (const call of message.tool_calls ?? []) {
+        let input = {};
+        try {
+            input = JSON.parse(call.function?.arguments ?? "{}");
+        }
+        catch {
+            input = { raw: call.function?.arguments ?? "" };
+        }
+        blocks.push({ toolUse: {
+                toolUseId: call.id ?? randomId(12, "toolu_"),
+                name: call.function?.name ?? "tool",
+                input: input
+            } });
+    }
+    return blocks;
+}
+function bedrockMessages(body) {
+    const systemText = (body.messages ?? []).filter((message) => message.role === "system")
+        .map((message) => textParts(message.content)).filter((text) => text.length > 0);
+    const messages = [];
+    const sourceMessages = body.messages ?? [];
+    for (let index = 0; index < sourceMessages.length; index += 1) {
+        const message = sourceMessages[index];
+        if (message.role === "system")
+            continue;
+        if (message.role === "tool") {
+            const content = [];
+            let cursor = index;
+            while (cursor < sourceMessages.length && sourceMessages[cursor]?.role === "tool") {
+                const toolMessage = sourceMessages[cursor];
+                content.push({ toolResult: {
+                        toolUseId: toolMessage.tool_call_id ?? "",
+                        content: [{ text: textParts(toolMessage.content) }]
+                    } });
+                cursor += 1;
+            }
+            messages.push({ role: "user", content });
+            index = cursor - 1;
+            continue;
+        }
+        if (message.role !== "user" && message.role !== "assistant")
+            continue;
+        const content = messageContent(message);
+        if (content.length > 0)
+            messages.push({ role: message.role, content });
+    }
+    return {
+        ...(systemText.length > 0 ? { system: systemText.map((text) => ({ text })) } : {}),
+        messages
+    };
+}
+function bedrockTools(body) {
+    const tools = (body.tools ?? []).flatMap((tool) => {
+        const fn = tool.function;
+        if (tool.type !== "function" || typeof fn?.name !== "string")
+            return [];
+        return [{ toolSpec: {
+                    name: fn.name,
+                    ...(typeof fn.description === "string" ? { description: fn.description } : {}),
+                    inputSchema: { json: (record(fn.parameters) ?? {}) }
+                } }];
+    });
+    return tools.length > 0 ? tools : undefined;
+}
+function toolChoice(value) {
+    if (value === "required")
+        return { any: {} };
+    const name = record(record(value)?.function)?.name;
+    if (typeof name === "string")
+        return { tool: { name } };
+    return { auto: {} };
+}
+export function toBedrockConverseInput(body) {
+    const canonical = withoutRouteKitExtensions(body);
+    if (typeof canonical.model !== "string" || canonical.model.length === 0)
+        throw new Error("Bedrock chat requires a model");
+    const translated = bedrockMessages(canonical);
+    const tools = canonical.tool_choice === "none" ? undefined : bedrockTools(canonical);
+    const maxTokens = typeof canonical.max_completion_tokens === "number" ? canonical.max_completion_tokens : canonical.max_tokens;
+    const stops = typeof canonical.stop === "string" ? [canonical.stop] : Array.isArray(canonical.stop)
+        ? canonical.stop.filter((value) => typeof value === "string") : undefined;
+    const selection = reasoningSelectionOf(body);
+    const thinking = selection.mode === "budget"
+        ? { thinking: { type: "enabled", budget_tokens: selection.budgetTokens } }
+        : undefined;
+    const additionalModelRequestFields = thinking !== undefined || typeof canonical.top_k === "number"
+        ? {
+            ...thinking,
+            ...(typeof canonical.top_k === "number" ? { top_k: canonical.top_k } : {})
+        }
+        : undefined;
+    return {
+        modelId: canonical.model,
+        ...translated,
+        ...(tools !== undefined ? { toolConfig: { tools, toolChoice: toolChoice(canonical.tool_choice) } } : {}),
+        ...(typeof maxTokens === "number" || typeof canonical.temperature === "number" ||
+            typeof canonical.top_p === "number" || stops !== undefined ? { inferenceConfig: {
+                ...(typeof maxTokens === "number" ? { maxTokens } : {}),
+                ...(typeof canonical.temperature === "number" ? { temperature: canonical.temperature } : {}),
+                ...(typeof canonical.top_p === "number" ? { topP: canonical.top_p } : {}),
+                ...(stops !== undefined ? { stopSequences: stops } : {})
+            } } : {}),
+        ...(additionalModelRequestFields !== undefined ? { additionalModelRequestFields } : {})
+    };
+}
+function finishReason(reason) {
+    switch (reason) {
+        case "max_tokens": return "length";
+        case "tool_use": return "tool_calls";
+        case "content_filtered":
+        case "guardrail_intervened": return "content_filter";
+        default: return "stop";
+    }
+}
+function usage(value) {
+    if (value === undefined)
+        return undefined;
+    const prompt = value.inputTokens ?? 0;
+    const completion = value.outputTokens ?? 0;
+    return { prompt_tokens: prompt, completion_tokens: completion, total_tokens: value.totalTokens ?? prompt + completion };
+}
+function outputMessage(output) {
+    const content = output.output?.message?.content ?? [];
+    let text = "";
+    let reasoning = "";
+    const reasoningDetails = [];
+    const toolCalls = [];
+    for (const [index, block] of content.entries()) {
+        if ("text" in block && typeof block.text === "string")
+            text += block.text;
+        if ("toolUse" in block && block.toolUse !== undefined)
+            toolCalls.push({
+                id: block.toolUse.toolUseId, type: "function",
+                function: { name: block.toolUse.name, arguments: JSON.stringify(block.toolUse.input ?? {}) }
+            });
+        if ("reasoningContent" in block && block.reasoningContent !== undefined) {
+            if ("reasoningText" in block.reasoningContent && block.reasoningContent.reasoningText !== undefined) {
+                const reasoningText = block.reasoningContent.reasoningText;
+                reasoning += reasoningText.text ?? "";
+                reasoningDetails.push({
+                    type: "thinking",
+                    index,
+                    thinking: reasoningText.text ?? "",
+                    signature: reasoningText.signature ?? ""
+                });
+            }
+            else if ("redactedContent" in block.reasoningContent && block.reasoningContent.redactedContent !== undefined) {
+                reasoningDetails.push({
+                    type: "redacted_thinking",
+                    index,
+                    data: Buffer.from(block.reasoningContent.redactedContent).toString("base64")
+                });
+            }
+        }
+    }
+    return { role: "assistant", content: text,
+        ...(reasoning.length > 0 ? { reasoning } : {}),
+        ...(reasoningDetails.length > 0 ? { reasoning_details: reasoningDetails } : {}),
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}) };
+}
+export function fromBedrockConverseOutput(output, model) {
+    return {
+        id: output.$metadata.requestId ?? randomId(18, "chatcmpl_"), object: "chat.completion",
+        created: Math.floor(Date.now() / 1000), model,
+        choices: [{ index: 0, message: outputMessage(output), finish_reason: finishReason(output.stopReason) }],
+        ...(usage(output.usage) !== undefined ? { usage: usage(output.usage) } : {})
+    };
+}
+function streamError(event) {
+    for (const key of ["internalServerException", "modelStreamErrorException", "validationException", "throttlingException", "serviceUnavailableException"]) {
+        const value = event[key];
+        if (value !== undefined)
+            return new Error(value.message ?? `Bedrock stream ${key}`);
+    }
+    return undefined;
+}
+function sse(data) {
+    return new TextEncoder().encode(`data: ${typeof data === "string" ? data : JSON.stringify(data)}\n\n`);
+}
+function streamResponse(stream, model, signal) {
+    const id = randomId(18, "chatcmpl_");
+    const created = Math.floor(Date.now() / 1000);
+    const chunk = (delta, finishReasonValue = null, extra = {}) => ({
+        id, object: "chat.completion.chunk", created, model,
+        choices: [{ index: 0, delta, finish_reason: finishReasonValue }], ...extra
+    });
+    const body = new ReadableStream({
+        async start(controller) {
+            const indexes = new Map();
+            const reasoningIndexes = new Set();
+            let nextTool = 0;
+            try {
+                controller.enqueue(sse(chunk({ role: "assistant" })));
+                for await (const event of stream) {
+                    if (signal?.aborted === true)
+                        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+                    const error = streamError(event);
+                    if (error !== undefined)
+                        throw error;
+                    if (event.contentBlockStart?.start?.toolUse !== undefined) {
+                        const sourceIndex = event.contentBlockStart.contentBlockIndex;
+                        const index = nextTool++;
+                        if (sourceIndex !== undefined)
+                            indexes.set(sourceIndex, index);
+                        const tool = event.contentBlockStart.start.toolUse;
+                        controller.enqueue(sse(chunk({ tool_calls: [{ index, id: tool.toolUseId, type: "function", function: { name: tool.name, arguments: "" } }] })));
+                    }
+                    const delta = event.contentBlockDelta?.delta;
+                    if (delta !== undefined && "text" in delta && typeof delta.text === "string")
+                        controller.enqueue(sse(chunk({ content: delta.text })));
+                    if (delta !== undefined && "toolUse" in delta && delta.toolUse !== undefined) {
+                        const sourceIndex = event.contentBlockDelta?.contentBlockIndex;
+                        const index = sourceIndex === undefined ? 0 : indexes.get(sourceIndex) ?? 0;
+                        controller.enqueue(sse(chunk({ tool_calls: [{ index, function: { arguments: delta.toolUse.input ?? "" } }] })));
+                    }
+                    if (delta !== undefined && "reasoningContent" in delta && delta.reasoningContent !== undefined) {
+                        const reasoningIndex = event.contentBlockDelta?.contentBlockIndex ?? 0;
+                        const isThinkingDelta = ("text" in delta.reasoningContent && typeof delta.reasoningContent.text === "string") ||
+                            ("signature" in delta.reasoningContent && typeof delta.reasoningContent.signature === "string");
+                        if (isThinkingDelta && !reasoningIndexes.has(reasoningIndex)) {
+                            reasoningIndexes.add(reasoningIndex);
+                            controller.enqueue(sse(chunk({ reasoning_details: [{
+                                        type: "thinking", index: reasoningIndex, phase: "start"
+                                    }] })));
+                        }
+                        if ("text" in delta.reasoningContent && typeof delta.reasoningContent.text === "string") {
+                            controller.enqueue(sse(chunk({
+                                reasoning: delta.reasoningContent.text,
+                                reasoning_details: [{
+                                        type: "thinking", index: reasoningIndex, phase: "delta",
+                                        thinking: delta.reasoningContent.text
+                                    }]
+                            })));
+                        }
+                        else if ("signature" in delta.reasoningContent && typeof delta.reasoningContent.signature === "string") {
+                            controller.enqueue(sse(chunk({ reasoning_details: [{
+                                        type: "thinking", index: reasoningIndex, phase: "signature",
+                                        signature: delta.reasoningContent.signature
+                                    }] })));
+                        }
+                        else if ("redactedContent" in delta.reasoningContent && delta.reasoningContent.redactedContent !== undefined) {
+                            controller.enqueue(sse(chunk({ reasoning_details: [{
+                                        type: "redacted_thinking", index: reasoningIndex, phase: "block",
+                                        data: Buffer.from(delta.reasoningContent.redactedContent).toString("base64")
+                                    }] })));
+                        }
+                    }
+                    const stoppedIndex = event.contentBlockStop?.contentBlockIndex;
+                    if (stoppedIndex !== undefined && reasoningIndexes.has(stoppedIndex)) {
+                        controller.enqueue(sse(chunk({ reasoning_details: [{
+                                    type: "thinking", index: stoppedIndex, phase: "stop"
+                                }] })));
+                    }
+                    if (event.messageStop !== undefined)
+                        controller.enqueue(sse(chunk({}, finishReason(event.messageStop.stopReason))));
+                    if (event.metadata?.usage !== undefined)
+                        controller.enqueue(sse(chunk({}, null, { usage: usage(event.metadata.usage) })));
+                }
+                controller.enqueue(sse("[DONE]"));
+                controller.close();
+            }
+            catch (error) {
+                if (signal?.aborted !== true) {
+                    controller.enqueue(sse({ error: { type: "provider_error", message: error instanceof Error ? error.message : String(error) } }));
+                    controller.enqueue(sse("[DONE]"));
+                }
+                controller.close();
+            }
+        }
+    });
+    return new Response(body, { headers: { "content-type": "text/event-stream; charset=utf-8" } });
+}
+function errorResponse(error) {
+    const metadata = record(record(error)?.$metadata);
+    const status = typeof metadata?.httpStatusCode === "number" ? metadata.httpStatusCode : 502;
+    return Response.json({ error: { type: "provider_error", message: error instanceof Error ? error.message : String(error) } }, { status });
+}
+export class BedrockProviderSource {
+    sourceId = "bedrock";
+    #control;
+    #runtime;
+    constructor(options = {}) {
+        this.#control = options.controlClient ?? new BedrockClient({});
+        this.#runtime = options.runtimeClient ?? new BedrockRuntimeClient({});
+    }
+    async discoverModels(signal) {
+        const foundation = await this.#control.send(new ListFoundationModelsCommand({ byProvider: "Anthropic" }), signal === undefined ? undefined : { abortSignal: signal });
+        const foundations = (foundation.modelSummaries ?? []).filter(anthropicFoundationModel);
+        const ids = new Set(foundations.map((model) => model.modelId));
+        const discovered = new Set(ids);
+        let nextToken;
+        do {
+            const profiles = await this.#control.send(new ListInferenceProfilesCommand({ ...(nextToken !== undefined ? { nextToken } : {}) }), signal === undefined ? undefined : { abortSignal: signal });
+            for (const profile of profiles.inferenceProfileSummaries ?? [])
+                if (activeAnthropicProfile(profile, ids))
+                    discovered.add(profile.inferenceProfileId);
+            nextToken = profiles.nextToken;
+        } while (nextToken !== undefined && nextToken.length > 0);
+        if (discovered.size === 0)
+            throw new Error("model discovery returned no active Anthropic Bedrock models");
+        return [...discovered].map((id) => ({ id }));
+    }
+    async chat(body, signal, _options) {
+        let input;
+        try {
+            input = toBedrockConverseInput(body);
+        }
+        catch (error) {
+            return Response.json({ error: { type: "invalid_request_error", message: error instanceof Error ? error.message : String(error) } }, { status: 400 });
+        }
+        const stream = record(body)?.stream === true;
+        const modelId = input.modelId;
+        if (modelId === undefined)
+            return errorResponse(new Error("Bedrock chat requires a model"));
+        try {
+            if (stream) {
+                const output = await this.#runtime.send(new ConverseStreamCommand(input), signal === undefined ? undefined : { abortSignal: signal });
+                if (output.stream === undefined)
+                    throw new Error("Bedrock returned no response stream");
+                return streamResponse(output.stream, modelId, signal);
+            }
+            const output = await this.#runtime.send(new ConverseCommand(input), signal === undefined ? undefined : { abortSignal: signal });
+            return Response.json(fromBedrockConverseOutput(output, modelId));
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    }
+    embeddings() {
+        return Promise.resolve(Response.json({ error: { type: "not_implemented", message: "Bedrock embeddings are not supported" } }, { status: 501 }));
+    }
+    reasoningCapabilities() {
+        return {
+            status: "unknown",
+            wireShape: "bedrock-converse",
+            provenance: "provider"
+        };
+    }
+    close() {
+        this.#control.destroy?.();
+        this.#runtime.destroy?.();
+    }
+}

package/dist/endpoint-health.js

@@ -38,6 +38,8 @@ export function providerAuthHeaders(auth, credential) {
             return { "x-api-key": credential };
         case "x-goog-api-key":
             return { "x-goog-api-key": credential };
+        case "aws-sdk":
+            return {};
         default: {
             const exhaustive = auth;
             throw new Error(`unknown provider authentication style: ${String(exhaustive)}`);

package/dist/index.d.ts

@@ -7,8 +7,10 @@ export { joinPath, ModelRoutedBackend, OpenAiBackend } from "./backend.js";
 export type { Backend, BackendModelRoute, BackendRequestOptions, RequestAttributionUpdate, ModelRoutedBackendOptions, OpenAiBackendOptions } from "./backend.js";
 export { AnthropicBackend, CodexResponsesBackend, GoogleGenAiBackend } from "./provider-backends.js";
 export type { ProviderBackendOptions, ProviderTransport } from "./provider-backends.js";
-export { CatalogBackend, isSubscriptionProvider, NoModelAvailableError, normalizeRouterConfigAliases, parseRouterConfig, routerConfigSchema, splitNamespacedModel, UnknownModelError } from "./router.js";
-export type { CatalogBackendOptions, CatalogModelInfo, ProviderPolicy, RouterConfig, } from "./router.js";
+export { BedrockProviderSource, fromBedrockConverseOutput, toBedrockConverseInput } from "./bedrock-source.js";
+export type { BedrockControlClient, BedrockProviderSourceOptions, BedrockRuntime } from "./bedrock-source.js";
+export { CatalogBackend, DEFAULT_LEADERBOARD_DURABLE_RETENTION_DAYS, DEFAULT_LEADERBOARD_LIVE_LIMIT, DEFAULT_LEADERBOARD_LIVE_TTL_HOURS, isSubscriptionProvider, leaderboardConfigSchema, NoModelAvailableError, modelPolicyAllowsModel, modelPolicyRuleMatches, normalizeRouterConfigAliases, parseRouterConfig, resolveLeaderboardConfig, routerConfigSchema, splitNamespacedModel, UnknownModelError } from "./router.js";
+export type { CatalogBackendOptions, CatalogModelInfo, LeaderboardConfig, ModelPolicy, ProviderPolicy, RouterConfig, } from "./router.js";
 export { API_PROVIDER_IDS, ApiProviderSource, parseDiscoveredModels, parseReasoningCapabilities, PROVIDER_IDS, SUBSCRIPTION_PROVIDER_IDS } from "./provider-source.js";
 export type { ApiProviderId, ApiProviderSourceOptions, DiscoveredModel, ProviderId, ProviderSource, ProviderSourceTransport, SubscriptionProviderId } from "./provider-source.js";
 export { endpointHealthProbe, probeEndpointHealth, providerAuthHeaders } from "./endpoint-health.js";

package/dist/index.js

@@ -3,7 +3,8 @@ export { startGateway } from "./server.js";
 export { startSwitchingGatewayProxy } from "./switching-proxy.js";
 export { joinPath, ModelRoutedBackend, OpenAiBackend } from "./backend.js";
 export { AnthropicBackend, CodexResponsesBackend, GoogleGenAiBackend } from "./provider-backends.js";
-export { CatalogBackend, isSubscriptionProvider, NoModelAvailableError, normalizeRouterConfigAliases, parseRouterConfig, routerConfigSchema, splitNamespacedModel, UnknownModelError } from "./router.js";
+export { BedrockProviderSource, fromBedrockConverseOutput, toBedrockConverseInput } from "./bedrock-source.js";
+export { CatalogBackend, DEFAULT_LEADERBOARD_DURABLE_RETENTION_DAYS, DEFAULT_LEADERBOARD_LIVE_LIMIT, DEFAULT_LEADERBOARD_LIVE_TTL_HOURS, isSubscriptionProvider, leaderboardConfigSchema, NoModelAvailableError, modelPolicyAllowsModel, modelPolicyRuleMatches, normalizeRouterConfigAliases, parseRouterConfig, resolveLeaderboardConfig, routerConfigSchema, splitNamespacedModel, UnknownModelError } from "./router.js";
 export { API_PROVIDER_IDS, ApiProviderSource, parseDiscoveredModels, parseReasoningCapabilities, PROVIDER_IDS, SUBSCRIPTION_PROVIDER_IDS } from "./provider-source.js";
 export { endpointHealthProbe, probeEndpointHealth, providerAuthHeaders } from "./endpoint-health.js";
 export { CapacityPool } from "./capacity-pool.js";

package/dist/provider-source.d.ts

@@ -1,9 +1,9 @@
 import { type ProviderDiscoveryResponseShape } from "@velum-labs/routekit-registry";
 import type { ModelReasoningCapabilities } from "@velum-labs/routekit-contracts";
 import type { BackendRequestOptions } from "./backend.js";
-export declare const API_PROVIDER_IDS: readonly ["openai", "anthropic", "google", "openrouter", "cliproxy"];
+export declare const API_PROVIDER_IDS: readonly ["openai", "anthropic", "bedrock", "google", "openrouter", "cliproxy"];
 export declare const SUBSCRIPTION_PROVIDER_IDS: readonly ["codex", "claude-code"];
-export declare const PROVIDER_IDS: readonly ["openai", "anthropic", "google", "openrouter", "cliproxy", "codex", "claude-code"];
+export declare const PROVIDER_IDS: readonly ["openai", "anthropic", "bedrock", "google", "openrouter", "cliproxy", "codex", "claude-code"];
 export type ApiProviderId = (typeof API_PROVIDER_IDS)[number];
 export type SubscriptionProviderId = (typeof SUBSCRIPTION_PROVIDER_IDS)[number];
 export type ProviderId = (typeof PROVIDER_IDS)[number];

package/dist/provider-source.js

@@ -4,6 +4,7 @@ import { AnthropicBackend, CodexResponsesBackend, GoogleGenAiBackend } from "./p
 export const API_PROVIDER_IDS = [
     "openai",
     "anthropic",
+    "bedrock",
     "google",
     "openrouter",
     "cliproxy"
@@ -52,6 +53,8 @@ function reasoningWireShape(provider) {
         case "anthropic":
         case "claude-code":
             return "anthropic";
+        case "bedrock":
+            return "bedrock-converse";
         case "google":
             return "google";
         case "openrouter":
@@ -195,6 +198,9 @@ export function parseDiscoveredModels(shape, payload, provider) {
         case "codex":
             entries = Array.isArray(payload.models) ? payload.models : [];
             break;
+        case "bedrock":
+            entries = Array.isArray(payload.models) ? payload.models : [];
+            break;
         default: {
             const unreachable = shape;
             throw new Error(`unsupported discovery response shape: ${String(unreachable)}`);
@@ -233,6 +239,8 @@ function authHeaders(style, credential) {
             return { "x-api-key": credential };
         case "x-goog-api-key":
             return { "x-goog-api-key": credential };
+        case "aws-sdk":
+            return {};
         default: {
             const unreachable = style;
             throw new Error(`unsupported provider auth style: ${String(unreachable)}`);
@@ -269,6 +277,8 @@ function providerBackend(protocol, baseUrl, apiKey, headers) {
             return new GoogleGenAiBackend(options);
         case "codex":
             return new CodexResponsesBackend(options);
+        case "bedrock":
+            throw new Error("Bedrock uses its dedicated AWS SDK provider source");
         default: {
             const unreachable = protocol;
             throw new Error(`unsupported provider wire protocol: ${String(unreachable)}`);

package/dist/router.d.ts

@@ -1,8 +1,8 @@
-import { z } from "zod";
 import type { ModelReasoningCapabilities } from "@velum-labs/routekit-contracts";
+import { z } from "zod";
 import type { Backend, BackendModelRoute, BackendRequestOptions } from "./backend.js";
-import { SUBSCRIPTION_PROVIDER_IDS } from "./provider-source.js";
 import type { ApiProviderId, ProviderId, ProviderSource } from "./provider-source.js";
+import { SUBSCRIPTION_PROVIDER_IDS } from "./provider-source.js";
 export declare class UnknownModelError extends Error {
     readonly model: string;
     constructor(model: string);
@@ -10,6 +10,10 @@ export declare class UnknownModelError extends Error {
 export declare class NoModelAvailableError extends Error {
     constructor();
 }
+declare const modelPolicySchema: z.ZodObject<{
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 declare const providerPolicySchema: z.ZodObject<{
     strategy: z.ZodDefault<z.ZodEnum<{
         sticky: "sticky";
@@ -20,6 +24,15 @@ declare const providerPolicySchema: z.ZodObject<{
     probeIntervalMs: z.ZodOptional<z.ZodNumber>;
     fallbackCooldownSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+export declare const DEFAULT_LEADERBOARD_LIVE_LIMIT = 1000;
+export declare const DEFAULT_LEADERBOARD_LIVE_TTL_HOURS = 24;
+export declare const DEFAULT_LEADERBOARD_DURABLE_RETENTION_DAYS = 14;
+export declare const leaderboardConfigSchema: z.ZodObject<{
+    liveLimit: z.ZodDefault<z.ZodNumber>;
+    liveTtlHours: z.ZodDefault<z.ZodNumber>;
+    durable: z.ZodDefault<z.ZodBoolean>;
+    durableRetentionDays: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
 export declare const routerConfigSchema: z.ZodObject<{
     providers: z.ZodObject<{
         openai: z.ZodOptional<z.ZodObject<{
@@ -42,6 +55,16 @@ export declare const routerConfigSchema: z.ZodObject<{
             probeIntervalMs: z.ZodOptional<z.ZodNumber>;
             fallbackCooldownSeconds: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
+        bedrock: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodDefault<z.ZodEnum<{
+                sticky: "sticky";
+                round_robin: "round_robin";
+                capacity_weighted: "capacity_weighted";
+            }>>;
+            switchThreshold: z.ZodDefault<z.ZodNumber>;
+            probeIntervalMs: z.ZodOptional<z.ZodNumber>;
+            fallbackCooldownSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
         google: z.ZodOptional<z.ZodObject<{
             strategy: z.ZodDefault<z.ZodEnum<{
                 sticky: "sticky";
@@ -94,12 +117,16 @@ export declare const routerConfigSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>;
     defaultModel: z.ZodOptional<z.ZodString>;
+    modelPolicy: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
     modelAliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     reasoningCapabilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         status: z.ZodDefault<z.ZodEnum<{
             unknown: "unknown";
-            unsupported: "unsupported";
             supported: "supported";
+            unsupported: "unsupported";
         }>>;
         efforts: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -116,9 +143,19 @@ export declare const routerConfigSchema: z.ZodObject<{
         adaptive: z.ZodOptional<z.ZodBoolean>;
         wireShape: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
+    leaderboard: z.ZodOptional<z.ZodObject<{
+        liveLimit: z.ZodDefault<z.ZodNumber>;
+        liveTtlHours: z.ZodDefault<z.ZodNumber>;
+        durable: z.ZodDefault<z.ZodBoolean>;
+        durableRetentionDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
+export type ModelPolicy = z.infer<typeof modelPolicySchema>;
 export type ProviderPolicy = z.infer<typeof providerPolicySchema>;
 export type RouterConfig = z.infer<typeof routerConfigSchema>;
+export type LeaderboardConfig = z.infer<typeof leaderboardConfigSchema>;
+/** Resolve leaderboard settings with schema defaults when the block is omitted. */
+export declare function resolveLeaderboardConfig(config: Pick<RouterConfig, "leaderboard">): LeaderboardConfig;
 export declare function normalizeRouterConfigAliases(value: unknown): unknown;
 export declare function splitNamespacedModel(model: string): {
     provider: ProviderId;
@@ -142,6 +179,10 @@ export type CatalogBackendOptions = {
     createApiSource?: (provider: ApiProviderId, env: Readonly<Record<string, string | undefined>>) => ProviderSource;
     signal?: AbortSignal;
 };
+/** Match an anchored model-policy glob where only `*` has special meaning. */
+export declare function modelPolicyRuleMatches(rule: string, canonicalModel: string): boolean;
+/** Apply inclusive allowlist then denylist; a matching deny rule always wins. */
+export declare function modelPolicyAllowsModel(policy: RouterConfig["modelPolicy"], canonicalModel: string): boolean;
 /**
  * Conservative fallback for models whose discovery API omits reasoning metadata.
  * Keep this allowlist tied to model families whose exact controls have been