@danypops/jittor 0.5.0 → 0.6.0

package/src/service.ts

@@ -1,7 +1,11 @@
-import { CONTEXT_ASSESSMENT_DEFAULT_WINDOW_MS, CONTEXT_ASSESSMENT_QUERY_LIMIT, SERVICE_MAX_BODY_BYTES } from "./constants.ts";
+import { COMPACTION_DURATION_ESTIMATE_MAX_SAMPLES, CONTEXT_ASSESSMENT_DEFAULT_WINDOW_MS, CONTEXT_ASSESSMENT_QUERY_LIMIT, SERVICE_MAX_BODY_BYTES, SERVICE_MAX_RESPONSE_BYTES } from "./constants.ts";
 import { VERSION } from "./version.ts";
 import { validateMetricObservation, type MetricObservation, type MetricQuery, type StoredMetricObservation } from "./domain/metric.ts";
-import { assessContextTelemetry, type ContextAssessment } from "./domain/context-telemetry.ts";
+import { assessContextTelemetry, estimateCompactionDuration, type CompactionDurationEstimate, type ContextAssessment } from "./domain/context-telemetry.ts";
+import type { BenchmarkQuery, BenchmarkQueryResult, BenchmarkRefreshResult } from "./domain/benchmark.ts";
+import type { ModelRanker, ModelRecommendationInput } from "./domain/model-ranking-service.ts";
+import type { ModelRankingResult } from "./domain/model-ranking.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 type { PolicyDecision, Route } from "./policy.ts";
@@ -10,7 +14,12 @@ export const EXPECTED_OPERATION_NAMES = [
 	"metrics.record",
 	"metrics.query",
 	"metrics.prune",
+	"benchmark.refresh",
+	"benchmark.status",
+	"benchmark.query",
+	"models.rank",
 	"context.assess",
+	"compaction.estimate",
 	"service.checkpoint",
 	"telemetry.poll",
 	"router.status",
@@ -28,7 +37,12 @@ export interface OperationInputs {
 	"metrics.record": MetricObservation;
 	"metrics.query": MetricQuery;
 	"metrics.prune": { before: number };
+	"benchmark.refresh": { force?: boolean };
+	"benchmark.status": Record<string, never>;
+	"benchmark.query": BenchmarkQuery;
+	"models.rank": ModelRecommendationInput;
 	"context.assess": { since?: number; until?: number };
+	"compaction.estimate": Record<string, never>;
 	"service.checkpoint": Record<string, never>;
 	"telemetry.poll": Record<string, never>;
 	"router.status": Record<string, never>;
@@ -44,7 +58,12 @@ export interface OperationOutputs {
 	"metrics.record": StoredMetricObservation;
 	"metrics.query": StoredMetricObservation[];
 	"metrics.prune": { deleted: number };
+	"benchmark.refresh": BenchmarkRefreshResult;
+	"benchmark.status": BenchmarkRefreshResult;
+	"benchmark.query": BenchmarkQueryResult;
+	"models.rank": ModelRankingResult;
 	"context.assess": ContextAssessment;
+	"compaction.estimate": CompactionDurationEstimate;
 	"service.checkpoint": { ok: true };
 	"telemetry.poll": TelemetryPollResult;
 	"router.status": RouterStatus;
@@ -59,6 +78,16 @@ export interface OperationOutputs {
 
 export class UnknownOperationError extends Error {}
 
+class UnavailableModelRanker implements ModelRanker {
+	rank(): ModelRankingResult { throw new Error("model ranking is not configured"); }
+}
+
+class UnavailableBenchmarkController implements BenchmarkController {
+	async refresh(): Promise<BenchmarkRefreshResult> { return this.status(); }
+	status(): BenchmarkRefreshResult { return { observedAt: Date.now(), sources: [] }; }
+	query(): BenchmarkQueryResult { throw new Error("benchmark evidence is not configured"); }
+}
+
 class UnavailableRouter implements RouterController {
 	private readonly unavailable: RouterStatus = { ready: false, paused: false, sources: [], lastDecision: null, override: null, currentRoute: null, availableRoutes: [] };
 	async poll(): Promise<TelemetryPollResult> { return { sources: [], observedAt: Date.now() }; }
@@ -76,6 +105,8 @@ export class JittorService {
 	constructor(
 		private readonly metrics: MetricStore,
 		private readonly router: RouterController = new UnavailableRouter(),
+		private readonly benchmarks: BenchmarkController = new UnavailableBenchmarkController(),
+		private readonly modelRanker: ModelRanker = new UnavailableModelRanker(),
 	) {}
 
 	operationNames(): OperationName[] {
@@ -93,6 +124,14 @@ export class JittorService {
 				if (typeof before !== "number") throw new Error("before is required");
 				return { deleted: this.metrics.pruneBefore(before) };
 			}
+			case "benchmark.refresh": return this.benchmarks.refresh(input["force"] === true);
+			case "benchmark.status": return this.benchmarks.status();
+			case "benchmark.query": return this.benchmarks.query(input as unknown as BenchmarkQuery);
+			case "models.rank": {
+				const result = this.modelRanker.rank(input as unknown as ModelRecommendationInput);
+				if (result.automaticSelection && this.router.applyModelRanking) this.router.applyModelRanking(result.ranked.map((item) => item.candidate));
+				return result;
+			}
 			case "context.assess": {
 				const until = input["until"] === undefined ? Date.now() : input["until"];
 				const since = input["since"] === undefined && typeof until === "number" ? Math.max(0, until - CONTEXT_ASSESSMENT_DEFAULT_WINDOW_MS) : input["since"];
@@ -106,6 +145,13 @@ export class JittorService {
 					truncated: injections.length >= CONTEXT_ASSESSMENT_QUERY_LIMIT || compactions.length >= CONTEXT_ASSESSMENT_QUERY_LIMIT,
 				});
 			}
+			case "compaction.estimate": {
+				const rows = this.metrics.query({
+					source: "pi-context", scope: "compaction", metric: "compaction-duration",
+					order: "desc", limit: COMPACTION_DURATION_ESTIMATE_MAX_SAMPLES,
+				});
+				return estimateCompactionDuration(rows);
+			}
 			case "service.checkpoint": this.metrics.checkpoint(); return { ok: true };
 			case "telemetry.poll": return this.router.poll();
 			case "router.status": return this.router.status();
@@ -140,7 +186,18 @@ function authorized(request: Request, token: string): boolean {
 }
 
 function json(value: unknown, status = 200): Response {
-	return Response.json(value, { status });
+	const body = JSON.stringify(value);
+	if (new TextEncoder().encode(body).byteLength > SERVICE_MAX_RESPONSE_BYTES) {
+		const error = JSON.stringify({ error: "response too large" });
+		return new Response(error, {
+			status: 413,
+			headers: { "content-type": "application/json", "content-length": String(new TextEncoder().encode(error).byteLength) },
+		});
+	}
+	return new Response(body, {
+		status,
+		headers: { "content-type": "application/json", "content-length": String(new TextEncoder().encode(body).byteLength) },
+	});
 }
 
 export function createApp(options: JittorAppOptions): { fetch(request: Request): Promise<Response> } {