@danypops/jittor 0.16.3 → 0.18.0

package/src/{service.ts → vehicle/service.ts}

@@ -1,29 +1,44 @@
 import { VehicleRegistry } from "@danypops/vehicle-server";
 import { createVehicleHttpApp } from "@danypops/vehicle-server/http";
 import { errorResponse, healthResponse, readyResponse, requireBearerToken } from "@danypops/vehicle-server/rpc-http";
-import { SERVICE_MAX_BODY_BYTES, SERVICE_MAX_RESPONSE_BYTES } from "./constants.ts";
-import type { BenchmarkQuery, BenchmarkQueryResult, BenchmarkRefreshResult } from "./domain/benchmark.ts";
-import type { CompactionDurationEstimate, ContextAssessment } from "./domain/context-telemetry.ts";
-import type { MetricObservation, MetricQuery, StoredMetricObservation } from "./domain/metric.ts";
-import type { ModelRankingResult } from "./domain/model-ranking.ts";
-import type { ModelRanker, ModelRecommendationInput } from "./domain/model-ranking-service.ts";
-import type { TaskCostSummary } from "./domain/task-cost.ts";
-import type { UsageAggregateRow } from "./domain/usage.ts";
-import { benchmarkOperations } from "./operations/benchmark-operations.ts";
-import { contextOperations } from "./operations/context-operations.ts";
-import { metricsOperations } from "./operations/metrics-operations.ts";
-import { modelRankingOperations } from "./operations/model-ranking-operations.ts";
-import { routerOperations } from "./operations/router-operations.ts";
-import { sessionIdentityOperations } from "./operations/session-identity-operations.ts";
-import { routerMutationAuthorizer } from "./operations/session-scope.ts";
-import type { OperationHandlerMap } from "./operations/types.ts";
-import type { PolicyDecision, Route } from "./policy.ts";
-import type { BenchmarkController } from "./ports/benchmark-controller.ts";
-import type { MetricStore } from "./ports/metric-store.ts";
-import type { RouteOverride, RouterController, RouterStatus, TelemetryPollResult } from "./ports/router-controller.ts";
-import { InvalidSessionSecretError, type RegisterSessionIdentityResult, type SessionIdentity } from "./session-identity-service.ts";
-import { registerJittorVehicleOperations } from "./vehicle-registration.ts";
-import { VERSION } from "./version.ts";
+import { SERVICE_MAX_BODY_BYTES, SERVICE_MAX_RESPONSE_BYTES } from "../constants.ts";
+import type { CacheEconomicsSummary } from "../observability/cache-economics.ts";
+import type { ContextDelta, ContextSnapshot } from "../observability/context-delta.ts";
+import { type ContextSnapshotHistory, MetricContextSnapshotHistory } from "../observability/context-snapshot-history.ts";
+import type { CompactionDurationEstimate, ContextAssessment } from "../observability/context-telemetry.ts";
+import type { MetricObservation, MetricQuery, StoredMetricObservation } from "../observability/metric.ts";
+import type { MetricStore } from "../observability/store.ts";
+import type { TaskCostSummary } from "../observability/task-cost.ts";
+import type { UsageAggregateRow } from "../observability/usage.ts";
+import type { UsageImportController, UsageImportResult, UsageImportStatus } from "../observability/usage-import.ts";
+import type { BenchmarkQuery, BenchmarkQueryResult, BenchmarkRefreshResult } from "../optimization/model-selection/benchmark.ts";
+import type {
+	ModelCatalogController,
+	ModelCatalogQuery,
+	ModelCatalogQueryResult,
+	ModelCatalogStatus,
+} from "../optimization/model-selection/catalog.ts";
+import type { BenchmarkController } from "../optimization/model-selection/controller.ts";
+import type { ModelRanker, ModelRecommendationInput } from "../optimization/model-selection/ranker.ts";
+import type { ModelRankingResult } from "../optimization/model-selection/ranking.ts";
+import type { RouteOverride, RouterController, RouterStatus, TelemetryPollResult } from "../optimization/routing/controller.ts";
+import type { PolicyDecision, Route } from "../optimization/routing/policy.ts";
+import { InvalidSessionSecretError, type RegisterSessionIdentityResult, type SessionIdentity } from "../sessions/identity.ts";
+import { routerMutationAuthorizer } from "../sessions/router-authorization.ts";
+import { DisabledObservationExporter, type ObservationExporter, type ObservationExportStatus } from "../telemetry-export/exporter.ts";
+import { VERSION } from "../version.ts";
+import { benchmarkOperations } from "./benchmark-operations.ts";
+import { cacheEconomicsOperations } from "./cache-operations.ts";
+import { catalogOperations } from "./catalog-operations.ts";
+import { contextOperations } from "./context-operations.ts";
+import { exportOperations } from "./export-operations.ts";
+import { metricsOperations } from "./metric-operations.ts";
+import { modelRankingOperations } from "./model-ranking-operations.ts";
+import type { OperationHandlerMap } from "./operation-types.ts";
+import { registerJittorVehicleOperations } from "./registration.ts";
+import { routerOperations } from "./routing-operations.ts";
+import { sessionIdentityOperations } from "./session-operations.ts";
+import { usageImportOperations } from "./usage-import-operations.ts";
 
 export const EXPECTED_OPERATION_NAMES = [
 	"metrics.record",
@@ -36,10 +51,20 @@ export const EXPECTED_OPERATION_NAMES = [
 	"benchmark.refresh",
 	"benchmark.status",
 	"benchmark.query",
+	"catalog.refresh",
+	"catalog.status",
+	"catalog.query",
+	"usage.import",
+	"usage.import_status",
+	"usage.import_cancel",
+	"export.status",
+	"export.flush",
 	"session.register",
 	"session.release",
 	"models.rank",
 	"context.assess",
+	"context.delta",
+	"context.snapshot",
 	"compaction.estimate",
 	"service.checkpoint",
 	"telemetry.poll",
@@ -51,6 +76,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	"router.clear_override",
 	"router.current_route",
 	"router.available_routes",
+	"cache.economics",
 ] as const;
 
 export type OperationName = (typeof EXPECTED_OPERATION_NAMES)[number];
@@ -71,8 +97,18 @@ export interface OperationInputs {
 	"benchmark.refresh": { force?: boolean };
 	"benchmark.status": Record<string, never>;
 	"benchmark.query": BenchmarkQuery;
+	"catalog.refresh": { force?: boolean };
+	"catalog.status": Record<string, never>;
+	"catalog.query": ModelCatalogQuery;
+	"usage.import": { dryRun?: boolean };
+	"usage.import_status": Record<string, never>;
+	"usage.import_cancel": Record<string, never>;
+	"export.status": Record<string, never>;
+	"export.flush": Record<string, never>;
 	"models.rank": ModelRecommendationInput & RouterScopeInput;
 	"context.assess": { since?: number; until?: number };
+	"context.delta": { session_id: string };
+	"context.snapshot": ContextSnapshot;
 	"compaction.estimate": Record<string, never>;
 	"service.checkpoint": Record<string, never>;
 	"telemetry.poll": Record<string, never>;
@@ -84,6 +120,7 @@ export interface OperationInputs {
 	"router.clear_override": RouterScopeInput;
 	"router.current_route": Route & RouterScopeInput;
 	"router.available_routes": { routes: Route[] } & RouterScopeInput;
+	"cache.economics": { since: number; until: number };
 }
 export interface OperationOutputs {
 	"session.register": RegisterSessionIdentityResult;
@@ -98,8 +135,18 @@ export interface OperationOutputs {
 	"benchmark.refresh": BenchmarkRefreshResult;
 	"benchmark.status": BenchmarkRefreshResult;
 	"benchmark.query": BenchmarkQueryResult;
+	"catalog.refresh": ModelCatalogStatus;
+	"catalog.status": ModelCatalogStatus;
+	"catalog.query": ModelCatalogQueryResult;
+	"usage.import": UsageImportResult;
+	"usage.import_status": UsageImportStatus;
+	"usage.import_cancel": UsageImportStatus;
+	"export.status": ObservationExportStatus;
+	"export.flush": ObservationExportStatus;
 	"models.rank": ModelRankingResult;
 	"context.assess": ContextAssessment;
+	"context.delta": ContextDelta | null;
+	"context.snapshot": ContextDelta;
 	"compaction.estimate": CompactionDurationEstimate;
 	"service.checkpoint": { ok: true };
 	"telemetry.poll": TelemetryPollResult;
@@ -111,11 +158,44 @@ export interface OperationOutputs {
 	"router.clear_override": RouterStatus;
 	"router.current_route": RouterStatus;
 	"router.available_routes": RouterStatus;
+	"cache.economics": CacheEconomicsSummary;
 }
 
 export class UnknownOperationError extends Error {}
 export { InvalidSessionSecretError };
 
+class UnavailableUsageImporter implements UsageImportController {
+	async run(): Promise<UsageImportResult> {
+		throw new Error("historical usage import is not configured");
+	}
+	status(): UsageImportStatus {
+		return { running: false, cancelRequested: false, lastResult: null };
+	}
+	cancel(): UsageImportStatus {
+		return this.status();
+	}
+}
+
+class UnavailableModelCatalog implements ModelCatalogController {
+	async refresh(): Promise<ModelCatalogStatus> {
+		return this.status();
+	}
+	status(): ModelCatalogStatus {
+		return {
+			configured: false,
+			ok: null,
+			hasSnapshot: false,
+			lastAttemptAt: null,
+			lastSuccessAt: null,
+			entries: 0,
+			revision: null,
+		};
+	}
+	query(): ModelCatalogQueryResult {
+		throw new Error("model catalog is not configured");
+	}
+}
+
 class UnavailableModelRanker implements ModelRanker {
 	rank(): ModelRankingResult {
 		throw new Error("model ranking is not configured");
@@ -191,6 +271,10 @@ export class JittorService {
 		benchmarks: BenchmarkController = new UnavailableBenchmarkController(),
 		modelRanker: ModelRanker = new UnavailableModelRanker(),
 		sessionIdentity?: SessionIdentity,
+		contextSnapshots: ContextSnapshotHistory = new MetricContextSnapshotHistory(metrics),
+		catalog: ModelCatalogController = new UnavailableModelCatalog(),
+		usageImporter: UsageImportController = new UnavailableUsageImporter(),
+		exporter: ObservationExporter = new DisabledObservationExporter(),
 	) {
 		this.router = router;
 		const authorize = routerMutationAuthorizer(sessionIdentity);
@@ -200,15 +284,19 @@ export class JittorService {
 		this.operations = {
 			...metricsOperations(metrics),
 			...benchmarkOperations(benchmarks),
-			...contextOperations(metrics),
+			...catalogOperations(catalog),
+			...usageImportOperations(usageImporter),
+			...exportOperations(exporter),
+			...contextOperations(metrics, contextSnapshots),
 			...routerOperations(router, authorize),
 			...modelRankingOperations(modelRanker, router, authorize),
 			...sessionIdentityOperations(sessionIdentity),
+			...cacheEconomicsOperations(metrics, catalog),
 		};
 		this.vehicleRegistry = new VehicleRegistry({
 			name: "jittor",
-			packageJsonUrl: new URL("../package.json", import.meta.url),
-			description: "Just-in-Time Token Optimizing Router for Pi -- metrics, benchmark evidence, model ranking, and router policy.",
+			packageJsonUrl: new URL("../../package.json", import.meta.url),
+			description: "Just-in-Time Token Optimization Router for Pi -- token and context observability with optimization policies.",
 		});
 		// withJittorErrorParity() already converts every real handler error into a well-formed
 		// VehicleError, so this only affects a genuine registration/binding bug.

package/src/{operations/session-identity-operations.ts → vehicle/session-operations.ts}

@@ -1,6 +1,6 @@
-import type { SessionIdentity } from "../session-identity-service.ts";
-import { requiredString, routerSessionSecret } from "./session-scope.ts";
-import type { OperationHandlerMap } from "./types.ts";
+import type { SessionIdentity } from "../sessions/identity.ts";
+import { requiredString, routerSessionSecret } from "../sessions/router-authorization.ts";
+import type { OperationHandlerMap } from "../vehicle/operation-types.ts";
 
 /** session.register and session.release -- the only two operations that mutate SessionIdentity itself, distinct from the router mutations it later authorizes. */
 export function sessionIdentityOperations(sessionIdentity: SessionIdentity | undefined): OperationHandlerMap {

package/src/vehicle/usage-import-operations.ts

@@ -0,0 +1,10 @@
+import type { UsageImportController } from "../observability/usage-import.ts";
+import type { OperationHandlerMap } from "./operation-types.ts";
+
+export function usageImportOperations(importer: UsageImportController): OperationHandlerMap {
+	return {
+		"usage.import": (input) => importer.run({ dryRun: input.dryRun === true }),
+		"usage.import_status": () => importer.status(),
+		"usage.import_cancel": () => importer.cancel(),
+	};
+}

package/src/providers/telemetry-sources.ts

@@ -1,108 +0,0 @@
-import type { BudgetWindow } from "../policy.ts";
-import type { TelemetryBatch, TelemetrySource } from "../ports/telemetry-source.ts";
-import {
-	type CodexRateLimitSnapshot,
-	CodexSubscriptionTelemetryAdapter,
-	type CodexTransport,
-	type CodexWindow,
-	loadCodexFileCredentials,
-} from "./codex.ts";
-import type { GoogleAdcTokenProvider } from "./google-adc-auth.ts";
-import { GoogleVertexBudgetTelemetryAdapter, type GoogleVertexBudgetTransport } from "./google-vertex-budget.ts";
-import type { GoogleVertexMetricSource } from "./google-vertex-contracts.ts";
-import { OpenRouterTelemetryAdapter, type OpenRouterTransport } from "./openrouter.ts";
-
-function budgetWindow(limit: CodexRateLimitSnapshot, name: "primary" | "secondary", window: CodexWindow | null): BudgetWindow | null {
-	if (!window || window.windowSeconds === null || window.resetsAt === null) return null;
-	return {
-		id: `${limit.limitId}:${name}@${limit.observedAt}`,
-		source: "codex-subscription",
-		scope: limit.limitId === "codex" ? `codex:${name}` : `${limit.limitId}:${name}`,
-		usedFraction: window.usedPercent / 100,
-		windowSeconds: window.windowSeconds,
-		resetsAt: window.resetsAt * 1_000,
-		observedAt: limit.observedAt,
-		freshness: "fresh",
-		confidence: 0.8,
-	};
-}
-
-function windowsFromLimit(limit: CodexRateLimitSnapshot): BudgetWindow[] {
-	return [budgetWindow(limit, "primary", limit.primary), budgetWindow(limit, "secondary", limit.secondary)].filter(
-		(window): window is BudgetWindow => window !== null,
-	);
-}
-
-export class CodexTelemetrySource implements TelemetrySource {
-	readonly id = "codex-subscription";
-	readonly provider = "openai-codex";
-	readonly required = true;
-
-	constructor(
-		private readonly authFile: string,
-		private readonly transport: CodexTransport = fetch,
-		private readonly clock: () => number = Date.now,
-	) {}
-
-	async poll(): Promise<TelemetryBatch> {
-		const observedAt = this.clock();
-		const adapter = new CodexSubscriptionTelemetryAdapter(loadCodexFileCredentials(this.authFile), this.transport);
-		const snapshot = await adapter.readUsage(observedAt);
-		return {
-			observedAt,
-			metrics: snapshot.metrics,
-			windows: [snapshot.defaultLimit, ...snapshot.additionalLimits].flatMap(windowsFromLimit),
-		};
-	}
-}
-
-export class OpenRouterTelemetrySource implements TelemetrySource {
-	readonly id = "openrouter";
-	readonly provider = "openrouter";
-	readonly required = false;
-
-	constructor(
-		private readonly apiKey: string,
-		private readonly transport: OpenRouterTransport = fetch,
-		private readonly clock: () => number = Date.now,
-	) {}
-
-	async poll(): Promise<TelemetryBatch> {
-		const observedAt = this.clock();
-		const snapshot = await new OpenRouterTelemetryAdapter(this.apiKey, this.transport).readKey(observedAt);
-		return { observedAt, metrics: snapshot.metrics, windows: [] };
-	}
-}
-
-/**
- * Optional (never `required`): the one-time GCP setup (Pub/Sub topic + pull subscription
- * connected to the individual project's budget) lives entirely outside Jittor, so a subscription
- * that doesn't exist yet, or a project not yet migrated onto the individual-project model, must
- * not block every other route the way a missing required source would.
- */
-export class GoogleVertexBudgetTelemetrySource implements TelemetrySource {
-	readonly id: string;
-	readonly provider: GoogleVertexMetricSource;
-	readonly required = false;
-
-	private readonly adapter: GoogleVertexBudgetTelemetryAdapter;
-
-	constructor(
-		subscription: string,
-		tokenProvider: GoogleAdcTokenProvider,
-		private readonly clock: () => number = Date.now,
-		transport: GoogleVertexBudgetTransport = fetch,
-		source: GoogleVertexMetricSource = "google-vertex",
-	) {
-		this.id = `google-vertex-budget:${source}`;
-		this.provider = source;
-		this.adapter = new GoogleVertexBudgetTelemetryAdapter(subscription, tokenProvider, transport, source);
-	}
-
-	async poll(): Promise<TelemetryBatch> {
-		const observedAt = this.clock();
-		const snapshot = await this.adapter.pull(observedAt);
-		if (!snapshot) return { observedAt, metrics: [], windows: [] };
-		return { observedAt, metrics: snapshot.metrics, windows: snapshot.window ? [snapshot.window] : [] };
-	}
-}