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

package/dist/services/training-service.js

@@ -0,0 +1,154 @@
+import { createHashAnonymizer } from "../core/privacy-filter.js";
+import { buildTrajectoryExportBundle } from "../core/trajectory-export-bundle.js";
+class NotImplementedError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotImplementedError";
+  }
+}
+function isNotImplementedError(err) {
+  return err instanceof NotImplementedError;
+}
+class TrainingService {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  listeners = /* @__PURE__ */ new Set();
+  async initialize() {
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  trajectoryService() {
+    const runtime = this.options.getRuntime();
+    const service = runtime?.getService("trajectories");
+    if (!service || typeof service.listTrajectories !== "function" || typeof service.getTrajectoryDetail !== "function") {
+      throw new NotImplementedError(
+        "The trajectories service is not available on the current runtime."
+      );
+    }
+    return service;
+  }
+  getStatus() {
+    return {
+      runtimeAvailable: this.options.getRuntime() !== null
+    };
+  }
+  async listTrajectories(options) {
+    return await this.trajectoryService().listTrajectories(options);
+  }
+  async getTrajectoryById(trajectoryId) {
+    return await this.trajectoryService().getTrajectoryDetail(trajectoryId);
+  }
+  /** Datasets are produced as export bundles on disk; there is no persisted list. */
+  listDatasets() {
+    return [];
+  }
+  async buildDataset(options) {
+    const service = this.trajectoryService();
+    const PAGE_SIZE = 500;
+    const items = [];
+    let offset = 0;
+    while (true) {
+      const remaining = options.limit !== void 0 ? options.limit - items.length : PAGE_SIZE;
+      if (options.limit !== void 0 && remaining <= 0) break;
+      const pageLimit = Math.min(PAGE_SIZE, Math.max(1, remaining));
+      const page = await service.listTrajectories({ limit: pageLimit, offset });
+      items.push(...page.trajectories);
+      offset += page.trajectories.length;
+      if (page.trajectories.length < pageLimit || page.trajectories.length === 0)
+        break;
+    }
+    const DETAIL_CHUNK = 100;
+    const hydrated = [];
+    for (let i = 0; i < items.length; i += DETAIL_CHUNK) {
+      const chunk = items.slice(i, i + DETAIL_CHUNK);
+      hydrated.push(
+        ...await Promise.all(
+          chunk.map((item) => service.getTrajectoryDetail(item.id))
+        )
+      );
+    }
+    const trajectories = hydrated.filter((t) => t !== null);
+    const minCalls = options.minLlmCallsPerTrajectory ?? 0;
+    const eligible = minCalls > 0 ? trajectories.filter(
+      (t) => (t.steps ?? []).reduce(
+        (sum, step) => sum + (step.llmCalls?.length ?? 0),
+        0
+      ) >= minCalls
+    ) : trajectories;
+    const bundle = await buildTrajectoryExportBundle({
+      trajectories: eligible,
+      outputDir: `.tmp/training-dataset-${Date.now()}`,
+      privacy: {
+        apply: true,
+        options: { anonymizer: createHashAnonymizer() }
+      },
+      source: {
+        kind: "training-build-dataset",
+        metadata: {
+          // null = no cap (full dataset); a number is the explicit hard cap.
+          requestedLimit: options.limit ?? null,
+          minLlmCallsPerTrajectory: minCalls,
+          consideredTrajectories: trajectories.length,
+          eligibleTrajectories: eligible.length
+        }
+      }
+    });
+    this.emit({ kind: "dataset_built", manifestPath: bundle.manifestPath });
+    return {
+      outputDir: bundle.outputDir,
+      manifestPath: bundle.manifestPath,
+      manifest: bundle.manifest
+    };
+  }
+  /** GPU fine-tune jobs live under `/api/training/vast/jobs`. */
+  listJobs() {
+    return [];
+  }
+  async startTrainingJob() {
+    throw new NotImplementedError(
+      "GPU fine-tune jobs are managed via /api/training/vast/jobs; prompt optimization runs via /api/training/auto/trigger."
+    );
+  }
+  getJob() {
+    return null;
+  }
+  async cancelJob() {
+    throw new NotImplementedError(
+      "GPU fine-tune jobs are managed via /api/training/vast/jobs."
+    );
+  }
+  /** Trained models are tracked by the Vast registry under `/api/training/vast/models`. */
+  listModels() {
+    return [];
+  }
+  async importModelToOllama() {
+    throw new NotImplementedError(
+      "Importing trained checkpoints into Ollama is not wired through this API. Use the GGUF \u2192 catalog flow."
+    );
+  }
+  async activateModel() {
+    throw new NotImplementedError(
+      "Activating a trained model is not wired through this API. Configure the model provider directly."
+    );
+  }
+  async benchmarkModel() {
+    throw new NotImplementedError(
+      "Model benchmarking runs via /api/training/vast/jobs/:id/eval."
+    );
+  }
+}
+export {
+  NotImplementedError,
+  TrainingService,
+  isNotImplementedError
+};
+//# sourceMappingURL=training-service.js.map

package/dist/services/training-service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/training-service.ts"],"sourcesContent":["import type { Trajectory, TrajectoryListResult } from \"@elizaos/agent\";\nimport type { AgentRuntime } from \"@elizaos/core\";\nimport { createHashAnonymizer } from \"../core/privacy-filter.js\";\nimport { buildTrajectoryExportBundle } from \"../core/trajectory-export-bundle.js\";\nimport type { TrainingServiceWithRuntime } from \"./training-service-like.js\";\n\n/**\n * Thrown for endpoints whose real implementation lives on another surface\n * (GPU fine-tunes on `/api/training/vast/jobs`, prompt optimization on\n * `/api/training/auto/trigger`). The route layer maps this to a 501 with the\n * message verbatim — we do not fabricate success responses for unwired flows.\n */\nexport class NotImplementedError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"NotImplementedError\";\n  }\n}\n\nexport function isNotImplementedError(\n  err: unknown,\n): err is NotImplementedError {\n  return err instanceof NotImplementedError;\n}\n\ninterface TrainingServiceOptions {\n  getRuntime: () => AgentRuntime | null;\n  getConfig: () => unknown;\n  setConfig: (nextConfig: unknown) => void;\n}\n\ninterface TrajectoryServiceLike {\n  listTrajectories: (options: {\n    limit?: number;\n    offset?: number;\n    runId?: string;\n  }) => Promise<TrajectoryListResult>;\n  getTrajectoryDetail: (id: string) => Promise<Trajectory | null>;\n}\n\n/**\n * Public training API service. Reads trajectories from the runtime\n * `trajectories` DB service and builds privacy-filtered export bundles via\n * `buildTrajectoryExportBundle`. GPU fine-tunes, Ollama import, model\n * activation, and benchmarking are handled by other surfaces — this service\n * does not emulate them.\n */\nexport class TrainingService implements TrainingServiceWithRuntime {\n  private readonly listeners = new Set<(event: unknown) => void>();\n\n  constructor(private readonly options: TrainingServiceOptions) {}\n\n  async initialize(): Promise<void> {}\n\n  subscribe(listener: (event: unknown) => void): () => void {\n    this.listeners.add(listener);\n    return () => this.listeners.delete(listener);\n  }\n\n  private emit(event: unknown): void {\n    for (const listener of this.listeners) {\n      listener(event);\n    }\n  }\n\n  private trajectoryService(): TrajectoryServiceLike {\n    const runtime = this.options.getRuntime();\n    const service = runtime?.getService(\"trajectories\") as unknown as\n      | TrajectoryServiceLike\n      | null\n      | undefined;\n    if (\n      !service ||\n      typeof service.listTrajectories !== \"function\" ||\n      typeof service.getTrajectoryDetail !== \"function\"\n    ) {\n      throw new NotImplementedError(\n        \"The trajectories service is not available on the current runtime.\",\n      );\n    }\n    return service;\n  }\n\n  getStatus(): Record<string, unknown> {\n    return {\n      runtimeAvailable: this.options.getRuntime() !== null,\n    };\n  }\n\n  async listTrajectories(options: {\n    limit?: number;\n    offset?: number;\n    runId?: string;\n  }): Promise<TrajectoryListResult> {\n    return await this.trajectoryService().listTrajectories(options);\n  }\n\n  async getTrajectoryById(trajectoryId: string): Promise<Trajectory | null> {\n    return await this.trajectoryService().getTrajectoryDetail(trajectoryId);\n  }\n\n  /** Datasets are produced as export bundles on disk; there is no persisted list. */\n  listDatasets(): Record<string, unknown>[] {\n    return [];\n  }\n\n  async buildDataset(options: {\n    limit?: number;\n    minLlmCallsPerTrajectory?: number;\n  }): Promise<Record<string, unknown>> {\n    const service = this.trajectoryService();\n\n    // When no explicit limit is given, the dataset covers the FULL set: the\n    // reader caps each page at 500, so a single call silently dropped every\n    // trajectory beyond the most-recent 500. Page through with an offset loop\n    // until the set is drained. An explicit `options.limit` is honored as a\n    // hard cap (the prior behavior).\n    const PAGE_SIZE = 500;\n    const items: TrajectoryListResult[\"trajectories\"] = [];\n    let offset = 0;\n    while (true) {\n      const remaining =\n        options.limit !== undefined ? options.limit - items.length : PAGE_SIZE;\n      if (options.limit !== undefined && remaining <= 0) break;\n      const pageLimit = Math.min(PAGE_SIZE, Math.max(1, remaining));\n      const page = await service.listTrajectories({ limit: pageLimit, offset });\n      items.push(...page.trajectories);\n      offset += page.trajectories.length;\n      if (\n        page.trajectories.length < pageLimit ||\n        page.trajectories.length === 0\n      )\n        break;\n    }\n\n    // Bound the detail fan-out: hydrate in chunks instead of one unbounded\n    // Promise.all over a potentially very large set.\n    const DETAIL_CHUNK = 100;\n    const hydrated: (Trajectory | null)[] = [];\n    for (let i = 0; i < items.length; i += DETAIL_CHUNK) {\n      const chunk = items.slice(i, i + DETAIL_CHUNK);\n      hydrated.push(\n        ...(await Promise.all(\n          chunk.map((item) => service.getTrajectoryDetail(item.id)),\n        )),\n      );\n    }\n    const trajectories = hydrated.filter((t): t is Trajectory => t !== null);\n    const minCalls = options.minLlmCallsPerTrajectory ?? 0;\n    const eligible =\n      minCalls > 0\n        ? trajectories.filter(\n            (t) =>\n              (t.steps ?? []).reduce(\n                (sum, step) => sum + (step.llmCalls?.length ?? 0),\n                0,\n              ) >= minCalls,\n          )\n        : trajectories;\n    const bundle = await buildTrajectoryExportBundle({\n      trajectories: eligible,\n      outputDir: `.tmp/training-dataset-${Date.now()}`,\n      privacy: {\n        apply: true,\n        options: { anonymizer: createHashAnonymizer() },\n      },\n      source: {\n        kind: \"training-build-dataset\",\n        metadata: {\n          // null = no cap (full dataset); a number is the explicit hard cap.\n          requestedLimit: options.limit ?? null,\n          minLlmCallsPerTrajectory: minCalls,\n          consideredTrajectories: trajectories.length,\n          eligibleTrajectories: eligible.length,\n        },\n      },\n    });\n    this.emit({ kind: \"dataset_built\", manifestPath: bundle.manifestPath });\n    return {\n      outputDir: bundle.outputDir,\n      manifestPath: bundle.manifestPath,\n      manifest: bundle.manifest,\n    };\n  }\n\n  /** GPU fine-tune jobs live under `/api/training/vast/jobs`. */\n  listJobs(): Record<string, unknown>[] {\n    return [];\n  }\n\n  async startTrainingJob(): Promise<Record<string, unknown>> {\n    throw new NotImplementedError(\n      \"GPU fine-tune jobs are managed via /api/training/vast/jobs; prompt optimization runs via /api/training/auto/trigger.\",\n    );\n  }\n\n  getJob(): Record<string, unknown> | null {\n    return null;\n  }\n\n  async cancelJob(): Promise<Record<string, unknown>> {\n    throw new NotImplementedError(\n      \"GPU fine-tune jobs are managed via /api/training/vast/jobs.\",\n    );\n  }\n\n  /** Trained models are tracked by the Vast registry under `/api/training/vast/models`. */\n  listModels(): Record<string, unknown>[] {\n    return [];\n  }\n\n  async importModelToOllama(): Promise<Record<string, unknown>> {\n    throw new NotImplementedError(\n      \"Importing trained checkpoints into Ollama is not wired through this API. Use the GGUF → catalog flow.\",\n    );\n  }\n\n  async activateModel(): Promise<Record<string, unknown>> {\n    throw new NotImplementedError(\n      \"Activating a trained model is not wired through this API. Configure the model provider directly.\",\n    );\n  }\n\n  async benchmarkModel(): Promise<Record<string, unknown>> {\n    throw new NotImplementedError(\n      \"Model benchmarking runs via /api/training/vast/jobs/:id/eval.\",\n    );\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/services/training-trigger.d.ts

@@ -0,0 +1,177 @@
+/**
+ * TrainingTriggerService — counts completed trajectories per task and fires
+ * `triggerTraining` when the configured threshold is reached for a task whose
+ * cooldown has elapsed.
+ *
+ * State is held in-memory and mirrored to disk at
+ * `<state>/training/trigger-state.json` so a process restart does not lose
+ * progress mid-bucket. The persisted shape is intentionally tiny and
+ * forward-compatible: extra keys are ignored on read.
+ *
+ * Service identifier: `TRAINING_TRIGGER_SERVICE`.
+ *
+ * Trajectory storage calls `notifyTrajectoryCompleted(trajectoryId)` from
+ * `eliza/packages/agent/src/runtime/trajectory-storage.ts` whenever a
+ * trajectory transitions to `completed`. The service looks up the trajectory
+ * detail, infers the tasks it touches, and increments those counters.
+ */
+import { type IAgentRuntime, Service, type ServiceTypeName } from "@elizaos/core";
+import type { AnonymizerLookup } from "../core/privacy-filter.js";
+import { type TrainingBackend, type TrainingConfig } from "../core/training-config.js";
+import { type TrainingRunRecord, triggerTraining } from "../core/training-orchestrator.js";
+import { type TrajectoryTrainingTask } from "../core/trajectory-task-datasets.js";
+declare module "@elizaos/core" {
+    interface ServiceTypeRegistry {
+        TRAINING_TRIGGER_SERVICE: "training_trigger_service";
+    }
+}
+export declare const TRAINING_TRIGGER_SERVICE: ServiceTypeName;
+interface MinimalLogger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+/**
+ * Minimal runtime shape the trigger service + bootstrap helpers depend on.
+ * Structurally a subset of `IAgentRuntime`, so full runtimes satisfy it
+ * without casts. Tests pass a small shim that matches this shape.
+ */
+interface RuntimeLike {
+    getService: (name: string) => unknown;
+    logger?: MinimalLogger;
+}
+export interface TriggerStatusSnapshot {
+    autoTrainEnabled: boolean;
+    triggerThreshold: number;
+    cooldownHours: number;
+    counters: Record<TrajectoryTrainingTask, number>;
+    lastTrain: Partial<Record<TrajectoryTrainingTask, {
+        runId: string;
+        source: string;
+        finishedAt: string;
+        status: string;
+    }>>;
+    perTaskThresholds: Record<TrajectoryTrainingTask, number>;
+    perTaskCooldownMs: Record<TrajectoryTrainingTask, number>;
+}
+export interface TrainingTriggerServiceOptions {
+    /** Defaults to <state>/training/trigger-state.json. */
+    statePath?: string;
+    /** Override config loader (tests). */
+    configLoader?: () => TrainingConfig;
+    /** Forward to the orchestrator (tests). */
+    triggerImpl?: typeof triggerTraining;
+    /** Anonymizer forwarded to the orchestrator. */
+    anonymizer?: AnonymizerLookup;
+    /** Clock injection (tests). */
+    now?: () => number;
+}
+/**
+ * Lightweight service registered directly into the runtime service map. It has
+ * no `start()` lifecycle, but extends the core base class so the registration
+ * stays assignable to the runtime's `Service[]` registry.
+ */
+export declare class TrainingTriggerService extends Service {
+    readonly capabilityDescription = "Tracks completed trajectories and fires training runs when per-task counters hit the configured threshold.";
+    readonly instance: this;
+    private readonly runtimeRef;
+    private readonly statePath;
+    private readonly configLoader;
+    private readonly triggerImpl;
+    private readonly anonymizer?;
+    private readonly now;
+    private readonly inflight;
+    private state;
+    constructor(runtime: RuntimeLike, options?: TrainingTriggerServiceOptions);
+    /** Idempotent stop hook for the service lifecycle. */
+    stop(): Promise<void>;
+    getStatus(): TriggerStatusSnapshot;
+    /**
+     * Called by trajectory storage when a trajectory transitions to
+     * `completed`. Looks up the detail, increments the relevant counters, and
+     * checks each touched task's threshold + cooldown.
+     *
+     * Errors propagate by design — the caller uses optional chaining so a missing
+     * service skips training triggers, while a misconfigured service that throws
+     * during increment is still surfaced.
+     */
+    notifyTrajectoryCompleted(trajectoryId: string): Promise<void>;
+    /** Manual fire — bypasses the autoTrain toggle (operator action). */
+    runManually(input: {
+        task?: TrajectoryTrainingTask;
+        backend?: TrainingBackend;
+        dryRun?: boolean;
+    }): Promise<TrainingRunRecord>;
+    /**
+     * Reset counters — primarily for tests and operator recovery. The persisted
+     * `lastTrainAt`/`lastTrainRecord` map is preserved so cooldowns still
+     * apply after a reset.
+     */
+    resetCounters(task?: TrajectoryTrainingTask): void;
+    private maybeFire;
+    private recordCompletion;
+}
+/**
+ * Registered entry shape — kept as a standalone interface so callers that
+ * `getService(TRAINING_TRIGGER_SERVICE)` can type the result without
+ * importing the concrete class.
+ */
+export interface RegisteredTrainingTriggerEntry extends Service {
+    notifyTrajectoryCompleted: (trajectoryId: string) => Promise<void>;
+    getStatus: () => TriggerStatusSnapshot;
+    runManually: (input: {
+        task?: TrajectoryTrainingTask;
+        backend?: TrainingBackend;
+        dryRun?: boolean;
+    }) => Promise<TrainingRunRecord>;
+    resetCounters: (task?: TrajectoryTrainingTask) => void;
+    stop: () => Promise<void>;
+    capabilityDescription: string;
+    instance: TrainingTriggerService;
+}
+/**
+ * Register the service against a runtime's services map. Mirrors the
+ * workflow-dispatch pattern in `packages/app-core/src/runtime/eliza.ts`: we
+ * insert a function-shaped service entry directly rather than going through
+ * the `Service.start()` lifecycle, which expects a class.
+ *
+ * Safe to call multiple times — subsequent calls replace the entry.
+ */
+export declare function registerTrainingTriggerService(runtime: IAgentRuntime, options?: TrainingTriggerServiceOptions): TrainingTriggerService;
+interface UserNotifier {
+    notify: (message: string) => void;
+}
+export interface BootstrapOptimizationOptions {
+    configLoader?: () => TrainingConfig;
+    notifier?: UserNotifier;
+    /**
+     * Override the service used to trigger the run. Tests pass a controlled
+     * trigger; production looks up the registered TrainingTriggerService from
+     * runtime.services.
+     */
+    triggerOverride?: (input: {
+        task: TrajectoryTrainingTask;
+        backend: TrainingBackend;
+    }) => Promise<TrainingRunRecord>;
+}
+/**
+ * One-shot bootstrap pass for default-on Hermes parity.
+ *
+ * Called immediately after `registerTrainingTriggerService` during runtime
+ * boot. For each high-leverage task (should_respond + action_planner):
+ *   - If `ELIZA_DISABLE_AUTO_BOOTSTRAP=1`, do nothing.
+ *   - If the OptimizedPromptService already has an artifact for the task,
+ *     do nothing (the operator's previous run wins).
+ *   - If the per-task trajectory counter is below the threshold, do nothing
+ *     (we don't want to optimize against a thin dataset).
+ *   - Otherwise, fire `triggerTraining({ source: 'bootstrap', backend: 'native' })`
+ *     and notify the user that progress can be tracked in
+ *     Settings → Auto-Training.
+ *
+ * This is fire-and-forget on purpose: the runtime boot must not block on
+ * an LLM-driven optimization round. Errors propagate so the boot logger
+ * surfaces them rather than swallowing them silently.
+ */
+export declare function bootstrapOptimizationFromAccumulatedTrajectories(runtime: IAgentRuntime, service: TrainingTriggerService, options?: BootstrapOptimizationOptions): Promise<TrajectoryTrainingTask[]>;
+export {};
+//# sourceMappingURL=training-trigger.d.ts.map

package/dist/services/training-trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"training-trigger.d.ts","sourceRoot":"","sources":["../../src/services/training-trigger.ts"],"names":[],"mappings":"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"}

package/dist/services/training-trigger.js

@@ -0,0 +1,300 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import {
+  Service
+} from "@elizaos/core";
+import {
+  ALL_TRAINING_TASKS,
+  loadTrainingConfig,
+  resolveTaskPolicy,
+  trainingStateRoot
+} from "../core/training-config.js";
+import {
+  triggerTraining
+} from "../core/training-orchestrator.js";
+import {
+  buildTaskRecord
+} from "../core/trajectory-task-datasets.js";
+const TRAINING_TRIGGER_SERVICE = "training_trigger_service";
+function emptyCounters() {
+  return buildTaskRecord(() => 0);
+}
+function isStringRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function readPersisted(path) {
+  if (!existsSync(path)) {
+    return {
+      counters: emptyCounters(),
+      lastTrainAt: {},
+      lastTrainRecord: {}
+    };
+  }
+  const raw = readFileSync(path, "utf-8");
+  const parsed = JSON.parse(raw);
+  const counters = emptyCounters();
+  if (isStringRecord(parsed) && isStringRecord(parsed.counters)) {
+    for (const task of ALL_TRAINING_TASKS) {
+      const value = parsed.counters[task];
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+        counters[task] = Math.floor(value);
+      }
+    }
+  }
+  const lastTrainAt = {};
+  if (isStringRecord(parsed) && isStringRecord(parsed.lastTrainAt)) {
+    for (const task of ALL_TRAINING_TASKS) {
+      const value = parsed.lastTrainAt[task];
+      if (typeof value === "number" && Number.isFinite(value)) {
+        lastTrainAt[task] = value;
+      }
+    }
+  }
+  const lastTrainRecord = {};
+  if (isStringRecord(parsed) && isStringRecord(parsed.lastTrainRecord)) {
+    for (const task of ALL_TRAINING_TASKS) {
+      const value = parsed.lastTrainRecord[task];
+      if (isStringRecord(value) && typeof value.runId === "string" && typeof value.source === "string" && typeof value.finishedAt === "string" && typeof value.status === "string") {
+        lastTrainRecord[task] = {
+          runId: value.runId,
+          source: value.source,
+          finishedAt: value.finishedAt,
+          status: value.status
+        };
+      }
+    }
+  }
+  return { counters, lastTrainAt, lastTrainRecord };
+}
+function writePersisted(path, state) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+}
+function tasksForTrajectory(detail) {
+  const tasks = /* @__PURE__ */ new Set();
+  for (const step of detail.steps ?? []) {
+    for (const call of step.llmCalls ?? []) {
+      const purpose = (call.purpose ?? "").toLowerCase();
+      const callKind = typeof call.metadata?.callKind === "string" ? call.metadata.callKind.toLowerCase() : "";
+      const hint = `${purpose} ${callKind}`;
+      if (hint.includes("should_respond") || hint.includes("response_handler") || hint.includes("shouldrespond")) {
+        tasks.add("should_respond");
+      }
+      if (hint.includes("action_planner") || hint.includes("planner") || hint.includes("runtime_use_model")) {
+        tasks.add("action_planner");
+      }
+      if (hint.includes("media_description") || hint.includes("image_description") || hint.includes("describe_")) {
+        tasks.add("media_description");
+      }
+      if (hint.includes("response") || hint.includes("reply") || hint.includes("message_response")) {
+        tasks.add("response");
+      }
+      if (typeof call.response === "string" && /context_routing/i.test(call.response)) {
+        tasks.add("context_routing");
+      }
+      if (hint.includes("view_context") || hint.includes("view_selection") || typeof call.response === "string" && /"viewId"\s*:/.test(call.response)) {
+        tasks.add("view_context");
+      }
+    }
+  }
+  if (tasks.size === 0 && (detail.steps?.length ?? 0) > 0) {
+    tasks.add("response");
+  }
+  return [...tasks];
+}
+class TrainingTriggerService extends Service {
+  capabilityDescription = "Tracks completed trajectories and fires training runs when per-task counters hit the configured threshold.";
+  instance = this;
+  runtimeRef;
+  statePath;
+  configLoader;
+  triggerImpl;
+  anonymizer;
+  now;
+  inflight = /* @__PURE__ */ new Set();
+  state;
+  constructor(runtime, options = {}) {
+    super();
+    this.runtimeRef = runtime;
+    this.statePath = options.statePath ?? join(trainingStateRoot(), "trigger-state.json");
+    this.configLoader = options.configLoader ?? loadTrainingConfig;
+    this.triggerImpl = options.triggerImpl ?? triggerTraining;
+    this.anonymizer = options.anonymizer;
+    this.now = options.now ?? (() => Date.now());
+    this.state = readPersisted(this.statePath);
+  }
+  /** Idempotent stop hook for the service lifecycle. */
+  async stop() {
+  }
+  getStatus() {
+    const config = this.configLoader();
+    const perTaskThresholds = buildTaskRecord(() => 0);
+    const perTaskCooldownMs = buildTaskRecord(() => 0);
+    for (const task of ALL_TRAINING_TASKS) {
+      const policy = resolveTaskPolicy(config, task);
+      perTaskThresholds[task] = policy.threshold;
+      perTaskCooldownMs[task] = policy.cooldownMs;
+    }
+    return {
+      autoTrainEnabled: config.autoTrain,
+      triggerThreshold: config.triggerThreshold,
+      cooldownHours: config.triggerCooldownHours,
+      counters: { ...this.state.counters },
+      lastTrain: { ...this.state.lastTrainRecord },
+      perTaskThresholds,
+      perTaskCooldownMs
+    };
+  }
+  /**
+   * Called by trajectory storage when a trajectory transitions to
+   * `completed`. Looks up the detail, increments the relevant counters, and
+   * checks each touched task's threshold + cooldown.
+   *
+   * Errors propagate by design — the caller uses optional chaining so a missing
+   * service skips training triggers, while a misconfigured service that throws
+   * during increment is still surfaced.
+   */
+  async notifyTrajectoryCompleted(trajectoryId) {
+    if (!trajectoryId.trim()) return;
+    const config = this.configLoader();
+    if (!config.autoTrain) return;
+    const trajectoryService = this.runtimeRef.getService(
+      "trajectories"
+    );
+    if (!trajectoryService || typeof trajectoryService.getTrajectoryDetail !== "function") {
+      return;
+    }
+    const detail = await trajectoryService.getTrajectoryDetail(trajectoryId);
+    if (!detail) return;
+    const tasks = tasksForTrajectory(detail);
+    if (tasks.length === 0) return;
+    let dirty = false;
+    for (const task of tasks) {
+      this.state.counters[task] = (this.state.counters[task] ?? 0) + 1;
+      dirty = true;
+    }
+    if (dirty) writePersisted(this.statePath, this.state);
+    for (const task of tasks) {
+      await this.maybeFire(task, config);
+    }
+  }
+  /** Manual fire — bypasses the autoTrain toggle (operator action). */
+  async runManually(input) {
+    const record = await this.triggerImpl(this.runtimeRef, {
+      task: input.task,
+      backend: input.backend,
+      source: "manual",
+      dryRun: input.dryRun,
+      anonymizer: this.anonymizer
+    });
+    this.recordCompletion(record);
+    return record;
+  }
+  /**
+   * Reset counters — primarily for tests and operator recovery. The persisted
+   * `lastTrainAt`/`lastTrainRecord` map is preserved so cooldowns still
+   * apply after a reset.
+   */
+  resetCounters(task) {
+    if (task) {
+      this.state.counters[task] = 0;
+    } else {
+      this.state.counters = emptyCounters();
+    }
+    writePersisted(this.statePath, this.state);
+  }
+  async maybeFire(task, config) {
+    const policy = resolveTaskPolicy(config, task);
+    const count = this.state.counters[task];
+    if (count < policy.threshold) return;
+    const lastAt = this.state.lastTrainAt[task];
+    const now = this.now();
+    if (typeof lastAt === "number" && now - lastAt < policy.cooldownMs) {
+      return;
+    }
+    if (this.inflight.has(task)) return;
+    this.inflight.add(task);
+    const log = this.runtimeRef.logger ?? {
+      info: () => {
+      },
+      warn: () => {
+      },
+      error: () => {
+      }
+    };
+    log.info(
+      `[TrainingTriggerService] firing task=${task} threshold=${policy.threshold} count=${count} backend=${policy.backend ?? "<none>"}`
+    );
+    try {
+      const record = await this.triggerImpl(this.runtimeRef, {
+        task,
+        source: "threshold",
+        anonymizer: this.anonymizer
+      });
+      this.recordCompletion(record);
+      this.state.counters[task] = 0;
+      writePersisted(this.statePath, this.state);
+    } finally {
+      this.inflight.delete(task);
+    }
+  }
+  recordCompletion(record) {
+    if (!record.task) return;
+    this.state.lastTrainAt[record.task] = this.now();
+    this.state.lastTrainRecord[record.task] = {
+      runId: record.runId,
+      source: record.source,
+      finishedAt: record.finishedAt,
+      status: record.status
+    };
+    writePersisted(this.statePath, this.state);
+  }
+}
+function registerTrainingTriggerService(runtime, options = {}) {
+  const service = new TrainingTriggerService(runtime, options);
+  runtime.services.set(TRAINING_TRIGGER_SERVICE, [service]);
+  return service;
+}
+const BOOTSTRAP_TASKS = [
+  "should_respond",
+  "action_planner"
+];
+function hasOptimizedPromptService(service) {
+  return !!service && typeof service.hasOptimized === "function";
+}
+async function bootstrapOptimizationFromAccumulatedTrajectories(runtime, service, options = {}) {
+  if (process.env.ELIZA_DISABLE_AUTO_BOOTSTRAP === "1") {
+    return [];
+  }
+  const config = (options.configLoader ?? loadTrainingConfig)();
+  if (!config.autoTrain) return [];
+  if (!config.backends.includes("native")) return [];
+  const optimizedPromptService = runtime.getService("optimized_prompt");
+  const status = service.getStatus();
+  const fired = [];
+  for (const task of BOOTSTRAP_TASKS) {
+    const threshold = status.perTaskThresholds[task] ?? Number.POSITIVE_INFINITY;
+    const count = status.counters[task] ?? 0;
+    if (count < threshold) continue;
+    if (hasOptimizedPromptService(optimizedPromptService) && optimizedPromptService.hasOptimized(task)) {
+      continue;
+    }
+    const trigger = options.triggerOverride ?? (async (input) => service.runManually({ task: input.task, backend: input.backend }));
+    await trigger({ task, backend: "native" });
+    fired.push(task);
+  }
+  if (fired.length > 0) {
+    const message = `Bootstrapping prompt optimization from accumulated trajectories (${fired.join(", ")}). Track progress in Settings \u2192 Auto-Training.`;
+    options.notifier?.notify(message);
+    runtime.logger.info(`[TrainingTriggerService] ${message}`);
+  }
+  return fired;
+}
+export {
+  TRAINING_TRIGGER_SERVICE,
+  TrainingTriggerService,
+  bootstrapOptimizationFromAccumulatedTrajectories,
+  registerTrainingTriggerService
+};
+//# sourceMappingURL=training-trigger.js.map