@elizaos/training 2.0.0-alpha.13 → 2.0.0-alpha.15

package/src/training/RulerScoringService.ts

@@ -13,22 +13,23 @@
  * Based on: https://art.openpipe.ai/fundamentals/ruler
  */
 
-import { getTrainingDataAdapter, type JsonValue, type UUID } from '../adapter';
+import { getTrainingDataAdapter, type JsonValue, type UUID } from "../adapter";
 
 /** Cast string to UUID (replaces @elizaos/core asUUID) */
 function asUUID(id: string): UUID {
   return id as UUID;
 }
-import { v4 as uuidv4 } from 'uuid';
+
+import { v4 as uuidv4 } from "uuid";
 import {
   getLLMCaller,
   getToTrainingMessages,
   type TrajectoryForTraining,
   type TrajectoryStepForTraining,
-} from '../dependencies';
-import { getRubric, sanitizeArchetype } from '../rubrics';
-import { logger, splitIntoBatches } from '../utils';
-import type { TrajectoryStep as TrainingTrajectoryStep } from './types';
+} from "../dependencies";
+import { getRubric, sanitizeArchetype } from "../rubrics";
+import { logger, splitIntoBatches } from "../utils";
+import type { TrajectoryStep as TrainingTrajectoryStep } from "./types";
 
 // Use types from dependencies
 type RichTrajectory = TrajectoryForTraining;
@@ -43,7 +44,7 @@ export interface RulerScore {
 
 export interface MarketOutcomes {
   stocks: Array<{ ticker: string; changePercent: number }>;
-  predictions: Array<{ marketId: string; outcome: 'YES' | 'NO' }>;
+  predictions: Array<{ marketId: string; outcome: "YES" | "NO" }>;
 }
 
 interface TrajectoryScore {
@@ -83,21 +84,21 @@ export class RulerScoringService {
     const trajectoriesResult = await this.getTrajectoriesToScore(trajectoryIds);
 
     if (trajectoriesResult.length === 0) {
-      logger.info('No trajectories to score', {}, 'RulerScoring');
+      logger.info("No trajectories to score", {}, "RulerScoring");
       return 0;
     }
 
     const groups = this.groupByScenario(trajectoriesResult);
 
     logger.info(
-      'Grouped trajectories for RULER scoring',
+      "Grouped trajectories for RULER scoring",
       {
         totalTrajectories: trajectoriesResult.length,
         groups: groups.length,
         avgGroupSize:
           groups.length > 0 ? trajectoriesResult.length / groups.length : 0,
       },
-      'RulerScoring'
+      "RulerScoring",
     );
 
     let totalScored = 0;
@@ -105,13 +106,13 @@ export class RulerScoringService {
     for (const group of groups) {
       if (group.trajectories.length < this.minGroupSize) {
         logger.warn(
-          'Skipping group with insufficient trajectories',
+          "Skipping group with insufficient trajectories",
           {
             scenarioId: group.scenarioId,
             count: group.trajectories.length,
             minRequired: this.minGroupSize,
           },
-          'RulerScoring'
+          "RulerScoring",
         );
         continue;
       }
@@ -125,12 +126,12 @@ export class RulerScoringService {
     }
 
     logger.info(
-      'RULER scoring complete',
+      "RULER scoring complete",
       {
         totalScored,
         totalTrajectories: trajectoriesResult.length,
       },
-      'RulerScoring'
+      "RulerScoring",
     );
 
     return totalScored;
@@ -148,7 +149,8 @@ export class RulerScoringService {
       return null;
     }
 
-    const updated = await getTrainingDataAdapter().getTrajectoryById(trajectoryId);
+    const updated =
+      await getTrainingDataAdapter().getTrajectoryById(trajectoryId);
 
     if (!updated || updated.aiJudgeReward === null) {
       return null;
@@ -157,7 +159,7 @@ export class RulerScoringService {
     return {
       trajectoryId: updated.trajectoryId,
       overallScore: updated.aiJudgeReward,
-      reasoning: updated.aiJudgeReasoning || '',
+      reasoning: updated.aiJudgeReasoning || "",
       scoredAt: updated.judgedAt || new Date(),
     };
   }
@@ -181,7 +183,7 @@ export class RulerScoringService {
       episodeLength: number | null;
       archetype: string | null;
     }>,
-    scenarioId: string
+    scenarioId: string,
   ): Promise<number> {
     const richTrajectories: Array<{
       traj: RichTrajectory;
@@ -192,15 +194,15 @@ export class RulerScoringService {
     for (const dbTraj of trajectoriesData) {
       if (
         !dbTraj.stepsJson ||
-        dbTraj.stepsJson === 'null' ||
-        dbTraj.stepsJson === '[]'
+        dbTraj.stepsJson === "null" ||
+        dbTraj.stepsJson === "[]"
       ) {
         logger.warn(
-          'Skipping trajectory with invalid stepsJson',
+          "Skipping trajectory with invalid stepsJson",
           {
             trajectoryId: dbTraj.trajectoryId,
           },
-          'RulerScoring'
+          "RulerScoring",
         );
         continue;
       }
@@ -249,11 +251,11 @@ export class RulerScoringService {
               maxTokens: l.maxTokens,
               latencyMs: l.latencyMs,
               purpose: l.purpose as
-                | 'action'
-                | 'reasoning'
-                | 'evaluation'
-                | 'response'
-                | 'other',
+                | "action"
+                | "reasoning"
+                | "evaluation"
+                | "response"
+                | "other",
               actionType: l.actionType,
             })),
             action: {
@@ -270,7 +272,7 @@ export class RulerScoringService {
             reward: s.reward,
             done: idx === steps.length - 1,
             metadata: {},
-          })
+          }),
         ),
         totalReward: steps.reduce((sum, s) => sum + s.reward, 0),
         rewardComponents: {
@@ -278,7 +280,7 @@ export class RulerScoringService {
         },
         metrics: {
           episodeLength: dbTraj.episodeLength || steps.length,
-          finalStatus: 'completed',
+          finalStatus: "completed",
           finalPnL: dbTraj.finalPnL || undefined,
         },
         metadata: {
@@ -295,24 +297,24 @@ export class RulerScoringService {
 
     if (richTrajectories.length < this.minGroupSize) {
       logger.warn(
-        'Insufficient valid trajectories in group',
+        "Insufficient valid trajectories in group",
         {
           scenarioId,
           validCount: richTrajectories.length,
         },
-        'RulerScoring'
+        "RulerScoring",
       );
       return 0;
     }
 
     const commonPrefix = this.extractCommonPrefix(
-      richTrajectories.map((rt) => rt.messages)
+      richTrajectories.map((rt) => rt.messages),
     );
 
     const judgePrompt = this.buildJudgePrompt(
       richTrajectories,
       commonPrefix,
-      scenarioId
+      scenarioId,
     );
 
     const judgeResponse = await this.callJudge(judgePrompt);
@@ -322,12 +324,12 @@ export class RulerScoringService {
       judgeResponse.scores.length !== richTrajectories.length
     ) {
       logger.error(
-        'Invalid judge response',
+        "Invalid judge response",
         {
           expectedScores: richTrajectories.length,
           receivedScores: judgeResponse?.scores.length || 0,
         },
-        'RulerScoring'
+        "RulerScoring",
       );
       return 0;
     }
@@ -344,35 +346,35 @@ export class RulerScoringService {
 
       if (!scoreData) {
         logger.warn(
-          'Judge did not return score for trajectory',
+          "Judge did not return score for trajectory",
           {
             expectedTrajId,
             receivedIds: judgeResponse.scores.map((s) => s.trajectory_id),
           },
-          'RulerScoring'
+          "RulerScoring",
         );
         continue;
       }
 
-      const trajectoryId = richTrajectories[i]!.traj.trajectoryId;
+      const trajectoryId = richTrajectories[i]?.traj.trajectoryId;
 
       await getTrainingDataAdapter().updateTrajectoryScore(
         trajectoryId,
         Math.max(0, Math.min(1, scoreData.score)),
-        scoreData.explanation
+        scoreData.explanation,
       );
 
       scored++;
     }
 
     logger.info(
-      'Scored trajectory group',
+      "Scored trajectory group",
       {
         scenarioId,
         scored,
         groupSize: richTrajectories.length,
       },
-      'RulerScoring'
+      "RulerScoring",
     );
 
     return scored;
@@ -391,13 +393,13 @@ export class RulerScoringService {
       archetype: string;
     }>,
     commonPrefix: Array<{ role: string; content: string }>,
-    scenarioId: string
+    scenarioId: string,
   ): string {
     // Build context section with game knowledge (injected into prompt)
     const contextParts: string[] = [];
     contextParts.push(`Scenario: ${scenarioId}`);
     contextParts.push(
-      `\nTrajectory Performance Context (use this to inform your scoring):`
+      `\nTrajectory Performance Context (use this to inform your scoring):`,
     );
 
     for (let i = 0; i < richTrajectories.length; i++) {
@@ -407,24 +409,24 @@ export class RulerScoringService {
       contextParts.push(`\n${trajId}:`);
       contextParts.push(`  - Archetype: ${rt.archetype}`);
       contextParts.push(
-        `  - Final P&L: $${rt.traj.metrics.finalPnL?.toFixed(2) || '0.00'}`
+        `  - Final P&L: $${rt.traj.metrics.finalPnL?.toFixed(2) || "0.00"}`,
       );
       contextParts.push(
-        `  - Episode Length: ${rt.traj.metrics.episodeLength || 0} steps`
+        `  - Episode Length: ${rt.traj.metrics.episodeLength || 0} steps`,
       );
       contextParts.push(`  - Total Reward: ${rt.traj.totalReward.toFixed(2)}`);
 
       const actionTypes = rt.traj.steps
         .filter((s: TrajectoryStep): boolean => !!s.action)
-        .map((s: TrajectoryStep): string => s.action!.actionType);
+        .map((s: TrajectoryStep): string => s.action?.actionType);
       const uniqueActions = [...new Set(actionTypes)];
       contextParts.push(
-        `  - Actions Taken: ${uniqueActions.join(', ')} (${actionTypes.length} total)`
+        `  - Actions Taken: ${uniqueActions.join(", ")} (${actionTypes.length} total)`,
       );
 
       // Add success/error info
       const errors = rt.traj.steps.filter(
-        (s: TrajectoryStep): boolean => !!s.action && !s.action.success
+        (s: TrajectoryStep): boolean => !!s.action && !s.action.success,
       ).length;
       const successRate =
         rt.traj.steps.length > 0
@@ -432,7 +434,7 @@ export class RulerScoringService {
               ((rt.traj.steps.length - errors) / rt.traj.steps.length) *
               100
             ).toFixed(1)
-          : '0';
+          : "0";
       contextParts.push(`  - Success Rate: ${successRate}%`);
 
       if (errors > 0) {
@@ -462,24 +464,24 @@ export class RulerScoringService {
     const userContent =
       commonPrefix.length > 0
         ? `<context>\n${JSON.stringify(commonPrefix, null, 2)}\n</context>\n\n`
-        : '';
+        : "";
 
-    const prompt = `${userContent}${contextParts.join('\n')}\n\nTrajectories:\n\n${trajectorySections.join('\n\n')}`;
+    const prompt = `${userContent}${contextParts.join("\n")}\n\nTrajectories:\n\n${trajectorySections.join("\n\n")}`;
 
     // Determine archetype-specific rubric
     // If all trajectories share the same archetype, use that archetype's rubric
     // Otherwise, fall back to the default rubric
     const archetypes = [...new Set(richTrajectories.map((rt) => rt.archetype))];
     const isSingleArchetype =
-      archetypes.length === 1 && archetypes[0] !== 'default';
+      archetypes.length === 1 && archetypes[0] !== "default";
     const rubric = isSingleArchetype
       ? getRubric(archetypes[0]!)
       : DEFAULT_RUBRIC;
     const archetypeContext = isSingleArchetype
-      ? `\n\nYou are evaluating ${archetypes[0]!.toUpperCase()} agents. Score them based on how well they embody that archetype's behavior and goals.`
+      ? `\n\nYou are evaluating ${archetypes[0]?.toUpperCase()} agents. Score them based on how well they embody that archetype's behavior and goals.`
       : archetypes.length > 1
-        ? `\n\nNote: This group contains mixed archetypes (${archetypes.join(', ')}). Consider each agent's archetype when scoring.`
-        : '';
+        ? `\n\nNote: This group contains mixed archetypes (${archetypes.join(", ")}). Consider each agent's archetype when scoring.`
+        : "";
 
     const systemPrompt = `You are an expert evaluator of AI agent performance. All trajectories below were given the same goal/scenario. Your job is to compare them and assign scores from 0 to 1 based on how well each trajectory achieved its goal.${archetypeContext}
 
@@ -529,26 +531,26 @@ Return ONLY the JSON, no other text.`;
     const response = await llmCaller.callGroqDirect({
       prompt: structuredPrompt,
       system: promptData.system,
-      modelSize: 'large',
+      modelSize: "large",
       temperature: 0.3,
       maxTokens: 2000,
-      actionType: 'ruler_score_trajectories',
+      actionType: "ruler_score_trajectories",
     });
 
     let jsonText = response.trim();
     jsonText = jsonText
-      .replace(/```json\n?/g, '')
-      .replace(/```\n?/g, '')
+      .replace(/```json\n?/g, "")
+      .replace(/```\n?/g, "")
       .trim();
 
     const jsonMatch = jsonText.match(/\{[\s\S]*\}/);
     if (!jsonMatch) {
       logger.error(
-        'Judge response does not contain JSON',
+        "Judge response does not contain JSON",
         {
           response: response.substring(0, 500),
         },
-        'RulerScoring'
+        "RulerScoring",
       );
       return null;
     }
@@ -557,9 +559,9 @@ Return ONLY the JSON, no other text.`;
 
     if (!parsed.scores || !Array.isArray(parsed.scores)) {
       logger.error(
-        'Invalid judge response structure',
+        "Invalid judge response structure",
         { parsed },
-        'RulerScoring'
+        "RulerScoring",
       );
       return null;
     }
@@ -579,7 +581,7 @@ Return ONLY the JSON, no other text.`;
    * RULER deduplicates common prefixes to save tokens.
    */
   private extractCommonPrefix(
-    messageLists: Array<Array<{ role: string; content: string }>>
+    messageLists: Array<Array<{ role: string; content: string }>>,
   ): Array<{ role: string; content: string }> {
     if (messageLists.length === 0) return [];
 
@@ -591,8 +593,8 @@ Return ONLY the JSON, no other text.`;
       const allMatch = messageLists.every(
         (msgs) =>
           msgs[i] &&
-          msgs[i]!.role === msg.role &&
-          msgs[i]!.content === msg.content
+          msgs[i]?.role === msg.role &&
+          msgs[i]?.content === msg.content,
       );
 
       if (allMatch) {
@@ -616,16 +618,16 @@ Return ONLY the JSON, no other text.`;
       finalPnL: number | null;
       episodeLength: number | null;
       archetype: string | null;
-    }>
+    }>,
   ): Array<{ scenarioId: string; trajectories: typeof trajectoriesData }> {
     const groups = new Map<string, typeof trajectoriesData>();
 
     for (const traj of trajectoriesData) {
-      const scenarioId = traj.scenarioId || 'default';
+      const scenarioId = traj.scenarioId || "default";
       if (!groups.has(scenarioId)) {
         groups.set(scenarioId, []);
       }
-      groups.get(scenarioId)!.push(traj);
+      groups.get(scenarioId)?.push(traj);
     }
 
     return Array.from(groups.entries()).map(([scenarioId, trajs]) => ({
@@ -640,9 +642,7 @@ Return ONLY the JSON, no other text.`;
   private async getTrajectoriesToScore(trajectoryIds?: string[]) {
     const adapter = getTrainingDataAdapter();
     return await adapter.getUnscoredTrajectories(
-      trajectoryIds && trajectoryIds.length > 0
-        ? { trajectoryIds }
-        : undefined
+      trajectoryIds && trajectoryIds.length > 0 ? { trajectoryIds } : undefined,
     );
   }
 
@@ -650,7 +650,8 @@ Return ONLY the JSON, no other text.`;
    * Score all unscored trajectories in a time window
    */
   async scoreWindow(windowId: string): Promise<number> {
-    const trajectoryIds = await getTrainingDataAdapter().getUnscoredWindowTrajectoryIds(windowId);
+    const trajectoryIds =
+      await getTrainingDataAdapter().getUnscoredWindowTrajectoryIds(windowId);
 
     if (trajectoryIds.length === 0) {
       return 0;

package/src/training/TrainingMonitor.ts

@@ -5,17 +5,17 @@
  * Monitors Python training process and W&B runs.
  */
 
-import { getTrainingDataAdapter } from '../adapter';
-import { logger } from '../utils/logger';
+import { getTrainingDataAdapter } from "../adapter";
+import { logger } from "../utils/logger";
 
 export type TrainingStatus =
-  | 'pending'
-  | 'preparing'
-  | 'scoring'
-  | 'training'
-  | 'uploading'
-  | 'completed'
-  | 'failed';
+  | "pending"
+  | "preparing"
+  | "scoring"
+  | "training"
+  | "uploading"
+  | "completed"
+  | "failed";
 
 export interface TrainingProgress {
   batchId: string;
@@ -36,12 +36,12 @@ export class TrainingMonitor {
    */
   async startMonitoring(batchId: string): Promise<void> {
     const adapter = getTrainingDataAdapter();
-    await adapter.updateBatchStatus(batchId, 'training');
+    await adapter.updateBatchStatus(batchId, "training");
 
     logger.info(
-      'Started monitoring training job',
+      "Started monitoring training job",
       { batchId },
-      'TrainingMonitor'
+      "TrainingMonitor",
     );
   }
 
@@ -50,23 +50,23 @@ export class TrainingMonitor {
    */
   async updateProgress(
     batchId: string,
-    progress: Partial<TrainingProgress>
+    progress: Partial<TrainingProgress>,
   ): Promise<void> {
     if (progress.status) {
       const adapter = getTrainingDataAdapter();
       const errorMsg =
-        progress.status === 'failed' ? progress.error : undefined;
+        progress.status === "failed" ? progress.error : undefined;
       await adapter.updateBatchStatus(batchId, progress.status, errorMsg);
     }
 
     logger.info(
-      'Updated training progress',
+      "Updated training progress",
       {
         batchId,
         status: progress.status,
         progress: progress.progress,
       },
-      'TrainingMonitor'
+      "TrainingMonitor",
     );
   }
 
@@ -84,32 +84,32 @@ export class TrainingMonitor {
     // Calculate progress based on status
     let progress = 0;
     switch (batch.status) {
-      case 'pending':
+      case "pending":
         progress = 0;
         break;
-      case 'preparing':
+      case "preparing":
         progress = 0.1;
         break;
-      case 'scoring':
+      case "scoring":
         progress = 0.3;
         break;
-      case 'training':
+      case "training":
         progress = 0.6;
         break;
-      case 'uploading':
+      case "uploading":
         progress = 0.9;
         break;
-      case 'completed':
+      case "completed":
         progress = 1.0;
         break;
-      case 'failed':
+      case "failed":
         progress = 0;
         break;
     }
 
     // Estimate ETA based on average training time
     let eta: number | undefined;
-    if (batch.status === 'training' && batch.startedAt) {
+    if (batch.status === "training" && batch.startedAt) {
       const avgTrainingTime = 2 * 60 * 60 * 1000; // 2 hours average
       const elapsed = Date.now() - batch.startedAt.getTime();
       eta = Math.max(0, avgTrainingTime - elapsed);
@@ -135,12 +135,12 @@ export class TrainingMonitor {
 
     if (stuckJobs.length > 0) {
       logger.warn(
-        'Found stuck training jobs',
+        "Found stuck training jobs",
         {
           count: stuckJobs.length,
           jobs: stuckJobs,
         },
-        'TrainingMonitor'
+        "TrainingMonitor",
       );
     }
 
@@ -152,12 +152,12 @@ export class TrainingMonitor {
    */
   async cancelJob(batchId: string, reason: string): Promise<void> {
     const adapter = getTrainingDataAdapter();
-    await adapter.updateBatchStatus(batchId, 'failed', `Cancelled: ${reason}`);
+    await adapter.updateBatchStatus(batchId, "failed", `Cancelled: ${reason}`);
 
     logger.warn(
-      'Training job cancelled',
+      "Training job cancelled",
       { batchId, reason },
-      'TrainingMonitor'
+      "TrainingMonitor",
     );
   }
 }