@velum-labs/routekit-gateway 0.9.0

package/dist/backend.js

@@ -0,0 +1,143 @@
+import { reasoningSelectionOf } from "./adapters/openai-chat-wire.js";
+/** Join a base URL (which may end in `/`) with a route path. */
+export function joinPath(baseUrl, path) {
+    const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const suffix = path.startsWith("/") ? path : `/${path}`;
+    return `${base}${suffix}`;
+}
+/** An OpenAI Chat Completions backend reached over HTTP. */
+export class OpenAiBackend {
+    #baseUrl;
+    #apiKey;
+    #forceModel;
+    #extraHeaders;
+    defaultModel;
+    constructor(options) {
+        this.#baseUrl = options.baseUrl;
+        this.#apiKey = options.apiKey ?? "not-needed";
+        this.#forceModel = options.forceModel;
+        this.#extraHeaders = options.headers ?? {};
+        this.defaultModel = options.defaultModel;
+    }
+    #headers(options = {}) {
+        return {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.#apiKey}`,
+            ...this.#extraHeaders,
+            ...(options.modelCallId ? { "x-routekit-model-call-id": options.modelCallId } : {})
+        };
+    }
+    chat(body, signal, options = {}) {
+        const routed = this.#forceModel !== undefined && typeof body === "object" && body !== null && !Array.isArray(body)
+            ? { ...body, model: this.#forceModel }
+            : body;
+        const selection = reasoningSelectionOf(routed);
+        if ((selection.mode === "budget" || selection.mode === "adaptive") &&
+            options.reasoningCapabilities?.wireShape !== "openrouter") {
+            return Promise.resolve(Response.json({
+                error: {
+                    type: "invalid_request_error",
+                    message: `OpenAI Chat cannot represent reasoning mode "${selection.mode}"`
+                }
+            }, { status: 400 }));
+        }
+        const payload = options.reasoningCapabilities?.wireShape === "openrouter" &&
+            routed !== null &&
+            typeof routed === "object" &&
+            !Array.isArray(routed)
+            ? this.#openRouterReasoning(routed, selection)
+            : routed;
+        return fetch(joinPath(this.#baseUrl, "/chat/completions"), {
+            method: "POST",
+            headers: this.#headers(options),
+            body: JSON.stringify(payload),
+            ...(signal ? { signal } : {})
+        });
+    }
+    #openRouterReasoning(body, selection) {
+        const payload = { ...body };
+        delete payload.reasoning_effort;
+        if (selection.mode === "effort") {
+            payload.reasoning = { effort: selection.effort };
+        }
+        else if (selection.mode === "budget") {
+            payload.reasoning = { max_tokens: selection.budgetTokens };
+        }
+        else if (selection.mode === "adaptive") {
+            payload.reasoning = { enabled: true };
+        }
+        else if (selection.mode === "disabled") {
+            payload.reasoning = { enabled: false };
+        }
+        return payload;
+    }
+    models(signal) {
+        return fetch(joinPath(this.#baseUrl, "/models"), {
+            method: "GET",
+            headers: this.#headers(),
+            ...(signal ? { signal } : {})
+        });
+    }
+    embeddings(body, signal, options = {}) {
+        return fetch(joinPath(this.#baseUrl, "/embeddings"), {
+            method: "POST",
+            headers: this.#headers(options),
+            body: JSON.stringify(body),
+            ...(signal ? { signal } : {})
+        });
+    }
+}
+/**
+ * A backend that dispatches by requested model id: ids in `routedModelIds` go
+ * to the `routed` backend, everything else to `primary`. This lets selected
+ * model ids use a secondary destination.
+ */
+export class ModelRoutedBackend {
+    #routedIds;
+    #routed;
+    #primary;
+    defaultModel;
+    constructor(options) {
+        this.#routedIds = new Set(options.routedModelIds);
+        this.#routed = options.routed;
+        this.#primary = options.primary;
+        this.defaultModel = options.primary.defaultModel;
+    }
+    #backendFor(model) {
+        return model !== undefined && this.#routedIds.has(model) ? this.#routed : this.#primary;
+    }
+    listModelIds() {
+        const ids = [...(this.#primary.listModelIds?.() ?? (this.defaultModel !== undefined ? [this.defaultModel] : []))];
+        for (const id of this.#routedIds) {
+            if (!ids.includes(id))
+                ids.push(id);
+        }
+        return ids;
+    }
+    resolveModel(requested) {
+        if (requested !== undefined && this.#routedIds.has(requested))
+            return requested;
+        return this.#primary.resolveModel?.(requested) ?? this.#primary.defaultModel;
+    }
+    chat(body, signal, options = {}) {
+        const model = typeof body === "object" && body !== null && typeof body.model === "string"
+            ? body.model
+            : undefined;
+        return this.#backendFor(model).chat(body, signal, options);
+    }
+    models(signal) {
+        return this.#primary.models(signal);
+    }
+    embeddings(body, signal, options) {
+        const model = typeof body === "object" &&
+            body !== null &&
+            typeof body.model === "string"
+            ? body.model
+            : undefined;
+        return this.#backendFor(model).embeddings(body, signal, options);
+    }
+    async close() {
+        await this.#primary.close?.();
+        await this.#routed.close?.();
+    }
+}

package/dist/capacity-pool.d.ts

@@ -0,0 +1,31 @@
+export type CapacityPoolStrategy = "sticky" | "round_robin" | "capacity_weighted";
+export type CapacityPoolMember<T> = {
+    id: string;
+    value: T;
+    capacity?: number;
+    healthy?: boolean;
+    coolingUntil?: number;
+    quotaUtilization?: number;
+};
+export type CapacityLease<T> = {
+    readonly id: string;
+    readonly value: T;
+    release(): void;
+};
+export type CapacityPoolOptions = {
+    strategy?: CapacityPoolStrategy;
+    now?: () => number;
+};
+/**
+ * Generic health-, quota-, and cooldown-aware selector. Values are opaque, so
+ * the same policy can balance HTTP endpoint instances and provider accounts.
+ */
+export declare class CapacityPool<T> {
+    #private;
+    constructor(members: readonly CapacityPoolMember<T>[], options?: CapacityPoolOptions);
+    list(): readonly CapacityPoolMember<T>[];
+    acquire(stickyKey?: string, excluded?: ReadonlySet<string>): CapacityLease<T>;
+    update(id: string, state: Partial<Omit<CapacityPoolMember<T>, "id" | "value">>): void;
+    markHealthy(id: string): void;
+    markFailure(id: string, cooldownMs: number): void;
+}

package/dist/capacity-pool.js

@@ -0,0 +1,99 @@
+/**
+ * Generic health-, quota-, and cooldown-aware selector. Values are opaque, so
+ * the same policy can balance HTTP endpoint instances and provider accounts.
+ */
+export class CapacityPool {
+    #members;
+    #strategy;
+    #now;
+    #sticky = new Map();
+    #roundRobin = 0;
+    constructor(members, options = {}) {
+        if (members.length === 0)
+            throw new Error("capacity pool requires at least one member");
+        const ids = new Set();
+        this.#members = members.map((member) => {
+            if (ids.has(member.id))
+                throw new Error(`duplicate capacity pool member: ${member.id}`);
+            ids.add(member.id);
+            return { ...member, inFlight: 0, lastUsed: 0 };
+        });
+        this.#strategy = options.strategy ?? "capacity_weighted";
+        this.#now = options.now ?? Date.now;
+    }
+    list() {
+        return this.#members.map(({ inFlight: _inFlight, lastUsed: _lastUsed, ...member }) => member);
+    }
+    acquire(stickyKey = "default", excluded = new Set()) {
+        const now = this.#now();
+        const eligible = this.#members.filter((member) => !excluded.has(member.id) &&
+            member.healthy !== false &&
+            (member.coolingUntil === undefined || member.coolingUntil <= now) &&
+            (member.quotaUtilization === undefined || member.quotaUtilization < 1));
+        if (eligible.length === 0)
+            throw new Error("capacity pool is exhausted");
+        const selected = this.#select(eligible, stickyKey);
+        selected.inFlight += 1;
+        selected.lastUsed = now;
+        this.#sticky.set(stickyKey, selected.id);
+        let released = false;
+        return {
+            id: selected.id,
+            value: selected.value,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                selected.inFlight = Math.max(0, selected.inFlight - 1);
+            }
+        };
+    }
+    update(id, state) {
+        const member = this.#member(id);
+        Object.assign(member, state);
+        if (state.healthy === false) {
+            for (const [key, stickyId] of this.#sticky) {
+                if (stickyId === id)
+                    this.#sticky.delete(key);
+            }
+        }
+    }
+    markHealthy(id) {
+        this.update(id, { healthy: true, coolingUntil: undefined });
+    }
+    markFailure(id, cooldownMs) {
+        this.update(id, {
+            coolingUntil: this.#now() + Math.max(0, cooldownMs)
+        });
+    }
+    #member(id) {
+        const member = this.#members.find((candidate) => candidate.id === id);
+        if (member === undefined)
+            throw new Error(`unknown capacity pool member: ${id}`);
+        return member;
+    }
+    #select(eligible, stickyKey) {
+        switch (this.#strategy) {
+            case "sticky": {
+                const stickyId = this.#sticky.get(stickyKey);
+                return eligible.find((member) => member.id === stickyId) ?? eligible[0];
+            }
+            case "round_robin": {
+                const selected = eligible[this.#roundRobin % eligible.length];
+                this.#roundRobin += 1;
+                return selected;
+            }
+            case "capacity_weighted":
+                return [...eligible].sort((left, right) => this.#score(right) - this.#score(left))[0];
+            default: {
+                const unreachable = this.#strategy;
+                throw new Error(`unhandled capacity pool strategy: ${String(unreachable)}`);
+            }
+        }
+    }
+    #score(member) {
+        const capacity = Math.max(1, member.capacity ?? 1);
+        const quotaHeadroom = 1 - (member.quotaUtilization ?? 0);
+        return (capacity * quotaHeadroom) / (member.inFlight + 1);
+    }
+}

package/dist/cost.d.ts

@@ -0,0 +1,49 @@
+export type ModelPricing = {
+    inputPer1mTokens: number;
+    outputPer1mTokens: number;
+    currency?: string;
+};
+export type TokenUsage = {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+};
+export type ProviderCostMetadata = {
+    source: "provider" | "estimate";
+    costUsd?: number;
+    generationId?: string;
+    providerName?: string;
+    upstreamInferenceCost?: number;
+    cacheDiscount?: number;
+    lookupStatus?: string;
+    tokensPrompt?: number;
+    tokensCompletion?: number;
+    nativeTokensPrompt?: number;
+    nativeTokensCompletion?: number;
+};
+export type CallCostRecord = {
+    model: string;
+    usage: TokenUsage;
+    costUsd?: number;
+    providerCostUsd?: number;
+    unknownUsage: boolean;
+    unknownCost: boolean;
+    partialUsage?: boolean;
+    currency: string;
+    providerCost?: ProviderCostMetadata;
+};
+export declare const DEFAULT_MODEL_PRICING: Readonly<Record<string, ModelPricing>>;
+export declare function parseUsage(value: unknown): TokenUsage | undefined;
+export declare function parseUsageFromSse(text: string): TokenUsage | undefined;
+export declare function lookupPricing(model: string, overrides?: Readonly<Record<string, ModelPricing>>): ModelPricing | undefined;
+export declare function estimateCost(usage: TokenUsage, pricing: ModelPricing | undefined): {
+    costUsd: number;
+    partialUsage: boolean;
+} | undefined;
+export declare function meterCall(input: {
+    model: string;
+    usage?: TokenUsage;
+    pricing?: Readonly<Record<string, ModelPricing>>;
+    providerCost?: ProviderCostMetadata;
+}): CallCostRecord;
+export declare function formatUsd(amount: number, currency?: string): string;

package/dist/cost.js

@@ -0,0 +1,112 @@
+import { DEFAULT_MODEL_PRICING as REGISTRY_MODEL_PRICING, PRICING_ALIASES } from "@velum-labs/routekit-registry";
+import { decodeBufferedSse } from "./sse/parse.js";
+const DEFAULT_CURRENCY = "USD";
+export const DEFAULT_MODEL_PRICING = REGISTRY_MODEL_PRICING;
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function nonnegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+export function parseUsage(value) {
+    const usage = asRecord(value);
+    if (usage === undefined)
+        return undefined;
+    const prompt = nonnegativeNumber(usage.prompt_tokens) ?? nonnegativeNumber(usage.input_tokens);
+    const completion = nonnegativeNumber(usage.completion_tokens) ?? nonnegativeNumber(usage.output_tokens);
+    const total = nonnegativeNumber(usage.total_tokens) ??
+        (prompt !== undefined && completion !== undefined ? prompt + completion : undefined);
+    if (prompt === undefined && completion === undefined && total === undefined)
+        return undefined;
+    return {
+        ...(prompt !== undefined ? { promptTokens: prompt } : {}),
+        ...(completion !== undefined ? { completionTokens: completion } : {}),
+        ...(total !== undefined ? { totalTokens: total } : {})
+    };
+}
+export function parseUsageFromSse(text) {
+    let usage;
+    for (const event of decodeBufferedSse(text)) {
+        const data = event.data.trim();
+        if (data.length === 0 || data === "[DONE]")
+            continue;
+        try {
+            const parsed = asRecord(JSON.parse(data));
+            const candidate = parseUsage(parsed?.usage) ??
+                parseUsage(asRecord(parsed?.response)?.usage);
+            if (candidate !== undefined)
+                usage = candidate;
+        }
+        catch {
+            // Usage extraction is observational and ignores malformed events.
+        }
+    }
+    return usage;
+}
+function canonicalPricingKey(model) {
+    const direct = Object.keys(DEFAULT_MODEL_PRICING).find((candidate) => candidate.toLowerCase() === model.toLowerCase());
+    if (direct !== undefined)
+        return direct;
+    const alias = Object.entries(PRICING_ALIASES).find(([candidate]) => candidate.toLowerCase() === model.toLowerCase());
+    return alias?.[1] ?? model;
+}
+export function lookupPricing(model, overrides = {}) {
+    const combined = {
+        ...DEFAULT_MODEL_PRICING,
+        ...overrides
+    };
+    const key = canonicalPricingKey(model);
+    const entry = Object.entries(combined).find(([candidate]) => candidate.toLowerCase() === key.toLowerCase());
+    return entry?.[1];
+}
+export function estimateCost(usage, pricing) {
+    if (pricing === undefined)
+        return undefined;
+    const hasPrompt = usage.promptTokens !== undefined;
+    const hasCompletion = usage.completionTokens !== undefined;
+    if (!hasPrompt && !hasCompletion)
+        return undefined;
+    return {
+        costUsd: ((usage.promptTokens ?? 0) * pricing.inputPer1mTokens +
+            (usage.completionTokens ?? 0) * pricing.outputPer1mTokens) /
+            1_000_000,
+        partialUsage: !hasPrompt || !hasCompletion
+    };
+}
+export function meterCall(input) {
+    const usage = input.usage ?? {};
+    const providerLookupFailed = input.providerCost?.source === "provider" &&
+        input.providerCost.costUsd === undefined &&
+        input.providerCost.lookupStatus !== undefined;
+    const configuredPricing = input.pricing ?? {};
+    const pricing = providerLookupFailed
+        ? Object.entries(configuredPricing).find(([candidate]) => candidate.toLowerCase() === input.model.toLowerCase())?.[1]
+        : lookupPricing(input.model, configuredPricing);
+    const estimate = estimateCost(usage, pricing);
+    const exact = input.providerCost?.source === "provider" ? input.providerCost.costUsd : undefined;
+    const providerCostUsd = exact ?? estimate?.costUsd;
+    const providerCost = providerLookupFailed && providerCostUsd !== undefined
+        ? {
+            ...input.providerCost,
+            source: "estimate",
+            costUsd: providerCostUsd,
+            lookupStatus: `fallback_${input.providerCost?.lookupStatus}`
+        }
+        : input.providerCost;
+    return {
+        model: input.model,
+        usage,
+        ...(providerCostUsd !== undefined ? { costUsd: providerCostUsd, providerCostUsd } : {}),
+        unknownUsage: input.usage === undefined,
+        unknownCost: providerCostUsd === undefined,
+        ...(estimate?.partialUsage === true ? { partialUsage: true } : {}),
+        currency: pricing?.currency ?? DEFAULT_CURRENCY,
+        ...(providerCost !== undefined ? { providerCost } : {})
+    };
+}
+export function formatUsd(amount, currency = DEFAULT_CURRENCY) {
+    const digits = amount >= 1 ? 2 : 4;
+    return `${currency === "USD" ? "$" : ""}${amount.toFixed(digits)}${currency === "USD" ? "" : ` ${currency}`}`;
+}

package/dist/endpoint-health.d.ts

@@ -0,0 +1,54 @@
+import type { ProviderAuthStyle } from "@velum-labs/routekit-registry";
+export type UrlEndpointConfig = {
+    endpointId: string;
+    model: string;
+    provider?: string;
+    baseUrl: string;
+    dialect: "openai" | "anthropic" | "google" | "codex";
+    headers?: Record<string, string>;
+};
+export type AccountEndpointConfig = {
+    endpointId: string;
+    model: string;
+    account: "claude-code" | "codex";
+};
+export type ModelEndpointConfig = UrlEndpointConfig | AccountEndpointConfig;
+export type EndpointHealthProbe = {
+    url: string;
+    headers: Readonly<Record<string, string>>;
+    invalidStatuses: readonly number[];
+};
+export type EndpointHealthProbePlan = {
+    supported: true;
+    probe: EndpointHealthProbe;
+} | {
+    supported: false;
+    reason: string;
+};
+export type EndpointHealthResult = {
+    kind: "response";
+    ok: boolean;
+    status: number;
+    authRejected: boolean;
+} | {
+    kind: "unsupported";
+    reason: string;
+} | {
+    kind: "error";
+    error: string;
+};
+type Fetcher = (input: string | URL, init?: RequestInit) => Promise<Response>;
+/** Build the registry-defined authentication header without mutating callers. */
+export declare function providerAuthHeaders(auth: ProviderAuthStyle, credential: string | undefined): Record<string, string>;
+/**
+ * Resolve a read-only endpoint health probe from registry metadata, falling
+ * back to the configured provider-native dialect for custom endpoints.
+ */
+export declare function endpointHealthProbe(endpoint: ModelEndpointConfig, credential?: string): EndpointHealthProbePlan;
+/** Execute a provider-native health probe without returning request secrets. */
+export declare function probeEndpointHealth(endpoint: ModelEndpointConfig, options?: {
+    credential?: string;
+    timeoutMs?: number;
+    fetchImpl?: Fetcher;
+}): Promise<EndpointHealthResult>;
+export {};

package/dist/endpoint-health.js

@@ -0,0 +1,123 @@
+import { PROVIDERS, providerKeyProbe } from "@velum-labs/routekit-registry";
+function isAccountEndpointConfig(endpoint) {
+    return "account" in endpoint;
+}
+function nativeDialectProbe(dialect) {
+    switch (dialect) {
+        case "openai":
+            return { path: "/models", auth: "bearer", invalidStatuses: [401, 403] };
+        case "anthropic":
+            return {
+                path: "/models",
+                auth: "x-api-key",
+                extraHeaders: { "anthropic-version": "2023-06-01" },
+                invalidStatuses: [401, 403]
+            };
+        case "google":
+            return {
+                path: "/models",
+                auth: "x-goog-api-key",
+                invalidStatuses: [400, 401, 403]
+            };
+        case "codex":
+            return undefined;
+        default: {
+            const exhaustive = dialect;
+            throw new Error(`unknown endpoint dialect: ${String(exhaustive)}`);
+        }
+    }
+}
+/** Build the registry-defined authentication header without mutating callers. */
+export function providerAuthHeaders(auth, credential) {
+    if (credential === undefined || credential.length === 0)
+        return {};
+    switch (auth) {
+        case "bearer":
+            return { authorization: `Bearer ${credential}` };
+        case "x-api-key":
+            return { "x-api-key": credential };
+        case "x-goog-api-key":
+            return { "x-goog-api-key": credential };
+        default: {
+            const exhaustive = auth;
+            throw new Error(`unknown provider authentication style: ${String(exhaustive)}`);
+        }
+    }
+}
+function probeUrl(baseUrl, probePath) {
+    const url = new URL(baseUrl);
+    const baseSegments = url.pathname.split("/").filter(Boolean);
+    const probeSegments = probePath.split("/").filter(Boolean);
+    let overlap = Math.min(baseSegments.length, probeSegments.length);
+    while (overlap > 0 &&
+        !baseSegments
+            .slice(baseSegments.length - overlap)
+            .every((segment, index) => segment === probeSegments[index])) {
+        overlap -= 1;
+    }
+    url.pathname = `/${[...baseSegments, ...probeSegments.slice(overlap)].join("/")}`;
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+}
+/**
+ * Resolve a read-only endpoint health probe from registry metadata, falling
+ * back to the configured provider-native dialect for custom endpoints.
+ */
+export function endpointHealthProbe(endpoint, credential) {
+    if (isAccountEndpointConfig(endpoint)) {
+        return {
+            supported: false,
+            reason: "account-backed endpoint health is reported by the subscription pool"
+        };
+    }
+    const registryProbe = endpoint.provider !== undefined ? providerKeyProbe(endpoint.provider) : undefined;
+    const providerInfo = endpoint.provider !== undefined ? PROVIDERS[endpoint.provider] : undefined;
+    if (registryProbe === undefined &&
+        providerInfo?.apiCompatibility === "openai-responses") {
+        return {
+            supported: false,
+            reason: "no safe read-only health probe is defined for the Codex responses provider"
+        };
+    }
+    const metadata = registryProbe ?? nativeDialectProbe(endpoint.dialect);
+    if (metadata === undefined) {
+        return {
+            supported: false,
+            reason: "no safe read-only health probe is defined for the Codex responses dialect"
+        };
+    }
+    return {
+        supported: true,
+        probe: {
+            url: probeUrl(endpoint.baseUrl, metadata.path),
+            headers: {
+                ...endpoint.headers,
+                ...metadata.extraHeaders,
+                ...providerAuthHeaders(metadata.auth, credential)
+            },
+            invalidStatuses: metadata.invalidStatuses
+        }
+    };
+}
+/** Execute a provider-native health probe without returning request secrets. */
+export async function probeEndpointHealth(endpoint, options = {}) {
+    const plan = endpointHealthProbe(endpoint, options.credential);
+    if (!plan.supported)
+        return { kind: "unsupported", reason: plan.reason };
+    try {
+        const response = await (options.fetchImpl ?? fetch)(plan.probe.url, {
+            headers: plan.probe.headers,
+            signal: AbortSignal.timeout(options.timeoutMs ?? 5_000)
+        });
+        return {
+            kind: "response",
+            ok: response.ok,
+            status: response.status,
+            authRejected: plan.probe.invalidStatuses.includes(response.status)
+        };
+    }
+    catch {
+        return { kind: "error", error: "health probe request failed" };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+/** Product-neutral RouteKit gateway and router. */
+export { startGateway } from "./server.js";
+export type { Gateway, GatewayOptions, ProviderRelay, ProviderRelayDialect } from "./server.js";
+export { startSwitchingGatewayProxy } from "./switching-proxy.js";
+export type { SwitchingGatewayProxy } from "./switching-proxy.js";
+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 { 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";
+export type { AccountEndpointConfig, EndpointHealthProbe, EndpointHealthProbePlan, EndpointHealthResult, ModelEndpointConfig, UrlEndpointConfig } from "./endpoint-health.js";
+export { CapacityPool } from "./capacity-pool.js";
+export type { CapacityLease, CapacityPoolMember, CapacityPoolOptions, CapacityPoolStrategy } from "./capacity-pool.js";
+export { effectiveModel, isStream, withDefaultModel } from "./adapters/chat.js";
+export { isCursorChatBody, translateCursorRequest } from "./adapters/cursor.js";
+export { anthropicModelsResponse, anthropicToChat, CLAUDE_ALIAS_PREFIX, chatToAnthropicMessage, claudeModelAlias, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic } from "./adapters/anthropic.js";
+export type { AnthropicRequest } from "./adapters/anthropic.js";
+export { chatToResponses, customToolNames, handleResponses, openAiSseToResponses, responsesToChat, responsesToolRegistry } from "./adapters/responses.js";
+export type { ResponsesRequest, ResponsesToolKind, ResponsesToolRegistry } from "./adapters/responses.js";
+export { MAX_WEB_SEARCHES_PER_TURN, resolveWebSearchExecutor } from "./adapters/web-search.js";
+export type { WebSearchDialect, WebSearchExecutor, WebSearchOutcome } from "./adapters/web-search.js";
+export { DIALECT_DROPPED_ATTRIBUTE, droppedField, resetDroppedFieldWarnings, withDroppedFieldSpan } from "./adapters/dropped.js";
+export type { DialectName, DroppedFieldSpan } from "./adapters/dropped.js";
+export { ACP_PROTOCOL_VERSION, runAcpAgent } from "./acp-agent.js";
+export type { AcpAgentOptions, AcpRunner, AcpRunnerInput, AcpRunnerResult } from "./acp-agent.js";
+export { ACP_REGISTRY_URL, fetchAcpRegistry, installAcpAdapters } from "./acp-registry.js";
+export type { AcpRegistry, AcpRegistryAgent, AcpRegistryFetcher, InstallAcpAdaptersOptions, InstalledAcpAdapter } from "./acp-registry.js";
+export { DEFAULT_MODEL_PRICING, estimateCost, formatUsd, lookupPricing, meterCall, parseUsage, parseUsageFromSse } from "./cost.js";
+export type { CallCostRecord, ModelPricing, ProviderCostMetadata, TokenUsage } from "./cost.js";
+export { buildModelCallRecord, MODEL_CALL_ID_HEADER, modelCallId, readProducerVersion, resolveProducerGitSha, responseBodyHash, UNKNOWN_GIT_SHA } from "./provenance.js";
+export type { GatewayDialect, ModelCallRecord, ModelGatewayCallContext, ModelGatewayCallResult, ProvenanceSink } from "./provenance.js";
+export { authorizedRequest } from "./auth.js";
+export { errorEvent, finishChunk, noticeChunk, reasoningChunk, sseResponse } from "./sse-wire.js";
+export { ChatStreamAssembler } from "./sse/chat-assembler.js";
+export type { AssembledToolCall } from "./sse/chat-assembler.js";
+export { decodeBufferedSse, SseDecoder, SseParseError } from "./sse/parse.js";