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

package/src/training/TrajectoryRecorder.ts

@@ -7,29 +7,29 @@
  * @packageDocumentation
  */
 
-import type { JsonValue, TrajectoryRecord } from '../adapter';
-import { getTrainingDataAdapter, getLlmLogAdapter } from '../adapter';
-import { logger } from '../utils/logger';
-import { generateSnowflakeId } from '../utils/snowflake';
+import type { JsonValue, TrajectoryRecord } from "../adapter";
+import { getLlmLogAdapter, getTrainingDataAdapter } from "../adapter";
+import { logger } from "../utils/logger";
+import { generateSnowflakeId } from "../utils/snowflake";
 import type {
   Action,
   EnvironmentState,
   LLMCall,
   ProviderAccess,
   TrajectoryStep,
-} from './types';
-import { getCurrentWindowId } from './window-utils';
+} from "./types";
+import { getCurrentWindowId } from "./window-utils";
 
 export type {
-  TrajectoryStep,
+  Action,
   EnvironmentState,
-  ProviderAccess,
   LLMCall,
-  Action,
+  ProviderAccess,
+  TrajectoryStep,
 };
 
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from "node:fs";
+import * as path from "node:path";
 
 // ─── Simulation mode flag ────────────────────────────────────────────
 // Replaces the `isSimulationMode` import from `@elizaos/db`.
@@ -118,7 +118,7 @@ export class TrajectoryRecorder {
       steps: [],
     });
 
-    logger.info('Started trajectory recording', {
+    logger.info("Started trajectory recording", {
       trajectoryId,
       agentId: options.agentId,
       archetype: options.archetype,
@@ -163,7 +163,7 @@ export class TrajectoryRecorder {
       providerName: string;
       data: Record<string, JsonValue>;
       purpose: string;
-    }
+    },
   ): void {
     const traj = this.activeTrajectories.get(trajectoryId);
     if (!traj?.currentStep) {
@@ -225,7 +225,7 @@ export class TrajectoryRecorder {
    */
   async endTrajectory(
     trajectoryId: string,
-    options: EndTrajectoryOptions = {}
+    options: EndTrajectoryOptions = {},
   ): Promise<void> {
     const traj = this.activeTrajectories.get(trajectoryId);
     if (!traj) {
@@ -240,19 +240,19 @@ export class TrajectoryRecorder {
     // Calculate metrics
     const tradesExecuted = traj.steps.filter(
       (s) =>
-        s.action.actionType.includes('BUY') ||
-        s.action.actionType.includes('SELL')
+        s.action.actionType.includes("BUY") ||
+        s.action.actionType.includes("SELL"),
     ).length;
 
     const postsCreated = traj.steps.filter((s) =>
-      s.action.actionType.includes('POST')
+      s.action.actionType.includes("POST"),
     ).length;
 
     const errorCount = traj.steps.filter((s) => !s.action.success).length;
-    const finalStatus = errorCount > 0 ? 'completed_with_errors' : 'completed';
+    const finalStatus = errorCount > 0 ? "completed_with_errors" : "completed";
 
     // 1. Prepare the standard data object (Used for both JSON and DB)
-    const trajectoryData: Omit<TrajectoryRecord, 'createdAt' | 'updatedAt'> = {
+    const trajectoryData: Omit<TrajectoryRecord, "createdAt" | "updatedAt"> = {
       id: await generateSnowflakeId(),
       trajectoryId,
       agentId: traj.agentId,
@@ -261,9 +261,7 @@ export class TrajectoryRecorder {
       endTime: new Date(endTime),
       durationMs,
       scenarioId: traj.scenarioId || windowId,
-      episodeId: traj.scenarioId
-        ? `${traj.scenarioId}-${Date.now()}`
-        : null,
+      episodeId: traj.scenarioId ? `${traj.scenarioId}-${Date.now()}` : null,
       windowId,
       windowHours: 1,
       batchId: null,
@@ -300,7 +298,7 @@ export class TrajectoryRecorder {
 
     // Simulation Mode Bypass
     if (isSimulationMode()) {
-      const outputDir = './training-data-output/trajectories';
+      const outputDir = "./training-data-output/trajectories";
       if (!fs.existsSync(outputDir)) {
         fs.mkdirSync(outputDir, { recursive: true });
       }
@@ -312,7 +310,7 @@ export class TrajectoryRecorder {
             stepNumber: step.stepNumber,
             callIndex: idx,
             ...call,
-          }))
+          })),
         ),
       };
 
@@ -320,9 +318,9 @@ export class TrajectoryRecorder {
       fs.writeFileSync(filePath, JSON.stringify(fullData, null, 2));
 
       logger.info(
-        'Saved trajectory to JSON (Simulation Mode)',
+        "Saved trajectory to JSON (Simulation Mode)",
         { trajectoryId, path: filePath },
-        'TrajectoryRecorder'
+        "TrajectoryRecorder",
       );
 
       this.activeTrajectories.delete(trajectoryId);
@@ -357,7 +355,7 @@ export class TrajectoryRecorder {
       }
     }
 
-    logger.info('Trajectory saved to database', {
+    logger.info("Trajectory saved to database", {
       trajectoryId,
       archetype: traj.archetype,
       steps: traj.steps.length,

package/src/training/__tests__/TrajectoryRecorder.test.ts

@@ -5,20 +5,20 @@
  * Uses simulation mode to avoid database dependency.
  */
 
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import * as fs from 'fs';
-import * as path from 'path';
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as path from "node:path";
 
-import { setSimulationMode, TrajectoryRecorder } from '../TrajectoryRecorder';
-import type { Action, EnvironmentState, LLMCall } from '../types';
+import { setSimulationMode, TrajectoryRecorder } from "../TrajectoryRecorder";
+import type { Action, EnvironmentState, LLMCall } from "../types";
 
 // =============================================================================
 // Test Setup
 // =============================================================================
 
-const TEST_OUTPUT_DIR = './training-data-output/trajectories';
+const TEST_OUTPUT_DIR = "./training-data-output/trajectories";
 
-describe('TrajectoryRecorder - Real Class Tests', () => {
+describe("TrajectoryRecorder - Real Class Tests", () => {
   let recorder: TrajectoryRecorder;
 
   beforeEach(() => {
@@ -28,7 +28,7 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     if (fs.existsSync(TEST_OUTPUT_DIR)) {
       const files = fs.readdirSync(TEST_OUTPUT_DIR);
       for (const file of files) {
-        if (file.startsWith('test-')) {
+        if (file.startsWith("test-")) {
           fs.unlinkSync(path.join(TEST_OUTPUT_DIR, file));
         }
       }
@@ -41,7 +41,7 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     if (fs.existsSync(TEST_OUTPUT_DIR)) {
       const files = fs.readdirSync(TEST_OUTPUT_DIR);
       for (const file of files) {
-        if (file.includes('test-agent')) {
+        if (file.includes("test-agent")) {
           try {
             fs.unlinkSync(path.join(TEST_OUTPUT_DIR, file));
           } catch {
@@ -56,23 +56,23 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
   // Lifecycle Tests
   // ===========================================================================
 
-  test('startTrajectory creates a new active trajectory', async () => {
+  test("startTrajectory creates a new active trajectory", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent-1',
-      archetype: 'trader',
+      agentId: "test-agent-1",
+      archetype: "trader",
     });
 
     expect(trajectoryId).toBeDefined();
-    expect(typeof trajectoryId).toBe('string');
+    expect(typeof trajectoryId).toBe("string");
     expect(trajectoryId.length).toBeGreaterThan(10);
     expect(recorder.isActive(trajectoryId)).toBe(true);
     expect(recorder.getActiveCount()).toBe(1);
   });
 
-  test('multiple trajectories can be active simultaneously', async () => {
-    const id1 = await recorder.startTrajectory({ agentId: 'test-agent-1' });
-    const id2 = await recorder.startTrajectory({ agentId: 'test-agent-2' });
-    const id3 = await recorder.startTrajectory({ agentId: 'test-agent-3' });
+  test("multiple trajectories can be active simultaneously", async () => {
+    const id1 = await recorder.startTrajectory({ agentId: "test-agent-1" });
+    const id2 = await recorder.startTrajectory({ agentId: "test-agent-2" });
+    const id3 = await recorder.startTrajectory({ agentId: "test-agent-3" });
 
     expect(recorder.getActiveCount()).toBe(3);
     expect(recorder.isActive(id1)).toBe(true);
@@ -82,24 +82,24 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     expect(id2).not.toBe(id3);
   });
 
-  test('getActiveTrajectory returns correct trajectory', async () => {
+  test("getActiveTrajectory returns correct trajectory", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent-x',
-      archetype: 'degen',
-      scenarioId: 'test-scenario',
+      agentId: "test-agent-x",
+      archetype: "degen",
+      scenarioId: "test-scenario",
     });
 
     const active = recorder.getActiveTrajectory(trajectoryId);
 
     expect(active).toBeDefined();
-    expect(active?.agentId).toBe('test-agent-x');
-    expect(active?.archetype).toBe('degen');
-    expect(active?.scenarioId).toBe('test-scenario');
+    expect(active?.agentId).toBe("test-agent-x");
+    expect(active?.archetype).toBe("degen");
+    expect(active?.scenarioId).toBe("test-scenario");
     expect(active?.steps).toHaveLength(0);
   });
 
-  test('getActiveTrajectory returns undefined for non-existent id', () => {
-    const result = recorder.getActiveTrajectory('non-existent-id');
+  test("getActiveTrajectory returns undefined for non-existent id", () => {
+    const result = recorder.getActiveTrajectory("non-existent-id");
     expect(result).toBeUndefined();
   });
 
@@ -107,9 +107,9 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
   // Step Recording Tests
   // ===========================================================================
 
-  test('startStep initializes current step with environment state', async () => {
+  test("startStep initializes current step with environment state", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
 
     const envState: EnvironmentState = {
@@ -126,19 +126,19 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     expect(active?.currentStep?.stepNumber).toBe(0);
   });
 
-  test('startStep throws for non-existent trajectory', () => {
+  test("startStep throws for non-existent trajectory", () => {
     expect(() => {
-      recorder.startStep('fake-id', {
+      recorder.startStep("fake-id", {
         agentBalance: 0,
         agentPnL: 0,
         openPositions: 0,
       });
-    }).toThrow('Trajectory not found: fake-id');
+    }).toThrow("Trajectory not found: fake-id");
   });
 
-  test('logProviderAccess adds provider data to current step', async () => {
+  test("logProviderAccess adds provider data to current step", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
     recorder.startStep(trajectoryId, {
       agentBalance: 1000,
@@ -147,36 +147,36 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     });
 
     recorder.logProviderAccess(trajectoryId, {
-      providerName: 'market-data',
-      data: { ticker: 'BTCAI', price: 50000 },
-      purpose: 'price lookup',
+      providerName: "market-data",
+      data: { ticker: "BTCAI", price: 50000 },
+      purpose: "price lookup",
     });
 
     const active = recorder.getActiveTrajectory(trajectoryId);
     expect(active?.currentStep?.providerAccesses).toHaveLength(1);
     expect(active?.currentStep?.providerAccesses?.[0]?.providerName).toBe(
-      'market-data'
+      "market-data",
     );
   });
 
-  test('logProviderAccess throws when no current step', async () => {
+  test("logProviderAccess throws when no current step", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
     // Don't call startStep
 
     expect(() => {
       recorder.logProviderAccess(trajectoryId, {
-        providerName: 'test',
+        providerName: "test",
         data: {},
-        purpose: 'test',
+        purpose: "test",
       });
-    }).toThrow('No current step');
+    }).toThrow("No current step");
   });
 
-  test('logLLMCall adds LLM call to current step', async () => {
+  test("logLLMCall adds LLM call to current step", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
     recorder.startStep(trajectoryId, {
       agentBalance: 1000,
@@ -185,14 +185,14 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     });
 
     const llmCall: LLMCall = {
-      model: 'qwen-32b',
-      systemPrompt: 'You are a trading agent',
-      userPrompt: 'What should I do?',
-      response: 'Buy BTCAI',
-      reasoning: 'Bullish momentum',
+      model: "qwen-32b",
+      systemPrompt: "You are a trading agent",
+      userPrompt: "What should I do?",
+      response: "Buy BTCAI",
+      reasoning: "Bullish momentum",
       temperature: 0.7,
       maxTokens: 2000,
-      purpose: 'action',
+      purpose: "action",
       latencyMs: 250,
     };
 
@@ -200,13 +200,13 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
 
     const active = recorder.getActiveTrajectory(trajectoryId);
     expect(active?.currentStep?.llmCalls).toHaveLength(1);
-    expect(active?.currentStep?.llmCalls?.[0]?.model).toBe('qwen-32b');
+    expect(active?.currentStep?.llmCalls?.[0]?.model).toBe("qwen-32b");
     expect(active?.currentStep?.llmCalls?.[0]?.latencyMs).toBe(250);
   });
 
-  test('completeStep finalizes step and adds to trajectory', async () => {
+  test("completeStep finalizes step and adds to trajectory", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
     recorder.startStep(trajectoryId, {
       agentBalance: 1000,
@@ -215,8 +215,8 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     });
 
     const action: Action = {
-      actionType: 'buy',
-      parameters: { ticker: 'BTCAI', amount: 100 },
+      actionType: "buy",
+      parameters: { ticker: "BTCAI", amount: 100 },
       success: true,
     };
 
@@ -224,14 +224,14 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
 
     const active = recorder.getActiveTrajectory(trajectoryId);
     expect(active?.steps).toHaveLength(1);
-    expect(active?.steps[0]?.action.actionType).toBe('buy');
+    expect(active?.steps[0]?.action.actionType).toBe("buy");
     expect(active?.steps[0]?.reward).toBe(0.5);
     expect(active?.currentStep).toBeUndefined();
   });
 
-  test('multiple steps increment step number correctly', async () => {
+  test("multiple steps increment step number correctly", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
 
     for (let i = 0; i < 5; i++) {
@@ -242,8 +242,8 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
       });
       recorder.completeStep(
         trajectoryId,
-        { actionType: 'hold', parameters: {}, success: true },
-        0.1
+        { actionType: "hold", parameters: {}, success: true },
+        0.1,
       );
     }
 
@@ -257,10 +257,10 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
   // End Trajectory Tests (Simulation Mode - File Output)
   // ===========================================================================
 
-  test('endTrajectory saves JSON file in simulation mode', async () => {
+  test("endTrajectory saves JSON file in simulation mode", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent-file',
-      archetype: 'trader',
+      agentId: "test-agent-file",
+      archetype: "trader",
     });
 
     // Add a step
@@ -270,18 +270,18 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
       openPositions: 0,
     });
     recorder.logLLMCall(trajectoryId, {
-      model: 'test-model',
-      systemPrompt: 'system',
-      userPrompt: 'user',
-      response: 'response',
+      model: "test-model",
+      systemPrompt: "system",
+      userPrompt: "user",
+      response: "response",
       temperature: 0.5,
       maxTokens: 100,
-      purpose: 'action',
+      purpose: "action",
     });
     recorder.completeStep(
       trajectoryId,
-      { actionType: 'buy', parameters: { ticker: 'BTCAI' }, success: true },
-      1.0
+      { actionType: "buy", parameters: { ticker: "BTCAI" }, success: true },
+      1.0,
     );
 
     await recorder.endTrajectory(trajectoryId, {
@@ -294,9 +294,9 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     expect(fs.existsSync(filePath)).toBe(true);
 
     // Verify file contents
-    const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    expect(content.trajectory.agentId).toBe('test-agent-file');
-    expect(content.trajectory.archetype).toBe('trader');
+    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    expect(content.trajectory.agentId).toBe("test-agent-file");
+    expect(content.trajectory.archetype).toBe("trader");
     expect(content.trajectory.episodeLength).toBe(1);
     expect(content.trajectory.finalBalance).toBe(10500);
     expect(content.trajectory.finalPnL).toBe(500);
@@ -306,9 +306,9 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     fs.unlinkSync(filePath);
   });
 
-  test('endTrajectory removes trajectory from active map', async () => {
+  test("endTrajectory removes trajectory from active map", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
     expect(recorder.isActive(trajectoryId)).toBe(true);
 
@@ -318,15 +318,15 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     expect(recorder.getActiveCount()).toBe(0);
   });
 
-  test('endTrajectory throws for non-existent trajectory', async () => {
-    await expect(recorder.endTrajectory('fake-id')).rejects.toThrow(
-      'Trajectory not found: fake-id'
+  test("endTrajectory throws for non-existent trajectory", async () => {
+    await expect(recorder.endTrajectory("fake-id")).rejects.toThrow(
+      "Trajectory not found: fake-id",
     );
   });
 
-  test('endTrajectory calculates metrics correctly', async () => {
+  test("endTrajectory calculates metrics correctly", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
 
     // Add buy action
@@ -337,8 +337,8 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     });
     recorder.completeStep(
       trajectoryId,
-      { actionType: 'BUY_YES', parameters: {}, success: true },
-      1.0
+      { actionType: "BUY_YES", parameters: {}, success: true },
+      1.0,
     );
 
     // Add sell action
@@ -349,8 +349,8 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     });
     recorder.completeStep(
       trajectoryId,
-      { actionType: 'SELL', parameters: {}, success: true },
-      0.5
+      { actionType: "SELL", parameters: {}, success: true },
+      0.5,
     );
 
     // Add failed action
@@ -362,24 +362,24 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     recorder.completeStep(
       trajectoryId,
       {
-        actionType: 'BUY_NO',
+        actionType: "BUY_NO",
         parameters: {},
         success: false,
-        error: 'Insufficient funds',
+        error: "Insufficient funds",
       },
-      -0.5
+      -0.5,
     );
 
     await recorder.endTrajectory(trajectoryId);
 
     // Check that file was written with correct metrics
     const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
-    const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
 
     expect(content.trajectory.episodeLength).toBe(3);
     expect(content.trajectory.tradesExecuted).toBe(3); // BUY_YES, SELL, BUY_NO
     expect(content.trajectory.totalReward).toBe(1.0); // 1.0 + 0.5 + (-0.5)
-    expect(content.trajectory.finalStatus).toBe('completed_with_errors');
+    expect(content.trajectory.finalStatus).toBe("completed_with_errors");
 
     fs.unlinkSync(filePath);
   });
@@ -388,15 +388,15 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
   // Edge Cases
   // ===========================================================================
 
-  test('handles trajectory with zero steps', async () => {
+  test("handles trajectory with zero steps", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
 
     await recorder.endTrajectory(trajectoryId);
 
     const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
-    const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
 
     expect(content.trajectory.episodeLength).toBe(0);
     expect(content.trajectory.totalReward).toBe(0);
@@ -405,9 +405,9 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     fs.unlinkSync(filePath);
   });
 
-  test('handles very long prompts in LLM calls', async () => {
+  test("handles very long prompts in LLM calls", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
     recorder.startStep(trajectoryId, {
       agentBalance: 1000,
@@ -415,22 +415,22 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
       openPositions: 0,
     });
 
-    const longPrompt = 'A'.repeat(50000); // 50k characters
+    const longPrompt = "A".repeat(50000); // 50k characters
 
     recorder.logLLMCall(trajectoryId, {
-      model: 'test',
+      model: "test",
       systemPrompt: longPrompt,
       userPrompt: longPrompt,
       response: longPrompt,
       temperature: 0.5,
       maxTokens: 100,
-      purpose: 'action',
+      purpose: "action",
     });
 
     recorder.completeStep(
       trajectoryId,
-      { actionType: 'hold', parameters: {}, success: true },
-      0
+      { actionType: "hold", parameters: {}, success: true },
+      0,
     );
 
     await recorder.endTrajectory(trajectoryId);
@@ -438,15 +438,15 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
     expect(fs.existsSync(filePath)).toBe(true);
 
-    const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
     expect(content.llmCalls[0].systemPrompt.length).toBe(50000);
 
     fs.unlinkSync(filePath);
   });
 
-  test('handles negative rewards correctly', async () => {
+  test("handles negative rewards correctly", async () => {
     const trajectoryId = await recorder.startTrajectory({
-      agentId: 'test-agent',
+      agentId: "test-agent",
     });
 
     recorder.startStep(trajectoryId, {
@@ -456,14 +456,14 @@ describe('TrajectoryRecorder - Real Class Tests', () => {
     });
     recorder.completeStep(
       trajectoryId,
-      { actionType: 'buy', parameters: {}, success: false, error: 'Bad trade' },
-      -5.0
+      { actionType: "buy", parameters: {}, success: false, error: "Bad trade" },
+      -5.0,
     );
 
     await recorder.endTrajectory(trajectoryId);
 
     const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
-    const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
 
     expect(content.trajectory.totalReward).toBe(-5.0);