@elizaos/plugin-training 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/routes/training-routes.js

@@ -0,0 +1,1239 @@
+import { parsePositiveInteger } from "@elizaos/shared";
+import { runActionBenchmark } from "../core/action-benchmark-runner.js";
+import {
+  writeBenchmarkMatrixArtifact,
+  writeBenchmarkMatrixArtifactFromArtifacts
+} from "../core/benchmark-matrix-artifact.js";
+import { runBenchmarkVsCerebras } from "../core/benchmark-vs-cerebras-runner.js";
+import { AGENT_CONTEXTS } from "../core/context-types.js";
+import { stageEliza1Bundle } from "../core/eliza1-bundle-stager.js";
+import {
+  runLocalEvalComparison,
+  writeEvalComparisonArtifact
+} from "../core/eval-comparison-artifact.js";
+import { runFeedGeneration } from "../core/feed-generation-runner.js";
+import { ingestHuggingFaceDataset } from "../core/huggingface-dataset-ingest.js";
+import { createHashAnonymizer } from "../core/privacy-filter.js";
+import { runScenarios } from "../core/scenario-runner.js";
+import { buildTrainingAnalysisIndex } from "../core/training-analysis-index.js";
+import {
+  buildTrainingCollectionPreflightWithProbes,
+  listTrainingCollections,
+  runTrainingCollection
+} from "../core/training-collection-runner.js";
+import {
+  ALL_TRAINING_BACKENDS,
+  ALL_TRAINING_TASKS,
+  loadTrainingConfig,
+  normalizeTrainingConfig,
+  saveTrainingConfig
+} from "../core/training-config.js";
+import {
+  listRuns,
+  loadRun,
+  triggerTraining
+} from "../core/training-orchestrator.js";
+import { writeTrainingReadinessReport } from "../core/training-readiness-report.js";
+import { resolveHfUploadConfig } from "../core/trajectory-hf-upload.js";
+import {
+  buildTaskRecord
+} from "../core/trajectory-task-datasets.js";
+import { detectAvailableBackends } from "../services/training-backend-check.js";
+import { isNotImplementedError } from "../services/training-service.js";
+import {
+  TRAINING_TRIGGER_SERVICE
+} from "../services/training-trigger.js";
+function resolveStringSetting(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function resolveBooleanSetting(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function sendServiceError(error, res, err, status = 400) {
+  if (isNotImplementedError(err)) {
+    error(res, err.message, 501);
+    return;
+  }
+  error(res, String(err), status);
+}
+function emptyTaskCounters() {
+  return buildTaskRecord(() => 0);
+}
+function getTriggerEntry(runtime) {
+  if (!runtime) return null;
+  const services = runtime.services;
+  if (!services) return null;
+  const entries = services.get(TRAINING_TRIGGER_SERVICE);
+  if (!Array.isArray(entries) || entries.length === 0) return null;
+  const candidate = entries[0];
+  if (candidate && typeof candidate === "object" && typeof candidate.notifyTrajectoryCompleted === "function") {
+    return candidate;
+  }
+  return null;
+}
+const AGENT_DECISIONS = ["RESPOND", "IGNORE", "STOP"];
+function narrowAgentContexts(input) {
+  if (!Array.isArray(input)) return void 0;
+  const out = [];
+  for (const entry of input) {
+    if (typeof entry === "string" && AGENT_CONTEXTS.includes(entry)) {
+      out.push(entry);
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function narrowAgentDecisions(input) {
+  if (!Array.isArray(input)) return void 0;
+  const out = [];
+  for (const entry of input) {
+    if (typeof entry === "string" && AGENT_DECISIONS.includes(entry)) {
+      out.push(entry);
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function narrowTrainingTasks(input) {
+  if (!Array.isArray(input)) return void 0;
+  const out = [];
+  for (const entry of input) {
+    if (typeof entry === "string" && ALL_TRAINING_TASKS.includes(entry)) {
+      out.push(entry);
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function normalizeRunId(input) {
+  return typeof input === "string" && input.trim().length > 0 ? input.trim() : void 0;
+}
+function trajectoryHasRunId(trajectory, runId) {
+  const record = trajectory;
+  if (normalizeRunId(record.runId) === runId) return true;
+  if (normalizeRunId(record.metadata?.runId) === runId) return true;
+  if (normalizeRunId(record.metadata?.appRunId) === runId) return true;
+  for (const step of trajectory.steps ?? []) {
+    for (const call of step.llmCalls ?? []) {
+      if (normalizeRunId(call.runId) === runId) return true;
+    }
+    for (const access of step.providerAccesses ?? []) {
+      if (normalizeRunId(access.runId) === runId) return true;
+    }
+  }
+  return false;
+}
+function parseTaskOrNull(input) {
+  if (input === void 0 || input === null || input === "") return {};
+  if (typeof input !== "string") {
+    return { error: "task must be a string" };
+  }
+  if (!ALL_TRAINING_TASKS.includes(input)) {
+    return {
+      error: `task must be one of: ${ALL_TRAINING_TASKS.join(", ")}`
+    };
+  }
+  return { value: input };
+}
+function parseBackendOrNull(input) {
+  if (input === void 0 || input === null || input === "") return {};
+  if (typeof input !== "string") {
+    return { error: "backend must be a string" };
+  }
+  if (!ALL_TRAINING_BACKENDS.includes(input)) {
+    return {
+      error: `backend must be one of: ${ALL_TRAINING_BACKENDS.join(", ")}`
+    };
+  }
+  return { value: input };
+}
+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;
+}
+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();
+    const trigger = getTriggerEntry(runtime);
+    const triggerStatus = trigger?.getStatus() ?? null;
+    json(res, {
+      ...status,
+      runtimeAvailable: runtime !== null,
+      autoTrain: triggerStatus
+    });
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/training/auto/status") {
+    const trigger = getTriggerEntry(runtime);
+    if (!trigger) {
+      const config = loadTrainingConfig();
+      json(res, {
+        autoTrainEnabled: config.autoTrain,
+        triggerThreshold: config.triggerThreshold,
+        cooldownHours: config.triggerCooldownHours,
+        counters: emptyTaskCounters(),
+        lastTrain: {},
+        perTaskThresholds: emptyTaskCounters(),
+        perTaskCooldownMs: emptyTaskCounters(),
+        serviceRegistered: false
+      });
+      return true;
+    }
+    const snapshot = trigger.getStatus();
+    json(res, { ...snapshot, serviceRegistered: true });
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/auto/trigger") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const taskRejection = parseTaskOrNull(body.task);
+    if (taskRejection.error) {
+      error(res, taskRejection.error, 400);
+      return true;
+    }
+    const backendRejection = parseBackendOrNull(body.backend);
+    if (backendRejection.error) {
+      error(res, backendRejection.error, 400);
+      return true;
+    }
+    if (!runtime) {
+      error(res, "Runtime is required to trigger training", 503);
+      return true;
+    }
+    const trigger = getTriggerEntry(runtime);
+    const record = trigger ? await trigger.runManually({
+      task: taskRejection.value,
+      backend: backendRejection.value,
+      dryRun: body.dryRun === true
+    }) : await triggerTraining(runtime, {
+      task: taskRejection.value,
+      backend: backendRejection.value,
+      source: "manual",
+      dryRun: body.dryRun === true
+    });
+    json(res, { runId: record.runId, status: record.status, run: record }, 201);
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/training/auto/runs") {
+    const url = new URL(
+      req.url ?? "/",
+      `http://${req.headers.host ?? "localhost"}`
+    );
+    const limit = parsePositiveInteger(url.searchParams.get("limit"), 20);
+    const runs = await listRuns(limit);
+    json(res, { runs });
+    return true;
+  }
+  const runMatch = /^\/api\/training\/auto\/runs\/([^/]+)$/.exec(pathname);
+  if (method === "GET" && runMatch) {
+    const runId = decodeURIComponent(runMatch[1]);
+    const run = await loadRun(runId);
+    if (!run) {
+      error(res, "Run not found", 404);
+      return true;
+    }
+    json(res, { run });
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/training/auto/config") {
+    json(res, { config: loadTrainingConfig() });
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/auto/config") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const merged = normalizeTrainingConfig({
+      ...loadTrainingConfig(),
+      ...body
+    });
+    saveTrainingConfig(merged);
+    json(res, { config: merged });
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/analysis/index") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const roots = Array.isArray(body.roots) ? body.roots.filter(
+      (root) => typeof root === "string" && root.trim().length > 0
+    ) : void 0;
+    const outputDir = typeof body.outputDir === "string" && body.outputDir.trim().length > 0 ? body.outputDir.trim() : void 0;
+    const maxDepth = typeof body.maxDepth === "number" && Number.isFinite(body.maxDepth) ? Math.max(0, Math.floor(body.maxDepth)) : void 0;
+    try {
+      const index = await buildTrainingAnalysisIndex({
+        roots,
+        outputDir,
+        maxDepth
+      });
+      json(
+        res,
+        {
+          outputDir: index.outputDir,
+          indexHtmlPath: index.indexHtmlPath,
+          manifestPath: index.manifestPath,
+          manifest: index.manifest
+        },
+        201
+      );
+    } catch (err) {
+      error(res, `Training analysis index failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/analysis/readiness") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const roots = Array.isArray(body.roots) ? body.roots.filter(
+      (entry) => typeof entry === "string" && entry.trim().length > 0
+    ) : void 0;
+    try {
+      const index = await buildTrainingAnalysisIndex({
+        roots,
+        outputDir: resolveStringSetting(body.outputDir),
+        maxDepth: typeof body.maxDepth === "number" && Number.isFinite(body.maxDepth) ? Math.max(1, Math.floor(body.maxDepth)) : void 0
+      });
+      const result = await writeTrainingReadinessReport(index, {
+        outputDir: resolveStringSetting(body.reportOutputDir),
+        reportPath: resolveStringSetting(body.reportPath)
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Training readiness report failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/datasets/ingest-hf") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    try {
+      const result = await ingestHuggingFaceDataset({
+        repoId: resolveStringSetting(body.repoId),
+        revision: resolveStringSetting(body.revision),
+        files: Array.isArray(body.files) ? body.files.filter(
+          (file) => typeof file === "string" && file.trim().length > 0
+        ) : void 0,
+        outputDir: resolveStringSetting(body.outputDir),
+        token: resolveStringSetting(body.token),
+        dryRun: body.dryRun === true
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Hugging Face dataset ingest failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/feed/generate") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    try {
+      const result = await runFeedGeneration({
+        workspaceRoot: resolveStringSetting(body.workspaceRoot),
+        bun: resolveStringSetting(body.bun),
+        archetypes: resolveStringSetting(body.archetypes),
+        numAgents: typeof body.numAgents === "number" && Number.isFinite(body.numAgents) ? Math.max(1, Math.floor(body.numAgents)) : void 0,
+        ticks: typeof body.ticks === "number" && Number.isFinite(body.ticks) ? Math.max(1, Math.floor(body.ticks)) : void 0,
+        parallel: typeof body.parallel === "number" && Number.isFinite(body.parallel) ? Math.max(1, Math.floor(body.parallel)) : void 0,
+        managerId: resolveStringSetting(body.managerId),
+        cleanup: body.cleanup === true,
+        dryRun: body.dryRun === true,
+        outputDir: resolveStringSetting(body.outputDir)
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Feed generation failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/scenarios/run") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    try {
+      const result = await runScenarios({
+        workspaceRoot: resolveStringSetting(body.workspaceRoot),
+        bun: resolveStringSetting(body.bun),
+        scenarioDir: resolveStringSetting(body.scenarioDir),
+        outputDir: resolveStringSetting(body.outputDir),
+        runId: resolveStringSetting(body.runId),
+        scenario: resolveStringSetting(body.scenario),
+        fileGlobs: Array.isArray(body.fileGlobs) ? body.fileGlobs.filter(
+          (glob) => typeof glob === "string"
+        ) : void 0,
+        exportNative: typeof body.exportNative === "boolean" ? body.exportNative : void 0,
+        useDeterministicProxy: typeof body.useDeterministicProxy === "boolean" ? body.useDeterministicProxy : void 0,
+        dryRun: body.dryRun === true
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Scenario run failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/training/collections") {
+    const url = new URL(
+      req.url ?? "/",
+      `http://${req.headers.host ?? "localhost"}`
+    );
+    const limit = parsePositiveInteger(url.searchParams.get("limit"), 20);
+    const root = resolveStringSetting(url.searchParams.get("root"));
+    try {
+      const result = await listTrainingCollections({ root, limit });
+      json(res, result);
+    } catch (err) {
+      error(res, `Training collection listing failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/collect") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const objectSetting = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+    const objectArraySetting = (value) => Array.isArray(value) ? value.filter(
+      (item) => item !== null && typeof item === "object" && !Array.isArray(item)
+    ) : void 0;
+    const actionBenchmarkPairsSetting = (value) => typeof value === "string" ? value : objectArraySetting(value);
+    const naturalTrajectoryOptions = objectSetting(body.naturalTrajectories);
+    const naturalTrajectoryIds = Array.isArray(
+      naturalTrajectoryOptions?.trajectoryIds
+    ) ? naturalTrajectoryOptions.trajectoryIds.filter(
+      (id) => typeof id === "string" && id.trim().length > 0
+    ) : [];
+    const naturalRunId = resolveStringSetting(naturalTrajectoryOptions?.runId);
+    const naturalLimit = typeof naturalTrajectoryOptions?.limit === "number" && Number.isFinite(naturalTrajectoryOptions.limit) ? Math.max(1, Math.floor(naturalTrajectoryOptions.limit)) : 100;
+    try {
+      let naturalTrajectories = naturalTrajectoryOptions;
+      if (body.includeNaturalTrajectories === true && body.preflightOnly !== true && !naturalTrajectoryOptions?.sanitizedJsonlPath && !naturalTrajectoryOptions?.rawJsonlPath) {
+        const listedTrajectories = naturalTrajectoryIds.length > 0 ? null : await trainingService.listTrajectories({
+          limit: naturalLimit,
+          offset: 0,
+          runId: naturalRunId
+        });
+        const ids = naturalTrajectoryIds.length > 0 ? naturalTrajectoryIds : (listedTrajectories?.trajectories ?? []).map((item) => item.id).filter((id) => id.length > 0);
+        const details = (await Promise.all(
+          ids.map(
+            (trajectoryId) => trainingService.getTrajectoryById(trajectoryId)
+          )
+        )).filter((trajectory) => trajectory !== null);
+        naturalTrajectories = {
+          ...naturalTrajectoryOptions ?? {},
+          trajectories: naturalRunId ? details.filter(
+            (trajectory) => trajectoryHasRunId(trajectory, naturalRunId)
+          ) : details,
+          source: {
+            kind: "training_collection_natural_trajectories",
+            ...objectSetting(naturalTrajectoryOptions?.source),
+            runId: naturalRunId,
+            metadata: {
+              ...objectSetting(
+                objectSetting(naturalTrajectoryOptions?.source)?.metadata
+              ),
+              requestedLimit: naturalLimit,
+              requestedRunId: naturalRunId ?? null,
+              explicitTrajectoryIds: naturalTrajectoryIds.length,
+              selectedTrajectoryIds: ids.length,
+              loadedTrajectories: details.length
+            }
+          }
+        };
+      }
+      const collectionOptions = {
+        preflightOnly: body.preflightOnly === true,
+        preflightProbe: body.preflightProbe === true,
+        outputDir: resolveStringSetting(body.outputDir),
+        workspaceRoot: resolveStringSetting(body.workspaceRoot),
+        includeHuggingFace: typeof body.includeHuggingFace === "boolean" ? body.includeHuggingFace : void 0,
+        includeFeed: typeof body.includeFeed === "boolean" ? body.includeFeed : void 0,
+        includeNaturalTrajectories: typeof body.includeNaturalTrajectories === "boolean" ? body.includeNaturalTrajectories : void 0,
+        includeTestTrajectories: typeof body.includeTestTrajectories === "boolean" ? body.includeTestTrajectories : void 0,
+        includeScenarios: typeof body.includeScenarios === "boolean" ? body.includeScenarios : void 0,
+        includeEvalComparison: typeof body.includeEvalComparison === "boolean" ? body.includeEvalComparison : void 0,
+        includeActionBenchmark: typeof body.includeActionBenchmark === "boolean" ? body.includeActionBenchmark : void 0,
+        includeBenchmarkVsCerebras: typeof body.includeBenchmarkVsCerebras === "boolean" ? body.includeBenchmarkVsCerebras : void 0,
+        includeEliza1ModelRegistry: typeof body.includeEliza1ModelRegistry === "boolean" ? body.includeEliza1ModelRegistry : void 0,
+        includeEliza1BundleStage: typeof body.includeEliza1BundleStage === "boolean" ? body.includeEliza1BundleStage : void 0,
+        includeBenchmarkMatrix: typeof body.includeBenchmarkMatrix === "boolean" ? body.includeBenchmarkMatrix : void 0,
+        huggingFace: objectSetting(body.huggingFace),
+        feed: objectSetting(body.feed),
+        naturalTrajectories,
+        testTrajectories: objectSetting(body.testTrajectories),
+        scenarios: objectSetting(body.scenarios),
+        evalComparison: objectSetting(body.evalComparison),
+        actionBenchmark: objectSetting(body.actionBenchmark),
+        actionBenchmarkPair: objectSetting(body.actionBenchmarkPair),
+        actionBenchmarkPairs: actionBenchmarkPairsSetting(
+          body.actionBenchmarkPairs
+        ),
+        benchmarkVsCerebras: objectSetting(body.benchmarkVsCerebras),
+        eliza1BundleStage: objectSetting(body.eliza1BundleStage),
+        benchmarkMatrix: objectSetting(body.benchmarkMatrix),
+        analysis: objectSetting(body.analysis)
+      };
+      if (body.preflightOnly === true) {
+        json(
+          res,
+          {
+            preflight: await buildTrainingCollectionPreflightWithProbes({
+              options: collectionOptions,
+              workspaceRoot: collectionOptions.workspaceRoot,
+              trainingRoot: collectionOptions.workspaceRoot ? `${collectionOptions.workspaceRoot}/packages/training` : void 0
+            })
+          },
+          200
+        );
+        return true;
+      }
+      const result = await runTrainingCollection(collectionOptions);
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Training collection failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/benchmarks/action-selection/run") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    try {
+      const result = await runActionBenchmark({
+        workspaceRoot: resolveStringSetting(body.workspaceRoot),
+        bun: resolveStringSetting(body.bun),
+        outputDir: resolveStringSetting(body.outputDir),
+        useMocks: resolveBooleanSetting(body.useMocks),
+        forceTrajectoryCapture: body.forceTrajectoryCapture === false ? false : void 0,
+        filter: resolveStringSetting(body.filter),
+        runsPerCase: typeof body.runsPerCase === "number" && Number.isFinite(body.runsPerCase) ? Math.max(1, Math.floor(body.runsPerCase)) : void 0,
+        provider: resolveStringSetting(body.provider),
+        modelId: resolveStringSetting(body.modelId),
+        runtimeModel: resolveStringSetting(body.runtimeModel),
+        smallModel: resolveStringSetting(body.smallModel),
+        largeModel: resolveStringSetting(body.largeModel),
+        baseUrl: resolveStringSetting(body.baseUrl),
+        variant: body.variant === "reference" || body.variant === "base" || body.variant === "trained" ? body.variant : void 0,
+        tier: resolveStringSetting(body.tier),
+        benchmark: resolveStringSetting(body.benchmark),
+        datasetVersion: resolveStringSetting(body.datasetVersion),
+        codeCommit: resolveStringSetting(body.codeCommit),
+        dryRun: body.dryRun === true
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Action benchmark failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/evals/record-comparison") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    if (!body.report || typeof body.report !== "object" || Array.isArray(body.report)) {
+      error(res, "report must be a JSON object", 400);
+      return true;
+    }
+    try {
+      const result = await writeEvalComparisonArtifact({
+        report: body.report,
+        reportPath: resolveStringSetting(body.reportPath),
+        outputDir: resolveStringSetting(body.outputDir),
+        source: body.source && typeof body.source === "object" && !Array.isArray(body.source) ? body.source : void 0
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Eval comparison artifact failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/evals/run-local-comparison") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const backend = body.backend === "mlx" || body.backend === "cuda" || body.backend === "cpu" ? body.backend : void 0;
+    try {
+      const result = await runLocalEvalComparison({
+        trainingRoot: resolveStringSetting(body.trainingRoot),
+        python: resolveStringSetting(body.python),
+        manifestPath: resolveStringSetting(body.manifestPath),
+        model: resolveStringSetting(body.model),
+        trainedModelPath: resolveStringSetting(body.trainedModelPath),
+        backend,
+        promptFile: resolveStringSetting(body.promptFile),
+        maxTokens: typeof body.maxTokens === "number" && Number.isFinite(body.maxTokens) ? Math.max(1, Math.floor(body.maxTokens)) : void 0,
+        systemPrompt: resolveStringSetting(body.systemPrompt),
+        outputPath: resolveStringSetting(body.outputPath),
+        outputDir: resolveStringSetting(body.outputDir),
+        dryRun: body.dryRun === true
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Local eval comparison failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/benchmarks/matrix") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    if (!Array.isArray(body.rows)) {
+      error(res, "rows must be an array", 400);
+      return true;
+    }
+    const rows = body.rows.filter(
+      (row) => row !== null && typeof row === "object" && !Array.isArray(row) && typeof row.modelId === "string" && typeof row.benchmark === "string" && typeof row.score === "number" && (row.variant === "reference" || row.variant === "base" || row.variant === "trained")
+    );
+    if (rows.length !== body.rows.length) {
+      error(
+        res,
+        "each row must include modelId, benchmark, numeric score, and variant reference|base|trained",
+        400
+      );
+      return true;
+    }
+    try {
+      const result = await writeBenchmarkMatrixArtifact({
+        rows,
+        outputDir: resolveStringSetting(body.outputDir),
+        generatedAt: resolveStringSetting(body.generatedAt),
+        referenceModelId: resolveStringSetting(body.referenceModelId),
+        source: body.source && typeof body.source === "object" && !Array.isArray(body.source) ? body.source : void 0
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Benchmark matrix artifact failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/benchmarks/matrix/from-artifacts") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    if (!Array.isArray(body.artifacts)) {
+      error(res, "artifacts must be an array", 400);
+      return true;
+    }
+    const artifacts = body.artifacts.filter(
+      (artifact) => artifact !== null && typeof artifact === "object" && !Array.isArray(artifact) && typeof artifact.path === "string" && (artifact.variant === void 0 || artifact.variant === "reference" || artifact.variant === "base" || artifact.variant === "trained")
+    );
+    if (artifacts.length !== body.artifacts.length) {
+      error(
+        res,
+        "each artifact must include path and optional variant reference|base|trained",
+        400
+      );
+      return true;
+    }
+    try {
+      const result = await writeBenchmarkMatrixArtifactFromArtifacts({
+        artifacts,
+        outputDir: resolveStringSetting(body.outputDir),
+        generatedAt: resolveStringSetting(body.generatedAt),
+        referenceModelId: resolveStringSetting(body.referenceModelId),
+        source: body.source && typeof body.source === "object" && !Array.isArray(body.source) ? body.source : void 0
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Benchmark matrix from artifacts failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/benchmarks/run-vs-cerebras") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const benchmark = body.benchmark === "clawbench" || body.benchmark === "eliza_harness_action_selection" || body.benchmark === "hermes" || body.benchmark === "all" ? body.benchmark : void 0;
+    const variants = body.variants === "trained" || body.variants === "base" || body.variants === "both" ? body.variants : void 0;
+    try {
+      const result = await runBenchmarkVsCerebras({
+        trainingRoot: resolveStringSetting(body.trainingRoot),
+        python: resolveStringSetting(body.python),
+        tiers: resolveStringSetting(body.tiers),
+        benchmark,
+        variants,
+        cerebrasModel: resolveStringSetting(body.cerebrasModel),
+        maxSamples: typeof body.maxSamples === "number" && Number.isFinite(body.maxSamples) ? Math.max(1, Math.floor(body.maxSamples)) : void 0,
+        outputDir: resolveStringSetting(body.outputDir),
+        checkpointsDir: resolveStringSetting(body.checkpointsDir),
+        trainedModelPath: resolveStringSetting(body.trainedModelPath),
+        dryRun: body.dryRun === true,
+        resultsDb: resolveStringSetting(body.resultsDb),
+        datasetVersion: resolveStringSetting(body.datasetVersion),
+        codeCommit: resolveStringSetting(body.codeCommit),
+        matrixOutputDir: resolveStringSetting(body.matrixOutputDir)
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Benchmark vs Cerebras failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/models/stage-eliza1-bundle") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    try {
+      const result = await stageEliza1Bundle({
+        trainingRoot: resolveStringSetting(body.trainingRoot),
+        python: resolveStringSetting(body.python),
+        repoId: resolveStringSetting(body.repoId),
+        tier: resolveStringSetting(body.tier),
+        localDir: resolveStringSetting(body.localDir),
+        outputDir: resolveStringSetting(body.outputDir),
+        maxBytes: typeof body.maxBytes === "number" && Number.isFinite(body.maxBytes) ? Math.max(1, Math.floor(body.maxBytes)) : void 0,
+        apply: body.apply === true
+      });
+      json(res, result, 201);
+    } catch (err) {
+      error(res, `Eliza-1 bundle staging failed: ${String(err)}`, 500);
+    }
+    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;
+    try {
+      const dataset = await trainingService.buildDataset({
+        limit: body.limit,
+        minLlmCallsPerTrajectory: body.minLlmCallsPerTrajectory
+      });
+      json(res, { dataset }, 201);
+    } catch (err) {
+      sendServiceError(error, res, err, 500);
+    }
+    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) {
+      sendServiceError(error, res, err, 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) {
+      sendServiceError(error, res, err, 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 !== void 0 && 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) {
+      sendServiceError(error, res, err, 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) {
+      sendServiceError(error, res, err, 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) {
+      sendServiceError(error, res, err, 400);
+    }
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/training/blueprints") {
+    const { ALL_BLUEPRINTS, BLUEPRINT_STATS } = await import("../core/scenario-blueprints.js");
+    json(res, {
+      count: ALL_BLUEPRINTS.length,
+      stats: BLUEPRINT_STATS,
+      blueprints: ALL_BLUEPRINTS.map((b) => ({
+        id: b.id,
+        decision: b.decision,
+        primaryContext: b.primaryContext,
+        pattern: b.pattern,
+        description: b.description
+      }))
+    });
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/training/context-catalog") {
+    const { ACTION_CONTEXT_MAP, PROVIDER_CONTEXT_MAP, ALL_CONTEXTS } = await import("../core/context-catalog.js");
+    json(res, {
+      contexts: ALL_CONTEXTS,
+      actions: ACTION_CONTEXT_MAP,
+      providers: PROVIDER_CONTEXT_MAP
+    });
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/training/context-audit") {
+    if (!runtime || !Array.isArray(runtime.plugins)) {
+      error(
+        res,
+        "Runtime with loaded plugins is required for context audit",
+        503
+      );
+      return true;
+    }
+    const { auditRuntimeContextCoverage, hasContextAuditGaps } = await import("../core/context-audit.js");
+    const audit = auditRuntimeContextCoverage(
+      runtime
+    );
+    json(res, {
+      audit,
+      hasGaps: hasContextAuditGaps(audit)
+    });
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/generate-dataset") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const cerebrasKey = process.env.CEREBRAS_API_KEY;
+    const trainProvider = process.env.TRAIN_MODEL_PROVIDER?.trim() ?? process.env.TRAINING_PROVIDER?.trim();
+    const anthropicKey = resolveStringSetting(runtime?.getSetting?.("ANTHROPIC_API_KEY")) ?? process.env.ANTHROPIC_API_KEY;
+    const openaiKey = resolveStringSetting(runtime?.getSetting?.("OPENAI_API_KEY")) ?? process.env.OPENAI_API_KEY;
+    if (!cerebrasKey && !anthropicKey && !openaiKey) {
+      error(
+        res,
+        "No teacher model API key found. Set CEREBRAS_API_KEY (preferred), ANTHROPIC_API_KEY, or OPENAI_API_KEY.",
+        400
+      );
+      return true;
+    }
+    const {
+      generateDataset,
+      exportToElizaNativeJSONL,
+      createAnthropicTeacher,
+      createCerebrasTeacher,
+      createOpenAITeacher
+    } = await import("../core/dataset-generator.js");
+    const { buildRoleplayEpisodes, exportRoleplayEpisodes } = await import("../core/roleplay-trajectories.js");
+    const teacher = trainProvider === "cerebras" && cerebrasKey ? createCerebrasTeacher(runtime ?? void 0) : anthropicKey ? createAnthropicTeacher(anthropicKey, runtime ?? void 0) : createOpenAITeacher(openaiKey, runtime ?? void 0);
+    const outputDir = `.tmp/training-data-${Date.now()}`;
+    try {
+      const samples = await generateDataset({
+        variantsPerBlueprint: body.variantsPerBlueprint ?? 5,
+        teacher,
+        outputDir,
+        concurrency: body.concurrency ?? 5,
+        limitBlueprints: body.limitBlueprints,
+        filterContexts: narrowAgentContexts(body.filterContexts),
+        filterDecisions: narrowAgentDecisions(body.filterDecisions)
+      });
+      const { validateDataset } = await import("../core/replay-validator.js");
+      const report = validateDataset(samples);
+      const paths = await exportToElizaNativeJSONL(samples, outputDir);
+      const roleplayPaths = body.includeRoleplay === false ? void 0 : await exportRoleplayEpisodes(
+        buildRoleplayEpisodes(samples),
+        samples,
+        outputDir
+      );
+      json(
+        res,
+        {
+          samplesGenerated: samples.length,
+          report,
+          paths,
+          roleplayPaths,
+          outputDir
+        },
+        201
+      );
+    } catch (err) {
+      error(res, `Dataset generation failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/generate-roleplay") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    const cerebrasKey = process.env.CEREBRAS_API_KEY;
+    const trainProvider = process.env.TRAIN_MODEL_PROVIDER?.trim() ?? process.env.TRAINING_PROVIDER?.trim();
+    const anthropicKey = resolveStringSetting(runtime?.getSetting?.("ANTHROPIC_API_KEY")) ?? process.env.ANTHROPIC_API_KEY;
+    const openaiKey = resolveStringSetting(runtime?.getSetting?.("OPENAI_API_KEY")) ?? process.env.OPENAI_API_KEY;
+    if (!cerebrasKey && !anthropicKey && !openaiKey) {
+      error(
+        res,
+        "No teacher model API key found. Set CEREBRAS_API_KEY (preferred), ANTHROPIC_API_KEY, or OPENAI_API_KEY.",
+        400
+      );
+      return true;
+    }
+    const {
+      generateDataset,
+      createAnthropicTeacher,
+      createCerebrasTeacher,
+      createOpenAITeacher
+    } = await import("../core/dataset-generator.js");
+    const { buildRoleplayEpisodes, exportRoleplayEpisodes } = await import("../core/roleplay-trajectories.js");
+    const teacher = trainProvider === "cerebras" && cerebrasKey ? createCerebrasTeacher(runtime ?? void 0) : anthropicKey ? createAnthropicTeacher(anthropicKey, runtime ?? void 0) : createOpenAITeacher(openaiKey, runtime ?? void 0);
+    const outputDir = `.tmp/training-roleplay-${Date.now()}`;
+    try {
+      const samples = await generateDataset({
+        variantsPerBlueprint: body.variantsPerBlueprint ?? 3,
+        teacher,
+        outputDir,
+        concurrency: body.concurrency ?? 5,
+        limitBlueprints: body.limitBlueprints,
+        filterContexts: narrowAgentContexts(body.filterContexts),
+        filterDecisions: narrowAgentDecisions(body.filterDecisions)
+      });
+      const episodes = buildRoleplayEpisodes(samples);
+      const paths = await exportRoleplayEpisodes(episodes, samples, outputDir);
+      json(
+        res,
+        {
+          samplesGenerated: samples.length,
+          episodesGenerated: episodes.length,
+          outputDir,
+          paths
+        },
+        201
+      );
+    } catch (err) {
+      error(res, `Roleplay generation failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/roleplay/execute") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    if (!runtime) {
+      error(res, "Runtime is required to execute roleplay episodes", 503);
+      return true;
+    }
+    const inputPath = body.episodesPath ?? body.manifestPath;
+    if (!inputPath) {
+      error(res, "episodesPath or manifestPath is required", 400);
+      return true;
+    }
+    const {
+      buildRoleplayExecutionReport,
+      executeRoleplayEpisodes,
+      exportRoleplayExecutionResults,
+      loadRoleplayEpisodesFromPath
+    } = await import("../core/roleplay-executor.js");
+    try {
+      const episodes = await loadRoleplayEpisodesFromPath(inputPath);
+      const executions = await executeRoleplayEpisodes(episodes, {
+        runtime,
+        timeoutMs: body.timeoutMs,
+        executeAllParticipantTurns: body.executeAllParticipantTurns ?? false
+      });
+      const outputDir = body.outputDir ?? `.tmp/training-roleplay-execution-${Date.now()}`;
+      const paths = await exportRoleplayExecutionResults(executions, outputDir);
+      const report = buildRoleplayExecutionReport(
+        executions,
+        paths.trajectoryDataset?.summary ?? null
+      );
+      json(
+        res,
+        {
+          episodesExecuted: executions.length,
+          report,
+          outputDir,
+          paths
+        },
+        201
+      );
+    } catch (err) {
+      error(res, `Roleplay execution failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/trajectories/export") {
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    if (body.runId !== void 0 && !normalizeRunId(body.runId)) {
+      error(res, "runId must be a non-empty string", 400);
+      return true;
+    }
+    const outputPath = body.outputPath ?? `.tmp/training-trajectory-export-${Date.now()}.jsonl`;
+    try {
+      const explicitIds = Array.isArray(body.trajectoryIds) ? body.trajectoryIds.filter((id) => typeof id === "string" && id.trim()) : [];
+      const listedTrajectories = explicitIds.length > 0 ? null : await trainingService.listTrajectories({
+        limit: body.limit ?? 100,
+        offset: 0,
+        runId: normalizeRunId(body.runId)
+      });
+      const trajectoryIds = explicitIds.length > 0 ? explicitIds : (listedTrajectories?.trajectories ?? []).map((item) => item.id).filter((id) => id.length > 0);
+      const details = (await Promise.all(
+        trajectoryIds.map(
+          (trajectoryId) => trainingService.getTrajectoryById(trajectoryId)
+        )
+      )).filter((t) => t !== null);
+      if (body.bundle || body.exportBundle) {
+        const requestedRunId = normalizeRunId(body.runId);
+        const bundleTrajectories = requestedRunId ? details.filter(
+          (trajectory) => trajectoryHasRunId(trajectory, requestedRunId)
+        ) : details;
+        const { buildTrajectoryExportBundle } = await import("../core/trajectory-export-bundle.js");
+        const bundle = await buildTrajectoryExportBundle({
+          trajectories: bundleTrajectories,
+          outputDir: body.outputDir ?? `.tmp/training-trajectory-bundle-${Date.now()}`,
+          includeRawJsonl: body.includeRawJsonl === true || body.includeRaw === true,
+          tasks: narrowTrainingTasks(body.tasks),
+          source: {
+            kind: "training-trajectories-export-route",
+            runId: requestedRunId,
+            metadata: {
+              requestedLimit: body.limit ?? 100,
+              requestedRunId: requestedRunId ?? null,
+              explicitTrajectoryIds: explicitIds.length,
+              selectedTrajectoryIds: trajectoryIds.length,
+              loadedTrajectories: details.length,
+              bundledTrajectories: bundleTrajectories.length
+            }
+          }
+        });
+        json(
+          res,
+          {
+            trajectoriesConsidered: trajectoryIds.length,
+            trajectoriesBundled: bundleTrajectories.length,
+            outputDir: bundle.outputDir,
+            manifestPath: bundle.manifestPath,
+            bundle: bundle.manifest
+          },
+          201
+        );
+        return true;
+      }
+      let exported = 0;
+      let taskDataset;
+      if (body.splitByTask || body.outputDir || body.tasks?.length) {
+        const { exportTrajectoryTaskDatasets } = await import("../core/trajectory-task-datasets.js");
+        const dataset = await exportTrajectoryTaskDatasets(
+          details,
+          body.outputDir ?? `.tmp/training-trajectory-export-${Date.now()}`,
+          narrowTrainingTasks(body.tasks)
+        );
+        exported = dataset.counts.should_respond + dataset.counts.context_routing + dataset.counts.action_planner + dataset.counts.response + dataset.counts.media_description;
+        taskDataset = {
+          counts: dataset.counts,
+          paths: dataset.paths,
+          summary: dataset.summary
+        };
+      } else {
+        const { exportTrajectoriesAsTraining } = await import("../core/dataset-generator.js");
+        exported = await exportTrajectoriesAsTraining(
+          details,
+          body.agentName ?? runtime?.character?.name ?? "Agent",
+          outputPath
+        );
+      }
+      json(
+        res,
+        {
+          exportedExamples: exported,
+          trajectoriesConsidered: trajectoryIds.length,
+          outputPath,
+          taskDataset
+        },
+        201
+      );
+    } catch (err) {
+      error(res, `Trajectory export failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/training/trajectories/publish") {
+    const hfConfig = resolveHfUploadConfig();
+    if (!hfConfig) {
+      error(
+        res,
+        "HuggingFace publishing is not configured. Set ELIZA_TRAJECTORY_HF_REPO and an HF token (HF_TOKEN, with HUGGINGFACE_HUB_TOKEN / HUGGING_FACE_HUB_TOKEN accepted as fallbacks).",
+        409
+      );
+      return true;
+    }
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    try {
+      const explicitIds = Array.isArray(body.trajectoryIds) ? body.trajectoryIds.filter((id) => typeof id === "string" && id.trim()) : [];
+      const listed = explicitIds.length > 0 ? null : await trainingService.listTrajectories({
+        limit: body.limit ?? 500,
+        offset: 0
+      });
+      const trajectoryIds = explicitIds.length > 0 ? explicitIds : (listed?.trajectories ?? []).map((item) => item.id).filter((id) => id.length > 0);
+      const details = (await Promise.all(
+        trajectoryIds.map(
+          (trajectoryId) => trainingService.getTrajectoryById(trajectoryId)
+        )
+      )).filter((t) => t !== null);
+      const { buildTrajectoryExportBundle } = await import("../core/trajectory-export-bundle.js");
+      const bundle = await buildTrajectoryExportBundle({
+        trajectories: details,
+        outputDir: body.outputDir ?? `.tmp/training-trajectory-publish-${Date.now()}`,
+        tasks: narrowTrainingTasks(body.tasks),
+        // Privacy filter forced on with the default hash anonymizer.
+        privacy: {
+          apply: true,
+          options: { anonymizer: createHashAnonymizer() }
+        },
+        uploadToHuggingFace: hfConfig,
+        source: {
+          kind: "training-trajectories-publish-route",
+          metadata: {
+            requestedLimit: body.limit ?? 500,
+            explicitTrajectoryIds: explicitIds.length,
+            selectedTrajectoryIds: trajectoryIds.length,
+            loadedTrajectories: details.length
+          }
+        }
+      });
+      if (!bundle.manifest.cloudUpload.uploadedToHuggingFace) {
+        error(
+          res,
+          `HuggingFace upload failed: ${bundle.manifest.cloudUpload.huggingFaceError ?? "unknown error"}`,
+          502
+        );
+        return true;
+      }
+      json(
+        res,
+        {
+          trajectoriesConsidered: trajectoryIds.length,
+          trajectoriesPublished: bundle.manifest.counts.sanitizedTrajectoryRows,
+          outputDir: bundle.outputDir,
+          manifestPath: bundle.manifestPath,
+          cloudUpload: bundle.manifest.cloudUpload
+        },
+        201
+      );
+    } catch (err) {
+      error(res, `Trajectory publish failed: ${String(err)}`, 500);
+    }
+    return true;
+  }
+  return false;
+}
+export {
+  handleTrainingRoutes
+};
+//# sourceMappingURL=training-routes.js.map