@danypops/jittor 0.16.2 → 0.17.0

package/src/optimization/model-selection/catalog.ts

@@ -0,0 +1,478 @@
+import {
+	MODEL_CATALOG_DEFAULT_QUERY_LIMIT,
+	MODEL_CATALOG_FRESHNESS_MS,
+	MODEL_CATALOG_MAX_ENTRIES,
+	MODEL_CATALOG_MAX_QUERY_LIMIT,
+	MODEL_CATALOG_MAX_RESPONSE_BYTES,
+	MODEL_CATALOG_REQUEST_TIMEOUT_MS,
+} from "../../constants.ts";
+
+export type ModelCatalogAuthority = "models-dev-provider" | "user-override";
+export type ModelModality = "text" | "audio" | "image" | "video" | "pdf";
+
+export interface ModelCatalogProvenance {
+	sourceId: "models.dev";
+	sourceUrl: string;
+	revision: string;
+	retrievedAt: number;
+	freshUntil: number;
+	license: "MIT";
+}
+
+export interface ModelCatalogFieldAuthority {
+	authority: ModelCatalogAuthority;
+	sourceId: "models.dev" | "local-configuration";
+	revision: string;
+	retrievedAt: number;
+}
+
+export interface ModelCatalogPriceTier {
+	contextSize: number;
+	input: number;
+	output: number;
+	reasoning?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+}
+
+export interface ModelCatalogPricing {
+	input?: number;
+	output?: number;
+	reasoning?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	contextOver200k?: Omit<ModelCatalogPricing, "contextOver200k" | "tiers">;
+	tiers?: ModelCatalogPriceTier[];
+}
+
+export interface ModelCatalogEntry {
+	provider: string;
+	model: string;
+	canonical: string;
+	aliases: string[];
+	name: string;
+	status: "active" | "alpha" | "beta" | "deprecated";
+	capabilities: { attachment: boolean; reasoning: boolean; toolCall: boolean; structuredOutput: boolean };
+	modalities: { input: ModelModality[]; output: ModelModality[] };
+	limits: { context: number; input?: number; output: number };
+	pricing?: ModelCatalogPricing;
+	fieldAuthority: Record<string, ModelCatalogFieldAuthority>;
+}
+
+export interface ModelCatalogSnapshot {
+	snapshotId: string;
+	provenance: ModelCatalogProvenance;
+	entries: ModelCatalogEntry[];
+}
+
+export interface ModelCatalogStore {
+	publish(snapshot: ModelCatalogSnapshot): ModelCatalogSnapshot;
+	latest(): ModelCatalogSnapshot | null;
+}
+
+export interface ModelCatalogSource {
+	readonly id: "models.dev";
+	fetch(): Promise<ModelCatalogSnapshot>;
+}
+
+export interface ModelCatalogStatus {
+	configured: boolean;
+	ok: boolean | null;
+	hasSnapshot: boolean;
+	lastAttemptAt: number | null;
+	lastSuccessAt: number | null;
+	entries: number;
+	revision: string | null;
+	error?: "catalog refresh failed";
+}
+
+export interface ModelCatalogOverrides {
+	contextTokens?: number;
+	inputTokens?: number;
+	outputTokens?: number;
+	inputPrice?: number;
+	outputPrice?: number;
+}
+
+export interface ModelCatalogQuery {
+	provider?: string;
+	model?: string;
+	limit?: number;
+	overrides?: ModelCatalogOverrides;
+}
+
+export interface ModelCatalogQueryResult {
+	snapshotId: string;
+	provenance: ModelCatalogProvenance;
+	freshness: "fresh" | "stale";
+	completeness: "complete" | "truncated";
+	entries: ModelCatalogEntry[];
+}
+
+function record(value: unknown, name: string): Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${name} must be an object`);
+	return value as Record<string, unknown>;
+}
+
+function text(value: unknown, name: string, max = 200): string {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${name} is required`);
+	const result = value.trim();
+	if (result.length > max || /\p{Cc}/u.test(result)) throw new Error(`${name} is invalid`);
+	return result;
+}
+
+function identity(value: unknown, name: string): string {
+	const result = text(value, name).toLowerCase();
+	if (!/^[a-z0-9@~][a-z0-9@~._:+/-]*$/.test(result) || result.includes("//")) throw new Error(`${name} is invalid`);
+	return result;
+}
+
+function nonnegative(value: unknown, name: string, integer = false): number {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || (integer && !Number.isSafeInteger(value)))
+		throw new Error(`${name} must be a non-negative ${integer ? "integer" : "number"}`);
+	return value;
+}
+
+function optionalNumber(value: unknown, name: string, integer = false): number | undefined {
+	return value === undefined ? undefined : nonnegative(value, name, integer);
+}
+
+const MODALITIES = new Set<ModelModality>(["text", "audio", "image", "video", "pdf"]);
+function modalities(value: unknown, name: string): ModelModality[] {
+	if (!Array.isArray(value) || !value.every((item) => MODALITIES.has(item as ModelModality))) throw new Error(`${name} is invalid`);
+	return [...new Set(value as ModelModality[])];
+}
+
+function optionalBoolean(value: unknown, name: string, fallback = false): boolean {
+	if (value === undefined) return fallback;
+	if (typeof value !== "boolean") throw new Error(`${name} must be boolean`);
+	return value;
+}
+
+function pricing(value: unknown, path: string): ModelCatalogPricing | undefined {
+	if (value === undefined) return undefined;
+	const input = record(value, path);
+	const result: ModelCatalogPricing = {
+		input: nonnegative(input.input, `${path}.input`),
+		output: nonnegative(input.output, `${path}.output`),
+	};
+	const reasoning = optionalNumber(input.reasoning, `${path}.reasoning`);
+	const cacheRead = optionalNumber(input.cache_read, `${path}.cache_read`);
+	const cacheWrite = optionalNumber(input.cache_write, `${path}.cache_write`);
+	if (reasoning !== undefined) result.reasoning = reasoning;
+	if (cacheRead !== undefined) result.cacheRead = cacheRead;
+	if (cacheWrite !== undefined) result.cacheWrite = cacheWrite;
+	if (input.context_over_200k !== undefined) {
+		const over = pricing(input.context_over_200k, `${path}.context_over_200k`)!;
+		delete over.contextOver200k;
+		delete over.tiers;
+		result.contextOver200k = over;
+	}
+	if (input.tiers !== undefined) {
+		if (!Array.isArray(input.tiers)) throw new Error(`${path}.tiers must be an array`);
+		result.tiers = input.tiers.map((value, index) => {
+			const tier = record(value, `${path}.tiers[${index}]`);
+			const definition = record(tier.tier, `${path}.tiers[${index}].tier`);
+			if (definition.type !== undefined && definition.type !== "context") throw new Error(`${path}.tiers[${index}].tier.type is invalid`);
+			const translated: ModelCatalogPriceTier = {
+				contextSize: nonnegative(definition.size, `${path}.tiers[${index}].tier.size`, true),
+				input: nonnegative(tier.input, `${path}.tiers[${index}].input`),
+				output: nonnegative(tier.output, `${path}.tiers[${index}].output`),
+			};
+			const tierReasoning = optionalNumber(tier.reasoning, `${path}.tiers[${index}].reasoning`);
+			const tierRead = optionalNumber(tier.cache_read, `${path}.tiers[${index}].cache_read`);
+			const tierWrite = optionalNumber(tier.cache_write, `${path}.tiers[${index}].cache_write`);
+			if (tierReasoning !== undefined) translated.reasoning = tierReasoning;
+			if (tierRead !== undefined) translated.cacheRead = tierRead;
+			if (tierWrite !== undefined) translated.cacheWrite = tierWrite;
+			return translated;
+		});
+	}
+	return result;
+}
+
+function authority(provenance: ModelCatalogProvenance): ModelCatalogFieldAuthority {
+	return {
+		authority: "models-dev-provider",
+		sourceId: "models.dev",
+		revision: provenance.revision,
+		retrievedAt: provenance.retrievedAt,
+	};
+}
+
+function fieldAuthorities(
+	entry: Omit<ModelCatalogEntry, "fieldAuthority">,
+	provenance: ModelCatalogProvenance,
+): Record<string, ModelCatalogFieldAuthority> {
+	const fields = [
+		"status",
+		"limits.context",
+		"limits.output",
+		"capabilities.attachment",
+		"capabilities.reasoning",
+		"capabilities.toolCall",
+		"capabilities.structuredOutput",
+		"modalities.input",
+		"modalities.output",
+	];
+	if (entry.limits.input !== undefined) fields.push("limits.input");
+	if (entry.pricing) {
+		for (const key of ["input", "output", "reasoning", "cacheRead", "cacheWrite"] as const) {
+			if (entry.pricing[key] !== undefined) fields.push(`pricing.${key}`);
+		}
+		if (entry.pricing.contextOver200k) fields.push("pricing.contextOver200k");
+		if (entry.pricing.tiers) fields.push("pricing.tiers");
+	}
+	return Object.fromEntries(fields.map((field) => [field, authority(provenance)]));
+}
+
+export function translateModelsDevCatalog(
+	value: unknown,
+	input: Omit<ModelCatalogProvenance, "sourceId" | "license">,
+): ModelCatalogSnapshot {
+	const sourceUrl = new URL(input.sourceUrl);
+	if (sourceUrl.protocol !== "https:" && sourceUrl.hostname !== "127.0.0.1" && sourceUrl.hostname !== "localhost")
+		throw new Error("catalog source URL must use HTTPS or loopback HTTP");
+	if (!Number.isSafeInteger(input.retrievedAt) || input.retrievedAt <= 0) throw new Error("catalog retrieval time is invalid");
+	if (!Number.isSafeInteger(input.freshUntil) || input.freshUntil < input.retrievedAt)
+		throw new Error("catalog freshness deadline is invalid");
+	const provenance: ModelCatalogProvenance = { sourceId: "models.dev", license: "MIT", ...input, sourceUrl: sourceUrl.toString() };
+	const providers = record(value, "models.dev catalog");
+	const entries: ModelCatalogEntry[] = [];
+	for (const [providerKey, providerValue] of Object.entries(providers)) {
+		const provider = record(providerValue, `provider ${providerKey}`);
+		const providerId = identity(provider.id ?? providerKey, `provider ${providerKey}.id`);
+		if (providerId !== identity(providerKey, "provider key")) throw new Error(`provider ${providerKey} identity mismatch`);
+		const models = record(provider.models, `provider ${providerKey}.models`);
+		for (const [modelKey, modelValue] of Object.entries(models)) {
+			if (entries.length >= MODEL_CATALOG_MAX_ENTRIES) throw new Error("models.dev catalog exceeds the entry limit");
+			const path = `provider ${providerKey}.models.${modelKey}`;
+			const model = record(modelValue, path);
+			const modelId = identity(modelKey, `${path}.key`);
+			const reportedId = identity(model.id ?? modelKey, `${path}.id`);
+			const limit = record(model.limit, `${path}.limit`);
+			const modality = record(model.modalities, `${path}.modalities`);
+			const rawStatus = model.status ?? "active";
+			if (rawStatus !== "active" && rawStatus !== "alpha" && rawStatus !== "beta" && rawStatus !== "deprecated")
+				throw new Error(`${path}.status is invalid`);
+			const base: Omit<ModelCatalogEntry, "fieldAuthority"> = {
+				provider: providerId,
+				model: modelId,
+				canonical: `${providerId}/${modelId}`,
+				aliases: reportedId === modelId ? [] : [reportedId],
+				name: text(model.name, `${path}.name`),
+				status: rawStatus,
+				capabilities: {
+					attachment: optionalBoolean(model.attachment, `${path}.attachment`),
+					reasoning: optionalBoolean(model.reasoning, `${path}.reasoning`),
+					toolCall: optionalBoolean(model.tool_call, `${path}.tool_call`),
+					structuredOutput: optionalBoolean(model.structured_output, `${path}.structured_output`),
+				},
+				modalities: {
+					input: modalities(modality.input, `${path}.modalities.input`),
+					output: modalities(modality.output, `${path}.modalities.output`),
+				},
+				limits: {
+					context: nonnegative(limit.context, `${path}.limit.context`, true),
+					...(limit.input === undefined ? {} : { input: nonnegative(limit.input, `${path}.limit.input`, true) }),
+					output: nonnegative(limit.output, `${path}.limit.output`, true),
+				},
+				...(model.cost === undefined ? {} : { pricing: pricing(model.cost, `${path}.cost`) }),
+			};
+			entries.push({ ...base, fieldAuthority: fieldAuthorities(base, provenance) });
+		}
+	}
+	if (entries.length === 0) throw new Error("models.dev catalog contains no models");
+	return { snapshotId: input.revision, provenance, entries };
+}
+
+async function digestRevision(body: string): Promise<string> {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
+	return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+
+export type ModelCatalogTransport = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+export interface ModelsDevCatalogSourceOptions {
+	sourceUrl?: string;
+	transport?: ModelCatalogTransport;
+	clock?: () => number;
+	timeoutMs?: number;
+	maxResponseBytes?: number;
+	freshnessMs?: number;
+}
+
+export class ModelsDevCatalogSource implements ModelCatalogSource {
+	readonly id = "models.dev" as const;
+	private readonly sourceUrl: string;
+	private readonly transport: ModelCatalogTransport;
+	private readonly clock: () => number;
+	private readonly timeoutMs: number;
+	private readonly maxResponseBytes: number;
+	private readonly freshnessMs: number;
+
+	constructor(options: ModelsDevCatalogSourceOptions = {}) {
+		this.sourceUrl = options.sourceUrl ?? "https://models.dev/api.json";
+		this.transport = options.transport ?? fetch;
+		this.clock = options.clock ?? Date.now;
+		this.timeoutMs = options.timeoutMs ?? MODEL_CATALOG_REQUEST_TIMEOUT_MS;
+		this.maxResponseBytes = options.maxResponseBytes ?? MODEL_CATALOG_MAX_RESPONSE_BYTES;
+		this.freshnessMs = options.freshnessMs ?? MODEL_CATALOG_FRESHNESS_MS;
+	}
+
+	async fetch(): Promise<ModelCatalogSnapshot> {
+		const url = new URL(this.sourceUrl);
+		if (url.protocol !== "https:" && url.hostname !== "127.0.0.1" && url.hostname !== "localhost")
+			throw new Error("catalog source URL must use HTTPS or loopback HTTP");
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+		try {
+			const response = await this.transport(url, { signal: controller.signal, headers: { accept: "application/json" } });
+			if (!response.ok) throw new Error(`models.dev request failed (${response.status})`);
+			const length = Number(response.headers.get("content-length") ?? 0);
+			if (Number.isFinite(length) && length > this.maxResponseBytes) throw new Error("models.dev response exceeds the byte limit");
+			const body = await response.text();
+			if (new TextEncoder().encode(body).byteLength > this.maxResponseBytes) throw new Error("models.dev response exceeds the byte limit");
+			const retrievedAt = this.clock();
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(body);
+			} catch {
+				throw new Error("models.dev response is not valid JSON");
+			}
+			return translateModelsDevCatalog(parsed, {
+				sourceUrl: url.toString(),
+				retrievedAt,
+				freshUntil: retrievedAt + this.freshnessMs,
+				revision: await digestRevision(body),
+			});
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+}
+
+function localAuthority(now: number): ModelCatalogFieldAuthority {
+	return { authority: "user-override", sourceId: "local-configuration", revision: "runtime", retrievedAt: now };
+}
+
+function applyOverrides(entry: ModelCatalogEntry, overrides: ModelCatalogOverrides | undefined, now: number): ModelCatalogEntry {
+	if (!overrides) return entry;
+	const result = structuredClone(entry);
+	const values: Array<[keyof ModelCatalogOverrides, string, (value: number) => void]> = [
+		["contextTokens", "limits.context", (value) => (result.limits.context = value)],
+		["inputTokens", "limits.input", (value) => (result.limits.input = value)],
+		["outputTokens", "limits.output", (value) => (result.limits.output = value)],
+		[
+			"inputPrice",
+			"pricing.input",
+			(value) => {
+				if (!result.pricing) result.pricing = {};
+				result.pricing.input = value;
+			},
+		],
+		[
+			"outputPrice",
+			"pricing.output",
+			(value) => {
+				if (!result.pricing) result.pricing = {};
+				result.pricing.output = value;
+			},
+		],
+	];
+	for (const [key, field, assign] of values) {
+		const value = overrides[key];
+		if (value === undefined) continue;
+		nonnegative(value, `override ${key}`, key.endsWith("Tokens"));
+		assign(value);
+		result.fieldAuthority[field] = localAuthority(now);
+	}
+	return result;
+}
+
+export interface ModelCatalogController {
+	refresh(force?: boolean): Promise<ModelCatalogStatus>;
+	status(): ModelCatalogStatus;
+	query(input?: ModelCatalogQuery): ModelCatalogQueryResult;
+}
+
+export class ModelCatalog implements ModelCatalogController {
+	private readonly clock: () => number;
+	private state: ModelCatalogStatus;
+
+	constructor(
+		private readonly store: ModelCatalogStore,
+		private readonly source?: ModelCatalogSource,
+		options: { clock?: () => number } = {},
+	) {
+		this.clock = options.clock ?? Date.now;
+		const latest = store.latest();
+		this.state = {
+			configured: source !== undefined,
+			ok: null,
+			hasSnapshot: latest !== null,
+			lastAttemptAt: null,
+			lastSuccessAt: latest?.provenance.retrievedAt ?? null,
+			entries: latest?.entries.length ?? 0,
+			revision: latest?.provenance.revision ?? null,
+		};
+	}
+
+	async refresh(force = false): Promise<ModelCatalogStatus> {
+		const attemptedAt = this.clock();
+		if (!this.source) return structuredClone(this.state);
+		const latestBeforeRefresh = this.store.latest();
+		if (!force && latestBeforeRefresh && attemptedAt <= latestBeforeRefresh.provenance.freshUntil) return structuredClone(this.state);
+		try {
+			const snapshot = this.store.publish(await this.source.fetch());
+			this.state = {
+				configured: true,
+				ok: true,
+				hasSnapshot: true,
+				lastAttemptAt: attemptedAt,
+				lastSuccessAt: snapshot.provenance.retrievedAt,
+				entries: snapshot.entries.length,
+				revision: snapshot.provenance.revision,
+			};
+		} catch {
+			const latest = this.store.latest();
+			this.state = {
+				...this.state,
+				configured: true,
+				ok: false,
+				hasSnapshot: latest !== null,
+				lastAttemptAt: attemptedAt,
+				entries: latest?.entries.length ?? this.state.entries,
+				revision: latest?.provenance.revision ?? this.state.revision,
+				error: "catalog refresh failed",
+			};
+		}
+		return structuredClone(this.state);
+	}
+
+	status(): ModelCatalogStatus {
+		return structuredClone(this.state);
+	}
+
+	query(input: ModelCatalogQuery = {}): ModelCatalogQueryResult {
+		const snapshot = this.store.latest();
+		if (!snapshot) throw new Error("model catalog is not available");
+		const provider = input.provider?.trim().toLowerCase();
+		const model = input.model?.trim().toLowerCase();
+		const matched = snapshot.entries.filter(
+			(entry) =>
+				(!provider || entry.provider === provider) &&
+				(!model || entry.model === model || entry.canonical === model || entry.aliases.includes(model)),
+		);
+		const requested = Number.isSafeInteger(input.limit) ? input.limit! : MODEL_CATALOG_DEFAULT_QUERY_LIMIT;
+		const limit = Math.max(1, Math.min(MODEL_CATALOG_MAX_QUERY_LIMIT, requested));
+		const now = this.clock();
+		return {
+			snapshotId: snapshot.snapshotId,
+			provenance: structuredClone(snapshot.provenance),
+			freshness: now <= snapshot.provenance.freshUntil ? "fresh" : "stale",
+			completeness: matched.length > limit ? "truncated" : "complete",
+			entries: matched.slice(0, limit).map((entry) => applyOverrides(structuredClone(entry), input.overrides, now)),
+		};
+	}
+}

package/src/{ports/benchmark-controller.ts → optimization/model-selection/controller.ts}

@@ -1,4 +1,4 @@
-import type { BenchmarkQuery, BenchmarkQueryResult, BenchmarkRefreshResult } from "../domain/benchmark.ts";
+import type { BenchmarkQuery, BenchmarkQueryResult, BenchmarkRefreshResult } from "./benchmark.ts";
 
 export interface BenchmarkController {
 	refresh(force?: boolean): Promise<BenchmarkRefreshResult>;

package/src/{adapters/metric-benchmark-store.ts → optimization/model-selection/observation-store.ts}

@@ -1,8 +1,8 @@
-import { BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT, BENCHMARK_STORE_QUERY_LIMIT } from "../constants.ts";
-import { type BenchmarkObservation, type BenchmarkSnapshot, validateBenchmarkObservation } from "../domain/benchmark.ts";
-import type { StoredMetricObservation } from "../domain/metric.ts";
-import type { BenchmarkStore } from "../ports/benchmark-store.ts";
-import type { MetricStore } from "../ports/metric-store.ts";
+import { BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT, BENCHMARK_STORE_QUERY_LIMIT } from "../../constants.ts";
+import type { StoredMetricObservation } from "../../observability/metric.ts";
+import type { MetricStore } from "../../observability/store.ts";
+import { type BenchmarkObservation, type BenchmarkSnapshot, validateBenchmarkObservation } from "./benchmark.ts";
+import type { BenchmarkStore } from "./store.ts";
 
 const COMPLETE_METRIC = "snapshot-complete";
 const SNAPSHOT_SCOPE = "snapshot";

package/src/{domain/model-ranking-service.ts → optimization/model-selection/ranker.ts}

@@ -1,15 +1,9 @@
-import { MODEL_AGGREGATE_MAX_ROWS, MODEL_OBSERVATION_FRESH_MS, MODEL_RANKING_MAX_SOURCES } from "../constants.ts";
-import type { BenchmarkStore } from "../ports/benchmark-store.ts";
-import type { MetricStore } from "../ports/metric-store.ts";
-import type { ModelTaskDomain, ModelTaskType } from "./model-observation.ts";
-import { aggregateModelMetrics } from "./model-observation.ts";
-import {
-	type ModelCandidate,
-	type ModelRankingResult,
-	rankModelCandidates,
-	type ScopeAuthority,
-	type UtilityWeights,
-} from "./model-ranking.ts";
+import { MODEL_AGGREGATE_MAX_ROWS, MODEL_OBSERVATION_FRESH_MS, MODEL_RANKING_MAX_SOURCES } from "../../constants.ts";
+import type { ModelTaskDomain, ModelTaskType } from "../../observability/model-observation.ts";
+import { aggregateModelMetrics } from "../../observability/model-observation.ts";
+import type { MetricStore } from "../../observability/store.ts";
+import { type ModelCandidate, type ModelRankingResult, rankModelCandidates, type ScopeAuthority, type UtilityWeights } from "./ranking.ts";
+import type { BenchmarkStore } from "./store.ts";
 
 export interface ModelRecommendationInput {
 	candidates: ModelCandidate[];

package/src/{domain/model-ranking.ts → optimization/model-selection/ranking.ts}

@@ -1,6 +1,12 @@
-import { BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT, MAX_DYNAMIC_ROUTES, MODEL_AGGREGATE_MAX_ROWS } from "../constants.ts";
+import { BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT, MAX_DYNAMIC_ROUTES, MODEL_AGGREGATE_MAX_ROWS } from "../../constants.ts";
+import {
+	type ModelMetricAggregate,
+	type ModelTaskDomain,
+	type ModelTaskType,
+	TASK_DOMAINS,
+	TASK_TYPES,
+} from "../../observability/model-observation.ts";
 import { type BenchmarkObservation, normalizeModelIdentity } from "./benchmark.ts";
-import { type ModelMetricAggregate, type ModelTaskDomain, type ModelTaskType, TASK_DOMAINS, TASK_TYPES } from "./model-observation.ts";
 
 export type ScopeAuthority = "exact-session" | "available-models";
 export type UtilityComponentName = "quality" | "cost" | "latency" | "context" | "reliability";

package/src/{ports/benchmark-source.ts → optimization/model-selection/source.ts}

@@ -1,4 +1,4 @@
-import type { BenchmarkSourceSnapshot } from "../domain/benchmark.ts";
+import type { BenchmarkSourceSnapshot } from "./benchmark.ts";
 
 /** External evidence boundary. Implementations validate one source-specific schema. */
 export interface BenchmarkSource {

package/src/{ports/benchmark-store.ts → optimization/model-selection/store.ts}

@@ -1,4 +1,4 @@
-import type { BenchmarkObservation, BenchmarkSnapshot } from "../domain/benchmark.ts";
+import type { BenchmarkObservation, BenchmarkSnapshot } from "./benchmark.ts";
 
 /** Immutable evidence snapshot boundary. Only complete snapshots become visible. */
 export interface BenchmarkStore {

package/src/{domain/codex-recovery.ts → optimization/recovery/codex.ts}

@@ -1,4 +1,4 @@
-import { CODEX_ERROR_MESSAGE_LIMIT, CODEX_RETRY_AFTER_MAX_MS, MILLISECONDS_PER_SECOND } from "../constants.ts";
+import { CODEX_ERROR_MESSAGE_LIMIT, CODEX_RETRY_AFTER_MAX_MS, MILLISECONDS_PER_SECOND } from "../../constants.ts";
 
 export type CodexFailureKind =
 	| "concurrency"

package/src/{ports/router-controller.ts → optimization/routing/controller.ts}

@@ -1,4 +1,4 @@
-import type { PolicyDecision, Route } from "../policy.ts";
+import type { PolicyDecision, Route } from "./policy.ts";
 
 export interface TelemetrySourceStatus {
 	id: string;

package/src/{policy.ts → optimization/routing/policy.ts}

@@ -1,18 +1,8 @@
+import type { BudgetWindow } from "../../observability/budget.ts";
+
+export type { BudgetWindow, TelemetryFreshness } from "../../observability/budget.ts";
+
 export type PolicyAction = "continue" | "throttle" | "lower-thinking" | "switch-model" | "switch-provider" | "halt";
-export type TelemetryFreshness = "fresh" | "stale" | "failed";
-
-export interface BudgetWindow {
-	id: string;
-	source: string;
-	scope: string;
-	usedFraction: number;
-	windowSeconds: number;
-	resetsAt: number;
-	observedAt: number;
-	freshness: TelemetryFreshness;
-	confidence: number;
-	observedBurnPerSecond?: number;
-}
 
 export interface Route {
 	provider: string;

package/src/{router.ts → optimization/routing/router.ts}

@@ -1,14 +1,8 @@
-import { ROUTER_MAX_SESSION_SCOPES, ROUTER_SESSION_ID_MAX_CHARACTERS } from "./constants.ts";
+import { ROUTER_MAX_SESSION_SCOPES, ROUTER_SESSION_ID_MAX_CHARACTERS } from "../../constants.ts";
+import type { MetricStore } from "../../observability/store.ts";
+import type { TelemetrySource } from "../../observability/telemetry-source.ts";
+import type { RouteOverride, RouterController, RouterStatus, TelemetryPollResult, TelemetrySourceStatus } from "./controller.ts";
 import { type BudgetWindow, evaluateRoutingPolicy, type PolicyConfig, type PolicyDecision, type Route } from "./policy.ts";
-import type { MetricStore } from "./ports/metric-store.ts";
-import type {
-	RouteOverride,
-	RouterController,
-	RouterStatus,
-	TelemetryPollResult,
-	TelemetrySourceStatus,
-} from "./ports/router-controller.ts";
-import type { TelemetrySource } from "./ports/telemetry-source.ts";
 
 export interface JittorRouterOptions {
 	metrics: MetricStore;