@elizaos/agent 0.25.9 → 2.0.0-alpha.84

package/packages/agent/src/api/training-routes.js

@@ -0,0 +1,195 @@
+import { parsePositiveInteger } from "../utils/number-parsing";
+import { detectAvailableBackends } from "./training-backend-check";
+function resolveOllamaUrlRejection(rawUrl, isLoopbackHost) {
+    const trimmed = rawUrl.trim();
+    if (!trimmed)
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return "ollamaUrl must be a valid URL";
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return "ollamaUrl must use http:// or https://";
+    }
+    if (!isLoopbackHost(parsed.hostname)) {
+        return "ollamaUrl must target a loopback host (localhost, 127.0.0.1, or ::1)";
+    }
+    return null;
+}
+export async function handleTrainingRoutes(ctx) {
+    const { req, res, method, pathname, runtime, trainingService, json, error, readJsonBody, isLoopbackHost, } = ctx;
+    if (!pathname.startsWith("/api/training"))
+        return false;
+    if (method === "GET" && pathname === "/api/training/status") {
+        const status = trainingService.getStatus();
+        json(res, {
+            ...status,
+            runtimeAvailable: runtime !== null,
+        });
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/training/trajectories") {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        const limit = parsePositiveInteger(url.searchParams.get("limit"), 100);
+        const offset = Math.max(0, Number(url.searchParams.get("offset") ?? "0"));
+        const result = await trainingService.listTrajectories({ limit, offset });
+        json(res, result);
+        return true;
+    }
+    const trajectoryMatch = /^\/api\/training\/trajectories\/([^/]+)$/.exec(pathname);
+    if (method === "GET" && trajectoryMatch) {
+        const trajectoryId = decodeURIComponent(trajectoryMatch[1]);
+        const detail = await trainingService.getTrajectoryById(trajectoryId);
+        if (!detail) {
+            error(res, "Trajectory not found", 404);
+            return true;
+        }
+        json(res, { trajectory: detail });
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/training/datasets") {
+        json(res, { datasets: trainingService.listDatasets() });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/training/datasets/build") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const dataset = await trainingService.buildDataset({
+            limit: body.limit,
+            minLlmCallsPerTrajectory: body.minLlmCallsPerTrajectory,
+        });
+        json(res, { dataset }, 201);
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/training/backends") {
+        const backends = await detectAvailableBackends();
+        json(res, { backends });
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/training/jobs") {
+        json(res, { jobs: trainingService.listJobs() });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/training/jobs") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        if (body.backend && body.backend !== "cpu") {
+            const backends = await detectAvailableBackends();
+            if (!backends[body.backend]) {
+                const available = Object.entries(backends)
+                    .filter(([, ok]) => ok)
+                    .map(([name]) => name)
+                    .join(", ");
+                error(res, `Backend '${body.backend}' is not available on this system. Available backends: ${available}`, 400);
+                return true;
+            }
+        }
+        try {
+            const job = await trainingService.startTrainingJob({
+                datasetId: body.datasetId,
+                maxTrajectories: body.maxTrajectories,
+                backend: body.backend,
+                model: body.model,
+                iterations: body.iterations,
+                batchSize: body.batchSize,
+                learningRate: body.learningRate,
+            });
+            json(res, { job }, 201);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            error(res, message, 400);
+        }
+        return true;
+    }
+    const jobMatch = /^\/api\/training\/jobs\/([^/]+)$/.exec(pathname);
+    if (method === "GET" && jobMatch) {
+        const jobId = decodeURIComponent(jobMatch[1]);
+        const job = trainingService.getJob(jobId);
+        if (!job) {
+            error(res, "Training job not found", 404);
+            return true;
+        }
+        json(res, { job });
+        return true;
+    }
+    const cancelMatch = /^\/api\/training\/jobs\/([^/]+)\/cancel$/.exec(pathname);
+    if (method === "POST" && cancelMatch) {
+        const jobId = decodeURIComponent(cancelMatch[1]);
+        try {
+            const job = await trainingService.cancelJob(jobId);
+            json(res, { job });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            error(res, message, 404);
+        }
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/training/models") {
+        json(res, { models: trainingService.listModels() });
+        return true;
+    }
+    const importMatch = /^\/api\/training\/models\/([^/]+)\/import-ollama$/.exec(pathname);
+    if (method === "POST" && importMatch) {
+        const modelId = decodeURIComponent(importMatch[1]);
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        if (body.ollamaUrl !== undefined && typeof body.ollamaUrl !== "string") {
+            error(res, "ollamaUrl must be a string", 400);
+            return true;
+        }
+        if (typeof body.ollamaUrl === "string") {
+            const ollamaUrlRejection = resolveOllamaUrlRejection(body.ollamaUrl, isLoopbackHost);
+            if (ollamaUrlRejection) {
+                error(res, ollamaUrlRejection, 400);
+                return true;
+            }
+        }
+        try {
+            const model = await trainingService.importModelToOllama(modelId, body);
+            json(res, { model });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            error(res, message, 400);
+        }
+        return true;
+    }
+    const activateMatch = /^\/api\/training\/models\/([^/]+)\/activate$/.exec(pathname);
+    if (method === "POST" && activateMatch) {
+        const modelId = decodeURIComponent(activateMatch[1]);
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        try {
+            const result = await trainingService.activateModel(modelId, body.providerModel);
+            json(res, result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            error(res, message, 400);
+        }
+        return true;
+    }
+    const benchmarkMatch = /^\/api\/training\/models\/([^/]+)\/benchmark$/.exec(pathname);
+    if (method === "POST" && benchmarkMatch) {
+        const modelId = decodeURIComponent(benchmarkMatch[1]);
+        try {
+            const result = await trainingService.benchmarkModel(modelId);
+            json(res, result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            error(res, message, 400);
+        }
+        return true;
+    }
+    return false;
+}

package/packages/agent/src/api/training-service-like.d.ts

@@ -0,0 +1,38 @@
+export interface TrainingServiceLike {
+    getStatus(): Record<string, unknown>;
+    listTrajectories(options: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown>>;
+    getTrajectoryById(trajectoryId: string): Promise<Record<string, unknown> | null>;
+    listDatasets(): Record<string, unknown>[];
+    buildDataset(options: {
+        limit?: number;
+        minLlmCallsPerTrajectory?: number;
+    }): Promise<Record<string, unknown>>;
+    listJobs(): Record<string, unknown>[];
+    startTrainingJob(options: {
+        datasetId?: string;
+        maxTrajectories?: number;
+        backend?: "mlx" | "cuda" | "cpu";
+        model?: string;
+        iterations?: number;
+        batchSize?: number;
+        learningRate?: number;
+    }): Promise<Record<string, unknown>>;
+    getJob(jobId: string): Record<string, unknown> | null;
+    cancelJob(jobId: string): Promise<Record<string, unknown>>;
+    listModels(): Record<string, unknown>[];
+    importModelToOllama(modelId: string, body: {
+        modelName?: string;
+        baseModel?: string;
+        ollamaUrl?: string;
+    }): Promise<Record<string, unknown>>;
+    activateModel(modelId: string, providerModel?: string): Promise<Record<string, unknown>>;
+    benchmarkModel(modelId: string): Promise<Record<string, unknown>>;
+}
+export interface TrainingServiceWithRuntime extends TrainingServiceLike {
+    initialize(): Promise<void>;
+    subscribe(listener: (event: unknown) => void): () => void;
+}
+//# sourceMappingURL=training-service-like.d.ts.map

package/packages/agent/src/api/training-service-like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"training-service-like.d.ts","sourceRoot":"","sources":["../../../../../src/api/training-service-like.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,gBAAgB,CAAC,OAAO,EAAE;QACxB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrC,iBAAiB,CACf,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3C,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC1C,YAAY,CAAC,OAAO,EAAE;QACpB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,wBAAwB,CAAC,EAAE,MAAM,CAAC;KACnC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACtC,gBAAgB,CAAC,OAAO,EAAE;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,OAAO,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;QACjC,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACtD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACxC,mBAAmB,CACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE;QACJ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GACA,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpC,aAAa,CACX,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACnE;AAED,MAAM,WAAW,0BAA2B,SAAQ,mBAAmB;IACrE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC3D"}

package/packages/agent/src/api/training-service-like.js

@@ -0,0 +1 @@
+export {};

package/packages/agent/src/api/trajectory-routes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Trajectory API routes for the Eliza Control UI.
+ *
+ * Provides endpoints for:
+ * - Listing and searching trajectories
+ * - Viewing trajectory details with LLM calls and provider accesses
+ * - Exporting trajectories to JSON, CSV, or ZIP
+ * - Deleting trajectories
+ * - Getting trajectory statistics
+ * - Enabling/disabling trajectory logging
+ *
+ * Uses the @elizaos/plugin-trajectory-logger service for data access.
+ */
+import type http from "node:http";
+import type { AgentRuntime } from "@elizaos/core";
+export declare function handleTrajectoryRoute(req: http.IncomingMessage, res: http.ServerResponse, runtime: AgentRuntime, pathname: string, method: string): Promise<boolean>;
+//# sourceMappingURL=trajectory-routes.d.ts.map

package/packages/agent/src/api/trajectory-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trajectory-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/trajectory-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAirBlD,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CA+ClB"}

package/packages/agent/src/api/trajectory-routes.js

@@ -0,0 +1,405 @@
+/**
+ * Trajectory API routes for the Eliza Control UI.
+ *
+ * Provides endpoints for:
+ * - Listing and searching trajectories
+ * - Viewing trajectory details with LLM calls and provider accesses
+ * - Exporting trajectories to JSON, CSV, or ZIP
+ * - Deleting trajectories
+ * - Getting trajectory statistics
+ * - Enabling/disabling trajectory logging
+ *
+ * Uses the @elizaos/plugin-trajectory-logger service for data access.
+ */
+import { readJsonBody as parseJsonBody, sendJson, sendJsonError, } from "./http-helpers";
+import { createZipArchive } from "./zip-utils";
+// ============================================================================
+// Helpers
+// ============================================================================
+function isRouteCompatibleTrajectoryLogger(candidate) {
+    if (!candidate || typeof candidate !== "object")
+        return false;
+    const logger = candidate;
+    return (typeof logger.isEnabled === "function" &&
+        typeof logger.setEnabled === "function" &&
+        typeof logger.listTrajectories === "function" &&
+        typeof logger.getTrajectoryDetail === "function" &&
+        typeof logger.getStats === "function" &&
+        typeof logger.deleteTrajectories === "function" &&
+        typeof logger.clearAllTrajectories === "function" &&
+        typeof logger.exportTrajectories === "function");
+}
+function collectCandidates(runtimeLike) {
+    const seen = new Set();
+    const candidates = [];
+    const add = (candidate) => {
+        if (!candidate || seen.has(candidate))
+            return;
+        seen.add(candidate);
+        candidates.push(candidate);
+    };
+    if (typeof runtimeLike.getServicesByType === "function") {
+        const byType = runtimeLike.getServicesByType("trajectory_logger");
+        if (Array.isArray(byType)) {
+            for (const candidate of byType) {
+                add(candidate);
+            }
+        }
+        else {
+            add(byType);
+        }
+    }
+    if (typeof runtimeLike.getService === "function") {
+        add(runtimeLike.getService("trajectory_logger"));
+    }
+    return candidates;
+}
+function findCompatibleLogger(candidates) {
+    for (const candidate of candidates) {
+        if (isRouteCompatibleTrajectoryLogger(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function getTrajectoryLogger(runtime) {
+    const runtimeLike = runtime;
+    // Fast path: service already available.
+    const immediate = findCompatibleLogger(collectCandidates(runtimeLike));
+    if (immediate)
+        return immediate;
+    // The service may still be starting — wait for it if the runtime supports it.
+    const status = typeof runtimeLike.getServiceRegistrationStatus === "function"
+        ? runtimeLike.getServiceRegistrationStatus("trajectory_logger")
+        : "unknown";
+    if ((status === "pending" || status === "registering") &&
+        typeof runtimeLike.getServiceLoadPromise === "function") {
+        try {
+            await Promise.race([
+                runtimeLike.getServiceLoadPromise("trajectory_logger"),
+                new Promise((resolve) => setTimeout(resolve, 5000)),
+            ]);
+        }
+        catch {
+            // Service failed to start — fall through to return null.
+        }
+        // Re-check after waiting.
+        return findCompatibleLogger(collectCandidates(runtimeLike));
+    }
+    return null;
+}
+function toNullableString(value) {
+    return typeof value === "string" ? value : null;
+}
+function listItemToUIRecord(item) {
+    const status = item.status === "timeout" || item.status === "error"
+        ? "error"
+        : item.status;
+    return {
+        id: item.id,
+        agentId: item.agentId,
+        roomId: null,
+        entityId: null,
+        conversationId: null,
+        source: item.source,
+        status: status,
+        startTime: item.startTime,
+        endTime: item.endTime,
+        durationMs: item.durationMs,
+        llmCallCount: item.llmCallCount,
+        providerAccessCount: 0,
+        totalPromptTokens: item.totalPromptTokens,
+        totalCompletionTokens: item.totalCompletionTokens,
+        metadata: {},
+        createdAt: item.createdAt,
+        updatedAt: item.createdAt,
+    };
+}
+function trajectoryToUIDetail(traj) {
+    const finalStatus = traj.metrics?.finalStatus ?? "completed";
+    const normalizedEndTime = typeof traj.endTime === "number" && traj.endTime > 0 ? traj.endTime : null;
+    const status = finalStatus === "timeout" ||
+        finalStatus === "terminated" ||
+        finalStatus === "error"
+        ? "error"
+        : finalStatus === "completed"
+            ? "completed"
+            : normalizedEndTime
+                ? "completed"
+                : "active";
+    const llmCalls = [];
+    const providerAccesses = [];
+    let totalPromptTokens = 0;
+    let totalCompletionTokens = 0;
+    const steps = traj.steps || [];
+    const trajectoryId = String(traj.trajectoryId);
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const stepId = typeof step.stepId === "string" ? step.stepId : `step-${i}`;
+        // Process LLM Calls
+        const calls = step.llmCalls || [];
+        for (let j = 0; j < calls.length; j++) {
+            const call = calls[j];
+            llmCalls.push({
+                id: call.callId || `${stepId}-call-${j}`,
+                trajectoryId,
+                stepId,
+                model: call.model || "unknown",
+                systemPrompt: call.systemPrompt || "",
+                userPrompt: call.userPrompt || "",
+                response: call.response || "",
+                temperature: typeof call.temperature === "number" ? call.temperature : 0,
+                maxTokens: typeof call.maxTokens === "number" ? call.maxTokens : 0,
+                purpose: call.purpose || "",
+                actionType: call.actionType || "",
+                latencyMs: call.latencyMs || 0,
+                promptTokens: call.promptTokens,
+                completionTokens: call.completionTokens,
+                timestamp: call.timestamp || step.timestamp,
+                createdAt: new Date(call.timestamp || step.timestamp).toISOString(),
+            });
+            totalPromptTokens += call.promptTokens || 0;
+            totalCompletionTokens += call.completionTokens || 0;
+        }
+        // Process Provider Accesses
+        const accesses = step.providerAccesses || [];
+        for (let k = 0; k < accesses.length; k++) {
+            const access = accesses[k];
+            providerAccesses.push({
+                id: access.providerId || `${stepId}-provider-${k}`,
+                trajectoryId,
+                stepId,
+                providerName: access.providerName || "unknown",
+                purpose: access.purpose || "",
+                data: access.data || {},
+                query: access.query,
+                timestamp: access.timestamp || step.timestamp,
+                createdAt: new Date(access.timestamp || step.timestamp).toISOString(),
+            });
+        }
+    }
+    const metadata = (traj.metadata ?? {});
+    const normalizedDurationMs = status === "active"
+        ? null
+        : typeof traj.durationMs === "number"
+            ? traj.durationMs
+            : null;
+    const updatedAtMs = normalizedEndTime ?? (traj.startTime || Date.now());
+    const trajectory = {
+        id: trajectoryId,
+        agentId: String(traj.agentId),
+        roomId: toNullableString(metadata.roomId),
+        entityId: toNullableString(metadata.entityId),
+        conversationId: toNullableString(metadata.conversationId),
+        source: toNullableString(metadata.source) ?? "chat",
+        status,
+        startTime: traj.startTime,
+        endTime: normalizedEndTime,
+        durationMs: normalizedDurationMs,
+        llmCallCount: llmCalls.length,
+        providerAccessCount: providerAccesses.length,
+        totalPromptTokens,
+        totalCompletionTokens,
+        metadata,
+        createdAt: new Date(traj.startTime).toISOString(),
+        updatedAt: new Date(updatedAtMs).toISOString(),
+    };
+    return { trajectory, llmCalls, providerAccesses };
+}
+// ============================================================================
+// Handlers
+// ============================================================================
+async function handleGetTrajectories(req, res, runtime) {
+    const logger = await getTrajectoryLogger(runtime);
+    if (!logger) {
+        sendJsonError(res, "Trajectory logger service not available", 503);
+        return;
+    }
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const options = {
+        limit: Math.min(500, Math.max(1, Number(url.searchParams.get("limit")) || 50)),
+        offset: Math.max(0, Number(url.searchParams.get("offset")) || 0),
+        source: url.searchParams.get("source") || undefined,
+        status: url.searchParams.get("status") || undefined,
+        startDate: url.searchParams.get("startDate") || undefined,
+        endDate: url.searchParams.get("endDate") || undefined,
+        search: url.searchParams.get("search") || undefined,
+        scenarioId: url.searchParams.get("scenarioId") || undefined,
+        batchId: url.searchParams.get("batchId") || undefined,
+        isTrainingData: url.searchParams.has("isTrainingData")
+            ? url.searchParams.get("isTrainingData") === "true"
+            : undefined,
+    };
+    const result = await logger.listTrajectories(options);
+    const uiResult = {
+        trajectories: result.trajectories.map(listItemToUIRecord),
+        total: result.total,
+        offset: result.offset,
+        limit: result.limit,
+    };
+    sendJson(res, uiResult);
+}
+async function handleGetTrajectoryDetail(_req, res, runtime, trajectoryId) {
+    const logger = await getTrajectoryLogger(runtime);
+    if (!logger) {
+        sendJsonError(res, "Trajectory logger service not available", 503);
+        return;
+    }
+    const trajectory = await logger.getTrajectoryDetail(trajectoryId);
+    if (!trajectory) {
+        sendJsonError(res, `Trajectory "${trajectoryId}" not found`, 404);
+        return;
+    }
+    const uiDetail = trajectoryToUIDetail(trajectory);
+    sendJson(res, uiDetail);
+}
+async function handleGetStats(_req, res, runtime) {
+    const logger = await getTrajectoryLogger(runtime);
+    if (!logger) {
+        sendJsonError(res, "Trajectory logger service not available", 503);
+        return;
+    }
+    const stats = await logger.getStats();
+    sendJson(res, stats);
+}
+async function handleGetConfig(_req, res, runtime) {
+    const logger = await getTrajectoryLogger(runtime);
+    if (!logger) {
+        sendJsonError(res, "Trajectory logger service not available", 503);
+        return;
+    }
+    sendJson(res, {
+        enabled: logger.isEnabled(),
+    });
+}
+async function handlePutConfig(req, res, runtime) {
+    const logger = await getTrajectoryLogger(runtime);
+    if (!logger) {
+        sendJsonError(res, "Trajectory logger service not available", 503);
+        return;
+    }
+    const body = await parseJsonBody(req, res);
+    if (!body)
+        return;
+    if (typeof body.enabled === "boolean") {
+        logger.setEnabled(body.enabled);
+    }
+    sendJson(res, {
+        enabled: logger.isEnabled(),
+    });
+}
+async function handleExportTrajectories(req, res, runtime) {
+    const logger = await getTrajectoryLogger(runtime);
+    if (!logger) {
+        sendJsonError(res, "Trajectory logger service not available", 503);
+        return;
+    }
+    const body = await parseJsonBody(req, res);
+    if (!body)
+        return;
+    if (body.format === "zip") {
+        if (typeof logger.exportTrajectoriesZip !== "function") {
+            sendJsonError(res, "Trajectory ZIP export is unavailable in the active logger", 503);
+            return;
+        }
+        const zipOptions = {
+            includePrompts: body.includePrompts,
+            trajectoryIds: body.trajectoryIds,
+            startDate: body.startDate,
+            endDate: body.endDate,
+            scenarioId: body.scenarioId,
+            batchId: body.batchId,
+        };
+        const zipResult = await logger.exportTrajectoriesZip(zipOptions);
+        const archive = createZipArchive(zipResult.entries);
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/zip");
+        res.setHeader("Content-Disposition", `attachment; filename="${zipResult.filename}"`);
+        res.end(archive);
+        return;
+    }
+    if (body.format !== "json" &&
+        body.format !== "csv" &&
+        body.format !== "art") {
+        sendJsonError(res, "Format must be 'json', 'csv', 'art', or 'zip'", 400);
+        return;
+    }
+    const result = await logger.exportTrajectories({
+        format: body.format,
+        includePrompts: body.includePrompts,
+        trajectoryIds: body.trajectoryIds,
+        startDate: body.startDate,
+        endDate: body.endDate,
+        scenarioId: body.scenarioId,
+        batchId: body.batchId,
+    });
+    res.statusCode = 200;
+    res.setHeader("Content-Type", result.mimeType);
+    res.setHeader("Content-Disposition", `attachment; filename="${result.filename}"`);
+    res.end(result.data);
+}
+async function handleDeleteTrajectories(req, res, runtime) {
+    const logger = await getTrajectoryLogger(runtime);
+    if (!logger) {
+        sendJsonError(res, "Trajectory logger service not available", 503);
+        return;
+    }
+    const body = await parseJsonBody(req, res);
+    if (!body)
+        return;
+    if (body.all) {
+        const deletedCount = await logger.clearAllTrajectories();
+        sendJson(res, { deleted: deletedCount });
+        return;
+    }
+    if (Array.isArray(body.trajectoryIds) && body.trajectoryIds.length > 0) {
+        const deletedCount = await logger.deleteTrajectories(body.trajectoryIds);
+        sendJson(res, { deleted: deletedCount });
+        return;
+    }
+    sendJson(res, { deleted: 0 });
+}
+// ============================================================================
+// Main Router
+// ============================================================================
+export async function handleTrajectoryRoute(req, res, runtime, pathname, method) {
+    if (!pathname.startsWith("/api/trajectories"))
+        return false;
+    // GET /api/trajectories/config
+    if (pathname === "/api/trajectories/config" && method === "GET") {
+        await handleGetConfig(req, res, runtime);
+        return true;
+    }
+    // PUT /api/trajectories/config
+    if (pathname === "/api/trajectories/config" && method === "PUT") {
+        await handlePutConfig(req, res, runtime);
+        return true;
+    }
+    // POST /api/trajectories/export
+    if (pathname === "/api/trajectories/export" && method === "POST") {
+        await handleExportTrajectories(req, res, runtime);
+        return true;
+    }
+    // DELETE /api/trajectories
+    if (pathname === "/api/trajectories" && method === "DELETE") {
+        await handleDeleteTrajectories(req, res, runtime);
+        return true;
+    }
+    // GET /api/trajectories/stats
+    if (pathname === "/api/trajectories/stats" && method === "GET") {
+        await handleGetStats(req, res, runtime);
+        return true;
+    }
+    // GET /api/trajectories/:id
+    const detailMatch = pathname.match(/^\/api\/trajectories\/([^/]+)$/);
+    if (detailMatch && method === "GET") {
+        await handleGetTrajectoryDetail(req, res, runtime, detailMatch[1]);
+        return true;
+    }
+    // GET /api/trajectories
+    if (pathname === "/api/trajectories" && method === "GET") {
+        await handleGetTrajectories(req, res, runtime);
+        return true;
+    }
+    return false;
+}