@juno-ai/bind 2.0.0 → 4.0.0

package/plugins/tool.d.ts

@@ -0,0 +1,164 @@
+import type { z } from "zod";
+/**
+ * The plugin/tool vocabulary — the shape of a tool, a bundle of tools, and
+ * the result of running one.
+ *
+ * Two things are deliberately NOT fixed here, because they are where hosts
+ * genuinely diverge rather than incidentally differ:
+ *
+ *  - **The invocation context** (`TCtx`). A census of two production agent
+ *    runtimes' contexts found ~33 fields of which exactly one (`abortSignal`)
+ *    was shared; the rest are host identity (tenant, workspace, thread, role),
+ *    host authorization (principal, scope clamps), or host product
+ *    features. A common concrete context would be either a
+ *    lowest-common-denominator or a union of two products' identity models,
+ *    so the context is a type parameter and the host supplies it.
+ *
+ *  - **Multimodal content parts** (`TContentPart`). The wire shape is the
+ *    provider's, but building one from bytes needs host capabilities, so the
+ *    harness carries the parts through without interpreting them.
+ *
+ * Hosts extend `ToolPlugin` with their own fields via ordinary interface
+ * extension (Monad adds `configuration`, `skills`, `exposeViaMcp`).
+ */
+/**
+ * Behavioural hints that travel with a tool on `tools/list`. Mirrors
+ * the MCP `ToolAnnotations` shape — duplicated here so plugins can
+ * declare them without importing the SDK directly.
+ */
+export interface ToolAnnotations {
+    /** Human-readable title for the tool. */
+    title?: string;
+    /** True if the tool only reads data. */
+    readOnlyHint?: boolean;
+    /** True if the tool may make destructive changes. Meaningful only when readOnlyHint===false. */
+    destructiveHint?: boolean;
+    /** True if calling the tool with the same args yields the same result. */
+    idempotentHint?: boolean;
+    /** True if the tool may interact with external systems. */
+    openWorldHint?: boolean;
+}
+export interface ToolDef {
+    name: string;
+    description: string;
+    parameters: z.ZodType;
+    /**
+     * Pure post-parse canonicalization applied before run-scoped idempotency
+     * hashing and execution. Keep model-facing schemas JSON-Schema-compatible;
+     * semantic normalization such as sorting set-like arrays belongs here.
+     */
+    normalizeArgs?: (args: unknown) => unknown;
+    /**
+     * Pre-computed JSON Schema to pass to the LLM instead of converting via
+     * `z.toJSONSchema()`. Also the seam for a host whose tools are authored as
+     * raw JSON Schema rather than zod.
+     */
+    rawJsonSchema?: Record<string, unknown>;
+    /** Annotations forwarded on the MCP `tools/list` response. */
+    annotations?: ToolAnnotations;
+    /** If true, the dispatcher emits a periodic auto-heartbeat. */
+    supportsProgress?: boolean;
+    /**
+     * When `true`, the tool stays runnable (dispatch + `plugin.tools` lookup
+     * still resolve it) but is omitted from the model-facing catalog. Used to
+     * retire a tool from the prompt while keeping it callable for resumed
+     * sessions whose history still references it.
+     */
+    hidden?: boolean;
+    /**
+     * Optional human one-liner describing THIS call, derived from its args.
+     * MUST be pure + synchronous: `safeParse` the args with the tool's own
+     * schema, then read fields — no I/O, no context. Returns `null` to fall
+     * back to generic copy. Purity is load-bearing: it runs on the executor
+     * hot path inside a fire-and-forget emit.
+     */
+    summarizeActivity?: (args: unknown) => string | null;
+}
+/**
+ * Structured failure category for a failed `ToolResult`. Lets a host map a
+ * plugin failure onto its own error taxonomy — a protocol error code, an HTTP
+ * status, a retry decision — without matching on the error string, which is
+ * brittle and locale-dependent. Plugins should set it explicitly.
+ */
+export type ToolFailureKind = "authz" | "validation" | "not_found" | "conflict" | "external" | "system";
+/**
+ * Human-in-the-loop suspend directive. A first-party tool returns this on a
+ * successful result to **end the run** and record its open tool-call as
+ * awaiting resolution. Two resume kinds:
+ *  - `answer`: the run resumes by threading a human/external response back as
+ *    the matching `role:"tool"` result. The loop therefore WITHHOLDS this
+ *    call's tool message — the result is the future answer.
+ *  - `wake`: a time/event resume that re-enters via a prompt and keeps the
+ *    tool message.
+ * `request` is an opaque render/route payload, validated by the consumer and
+ * never inspected by the loop.
+ */
+export type SuspendDirective = {
+    reason: string;
+    resumeKind: "answer" | "wake";
+    request?: unknown;
+};
+export type ToolResult<TContentPart = unknown> = {
+    success: true;
+    data: unknown;
+    contentParts?: TContentPart[];
+    suspend?: SuspendDirective;
+} | {
+    success: false;
+    error: string;
+    kind?: ToolFailureKind;
+    /** Optional structured recovery context safe to expose to the model. */
+    data?: unknown;
+};
+/**
+ * Narrow helper: does this tool result ask the executor to relay multimodal
+ * content parts alongside the textual JSON result on the next turn?
+ */
+export declare function hasContentParts<TContentPart>(result: ToolResult<TContentPart>): result is {
+    success: true;
+    data: unknown;
+    contentParts: TContentPart[];
+    suspend?: SuspendDirective;
+};
+/**
+ * A self-contained bundle of related tools plus the metadata the catalog and
+ * the system prompt need. `execute` dispatches by tool name so a plugin can
+ * share setup across its tools.
+ */
+export interface ToolPlugin<TCtx, TContentPart = unknown> {
+    name: string;
+    description: string;
+    /**
+     * Optional short icon identifier a host UI may use to pick a glyph. Optional
+     * because a headless consumer has no glyph to pick; a host that renders tool
+     * activity can re-require it on its own extension of this interface.
+     */
+    icon?: string;
+    /**
+     * Global availability gate; unavailable plugins stay registered (so they can
+     * still be listed for configuration) but do not resolve for a run.
+     *
+     * **Must be constant for the lifetime of the process or isolate.** It is
+     * re-evaluated on every catalog render — which, for a host that re-renders
+     * its system prompt on each activation, is several times per run. A value
+     * that can flip mid-run (a TTL-cached feature flag, a health probe, a live
+     * credential check) rewrites the catalog and invalidates the provider
+     * prompt-cache prefix from that byte onward for every remaining turn, and
+     * nothing will fail a test. Gate on process-stable configuration; do the
+     * liveness check inside `execute`, where a failure is a tool error.
+     */
+    isAvailable?: () => boolean;
+    /** Instructions appended to the system prompt when this plugin is active. */
+    systemMessage?: string;
+    tools: ToolDef[];
+    execute(toolName: string, args: unknown, ctx: TCtx): Promise<ToolResult<TContentPart>>;
+}
+/**
+ * The structural minimum the registry and catalog need. Hosts pass their own
+ * richer plugin type; this is the constraint, not the contract.
+ */
+export interface RegistrablePlugin {
+    name: string;
+    description: string;
+    isAvailable?: () => boolean;
+}

package/plugins/tool.js

@@ -0,0 +1,9 @@
+/**
+ * Narrow helper: does this tool result ask the executor to relay multimodal
+ * content parts alongside the textual JSON result on the next turn?
+ */
+export function hasContentParts(result) {
+    return (result.success === true &&
+        Array.isArray(result.contentParts) &&
+        result.contentParts.length > 0);
+}

package/routing/billing-basis.d.ts

@@ -0,0 +1,48 @@
+import type { ProviderPricingBasis } from "./plan.js";
+/**
+ * Synchronous provider billing-basis cost —
+ * the configured-list-rate calculation used when a provider (Azure) reports
+ * usage but not dollars. OpenRouter's provider-reported cost keeps the
+ * existing path in `llm.ts` and never goes through this function.
+ *
+ * Results are USD cents at the inference log's numeric(10, 4) precision.
+ */
+export interface BillingBasisUsage {
+    readonly inputTokens: number;
+    /**
+     * Provider-reported cached (discounted) input tokens. Whether this is a
+     * subset of `inputTokens` or a disjoint count is DECLARED by the binding's
+     * `cachedTokenSemantics` — never inferred from the relative sizes.
+     */
+    readonly cachedInputTokens: number;
+    /**
+     * Provider completion-token total. Already includes reasoning tokens — do
+     * not add them a second time.
+     */
+    readonly outputTokens: number;
+}
+export type BillingBasisResult = Readonly<{
+    ok: true;
+    costCents: number;
+}> | Readonly<{
+    ok: false;
+    reason: string;
+}>;
+/**
+ * Compute the list-rate cost in USD cents from usage and configured
+ * per-million-token rates. Rejects internally inconsistent usage rather than
+ * producing a zero-cost call: negative counts, non-integers,
+ * all-zero usage (a request always consumes prompt tokens — zeros mean the
+ * provider's accounting is broken, not that the call was free), and — under
+ * declared `"subset"` semantics — cached counts exceeding total input.
+ *
+ * The uncached-input calculation follows the binding's declared
+ * `cachedTokenSemantics`:
+ * - `"subset"`  — cached ⊆ input (OpenAI): uncached = input − cached.
+ * - `"disjoint"` — cached reported alongside input (Grok via Azure AI
+ *   Foundry, observed live: cached 192 vs prompt 88): uncached = input.
+ * Either way every token prices exactly once at its own rate.
+ */
+export declare function computeConfiguredRatesCostCents(pricing: Extract<ProviderPricingBasis, {
+    kind: "configured_token_rates";
+}>, usage: BillingBasisUsage): BillingBasisResult;

package/routing/billing-basis.js

@@ -0,0 +1,67 @@
+function isUsableCount(value) {
+    return Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+function roundToScale4(value) {
+    return Math.round(value * 10_000) / 10_000;
+}
+/**
+ * Compute the list-rate cost in USD cents from usage and configured
+ * per-million-token rates. Rejects internally inconsistent usage rather than
+ * producing a zero-cost call: negative counts, non-integers,
+ * all-zero usage (a request always consumes prompt tokens — zeros mean the
+ * provider's accounting is broken, not that the call was free), and — under
+ * declared `"subset"` semantics — cached counts exceeding total input.
+ *
+ * The uncached-input calculation follows the binding's declared
+ * `cachedTokenSemantics`:
+ * - `"subset"`  — cached ⊆ input (OpenAI): uncached = input − cached.
+ * - `"disjoint"` — cached reported alongside input (Grok via Azure AI
+ *   Foundry, observed live: cached 192 vs prompt 88): uncached = input.
+ * Either way every token prices exactly once at its own rate.
+ */
+export function computeConfiguredRatesCostCents(pricing, usage) {
+    if (!isUsableCount(usage.inputTokens)) {
+        return { ok: false, reason: `invalid input token count: ${usage.inputTokens}` };
+    }
+    if (!isUsableCount(usage.cachedInputTokens)) {
+        return {
+            ok: false,
+            reason: `invalid cached input token count: ${usage.cachedInputTokens}`,
+        };
+    }
+    if (!isUsableCount(usage.outputTokens)) {
+        return { ok: false, reason: `invalid output token count: ${usage.outputTokens}` };
+    }
+    if (usage.inputTokens === 0 &&
+        usage.cachedInputTokens === 0 &&
+        usage.outputTokens === 0) {
+        return { ok: false, reason: "all-zero usage (provider reported no tokens)" };
+    }
+    let uncachedInputTokens;
+    switch (pricing.cachedTokenSemantics) {
+        case "subset":
+            if (usage.cachedInputTokens > usage.inputTokens) {
+                return {
+                    ok: false,
+                    reason: `cached input tokens (${usage.cachedInputTokens}) exceed input tokens ` +
+                        `(${usage.inputTokens}) under declared "subset" semantics — if this ` +
+                        `provider reports cached tokens alongside prompt tokens, declare ` +
+                        `cachedTokenSemantics: "disjoint" on its binding`,
+                };
+            }
+            uncachedInputTokens = usage.inputTokens - usage.cachedInputTokens;
+            break;
+        case "disjoint":
+            uncachedInputTokens = usage.inputTokens;
+            break;
+        default: {
+            const _exhaustive = pricing.cachedTokenSemantics;
+            throw new Error(`unknown cached-token semantics: ${JSON.stringify(_exhaustive)}`);
+        }
+    }
+    const usd = (uncachedInputTokens * pricing.inputUsdPerM +
+        usage.cachedInputTokens * pricing.cachedInputUsdPerM +
+        usage.outputTokens * pricing.outputUsdPerM) /
+        1_000_000;
+    return { ok: true, costCents: roundToScale4(usd * 100) };
+}

package/routing/circuit-breaker.d.ts

@@ -1,5 +1,5 @@
-import type { ProviderId } from "./canonical-model";
-import type { CredentialSource } from "./plan";
+import type { ProviderId } from "./canonical-model.js";
+import type { CredentialSource } from "./plan.js";
 /**
  * Circuit-breaker state is keyed by (provider, invocation model, credential
  * source) — LLM Provider Routing PRD §7.2. State is process-local in v1;

package/routing/errors.d.ts

@@ -1,4 +1,4 @@
-import type { CanonicalModelId, ProviderId } from "./canonical-model";
+import type { CanonicalModelId, ProviderId } from "./canonical-model.js";
 /**
  * The normative attempt-order cursor (LLM Provider Routing PRD §5.2):
  * structured-output attempt → model stage → provider candidate → same-endpoint

package/routing/executor.d.ts

@@ -1,6 +1,6 @@
-import type { RouteCandidate, RoutePlan } from "./plan";
-import { type InferenceAttemptError, type RouteAttemptCursor } from "./errors";
-import type { RouteCircuitBreaker } from "./circuit-breaker";
+import type { RouteCandidate, RoutePlan } from "./plan.js";
+import { type InferenceAttemptError, type RouteAttemptCursor } from "./errors.js";
+import type { RouteCircuitBreaker } from "./circuit-breaker.js";
 export type AttemptOutcome<T> = Readonly<{
     kind: "success";
     value: T;

package/routing/executor.js

@@ -1,4 +1,4 @@
-import { failureDisposition, isRetriableAttemptError, } from "./errors";
+import { failureDisposition, isRetriableAttemptError, } from "./errors.js";
 /**
  * Drive one structured-output attempt over a frozen route plan with the
  * normative loop nesting (PRD §5.2): model stage → provider candidate →

package/routing/index.d.ts

@@ -1,9 +1,11 @@
-export { canonicalModelIdSchema, providerIdSchema, type CanonicalModelId, type ProviderId, } from "./canonical-model";
-export { ROUTE_POLICY_VERSION, providerPolicySchema, modelRouteRegistrySchema, parseModelRouteRegistry, resolveProviderPolicy, policyProviderOrder, type RoutePolicyVersion, type ProviderPolicy, type ModelRouteRegistry, } from "./policy";
-export { INFERENCE_CAPABILITIES, planIsEmpty, type InferenceCapability, type CredentialSource, type InferenceRequirements, type CachedTokenSemantics, type ProviderPricingBasis, type RouteCandidate, type RouteStage, type RoutePlan, type RouteSkip, } from "./plan";
-export { type TransportAvailability, type CandidateResolution, type PlannerTransport, } from "./transport";
-export { buildRoutePlan, type RoutePlanRequest, type RoutePlanResult } from "./planner";
-export { fallbackKindOfCursor } from "./executor";
-export { failureDisposition, categorizeHttpStatus, isRetriableAttemptError, type RouteAttemptCursor, type AttemptTarget, type HttpFailureCategory, type InferenceAttemptError, type FailureDisposition, type BreakerEffect, } from "./errors";
-export { createCircuitBreaker, type BreakerKey, type CircuitBreakerOptions, type EndpointAdmission, type RecordFailureOptions, type RouteCircuitBreaker, } from "./circuit-breaker";
-export { executeRoutePlan, type AttemptOutcome, type AttemptFn, type FallbackKind, type ExecutePlanOptions, type RouteExecutionResult, } from "./executor";
+export { canonicalModelIdSchema, providerIdSchema, type CanonicalModelId, type ProviderId, } from "./canonical-model.js";
+export { ROUTE_POLICY_VERSION, providerPolicySchema, modelRouteRegistrySchema, parseModelRouteRegistry, resolveProviderPolicy, policyProviderOrder, type RoutePolicyVersion, type ProviderPolicy, type ModelRouteRegistry, } from "./policy.js";
+export { INFERENCE_CAPABILITIES, planIsEmpty, type InferenceCapability, type CredentialSource, type InferenceRequirements, type CachedTokenSemantics, type ProviderPricingBasis, type RouteCandidate, type RouteStage, type RoutePlan, type RouteSkip, } from "./plan.js";
+export { type TransportAvailability, type CandidateResolution, type PlannerTransport, } from "./transport.js";
+export { buildRoutePlan, type RoutePlanRequest, type RoutePlanResult } from "./planner.js";
+export { buildRoutePlanWithConfigDegradation, type DegradedStage, type DegradedPlanResult, } from "./plan-degradation.js";
+export { computeConfiguredRatesCostCents, type BillingBasisUsage, type BillingBasisResult, } from "./billing-basis.js";
+export { fallbackKindOfCursor } from "./executor.js";
+export { failureDisposition, categorizeHttpStatus, isRetriableAttemptError, type RouteAttemptCursor, type AttemptTarget, type HttpFailureCategory, type InferenceAttemptError, type FailureDisposition, type BreakerEffect, } from "./errors.js";
+export { createCircuitBreaker, type BreakerKey, type CircuitBreakerOptions, type EndpointAdmission, type RecordFailureOptions, type RouteCircuitBreaker, } from "./circuit-breaker.js";
+export { executeRoutePlan, type AttemptOutcome, type AttemptFn, type FallbackKind, type ExecutePlanOptions, type RouteExecutionResult, } from "./executor.js";

package/routing/index.js

@@ -1,9 +1,11 @@
-export { canonicalModelIdSchema, providerIdSchema, } from "./canonical-model";
-export { ROUTE_POLICY_VERSION, providerPolicySchema, modelRouteRegistrySchema, parseModelRouteRegistry, resolveProviderPolicy, policyProviderOrder, } from "./policy";
-export { INFERENCE_CAPABILITIES, planIsEmpty, } from "./plan";
-export {} from "./transport";
-export { buildRoutePlan } from "./planner";
-export { fallbackKindOfCursor } from "./executor";
-export { failureDisposition, categorizeHttpStatus, isRetriableAttemptError, } from "./errors";
-export { createCircuitBreaker, } from "./circuit-breaker";
-export { executeRoutePlan, } from "./executor";
+export { canonicalModelIdSchema, providerIdSchema, } from "./canonical-model.js";
+export { ROUTE_POLICY_VERSION, providerPolicySchema, modelRouteRegistrySchema, parseModelRouteRegistry, resolveProviderPolicy, policyProviderOrder, } from "./policy.js";
+export { INFERENCE_CAPABILITIES, planIsEmpty, } from "./plan.js";
+export {} from "./transport.js";
+export { buildRoutePlan } from "./planner.js";
+export { buildRoutePlanWithConfigDegradation, } from "./plan-degradation.js";
+export { computeConfiguredRatesCostCents, } from "./billing-basis.js";
+export { fallbackKindOfCursor } from "./executor.js";
+export { failureDisposition, categorizeHttpStatus, isRetriableAttemptError, } from "./errors.js";
+export { createCircuitBreaker, } from "./circuit-breaker.js";
+export { executeRoutePlan, } from "./executor.js";

package/routing/plan-degradation.d.ts

@@ -0,0 +1,34 @@
+import type { CanonicalModelId } from "./canonical-model.js";
+import type { RouteSkip } from "./plan.js";
+import { type RoutePlanRequest, type RoutePlanResult } from "./planner.js";
+import { type ProviderPolicy } from "./policy.js";
+/**
+ * Configuration-degradation wrapper around the harness planner.
+ *
+ * Policy: even when a provider has priority over the default (an explicit
+ * `only` fence or an ordered policy naming it first), **missing keys or
+ * configuration must never make inference unavailable** — the call degrades
+ * to the default provider and the caller logs an error. This keeps
+ * development environments that hold only an OpenRouter key fully working
+ * while a checked-in policy prioritizes (say) Azure, and keeps production
+ * serving through a provider-config regression instead of hard-failing.
+ *
+ * Scope: PLAN-TIME emptiness only — a stage with zero attemptable candidates
+ * (transport unconfigured/invalid, no binding for the model, capability
+ * mismatch). Runtime failures keep the fence semantics: a configured `only`
+ * provider that errors at request time is never retried through another
+ * provider; the executor's cross-provider traversal applies only
+ * within the plan the policy allowed.
+ */
+export interface DegradedStage {
+    readonly model: CanonicalModelId;
+    /** The policy that produced an empty stage. */
+    readonly fromPolicy: ProviderPolicy;
+    /** Plan skips recorded for this model under the original policy. */
+    readonly skips: readonly RouteSkip[];
+}
+export interface DegradedPlanResult extends RoutePlanResult {
+    /** Stages rebuilt under the degraded default; empty when nothing degraded. */
+    readonly degraded: readonly DegradedStage[];
+}
+export declare function buildRoutePlanWithConfigDegradation(request: RoutePlanRequest, degradedPolicy: ProviderPolicy): DegradedPlanResult;

package/routing/plan-degradation.js

@@ -0,0 +1,38 @@
+import { buildRoutePlan, } from "./planner.js";
+import { policyProviderOrder } from "./policy.js";
+function policiesEqual(a, b) {
+    const aOrder = policyProviderOrder(a);
+    const bOrder = policyProviderOrder(b);
+    return (a.mode === b.mode &&
+        aOrder.length === bOrder.length &&
+        aOrder.every((provider, index) => provider === bOrder[index]));
+}
+export function buildRoutePlanWithConfigDegradation(request, degradedPolicy) {
+    const first = buildRoutePlan(request);
+    const emptyStagePolicies = new Map();
+    for (const stage of first.plan.stages) {
+        if (stage.candidates.length === 0 &&
+            !policiesEqual(stage.policy, degradedPolicy)) {
+            emptyStagePolicies.set(stage.canonicalModelId, stage.policy);
+        }
+    }
+    if (emptyStagePolicies.size === 0) {
+        return { plan: first.plan, skips: first.skips, degraded: [] };
+    }
+    // Deterministic rebuild: identical inputs except the empty stages' models
+    // now resolve to the degraded default policy. If the default provider is
+    // ALSO unavailable (e.g. no OpenRouter key at all) the rebuilt stage stays
+    // empty and the caller's no-viable-endpoint handling applies unchanged.
+    const second = buildRoutePlan({
+        ...request,
+        policyFor: (model) => emptyStagePolicies.get(model) !== undefined
+            ? degradedPolicy
+            : request.policyFor(model),
+    });
+    const degraded = [...emptyStagePolicies.entries()].map(([model, fromPolicy]) => ({
+        model,
+        fromPolicy,
+        skips: first.skips.filter((skip) => skip.canonicalModelId === model),
+    }));
+    return { plan: second.plan, skips: second.skips, degraded };
+}

package/routing/plan.d.ts

@@ -1,5 +1,5 @@
-import type { CanonicalModelId, ProviderId } from "./canonical-model";
-import type { ProviderPolicy, RoutePolicyVersion } from "./policy";
+import type { CanonicalModelId, ProviderId } from "./canonical-model.js";
+import type { ProviderPolicy, RoutePolicyVersion } from "./policy.js";
 /**
  * Capabilities the planner checks before any network request (LLM Provider
  * Routing PRD §5.1/§5.3). `max_completion_tokens` is modeled as a capability

package/routing/planner.d.ts

@@ -1,7 +1,7 @@
-import type { CanonicalModelId, ProviderId } from "./canonical-model";
-import { type ProviderPolicy } from "./policy";
-import type { InferenceRequirements, RoutePlan, RouteSkip } from "./plan";
-import type { PlannerTransport } from "./transport";
+import type { CanonicalModelId, ProviderId } from "./canonical-model.js";
+import { type ProviderPolicy } from "./policy.js";
+import type { InferenceRequirements, RoutePlan, RouteSkip } from "./plan.js";
+import type { PlannerTransport } from "./transport.js";
 export interface RoutePlanRequest {
     readonly primaryModel: CanonicalModelId;
     /** A distinct fallback canonical model, or null. Equal to primary is ignored. */

package/routing/planner.js

@@ -1,4 +1,4 @@
-import { ROUTE_POLICY_VERSION, policyProviderOrder, } from "./policy";
+import { ROUTE_POLICY_VERSION, policyProviderOrder, } from "./policy.js";
 /**
  * Deterministically expand a canonical primary/fallback selection into an
  * immutable, ordered route plan (LLM Provider Routing PRD §5.1). The only

package/routing/policy.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type CanonicalModelId, type ProviderId } from "./canonical-model";
+import { type CanonicalModelId, type ProviderId } from "./canonical-model.js";
 /**
  * Policy order and semantics are versioned; the version string travels into
  * telemetry (LLM Provider Routing PRD §4.2) so a routing-behavior change is

package/routing/policy.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { canonicalModelIdSchema, providerIdSchema, } from "./canonical-model";
+import { canonicalModelIdSchema, providerIdSchema, } from "./canonical-model.js";
 /**
  * Policy order and semantics are versioned; the version string travels into
  * telemetry (LLM Provider Routing PRD §4.2) so a routing-behavior change is

package/routing/transport.d.ts

@@ -1,5 +1,5 @@
-import type { CanonicalModelId, ProviderId } from "./canonical-model";
-import type { InferenceRequirements, RouteCandidate, RouteSkip } from "./plan";
+import type { CanonicalModelId, ProviderId } from "./canonical-model.js";
+import type { InferenceRequirements, RouteCandidate, RouteSkip } from "./plan.js";
 export type TransportAvailability = Readonly<{
     available: true;
 }> | Readonly<{