@cloudpeers-jkl/model-router 0.2.0

package/README.md

@@ -0,0 +1,74 @@
+# @cloudpeers-jkl/model-router
+
+cloudpeers inference router — **embedded library** (Amendment A1.1: no
+central data plane). Each service embeds the router behind its existing
+seam; the sovereignty privacy gate runs in-process, where the data lives.
+Control plane (tier config, approved providers, gate stage, metering
+aggregation) distributes from the platform as deploy-time config.
+
+Canonical spec: `cloudpeers-github/docs/architecture/INFERENCE_ROUTER_SPEC.md`
+(read Amendment A1 first). Pointer + contract map: `mcp/docs/INFERENCE_ROUTER_SPEC.md`.
+
+## Two APIs, one enforcement path
+
+```ts
+import {
+  routeModel, routeMessages, defaultBackendAdapters,
+} from '@cloudpeers-jkl/model-router';
+
+const deps = {
+  adapters: defaultBackendAdapters(),   // selfhosted, gemini, anthropic — no OpenAI (directive)
+  meter,                                // the embedding service's token meter
+  quota,                                // and quota check (token-tracker in mcp)
+  hooks: {},                            // §7 mandate/policy/attribution — fail closed when named but unwired
+};
+
+// v1 convenience API — prompt in, text out
+const r = await routeModel({
+  taskClass: 'coaching',
+  prompt: '…',
+  sovereigntyClass: 'local_only',       // REQUIRED — the caller declares the data class
+  operation: 'lab_coaching',
+  userId, serviceId: 'experience-labs',
+}, deps);
+
+// Spec API — Anthropic Messages shape + cloudpeers envelope (§4)
+const { response, usage } = await routeMessages({
+  messages: [{ role: 'user', content: '…' }],
+  max_tokens: 1000,
+  cloudpeers: { v: 1, sovereignty_class: 'aggregate_only', task_class: 'reasoning' },
+}, { userId, serviceId, operation: 'my_op' }, deps);
+```
+
+In mcp, don't construct deps yourself — import the prewired composition from
+`server/lib/model-router.ts`.
+
+## Behavior contracts
+
+- **Privacy gate stages** (interim cloud-PHI policy 2026-07-09):
+  MONITOR (default, logs `[privacy-gate-monitor]` would_block lines) →
+  BAA egress (`MODEL_ROUTER_BAA_PROVIDERS`) → enforce
+  (`MODEL_PRIVACY_GATE_ENFORCE=true`, fail closed). The monitor log lines are
+  a stable interface — the Stage-3 flip decision is made from them.
+- **Fail closed:** `mandate_id`/`policy_id` named with no wired hook → blocked
+  (412). BYOK → 501 (deferred, A1.2). `tool_use_strict` with no capable
+  backend → 422. Errors carry `statusCode`/`code` for HTTP mapping.
+- **Static routing** (confidence v1): task-class tier chains in `policy.ts`;
+  schema-validation failure escalates a tier; exhausted chain returns
+  best-effort marked `degraded`.
+- **Uniform metering:** every call reports through the injected meter with a
+  `router` metadata block — provider, tier, taskClass, gate.
+
+## Env (deploy-time control plane)
+
+`MODEL_ROUTER_TIER0_MODEL` / `MODEL_ROUTER_TIER0_URL` (Tier 0 self-hosted),
+`MODEL_ROUTER_GEMINI_MODEL`, `MODEL_ROUTER_ANTHROPIC_MODEL`,
+`MODEL_ROUTER_BAA_PROVIDERS`, `MODEL_PRIVACY_GATE_ENFORCE`,
+plus the provider keys (`ANTHROPIC_API_KEY`, `GEMINI_SERVER_API_KEY`/`GEMINI_API_KEY`/`GOOGLE_AI_API_KEY`).
+
+## Publishing
+
+Not yet published. Consumed in-repo via relative imports (see
+`server/lib/model-router.ts`). To publish for external consumers
+(carepeers seams, gemini-proxy in Deno): `npm run build && npm publish`
+from this directory — `dist/` is what ships.

package/dist/adapters/anthropic.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Anthropic adapter — the lingua franca IS the Anthropic Messages shape, so
+ * translation is identity (§5.3: smoke test only). fetch-based, the
+ * carepeers-established pattern (no SDK dependency).
+ */
+import type { BackendAdapter } from '../types.js';
+export declare function anthropicAdapter(): BackendAdapter;

package/dist/adapters/anthropic.js

@@ -0,0 +1,121 @@
+const API_URL = 'https://api.anthropic.com/v1/messages';
+const API_VERSION = '2023-06-01';
+const TIMEOUT_MS = 30000;
+function apiKey() {
+    return process.env.ANTHROPIC_API_KEY ?? '';
+}
+function buildBody(req, stream) {
+    return JSON.stringify({
+        model: req.model,
+        max_tokens: req.max_tokens ?? 1024,
+        ...(req.temperature !== undefined ? { temperature: req.temperature } : {}),
+        ...(req.system ? { system: req.system } : {}),
+        ...(req.tools?.length ? { tools: req.tools } : {}),
+        ...(req.tool_choice ? { tool_choice: req.tool_choice } : {}),
+        messages: req.messages,
+        ...(stream ? { stream: true } : {}),
+    });
+}
+export function anthropicAdapter() {
+    return {
+        id: 'anthropic',
+        display_name: 'Anthropic Messages API',
+        surface: 'cloud',
+        supports_streaming: true,
+        supports_tool_use: true,
+        supports_prompt_caching: true,
+        tool_use: {
+            supports_tool_use: true,
+            supports_parallel_tool_use: true,
+            preserves_block_position: true,
+            supports_streaming_tool_use: true,
+            max_tools_per_request: null,
+        },
+        available: () => !!apiKey(),
+        async isEligible(_req, _ctx) {
+            if (!apiKey())
+                return { eligible: false, reason: 'ANTHROPIC_API_KEY not configured' };
+            return { eligible: true, estimated_latency_ms: 2000, estimated_cost_cents: 0 };
+        },
+        async invoke(req, ctx) {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+            ctx.signal?.addEventListener('abort', () => controller.abort(), { once: true });
+            try {
+                const res = await fetch(API_URL, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey(), 'anthropic-version': API_VERSION },
+                    body: buildBody(req, false),
+                    signal: controller.signal,
+                });
+                if (!res.ok)
+                    throw new Error(`Anthropic ${res.status}`);
+                const data = (await res.json());
+                if (!data.content?.length)
+                    throw new Error('Anthropic returned empty content');
+                return data;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+        async *invokeStream(req, ctx) {
+            const controller = new AbortController();
+            // Timeout covers time-to-first-byte only; a healthy stream is unbounded.
+            const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+            ctx.signal?.addEventListener('abort', () => controller.abort(), { once: true });
+            let res;
+            try {
+                res = await fetch(API_URL, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey(), 'anthropic-version': API_VERSION },
+                    body: buildBody(req, true),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!res.ok || !res.body)
+                throw new Error(`Anthropic ${res.status}`);
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const payload = line.slice(6).trim();
+                        if (!payload)
+                            continue;
+                        const event = JSON.parse(payload);
+                        yield event;
+                        if (event.type === 'message_stop')
+                            return;
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        },
+        reportUsage(_req, res) {
+            return {
+                backend_id: 'anthropic',
+                tokens_in: res.usage?.input_tokens ?? 0,
+                tokens_out: res.usage?.output_tokens ?? 0,
+                latency_ms: 0, // overwritten by the router's measured value
+                cost_cents: 0, // real cost computed by the platform meter (calculate_token_cost)
+                cache_hit: false, // v1 router does not set cache_control
+                sovereignty_class: 'externalizable', // overwritten by the router from the envelope
+            };
+        },
+    };
+}

package/dist/adapters/gemini.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Gemini adapter — owns the Anthropic-shape ⇄ generativelanguage translation
+ * (§5.2). Translation helpers are exported pure so the mandatory round-trip
+ * tests (§13) run without a network mock.
+ *
+ * Tool use is declared unsupported in v1: the Anthropic tool_use ⇄ Gemini
+ * functionCall mapping is the §8 hard problem and the anthropic backend is
+ * the v1 tool path. Requests with tools skip this backend (§8.2).
+ */
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import type { AnthropicMessagesRequest, AnthropicMessagesResponse, AnthropicSSEEvent, BackendAdapter } from '../types.js';
+/** Anthropic messages → Gemini `contents` (role user→user, assistant→model). */
+export declare function anthropicToGeminiContents(req: AnthropicMessagesRequest): {
+    role: "user" | "model";
+    parts: {
+        text: string;
+    }[];
+}[];
+export declare function geminiFinishToStopReason(finishReason: string | undefined): string;
+/** Gemini response fields → Anthropic Messages response shape. */
+export declare function geminiResponseToAnthropic(fields: {
+    text: string;
+    model: string;
+    finishReason?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+}): AnthropicMessagesResponse;
+/**
+ * Synthesize the Anthropic SSE event sequence from a Gemini chunk stream,
+ * preserving content_block_* boundaries (§5.2 streaming shape).
+ */
+export declare function geminiChunksToSSE(chunks: AsyncIterable<{
+    text: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    finishReason?: string;
+}>, model: string): AsyncIterable<AnthropicSSEEvent>;
+export declare function geminiAdapter(opts?: {
+    client?: GoogleGenerativeAI;
+}): BackendAdapter;

package/dist/adapters/gemini.js

@@ -0,0 +1,151 @@
+/**
+ * Gemini adapter — owns the Anthropic-shape ⇄ generativelanguage translation
+ * (§5.2). Translation helpers are exported pure so the mandatory round-trip
+ * tests (§13) run without a network mock.
+ *
+ * Tool use is declared unsupported in v1: the Anthropic tool_use ⇄ Gemini
+ * functionCall mapping is the §8 hard problem and the anthropic backend is
+ * the v1 tool path. Requests with tools skip this backend (§8.2).
+ */
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { randomUUID } from 'node:crypto';
+function blockText(content) {
+    if (typeof content === 'string')
+        return content;
+    return content
+        .filter((b) => b.type === 'text')
+        .map((b) => b.text)
+        .join('\n');
+}
+/** Anthropic messages → Gemini `contents` (role user→user, assistant→model). */
+export function anthropicToGeminiContents(req) {
+    return req.messages.map((m) => ({
+        role: m.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: blockText(m.content) }],
+    }));
+}
+export function geminiFinishToStopReason(finishReason) {
+    if (finishReason === 'MAX_TOKENS')
+        return 'max_tokens';
+    return 'end_turn';
+}
+/** Gemini response fields → Anthropic Messages response shape. */
+export function geminiResponseToAnthropic(fields) {
+    return {
+        id: `msg_gemini_${randomUUID()}`,
+        type: 'message',
+        role: 'assistant',
+        content: [{ type: 'text', text: fields.text }],
+        model: fields.model,
+        stop_reason: geminiFinishToStopReason(fields.finishReason),
+        usage: {
+            input_tokens: fields.promptTokens ?? 0,
+            output_tokens: fields.completionTokens ?? 0,
+        },
+    };
+}
+/**
+ * Synthesize the Anthropic SSE event sequence from a Gemini chunk stream,
+ * preserving content_block_* boundaries (§5.2 streaming shape).
+ */
+export async function* geminiChunksToSSE(chunks, model) {
+    const id = `msg_gemini_${randomUUID()}`;
+    yield {
+        type: 'message_start',
+        message: { id, type: 'message', role: 'assistant', content: [], model, stop_reason: null, usage: { input_tokens: 0, output_tokens: 0 } },
+    };
+    yield { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } };
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let finishReason;
+    for await (const chunk of chunks) {
+        if (chunk.text)
+            yield { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: chunk.text } };
+        if (chunk.promptTokens !== undefined)
+            inputTokens = chunk.promptTokens;
+        if (chunk.completionTokens !== undefined)
+            outputTokens = chunk.completionTokens;
+        if (chunk.finishReason)
+            finishReason = chunk.finishReason;
+    }
+    yield { type: 'content_block_stop', index: 0 };
+    yield {
+        type: 'message_delta',
+        delta: { stop_reason: geminiFinishToStopReason(finishReason) },
+        usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+    };
+    yield { type: 'message_stop' };
+}
+export function geminiAdapter(opts = {}) {
+    const apiKey = process.env.GEMINI_SERVER_API_KEY || process.env.GEMINI_API_KEY || process.env.GOOGLE_AI_API_KEY || '';
+    const client = opts.client ?? (apiKey ? new GoogleGenerativeAI(apiKey) : null);
+    function model(req) {
+        if (!client)
+            throw new Error('Gemini key not configured');
+        return client.getGenerativeModel({
+            model: req.model ?? '',
+            systemInstruction: req.system,
+            generationConfig: { temperature: req.temperature, maxOutputTokens: req.max_tokens },
+        });
+    }
+    return {
+        id: 'gemini',
+        display_name: 'Google Gemini (generativelanguage)',
+        surface: 'cloud',
+        supports_streaming: true,
+        supports_tool_use: false,
+        supports_prompt_caching: false,
+        tool_use: {
+            supports_tool_use: false,
+            supports_parallel_tool_use: false,
+            preserves_block_position: false,
+            supports_streaming_tool_use: false,
+            max_tools_per_request: 0,
+        },
+        available: () => !!client,
+        async isEligible(req, _ctx) {
+            if (!client)
+                return { eligible: false, reason: 'Gemini key not configured' };
+            if (req.tools?.length)
+                return { eligible: false, reason: 'tool use not supported by gemini adapter (v1)' };
+            return { eligible: true, estimated_latency_ms: 300, estimated_cost_cents: 0 };
+        },
+        async invoke(req, _ctx) {
+            const result = await model(req).generateContent({ contents: anthropicToGeminiContents(req) });
+            const usage = result.response.usageMetadata;
+            return geminiResponseToAnthropic({
+                text: result.response.text(),
+                model: req.model ?? 'gemini',
+                finishReason: result.response.candidates?.[0]?.finishReason,
+                promptTokens: usage?.promptTokenCount,
+                completionTokens: usage?.candidatesTokenCount,
+            });
+        },
+        async *invokeStream(req, _ctx) {
+            const result = await model(req).generateContentStream({ contents: anthropicToGeminiContents(req) });
+            async function* chunks() {
+                for await (const chunk of result.stream) {
+                    yield {
+                        text: chunk.text(),
+                        promptTokens: chunk.usageMetadata?.promptTokenCount,
+                        completionTokens: chunk.usageMetadata?.candidatesTokenCount,
+                        finishReason: chunk.candidates?.[0]?.finishReason,
+                    };
+                }
+            }
+            yield* geminiChunksToSSE(chunks(), req.model ?? 'gemini');
+        },
+        reportUsage(_req, res) {
+            return {
+                backend_id: 'gemini',
+                tokens_in: res.usage?.input_tokens ?? 0,
+                tokens_out: res.usage?.output_tokens ?? 0,
+                latency_ms: 0, // overwritten by the router's measured value
+                cost_cents: 0, // real cost computed by the platform meter (calculate_token_cost)
+                cache_hit: false,
+                cache_unsupported: true,
+                sovereignty_class: 'externalizable', // overwritten by the router from the envelope
+            };
+        },
+    };
+}

package/dist/adapters/selfhosted.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tier 0 — self-hosted in-boundary (surface: self_hosted). Honest stub until
+ * the OpenMed/Nemotron serving path lands (Q3 eval tracks): unavailable
+ * unless MODEL_ROUTER_TIER0_URL is set, then a minimal
+ * POST {model, prompt} → {text} contract. No streaming, no tools.
+ */
+import type { AnthropicMessagesRequest, BackendAdapter } from '../types.js';
+/**
+ * Flatten Anthropic messages to a single prompt. A lone user message passes
+ * through verbatim (byte-identical to what routeModel v1 sent); multi-turn
+ * conversations get role-prefixed lines.
+ */
+export declare function messagesToPrompt(req: AnthropicMessagesRequest): string;
+export declare function selfhostedAdapter(): BackendAdapter;

package/dist/adapters/selfhosted.js

@@ -0,0 +1,96 @@
+const TIMEOUT_MS = 30000;
+/**
+ * Flatten Anthropic messages to a single prompt. A lone user message passes
+ * through verbatim (byte-identical to what routeModel v1 sent); multi-turn
+ * conversations get role-prefixed lines.
+ */
+export function messagesToPrompt(req) {
+    const text = (content) => typeof content === 'string'
+        ? content
+        : content
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text)
+            .join('\n');
+    if (req.messages.length === 1 && req.messages[0].role === 'user')
+        return text(req.messages[0].content);
+    return req.messages.map((m) => `${m.role === 'assistant' ? 'Assistant' : 'User'}: ${text(m.content)}`).join('\n\n');
+}
+export function selfhostedAdapter() {
+    return {
+        id: 'selfhosted',
+        display_name: 'cloudpeers self-hosted in-boundary (Tier 0)',
+        surface: 'self_hosted',
+        supports_streaming: false,
+        supports_tool_use: false,
+        supports_prompt_caching: false,
+        tool_use: {
+            supports_tool_use: false,
+            supports_parallel_tool_use: false,
+            preserves_block_position: false,
+            supports_streaming_tool_use: false,
+            max_tools_per_request: 0,
+        },
+        available: () => !!process.env.MODEL_ROUTER_TIER0_URL,
+        async isEligible(req, _ctx) {
+            if (!process.env.MODEL_ROUTER_TIER0_URL)
+                return { eligible: false, reason: 'Tier 0 serving not configured (MODEL_ROUTER_TIER0_URL)' };
+            if (req.tools?.length)
+                return { eligible: false, reason: 'tool use not supported by Tier 0 serving' };
+            return { eligible: true, estimated_latency_ms: 100, estimated_cost_cents: 0 };
+        },
+        async invoke(req, ctx) {
+            const url = process.env.MODEL_ROUTER_TIER0_URL;
+            if (!url)
+                throw new Error('Tier 0 serving not configured');
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+            ctx.signal?.addEventListener('abort', () => controller.abort(), { once: true });
+            try {
+                const res = await fetch(`${url.replace(/\/$/, '')}/v1/generate`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        model: req.model,
+                        prompt: messagesToPrompt(req),
+                        system: req.system,
+                        max_tokens: req.max_tokens,
+                    }),
+                    signal: controller.signal,
+                });
+                if (!res.ok)
+                    throw new Error(`Tier0 ${res.status}`);
+                const data = (await res.json());
+                if (!data.text)
+                    throw new Error('Tier0 returned empty text');
+                return {
+                    id: `msg_tier0_${Math.random().toString(36).slice(2)}`,
+                    type: 'message',
+                    role: 'assistant',
+                    content: [{ type: 'text', text: data.text }],
+                    model: req.model ?? 'tier0',
+                    stop_reason: 'end_turn',
+                    usage: { input_tokens: data.prompt_tokens ?? 0, output_tokens: data.completion_tokens ?? 0 },
+                };
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+        // eslint-disable-next-line require-yield
+        async *invokeStream(_req, _ctx) {
+            throw new Error('Tier 0 serving does not support streaming (supports_streaming: false)');
+        },
+        reportUsage(_req, res) {
+            return {
+                backend_id: 'selfhosted',
+                tokens_in: res.usage?.input_tokens ?? 0,
+                tokens_out: res.usage?.output_tokens ?? 0,
+                latency_ms: 0, // overwritten by the router's measured value
+                cost_cents: 0,
+                cache_hit: false,
+                cache_unsupported: true,
+                sovereignty_class: 'local_only', // overwritten by the router from the envelope
+            };
+        },
+    };
+}

package/dist/capabilities.d.ts

@@ -0,0 +1,18 @@
+/**
+ * §8.1 — capability matrix, built from adapter declarations so it cannot
+ * drift from what the adapters actually claim (§13: "capability endpoint
+ * reflects truth"). Embedded-library v1 exposes this as a function; the
+ * mcp server surfaces it on its discovery endpoints.
+ */
+import type { BackendAdapter, BackendSurface, Provider, ToolUseCapability } from './types.js';
+export interface BackendCapabilities {
+    id: Provider;
+    display_name: string;
+    surface: BackendSurface;
+    available: boolean;
+    supports_streaming: boolean;
+    supports_tool_use: boolean;
+    supports_prompt_caching: boolean;
+    tool_use: ToolUseCapability;
+}
+export declare function capabilityMatrix(adapters: Partial<Record<Provider, BackendAdapter>>): BackendCapabilities[];

package/dist/capabilities.js

@@ -0,0 +1,14 @@
+export function capabilityMatrix(adapters) {
+    return Object.values(adapters)
+        .filter((a) => !!a)
+        .map((a) => ({
+        id: a.id,
+        display_name: a.display_name,
+        surface: a.surface,
+        available: a.available(),
+        supports_streaming: a.supports_streaming,
+        supports_tool_use: a.supports_tool_use,
+        supports_prompt_caching: a.supports_prompt_caching,
+        tool_use: a.tool_use,
+    }));
+}

package/dist/errors.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Router errors carry an HTTP-ish statusCode so embedding servers can map
+ * them onto responses without string-matching messages (§7.1 status
+ * semantics: 400 shape, 409 revoked, 410 expired, 412 no eligible backend,
+ * 422 tool-use strict, 501 deferred capability).
+ */
+export declare class RouterError extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    constructor(message: string, statusCode: number, code: string);
+}
+/** §7.1 #1 — request failed envelope/shape validation. */
+export declare class RouterValidationError extends RouterError {
+    constructor(message: string);
+}
+/**
+ * Enforcement blocked the request (privacy gate, mandate, policy, capability).
+ * Name and default semantics preserved from ModelRouter v1 — callers catch
+ * `RouterBlockedError` and existing behavior is unchanged.
+ */
+export declare class RouterBlockedError extends RouterError {
+    constructor(message: string, statusCode?: number, code?: string);
+}

package/dist/errors.js

@@ -0,0 +1,32 @@
+/**
+ * Router errors carry an HTTP-ish statusCode so embedding servers can map
+ * them onto responses without string-matching messages (§7.1 status
+ * semantics: 400 shape, 409 revoked, 410 expired, 412 no eligible backend,
+ * 422 tool-use strict, 501 deferred capability).
+ */
+export class RouterError extends Error {
+    constructor(message, statusCode, code) {
+        super(message);
+        this.name = 'RouterError';
+        this.statusCode = statusCode;
+        this.code = code;
+    }
+}
+/** §7.1 #1 — request failed envelope/shape validation. */
+export class RouterValidationError extends RouterError {
+    constructor(message) {
+        super(message, 400, 'invalid_request');
+        this.name = 'RouterValidationError';
+    }
+}
+/**
+ * Enforcement blocked the request (privacy gate, mandate, policy, capability).
+ * Name and default semantics preserved from ModelRouter v1 — callers catch
+ * `RouterBlockedError` and existing behavior is unchanged.
+ */
+export class RouterBlockedError extends RouterError {
+    constructor(message, statusCode = 412, code = 'routing_blocked') {
+        super(message, statusCode, code);
+        this.name = 'RouterBlockedError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @cloudpeers-jkl/model-router — cloudpeers inference router, embedded
+ * library surface (Amendment A1.1: no central data plane; the embedding
+ * service injects metering/quota/hooks and the envelope's sovereignty gate
+ * runs in-process, where the data lives).
+ */
+export * from './types.js';
+export { RouterError, RouterValidationError, RouterBlockedError } from './errors.js';
+export { parseRouterRequest, routerMessagesRequestSchema, cloudpeersEnvelopeSchema } from './schema.js';
+export { TIERS, TASK_ROUTES, evaluateGate, gateEnforced, resolveChain } from './policy.js';
+export { routeModel, routeMessages, routeMessagesStream } from './router.js';
+export type { RouteContext, MessagesStreamResult } from './router.js';
+export { capabilityMatrix } from './capabilities.js';
+export type { BackendCapabilities } from './capabilities.js';
+export { anthropicAdapter } from './adapters/anthropic.js';
+export { geminiAdapter, anthropicToGeminiContents, geminiResponseToAnthropic, geminiChunksToSSE, geminiFinishToStopReason, } from './adapters/gemini.js';
+export { selfhostedAdapter, messagesToPrompt } from './adapters/selfhosted.js';
+import type { BackendAdapter, Provider } from './types.js';
+/** The approved backend set (A1.2): selfhosted, gemini, anthropic. No OpenAI. */
+export declare function defaultBackendAdapters(): Record<Provider, BackendAdapter>;

package/dist/index.js

@@ -0,0 +1,22 @@
+/**
+ * @cloudpeers-jkl/model-router — cloudpeers inference router, embedded
+ * library surface (Amendment A1.1: no central data plane; the embedding
+ * service injects metering/quota/hooks and the envelope's sovereignty gate
+ * runs in-process, where the data lives).
+ */
+export * from './types.js';
+export { RouterError, RouterValidationError, RouterBlockedError } from './errors.js';
+export { parseRouterRequest, routerMessagesRequestSchema, cloudpeersEnvelopeSchema } from './schema.js';
+export { TIERS, TASK_ROUTES, evaluateGate, gateEnforced, resolveChain } from './policy.js';
+export { routeModel, routeMessages, routeMessagesStream } from './router.js';
+export { capabilityMatrix } from './capabilities.js';
+export { anthropicAdapter } from './adapters/anthropic.js';
+export { geminiAdapter, anthropicToGeminiContents, geminiResponseToAnthropic, geminiChunksToSSE, geminiFinishToStopReason, } from './adapters/gemini.js';
+export { selfhostedAdapter, messagesToPrompt } from './adapters/selfhosted.js';
+import { anthropicAdapter } from './adapters/anthropic.js';
+import { geminiAdapter } from './adapters/gemini.js';
+import { selfhostedAdapter } from './adapters/selfhosted.js';
+/** The approved backend set (A1.2): selfhosted, gemini, anthropic. No OpenAI. */
+export function defaultBackendAdapters() {
+    return { selfhosted: selfhostedAdapter(), gemini: geminiAdapter(), anthropic: anthropicAdapter() };
+}