@elizaos/plugin-trajectory-logger 2.0.0-alpha.12 → 2.0.0-alpha.13

package/dist/node/index.node.js

@@ -1,1266 +1,191 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
 // index.ts
-import {
-  createUniqueUuid
-} from "@elizaos/core";
-import crypto from "node:crypto";
+import { createUniqueUuid } from "@elizaos/core";
 
 // TrajectoryLoggerService.ts
-import { logger, Service } from "@elizaos/core";
+import { asUUID, logger } from "@elizaos/core";
 import { v4 as uuidv4 } from "uuid";
-function asNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (typeof value === "string") {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-function asString(value) {
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number" || typeof value === "boolean")
-    return String(value);
-  if (value instanceof Date)
-    return value.toISOString();
-  return null;
-}
-function asIsoString(value) {
-  if (value instanceof Date)
-    return value.toISOString();
-  const asText = asString(value);
-  if (!asText)
-    return new Date(0).toISOString();
-  const parsed = new Date(asText);
-  if (Number.isNaN(parsed.getTime()))
-    return new Date(0).toISOString();
-  return parsed.toISOString();
-}
-function pickCell(row, ...keys) {
-  for (const key of keys) {
-    if (Object.hasOwn(row, key)) {
-      return row[key];
-    }
-  }
-  return;
-}
-function sqlLiteral(v) {
-  if (v === null || v === undefined)
-    return "NULL";
-  if (typeof v === "number")
-    return String(v);
-  if (typeof v === "boolean")
-    return v ? "TRUE" : "FALSE";
-  if (typeof v === "object")
-    return `'${JSON.stringify(v).replace(/'/g, "''")}'`;
-  return `'${String(v).replace(/'/g, "''")}'`;
-}
 
-class TrajectoryLoggerService extends Service {
-  static serviceType = "trajectory_logger";
-  get serviceType() {
-    return TrajectoryLoggerService.serviceType;
-  }
-  capabilityDescription = "Captures and persists LLM calls, provider accesses, and full trajectories for debugging, analysis, and RL training";
-  enabled = true;
-  initialized = false;
+class TrajectoryLoggerService {
+  activeTrajectories = new Map;
   activeStepIds = new Map;
-  stepToTrajectory = new Map;
-  writeQueues = new Map;
-  static async start(runtime) {
-    const service = new this(runtime);
-    await service.initialize();
-    return service;
-  }
-  async stop() {
-    this.enabled = false;
-  }
-  setEnabled(enabled) {
-    this.enabled = enabled;
-  }
-  isEnabled() {
-    return this.enabled;
-  }
-  async getSqlHelper() {
-    const drizzle = await import("drizzle-orm");
-    return drizzle.sql;
-  }
-  async executeRawSql(sqlText) {
-    const runtime = this.runtime;
-    if (!runtime?.adapter) {
-      throw new Error("Database adapter not available");
-    }
-    const sqlHelper = await this.getSqlHelper();
-    const db = runtime.adapter.db;
-    const query = sqlHelper.raw(sqlText);
-    const result = await db.execute(query);
-    const rows = Array.isArray(result.rows) ? result.rows : [];
-    const columns = result.fields && Array.isArray(result.fields) ? result.fields.map((field) => field.name) : rows.length > 0 ? Object.keys(rows[0]) : [];
-    return { rows, columns };
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    const runtime = this.runtime;
-    if (!runtime?.adapter) {
-      logger.warn("[trajectory-logger] No runtime adapter available, skipping initialization");
-      return;
-    }
-    await this.ensureTablesExist();
-    await this.backfillTrajectoriesMissingLlmCalls();
-    this.initialized = true;
-    logger.info("[trajectory-logger] Trajectory logger service initialized");
-  }
-  async getTableColumnNames(tableName) {
-    const names = new Set;
-    try {
-      const result = await this.executeRawSql(`
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_name = ${sqlLiteral(tableName)}
-          AND table_schema NOT IN ('pg_catalog', 'information_schema')
-      `);
-      for (const row of result.rows) {
-        const name = asString(pickCell(row, "column_name"));
-        if (name)
-          names.add(name);
-      }
-      if (names.size > 0)
-        return names;
-    } catch {}
-    const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, "");
-    if (!safeTableName)
-      return names;
-    try {
-      const pragma = await this.executeRawSql(`PRAGMA table_info(${safeTableName})`);
-      for (const row of pragma.rows) {
-        const name = asString(pickCell(row, "name"));
-        if (name)
-          names.add(name);
-      }
-    } catch {}
-    return names;
-  }
-  async ensureTrajectoryColumnsExist() {
-    const columns = await this.getTableColumnNames("trajectories");
-    const requiredColumns = [
-      ["scenario_id", "TEXT"],
-      ["episode_id", "TEXT"],
-      ["batch_id", "TEXT"],
-      ["group_index", "INTEGER"],
-      ["steps_json", "JSONB NOT NULL DEFAULT '[]'"],
-      ["reward_components_json", "JSONB NOT NULL DEFAULT '{}'"],
-      ["metrics_json", "JSONB NOT NULL DEFAULT '{}'"],
-      ["metadata_json", "JSONB NOT NULL DEFAULT '{}'"],
-      ["is_training_data", "BOOLEAN NOT NULL DEFAULT FALSE"],
-      ["is_evaluation", "BOOLEAN NOT NULL DEFAULT FALSE"],
-      ["used_in_training", "BOOLEAN NOT NULL DEFAULT FALSE"],
-      ["judged_at", "TIMESTAMPTZ"]
-    ];
-    for (const [columnName, definition] of requiredColumns) {
-      if (columns.has(columnName))
-        continue;
-      try {
-        await this.executeRawSql(`
-          ALTER TABLE trajectories
-          ADD COLUMN IF NOT EXISTS ${columnName} ${definition}
-        `);
-      } catch (errWithIfExists) {
-        try {
-          await this.executeRawSql(`
-            ALTER TABLE trajectories
-            ADD COLUMN ${columnName} ${definition}
-          `);
-        } catch (errPlain) {
-          const combinedMessage = `${errWithIfExists instanceof Error ? errWithIfExists.message : String(errWithIfExists)} | ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`.toLowerCase();
-          if (combinedMessage.includes("already exists") || combinedMessage.includes("duplicate column") || combinedMessage.includes("duplicate_column")) {
-            continue;
-          }
-          logger.warn(`[trajectory-logger] Failed to add trajectories.${columnName} (non-fatal): ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`);
-        }
-      }
-    }
-    for (const statement of [
-      `ALTER TABLE trajectories
-       ALTER COLUMN start_time TYPE BIGINT USING start_time::BIGINT`,
-      `ALTER TABLE trajectories
-       ALTER COLUMN end_time TYPE BIGINT USING end_time::BIGINT`,
-      `ALTER TABLE trajectories
-       ALTER COLUMN duration_ms TYPE BIGINT USING duration_ms::BIGINT`
-    ]) {
-      try {
-        await this.executeRawSql(statement);
-      } catch {}
-    }
-  }
-  async ensureTablesExist() {
-    await this.executeRawSql(`
-      CREATE TABLE IF NOT EXISTS trajectories (
-        id TEXT PRIMARY KEY,
-        agent_id TEXT NOT NULL,
-        source TEXT NOT NULL DEFAULT 'chat',
-        status TEXT NOT NULL DEFAULT 'active',
-        start_time BIGINT NOT NULL,
-        end_time BIGINT,
-        duration_ms BIGINT,
-        step_count INTEGER NOT NULL DEFAULT 0,
-        llm_call_count INTEGER NOT NULL DEFAULT 0,
-        provider_access_count INTEGER NOT NULL DEFAULT 0,
-        total_prompt_tokens INTEGER NOT NULL DEFAULT 0,
-        total_completion_tokens INTEGER NOT NULL DEFAULT 0,
-        total_reward REAL NOT NULL DEFAULT 0,
-        scenario_id TEXT,
-        episode_id TEXT,
-        batch_id TEXT,
-        group_index INTEGER,
-        steps_json JSONB NOT NULL DEFAULT '[]',
-        reward_components_json JSONB NOT NULL DEFAULT '{}',
-        metrics_json JSONB NOT NULL DEFAULT '{}',
-        metadata_json JSONB NOT NULL DEFAULT '{}',
-        is_training_data BOOLEAN NOT NULL DEFAULT FALSE,
-        is_evaluation BOOLEAN NOT NULL DEFAULT FALSE,
-        used_in_training BOOLEAN NOT NULL DEFAULT FALSE,
-        ai_judge_reward REAL,
-        ai_judge_reasoning TEXT,
-        judged_at TIMESTAMPTZ,
-        created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await this.ensureTrajectoryColumnsExist();
-    try {
-      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_agent_id ON trajectories(agent_id)`);
-      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_source ON trajectories(source)`);
-      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_status ON trajectories(status)`);
-      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_created_at ON trajectories(created_at)`);
-      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_scenario_id ON trajectories(scenario_id)`);
-      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_batch_id ON trajectories(batch_id)`);
-      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_is_training ON trajectories(is_training_data)`);
-    } catch (e) {
-      logger.warn(`[trajectory-logger] Failed to create indexes (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
-    }
-    await this.executeRawSql(`
-      CREATE TABLE IF NOT EXISTS trajectory_step_index (
-        step_id TEXT PRIMARY KEY,
-        trajectory_id TEXT NOT NULL REFERENCES trajectories(id) ON DELETE CASCADE,
-        step_number INTEGER NOT NULL DEFAULT 0,
-        is_active BOOLEAN NOT NULL DEFAULT FALSE,
-        created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectory_step_index_trajectory_id ON trajectory_step_index(trajectory_id)`);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectory_step_index_is_active ON trajectory_step_index(is_active)`);
-  }
-  normalizeTrajectoryStatus(value) {
-    switch (value) {
-      case "active":
-      case "completed":
-      case "error":
-      case "timeout":
-      case "terminated":
-        return value;
-      default:
-        return "completed";
-    }
-  }
-  async backfillTrajectoriesMissingLlmCalls() {
-    const maxRows = 2000;
-    let fixed = 0;
-    try {
-      const rows = await this.executeRawSql(`
-        SELECT id, status
-        FROM trajectories
-        WHERE COALESCE(llm_call_count, 0) = 0
-          AND status <> 'active'
-        ORDER BY created_at ASC
-        LIMIT ${maxRows}
-      `);
-      for (const row of rows.rows) {
-        const trajectoryId = asString(pickCell(row, "id"));
-        if (!trajectoryId)
-          continue;
-        const status = this.normalizeTrajectoryStatus(asString(pickCell(row, "status")));
-        await this.withTrajectoryWriteLock(trajectoryId, async () => {
-          const trajectory = await this.getTrajectoryById(trajectoryId);
-          if (!trajectory)
-            return;
-          const inserted = this.ensureAtLeastOneLlmCall(trajectory, "backfill");
-          if (!inserted)
-            return;
-          await this.persistTrajectory(trajectoryId, trajectory, status);
-          fixed += 1;
-        });
-      }
-      if (fixed > 0) {
-        logger.info(`[trajectory-logger] Backfilled ${fixed} completed trajectories with synthetic LLM calls`);
-      }
-      if (rows.rows.length >= maxRows) {
-        logger.warn(`[trajectory-logger] Backfill hit safety cap (${maxRows}); remaining older trajectories will be fixed lazily when touched`);
-      }
-    } catch (err) {
-      logger.warn(`[trajectory-logger] Failed to backfill trajectories missing LLM calls (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  normalizePurpose(value) {
-    switch (value) {
-      case "action":
-      case "reasoning":
-      case "evaluation":
-      case "response":
-      case "other":
-        return value;
-      default:
-        return "other";
-    }
-  }
-  defaultEnvironmentState(timestamp = Date.now()) {
-    return {
-      timestamp,
-      agentBalance: 0,
-      agentPoints: 0,
-      agentPnL: 0,
-      openPositions: 0
-    };
-  }
-  createPendingAction(stepTimestamp) {
-    return {
-      attemptId: "",
-      timestamp: stepTimestamp,
-      actionType: "pending",
-      actionName: "pending",
-      parameters: {},
-      success: false
-    };
-  }
-  createStep(stepId, stepNumber, envState) {
-    const timestamp = envState.timestamp || Date.now();
-    return {
-      stepId,
-      stepNumber,
-      timestamp,
-      environmentState: envState,
-      observation: {},
-      llmCalls: [],
-      providerAccesses: [],
-      action: this.createPendingAction(timestamp),
-      reward: 0,
-      done: false
-    };
-  }
-  ensureAtLeastOneLlmCall(trajectory, source) {
-    if (this.computeTotals(trajectory.steps).llmCallCount > 0) {
-      return false;
-    }
-    const timestamp = Date.now();
-    let step = trajectory.steps[trajectory.steps.length - 1];
-    if (!step) {
-      step = this.createStep(uuidv4(), 0, this.defaultEnvironmentState(timestamp));
-      step.done = true;
-      trajectory.steps.push(step);
-    }
-    if (!Array.isArray(step.llmCalls)) {
-      step.llmCalls = [];
-    }
-    const syntheticCall = {
-      callId: uuidv4(),
-      timestamp,
-      model: "milady/synthetic-trajectory-fallback",
-      systemPrompt: "[synthetic] inserted by trajectory logger because no LLM calls were captured",
-      userPrompt: "[synthetic] this trajectory completed without recorded model activity",
-      response: "[synthetic] placeholder call inserted to enforce minimum llm_call_count=1",
-      temperature: 0,
-      maxTokens: 0,
-      promptTokens: 0,
-      completionTokens: 0,
-      latencyMs: 0,
-      purpose: "other",
-      actionType: "TRAJECTORY_FALLBACK"
-    };
-    step.llmCalls.push(syntheticCall);
-    if (!step.metadata)
-      step.metadata = {};
-    step.metadata.syntheticLlmCall = true;
-    step.metadata.syntheticLlmCallSource = source;
-    trajectory.metadata.syntheticLlmCall = true;
-    trajectory.metadata.syntheticLlmCallSource = source;
-    const existingFallbackCount = trajectory.metrics.syntheticLlmFallbackCount;
-    trajectory.metrics.syntheticLlmFallbackCount = typeof existingFallbackCount === "number" && Number.isFinite(existingFallbackCount) ? existingFallbackCount + 1 : 1;
-    return true;
-  }
-  computeTotals(steps) {
-    let llmCallCount = 0;
-    let providerAccessCount = 0;
-    let totalPromptTokens = 0;
-    let totalCompletionTokens = 0;
-    for (const step of steps) {
-      const llmCalls = Array.isArray(step.llmCalls) ? step.llmCalls : [];
-      const providerAccesses = Array.isArray(step.providerAccesses) ? step.providerAccesses : [];
-      llmCallCount += llmCalls.length;
-      providerAccessCount += providerAccesses.length;
-      for (const call of llmCalls) {
-        totalPromptTokens += call.promptTokens ?? 0;
-        totalCompletionTokens += call.completionTokens ?? 0;
-      }
-    }
-    return {
-      stepCount: steps.length,
-      llmCallCount,
-      providerAccessCount,
-      totalPromptTokens,
-      totalCompletionTokens
-    };
-  }
-  async withTrajectoryWriteLock(trajectoryId, task) {
-    const previous = this.writeQueues.get(trajectoryId) ?? Promise.resolve();
-    const next = previous.catch(() => {}).then(task);
-    this.writeQueues.set(trajectoryId, next);
-    try {
-      await next;
-    } finally {
-      if (this.writeQueues.get(trajectoryId) === next) {
-        this.writeQueues.delete(trajectoryId);
-      }
-    }
-  }
-  async getTrajectoryById(trajectoryId) {
-    const result = await this.executeRawSql(`SELECT * FROM trajectories WHERE id = ${sqlLiteral(trajectoryId)} LIMIT 1`);
-    if (result.rows.length === 0)
-      return null;
-    return this.rowToTrajectory(result.rows[0]);
-  }
-  async getStepIndex(stepId) {
-    const result = await this.executeRawSql(`SELECT trajectory_id, step_number, is_active FROM trajectory_step_index WHERE step_id = ${sqlLiteral(stepId)} LIMIT 1`);
-    const row = result.rows[0];
-    if (!row)
-      return null;
-    const trajectoryId = asString(pickCell(row, "trajectory_id"));
-    if (!trajectoryId)
-      return null;
-    const stepNumber = asNumber(pickCell(row, "step_number")) ?? 0;
-    const isActiveText = asString(pickCell(row, "is_active"));
-    const isActive = isActiveText === "true" || isActiveText === "t" || pickCell(row, "is_active") === true;
-    return { trajectoryId, stepNumber, isActive };
-  }
-  async setStepIndex(stepId, trajectoryId, stepNumber, isActive) {
-    await this.executeRawSql(`
-      INSERT INTO trajectory_step_index (
-        step_id, trajectory_id, step_number, is_active, updated_at
-      ) VALUES (
-        ${sqlLiteral(stepId)},
-        ${sqlLiteral(trajectoryId)},
-        ${stepNumber},
-        ${isActive ? "TRUE" : "FALSE"},
-        CURRENT_TIMESTAMP
-      )
-      ON CONFLICT (step_id) DO UPDATE SET
-        trajectory_id = EXCLUDED.trajectory_id,
-        step_number = EXCLUDED.step_number,
-        is_active = EXCLUDED.is_active,
-        updated_at = CURRENT_TIMESTAMP
-    `);
-  }
-  async markAllStepsInactive(trajectoryId) {
-    await this.executeRawSql(`
-      UPDATE trajectory_step_index
-      SET is_active = FALSE, updated_at = CURRENT_TIMESTAMP
-      WHERE trajectory_id = ${sqlLiteral(trajectoryId)}
-    `);
-  }
-  async resolveTrajectoryId(stepIdOrTrajectoryId) {
-    const cached = this.stepToTrajectory.get(stepIdOrTrajectoryId);
-    if (cached)
-      return cached;
-    const byStep = await this.getStepIndex(stepIdOrTrajectoryId);
-    if (byStep?.trajectoryId) {
-      this.stepToTrajectory.set(stepIdOrTrajectoryId, byStep.trajectoryId);
-      return byStep.trajectoryId;
-    }
-    const byId = await this.executeRawSql(`SELECT id FROM trajectories WHERE id = ${sqlLiteral(stepIdOrTrajectoryId)} LIMIT 1`);
-    const row = byId.rows[0];
-    const id = row ? asString(pickCell(row, "id")) : null;
-    return id;
-  }
-  async getCurrentStepIdFromDb(trajectoryId) {
-    const result = await this.executeRawSql(`
-      SELECT step_id
-      FROM trajectory_step_index
-      WHERE trajectory_id = ${sqlLiteral(trajectoryId)} AND is_active = TRUE
-      ORDER BY step_number DESC, updated_at DESC
-      LIMIT 1
-    `);
-    const row = result.rows[0];
-    return row ? asString(pickCell(row, "step_id")) : null;
-  }
-  async persistTrajectory(trajectoryId, trajectory, status = "active") {
-    if (status !== "active") {
-      this.ensureAtLeastOneLlmCall(trajectory, "finalize");
-    }
-    const totals = this.computeTotals(trajectory.steps);
-    const isFinalStatus = status !== "active";
-    const persistedEndTime = isFinalStatus ? trajectory.endTime : null;
-    const persistedDuration = isFinalStatus ? trajectory.durationMs : null;
-    const updatedAtIso = new Date().toISOString();
-    try {
-      await this.executeRawSql(`
-        UPDATE trajectories SET
-          status = ${sqlLiteral(status)},
-          end_time = ${sqlLiteral(persistedEndTime)},
-          duration_ms = ${sqlLiteral(persistedDuration)},
-          step_count = ${totals.stepCount},
-          llm_call_count = ${totals.llmCallCount},
-          provider_access_count = ${totals.providerAccessCount},
-          total_prompt_tokens = ${totals.totalPromptTokens},
-          total_completion_tokens = ${totals.totalCompletionTokens},
-          total_reward = ${trajectory.totalReward},
-          steps_json = ${sqlLiteral(trajectory.steps)},
-          reward_components_json = ${sqlLiteral(trajectory.rewardComponents)},
-          metrics_json = ${sqlLiteral(trajectory.metrics)},
-          metadata_json = ${sqlLiteral(trajectory.metadata)},
-          updated_at = ${sqlLiteral(updatedAtIso)}
-        WHERE id = ${sqlLiteral(trajectoryId)}
-      `);
-    } catch (modernErr) {
-      await this.executeRawSql(`
-        UPDATE trajectories SET
-          status = ${sqlLiteral(status)},
-          end_time = ${sqlLiteral(persistedEndTime)},
-          duration_ms = ${sqlLiteral(persistedDuration)},
-          step_count = ${totals.stepCount},
-          llm_call_count = ${totals.llmCallCount},
-          provider_access_count = ${totals.providerAccessCount},
-          total_prompt_tokens = ${totals.totalPromptTokens},
-          total_completion_tokens = ${totals.totalCompletionTokens},
-          total_reward = ${trajectory.totalReward},
-          steps_json = ${sqlLiteral(trajectory.steps)},
-          metadata = ${sqlLiteral(trajectory.metadata)},
-          updated_at = ${sqlLiteral(updatedAtIso)}
-        WHERE id = ${sqlLiteral(trajectoryId)}
-      `).catch((legacyErr) => {
-        logger.warn({ err: legacyErr, trajectoryId }, `[trajectory-logger] Failed to persist trajectory update after compatibility fallback: ${modernErr instanceof Error ? modernErr.message : String(modernErr)}`);
-        throw legacyErr;
-      });
-    }
-  }
-  async ensureStepExists(trajectory, stepId) {
-    let step = trajectory.steps.find((entry) => entry.stepId === stepId);
-    if (step) {
-      if (!Array.isArray(step.llmCalls))
-        step.llmCalls = [];
-      if (!Array.isArray(step.providerAccesses))
-        step.providerAccesses = [];
-      return step;
-    }
-    const index = await this.getStepIndex(stepId);
-    const stepNumber = index?.stepNumber ?? trajectory.steps.length;
-    step = this.createStep(stepId, stepNumber, this.defaultEnvironmentState());
-    trajectory.steps.push(step);
-    trajectory.steps.sort((a, b) => a.stepNumber - b.stepNumber);
-    return step;
-  }
-  logLlmCall(params) {
-    if (!this.enabled)
-      return;
-    (async () => {
-      const trajectoryId = await this.resolveTrajectoryId(params.stepId);
-      if (!trajectoryId) {
-        logger.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for LLM call");
-        return;
-      }
-      await this.withTrajectoryWriteLock(trajectoryId, async () => {
-        const trajectory = await this.getTrajectoryById(trajectoryId);
-        if (!trajectory)
-          return;
-        const step = await this.ensureStepExists(trajectory, params.stepId);
-        const llmCall = {
-          callId: uuidv4(),
-          timestamp: Date.now(),
-          model: params.model,
-          modelVersion: params.modelVersion,
-          systemPrompt: params.systemPrompt,
-          userPrompt: params.userPrompt,
-          response: params.response,
-          reasoning: params.reasoning,
-          temperature: params.temperature,
-          maxTokens: params.maxTokens,
-          purpose: this.normalizePurpose(params.purpose),
-          actionType: params.actionType,
-          promptTokens: params.promptTokens,
-          completionTokens: params.completionTokens,
-          latencyMs: params.latencyMs
-        };
-        step.llmCalls.push(llmCall);
-        await this.persistTrajectory(trajectoryId, trajectory, "active");
-      });
-    })().catch((err) => {
-      logger.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist LLM call");
-    });
-  }
-  logLLMCall(stepId, details) {
-    this.logLlmCall({
-      stepId,
-      model: details.model,
-      modelVersion: details.modelVersion,
-      systemPrompt: details.systemPrompt,
-      userPrompt: details.userPrompt,
-      response: details.response,
-      reasoning: details.reasoning,
-      temperature: details.temperature,
-      maxTokens: details.maxTokens,
-      purpose: details.purpose,
-      actionType: details.actionType ?? "",
-      latencyMs: details.latencyMs ?? 0,
-      promptTokens: details.promptTokens,
-      completionTokens: details.completionTokens
-    });
-  }
-  logProviderAccess(arg1, arg2) {
-    if (!this.enabled)
-      return;
-    const params = typeof arg1 === "string" ? {
-      stepId: arg1,
-      providerName: arg2?.providerName ?? "unknown",
-      data: arg2?.data ?? {},
-      purpose: arg2?.purpose ?? "other",
-      query: arg2?.query
-    } : arg1;
-    (async () => {
-      const trajectoryId = await this.resolveTrajectoryId(params.stepId);
-      if (!trajectoryId) {
-        logger.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for provider access");
-        return;
-      }
-      await this.withTrajectoryWriteLock(trajectoryId, async () => {
-        const trajectory = await this.getTrajectoryById(trajectoryId);
-        if (!trajectory)
-          return;
-        const step = await this.ensureStepExists(trajectory, params.stepId);
-        const access = {
-          providerId: uuidv4(),
-          providerName: params.providerName,
-          timestamp: Date.now(),
-          data: params.data,
-          query: params.query,
-          purpose: params.purpose
-        };
-        step.providerAccesses.push(access);
-        await this.persistTrajectory(trajectoryId, trajectory, "active");
-      });
-    })().catch((err) => {
-      logger.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist provider access");
-    });
-  }
-  logProviderAccessByTrajectoryId(trajectoryId, access) {
-    const stepId = this.getCurrentStepId(trajectoryId);
-    if (!stepId) {
-      logger.debug({ trajectoryId }, "[trajectory-logger] No active step for provider access by trajectory");
-      return;
-    }
-    this.logProviderAccess(stepId, access);
-  }
-  async startTrajectory(stepIdOrAgentId, options = {}) {
-    if (!this.enabled)
-      return uuidv4();
-    const legacyStepId = typeof options.agentId === "string" && options.agentId.length > 0 ? stepIdOrAgentId : null;
-    const agentId = (typeof options.agentId === "string" && options.agentId.length > 0 ? options.agentId : stepIdOrAgentId) ?? stepIdOrAgentId;
+  startTrajectory(agentId, options = {}) {
     const trajectoryId = uuidv4();
     const now = Date.now();
-    const timestampIso = new Date(now).toISOString();
-    const metadata = {
-      ...options.metadata ?? {}
-    };
-    if (options.roomId)
-      metadata.roomId = options.roomId;
-    if (options.entityId)
-      metadata.entityId = options.entityId;
     const trajectory = {
-      trajectoryId,
-      agentId,
+      trajectoryId: asUUID(trajectoryId),
+      agentId: asUUID(agentId),
       startTime: now,
       endTime: now,
       durationMs: 0,
-      scenarioId: options.scenarioId,
       episodeId: options.episodeId,
+      scenarioId: options.scenarioId,
       batchId: options.batchId,
       groupIndex: options.groupIndex,
       steps: [],
       totalReward: 0,
-      rewardComponents: { environmentReward: 0 },
+      rewardComponents: {
+        environmentReward: 0
+      },
       metrics: {
         episodeLength: 0,
         finalStatus: "completed"
       },
-      metadata: {
-        source: options.source ?? "chat",
-        ...metadata
-      }
+      metadata: options.metadata || {}
     };
-    let persistedStart = false;
-    try {
-      await this.executeRawSql(`
-        INSERT INTO trajectories (
-          id, agent_id, source, status, start_time, scenario_id, episode_id,
-          batch_id, group_index, metadata_json, steps_json, reward_components_json, metrics_json,
-          created_at, updated_at
-        ) VALUES (
-          ${sqlLiteral(trajectoryId)},
-          ${sqlLiteral(agentId)},
-          ${sqlLiteral(options.source ?? "chat")},
-          'active',
-          ${now},
-          ${sqlLiteral(options.scenarioId ?? null)},
-          ${sqlLiteral(options.episodeId ?? null)},
-          ${sqlLiteral(options.batchId ?? null)},
-          ${options.groupIndex ?? "NULL"},
-          ${sqlLiteral(trajectory.metadata)},
-          ${sqlLiteral([])},
-          ${sqlLiteral(trajectory.rewardComponents)},
-          ${sqlLiteral(trajectory.metrics)},
-          ${sqlLiteral(timestampIso)},
-          ${sqlLiteral(timestampIso)}
-        )
-      `);
-      persistedStart = true;
-    } catch (err) {
-      try {
-        await this.executeRawSql(`
-          INSERT INTO trajectories (
-            id, agent_id, source, status, start_time, steps_json, metadata, created_at, updated_at
-          ) VALUES (
-            ${sqlLiteral(trajectoryId)},
-            ${sqlLiteral(agentId)},
-            ${sqlLiteral(options.source ?? "chat")},
-            'active',
-            ${now},
-            ${sqlLiteral([])},
-            ${sqlLiteral(trajectory.metadata)},
-            ${sqlLiteral(timestampIso)},
-            ${sqlLiteral(timestampIso)}
-          )
-        `);
-        persistedStart = true;
-      } catch (legacyErr) {
-        logger.warn({ err: legacyErr, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
-      }
-    }
-    if (persistedStart && legacyStepId) {
-      this.stepToTrajectory.set(legacyStepId, trajectoryId);
-      try {
-        await this.setStepIndex(legacyStepId, trajectoryId, -1, false);
-      } catch (indexErr) {
-        logger.warn({ err: indexErr, trajectoryId, stepId: legacyStepId }, "[trajectory-logger] Failed to persist step index for trajectory start");
-      }
-    }
+    this.activeTrajectories.set(trajectoryId, trajectory);
     return trajectoryId;
   }
   startStep(trajectoryId, envState) {
-    if (!this.enabled)
-      return uuidv4();
     const stepId = uuidv4();
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      throw new Error(`Trajectory ${trajectoryId} not found`);
+    }
+    const step = {
+      stepId: asUUID(stepId),
+      stepNumber: trajectory.steps.length,
+      timestamp: envState.timestamp || Date.now(),
+      environmentState: envState,
+      observation: {},
+      llmCalls: [],
+      providerAccesses: [],
+      action: {
+        attemptId: "",
+        timestamp: 0,
+        actionType: "pending",
+        actionName: "pending",
+        parameters: {},
+        success: false
+      },
+      reward: 0,
+      done: false
+    };
+    trajectory.steps.push(step);
     this.activeStepIds.set(trajectoryId, stepId);
-    this.stepToTrajectory.set(stepId, trajectoryId);
-    this.withTrajectoryWriteLock(trajectoryId, async () => {
-      const trajectory = await this.getTrajectoryById(trajectoryId);
-      if (!trajectory) {
-        logger.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
-        return;
-      }
-      const step = this.createStep(stepId, trajectory.steps.length, envState);
-      trajectory.steps.push(step);
-      await this.markAllStepsInactive(trajectoryId);
-      await this.setStepIndex(stepId, trajectoryId, step.stepNumber, true);
-      await this.persistTrajectory(trajectoryId, trajectory, "active");
-    }).catch((err) => {
-      logger.warn({ err, trajectoryId, stepId }, "[trajectory-logger] Failed to persist startStep");
-    });
     return stepId;
   }
-  completeStep(trajectoryId, actionOrStepId, actionOrReward, maybeReward) {
-    if (!this.enabled)
+  logLLMCall(stepId, llmCall) {
+    const trajectory = this.findTrajectoryByStepId(stepId);
+    if (!trajectory) {
+      logger.warn({ stepId }, "Trajectory not found for LLM call");
       return;
-    const explicitStepId = typeof actionOrStepId === "string" ? actionOrStepId : null;
-    const action = typeof actionOrStepId === "string" ? actionOrReward : actionOrStepId;
-    const rewardInfo = typeof actionOrStepId === "string" ? maybeReward : actionOrReward;
-    if (!action)
+    }
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger.warn({ stepId }, "Step not found for LLM call");
       return;
-    this.withTrajectoryWriteLock(trajectoryId, async () => {
-      const trajectory = await this.getTrajectoryById(trajectoryId);
-      if (!trajectory)
-        return;
-      const stepId = explicitStepId ?? this.activeStepIds.get(trajectoryId) ?? await this.getCurrentStepIdFromDb(trajectoryId);
-      if (!stepId)
-        return;
-      const step = await this.ensureStepExists(trajectory, stepId);
-      step.action = {
-        attemptId: uuidv4(),
-        timestamp: Date.now(),
-        ...action
-      };
-      step.done = true;
-      if (rewardInfo?.reward !== undefined) {
-        step.reward = rewardInfo.reward;
-        trajectory.totalReward += rewardInfo.reward;
-      }
-      if (rewardInfo?.components) {
-        trajectory.rewardComponents = {
-          ...trajectory.rewardComponents,
-          ...rewardInfo.components
-        };
-      }
-      await this.setStepIndex(stepId, trajectoryId, step.stepNumber, false);
-      this.activeStepIds.delete(trajectoryId);
-      await this.persistTrajectory(trajectoryId, trajectory, "active");
-    }).catch((err) => {
-      logger.warn({ err, trajectoryId }, "[trajectory-logger] Failed to complete step");
-    });
+    }
+    const fullLLMCall = {
+      callId: uuidv4(),
+      timestamp: Date.now(),
+      ...llmCall
+    };
+    step.llmCalls.push(fullLLMCall);
   }
-  async endTrajectory(stepIdOrTrajectoryId, status = "completed", finalMetrics) {
-    if (!this.enabled)
-      return;
-    const trajectoryId = await this.resolveTrajectoryId(stepIdOrTrajectoryId);
-    if (!trajectoryId) {
-      logger.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No trajectory to end");
+  logProviderAccess(stepId, access) {
+    const trajectory = this.findTrajectoryByStepId(stepId);
+    if (!trajectory) {
+      logger.warn({ stepId }, "Trajectory not found for provider access");
       return;
     }
-    await this.withTrajectoryWriteLock(trajectoryId, async () => {
-      const trajectory = await this.getTrajectoryById(trajectoryId);
-      if (!trajectory) {
-        logger.debug({ trajectoryId }, "[trajectory-logger] Trajectory not found while ending");
-        return;
-      }
-      const now = Date.now();
-      trajectory.endTime = now;
-      trajectory.durationMs = now - trajectory.startTime;
-      trajectory.metrics.finalStatus = status;
-      trajectory.metrics.episodeLength = trajectory.steps.length;
-      if (finalMetrics) {
-        trajectory.metrics = {
-          ...trajectory.metrics,
-          ...finalMetrics
-        };
-      }
-      await this.markAllStepsInactive(trajectoryId);
-      this.activeStepIds.delete(trajectoryId);
-      await this.persistTrajectory(trajectoryId, trajectory, status);
-    });
-    for (const [stepId, mappedTrajectoryId] of this.stepToTrajectory.entries()) {
-      if (mappedTrajectoryId === trajectoryId) {
-        this.stepToTrajectory.delete(stepId);
-      }
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger.warn({ stepId }, "Step not found for provider access");
+      return;
     }
+    const fullAccess = {
+      providerId: uuidv4(),
+      timestamp: Date.now(),
+      ...access
+    };
+    step.providerAccesses.push(fullAccess);
   }
-  async listTrajectories(options = {}) {
-    const runtime = this.runtime;
-    if (!runtime?.adapter) {
-      return { trajectories: [], total: 0, offset: 0, limit: 50 };
-    }
-    const offset = Math.max(0, options.offset ?? 0);
-    const limit = Math.min(500, Math.max(1, options.limit ?? 50));
-    const whereClauses = [];
-    if (options.status) {
-      whereClauses.push(`status = ${sqlLiteral(options.status)}`);
-    }
-    if (options.source) {
-      whereClauses.push(`source = ${sqlLiteral(options.source)}`);
-    }
-    if (options.scenarioId) {
-      whereClauses.push(`scenario_id = ${sqlLiteral(options.scenarioId)}`);
-    }
-    if (options.batchId) {
-      whereClauses.push(`batch_id = ${sqlLiteral(options.batchId)}`);
-    }
-    if (options.isTrainingData !== undefined) {
-      whereClauses.push(`is_training_data = ${options.isTrainingData}`);
-    }
-    if (options.startDate) {
-      whereClauses.push(`created_at >= ${sqlLiteral(options.startDate)}::timestamptz`);
-    }
-    if (options.endDate) {
-      whereClauses.push(`created_at <= ${sqlLiteral(options.endDate)}::timestamptz`);
-    }
-    if (options.search) {
-      const escaped = options.search.replace(/'/g, "''").replace(/%/g, "\\%");
-      whereClauses.push(`(
-        id ILIKE '%${escaped}%' OR
-        agent_id ILIKE '%${escaped}%' OR
-        source ILIKE '%${escaped}%' OR
-        scenario_id ILIKE '%${escaped}%'
-      )`);
+  logLLMCallByTrajectoryId(trajectoryId, llmCall) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger.warn({ trajectoryId }, "No active step for trajectory");
+      return;
     }
-    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-    const countResult = await this.executeRawSql(`SELECT count(*)::int AS total FROM trajectories ${whereClause}`);
-    const total = asNumber(pickCell(countResult.rows[0] ?? {}, "total")) ?? 0;
-    const rowsResult = await this.executeRawSql(`
-      SELECT
-        id, agent_id, source, status, start_time, end_time, duration_ms,
-        step_count, llm_call_count, total_prompt_tokens, total_completion_tokens,
-        total_reward, scenario_id, batch_id, created_at
-      FROM trajectories
-      ${whereClause}
-      ORDER BY created_at DESC
-      LIMIT ${limit} OFFSET ${offset}
-    `);
-    const trajectories = rowsResult.rows.map((row) => {
-      const status = asString(pickCell(row, "status")) ?? "completed";
-      const rawLlmCallCount = asNumber(pickCell(row, "llm_call_count")) ?? 0;
-      const llmCallCount = status === "active" ? rawLlmCallCount : Math.max(1, rawLlmCallCount);
-      return {
-        id: asString(pickCell(row, "id")) ?? "",
-        agentId: asString(pickCell(row, "agent_id")) ?? "",
-        source: asString(pickCell(row, "source")) ?? "chat",
-        status,
-        startTime: asNumber(pickCell(row, "start_time")) ?? 0,
-        endTime: asNumber(pickCell(row, "end_time")),
-        durationMs: asNumber(pickCell(row, "duration_ms")),
-        stepCount: asNumber(pickCell(row, "step_count")) ?? 0,
-        llmCallCount,
-        totalPromptTokens: asNumber(pickCell(row, "total_prompt_tokens")) ?? 0,
-        totalCompletionTokens: asNumber(pickCell(row, "total_completion_tokens")) ?? 0,
-        totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
-        scenarioId: asString(pickCell(row, "scenario_id")),
-        batchId: asString(pickCell(row, "batch_id")),
-        createdAt: asIsoString(pickCell(row, "created_at"))
-      };
-    });
-    return { trajectories, total, offset, limit };
+    this.logLLMCall(stepId, llmCall);
   }
-  async getTrajectoryDetail(trajectoryId) {
-    const runtime = this.runtime;
-    if (!runtime?.adapter)
-      return null;
-    const safeId = trajectoryId.replace(/'/g, "''");
-    const result = await this.executeRawSql(`SELECT * FROM trajectories WHERE id = '${safeId}' LIMIT 1`);
-    if (result.rows.length === 0)
-      return null;
-    const row = result.rows[0];
-    const trajectory = this.rowToTrajectory(row);
-    const status = this.normalizeTrajectoryStatus(asString(pickCell(row, "status")));
-    if (status !== "active") {
-      const inserted = this.ensureAtLeastOneLlmCall(trajectory, "backfill");
-      if (inserted) {
-        await this.withTrajectoryWriteLock(trajectoryId, async () => {
-          await this.persistTrajectory(trajectoryId, trajectory, status);
-        });
-      }
+  logProviderAccessByTrajectoryId(trajectoryId, access) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger.warn({ trajectoryId }, "No active step for trajectory");
+      return;
     }
-    return trajectory;
+    this.logProviderAccess(stepId, access);
   }
-  async getStats() {
-    const runtime = this.runtime;
-    if (!runtime?.adapter) {
-      return {
-        totalTrajectories: 0,
-        totalSteps: 0,
-        totalLlmCalls: 0,
-        totalPromptTokens: 0,
-        totalCompletionTokens: 0,
-        averageDurationMs: 0,
-        averageReward: 0,
-        bySource: {},
-        byStatus: {},
-        byScenario: {}
-      };
-    }
-    const statsResult = await this.executeRawSql(`
-      SELECT
-        count(*)::int AS total_trajectories,
-        COALESCE(sum(step_count), 0)::int AS total_steps,
-        COALESCE(sum(llm_call_count), 0)::int AS total_llm_calls,
-        COALESCE(sum(total_prompt_tokens), 0)::int AS total_prompt_tokens,
-        COALESCE(sum(total_completion_tokens), 0)::int AS total_completion_tokens,
-        COALESCE(avg(duration_ms), 0)::int AS avg_duration_ms,
-        COALESCE(avg(total_reward), 0)::real AS avg_reward
-      FROM trajectories
-    `);
-    const sourceResult = await this.executeRawSql(`
-      SELECT source, count(*)::int AS cnt
-      FROM trajectories
-      GROUP BY source
-    `);
-    const statusResult = await this.executeRawSql(`
-      SELECT status, count(*)::int AS cnt
-      FROM trajectories
-      GROUP BY status
-    `);
-    const scenarioResult = await this.executeRawSql(`
-      SELECT scenario_id, count(*)::int AS cnt
-      FROM trajectories
-      WHERE scenario_id IS NOT NULL
-      GROUP BY scenario_id
-    `);
-    const stats = statsResult.rows[0] ?? {};
-    const bySource = {};
-    const byStatus = {};
-    const byScenario = {};
-    for (const row of sourceResult.rows) {
-      const source = asString(pickCell(row, "source"));
-      const cnt = asNumber(pickCell(row, "cnt"));
-      if (source && cnt !== null)
-        bySource[source] = cnt;
-    }
-    for (const row of statusResult.rows) {
-      const status = asString(pickCell(row, "status"));
-      const cnt = asNumber(pickCell(row, "cnt"));
-      if (status && cnt !== null)
-        byStatus[status] = cnt;
+  getCurrentStepId(trajectoryId) {
+    return this.activeStepIds.get(trajectoryId) || null;
+  }
+  completeStep(trajectoryId, stepId, action, rewardInfo) {
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      logger.warn({ trajectoryId }, "Trajectory not found for completeStep");
+      return;
     }
-    for (const row of scenarioResult.rows) {
-      const scenario = asString(pickCell(row, "scenario_id"));
-      const cnt = asNumber(pickCell(row, "cnt"));
-      if (scenario && cnt !== null)
-        byScenario[scenario] = cnt;
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger.warn({ trajectoryId, stepId }, "Step not found for completeStep");
+      return;
     }
-    return {
-      totalTrajectories: asNumber(pickCell(stats, "total_trajectories")) ?? 0,
-      totalSteps: asNumber(pickCell(stats, "total_steps")) ?? 0,
-      totalLlmCalls: asNumber(pickCell(stats, "total_llm_calls")) ?? 0,
-      totalPromptTokens: asNumber(pickCell(stats, "total_prompt_tokens")) ?? 0,
-      totalCompletionTokens: asNumber(pickCell(stats, "total_completion_tokens")) ?? 0,
-      averageDurationMs: asNumber(pickCell(stats, "avg_duration_ms")) ?? 0,
-      averageReward: asNumber(pickCell(stats, "avg_reward")) ?? 0,
-      bySource,
-      byStatus,
-      byScenario
+    step.action = {
+      attemptId: uuidv4(),
+      timestamp: Date.now(),
+      ...action
     };
-  }
-  async deleteTrajectories(trajectoryIds) {
-    const runtime = this.runtime;
-    if (!runtime?.adapter)
-      return 0;
-    if (trajectoryIds.length === 0)
-      return 0;
-    const ids = trajectoryIds.map(sqlLiteral).join(", ");
-    const result = await this.executeRawSql(`DELETE FROM trajectories WHERE id IN (${ids}) RETURNING id`);
-    return result.rows.length;
-  }
-  async clearAllTrajectories() {
-    const runtime = this.runtime;
-    if (!runtime?.adapter)
-      return 0;
-    const countResult = await this.executeRawSql(`SELECT count(*)::int AS cnt FROM trajectories`);
-    const count = asNumber(pickCell(countResult.rows[0] ?? {}, "cnt")) ?? 0;
-    await this.executeRawSql(`DELETE FROM trajectories`);
-    return count;
-  }
-  sanitizeZipFolderName(value) {
-    const sanitized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
-    return sanitized || "trajectory";
-  }
-  redactTrajectoryPrompts(trajectory) {
-    return {
-      ...trajectory,
-      steps: trajectory.steps.map((step) => ({
-        ...step,
-        llmCalls: step.llmCalls.map((call) => ({
-          ...call,
-          systemPrompt: "[redacted]",
-          userPrompt: "[redacted]",
-          response: "[redacted]"
-        }))
-      }))
-    };
-  }
-  buildZipSummary(trajectory) {
-    const finalStatus = trajectory.metrics?.finalStatus ?? "completed";
-    const normalizedEndTime = typeof trajectory.endTime === "number" && trajectory.endTime > 0 ? trajectory.endTime : null;
-    const status = finalStatus === "timeout" || finalStatus === "terminated" || finalStatus === "error" ? "error" : finalStatus === "completed" ? "completed" : normalizedEndTime ? "completed" : "active";
-    let llmCallCount = 0;
-    let providerAccessCount = 0;
-    let totalPromptTokens = 0;
-    let totalCompletionTokens = 0;
-    for (const step of trajectory.steps) {
-      providerAccessCount += step.providerAccesses.length;
-      llmCallCount += step.llmCalls.length;
-      for (const call of step.llmCalls) {
-        totalPromptTokens += call.promptTokens ?? 0;
-        totalCompletionTokens += call.completionTokens ?? 0;
-      }
+    if (rewardInfo?.reward !== undefined) {
+      step.reward = rewardInfo.reward;
+      trajectory.totalReward += rewardInfo.reward;
+    }
+    if (rewardInfo?.components) {
+      trajectory.rewardComponents = {
+        ...trajectory.rewardComponents,
+        ...rewardInfo.components
+      };
     }
-    const metadata = trajectory.metadata ?? {};
-    const asNullableString = (value) => typeof value === "string" ? value : null;
-    const source = typeof metadata.source === "string" ? metadata.source : "chat";
-    const normalizedDurationMs = status === "active" ? null : typeof trajectory.durationMs === "number" ? trajectory.durationMs : null;
-    const updatedAtMs = normalizedEndTime ?? (trajectory.startTime || Date.now());
-    return {
-      id: trajectory.trajectoryId,
-      agentId: trajectory.agentId,
-      roomId: asNullableString(metadata.roomId),
-      entityId: asNullableString(metadata.entityId),
-      conversationId: asNullableString(metadata.conversationId),
-      source,
-      status,
-      startTime: trajectory.startTime,
-      endTime: normalizedEndTime,
-      durationMs: normalizedDurationMs,
-      llmCallCount,
-      providerAccessCount,
-      totalPromptTokens,
-      totalCompletionTokens,
-      metadata,
-      createdAt: new Date(trajectory.startTime).toISOString(),
-      updatedAt: new Date(updatedAtMs).toISOString()
-    };
+    this.activeStepIds.delete(trajectoryId);
   }
-  async exportTrajectoriesZip(options = {}) {
-    let targetIds = Array.isArray(options.trajectoryIds) ? options.trajectoryIds.filter((id) => typeof id === "string" && id.trim().length > 0) : [];
-    if (targetIds.length === 0) {
-      const list = await this.listTrajectories({
-        limit: 500,
-        startDate: options.startDate,
-        endDate: options.endDate,
-        scenarioId: options.scenarioId,
-        batchId: options.batchId
-      });
-      targetIds = list.trajectories.map((trajectory) => trajectory.id);
-    }
-    const entries = [];
-    const manifestRows = [];
-    for (const trajectoryId of targetIds) {
-      const detail = await this.getTrajectoryDetail(trajectoryId);
-      if (!detail)
-        continue;
-      const exportTrajectory = options.includePrompts === false ? this.redactTrajectoryPrompts(detail) : detail;
-      const summary = this.buildZipSummary(exportTrajectory);
-      const folderName = this.sanitizeZipFolderName(trajectoryId);
-      entries.push({
-        name: `${folderName}/trajectory.json`,
-        data: JSON.stringify(exportTrajectory, null, 2)
-      });
-      entries.push({
-        name: `${folderName}/summary.json`,
-        data: JSON.stringify(summary, null, 2)
-      });
-      manifestRows.push({
-        trajectoryId,
-        folder: folderName,
-        createdAt: summary.createdAt
-      });
+  completeCurrentStep(trajectoryId, action, rewardInfo) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger.warn({ trajectoryId }, "No active step for trajectory");
+      return;
     }
-    entries.unshift({
-      name: "manifest.json",
-      data: JSON.stringify({
-        exportedAt: new Date().toISOString(),
-        trajectories: manifestRows
-      }, null, 2)
-    });
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    return {
-      filename: `trajectories-${timestamp}.zip`,
-      entries
-    };
+    this.completeStep(trajectoryId, stepId, action, rewardInfo);
   }
-  async exportTrajectories(options) {
-    const runtime = this.runtime;
-    if (!runtime?.adapter) {
-      throw new Error("Database not available");
-    }
-    const whereClauses = [];
-    if (options.trajectoryIds && options.trajectoryIds.length > 0) {
-      const ids = options.trajectoryIds.map(sqlLiteral).join(", ");
-      whereClauses.push(`id IN (${ids})`);
-    }
-    if (options.startDate) {
-      whereClauses.push(`created_at >= ${sqlLiteral(options.startDate)}::timestamptz`);
-    }
-    if (options.endDate) {
-      whereClauses.push(`created_at <= ${sqlLiteral(options.endDate)}::timestamptz`);
-    }
-    if (options.scenarioId) {
-      whereClauses.push(`scenario_id = ${sqlLiteral(options.scenarioId)}`);
-    }
-    if (options.batchId) {
-      whereClauses.push(`batch_id = ${sqlLiteral(options.batchId)}`);
+  async endTrajectory(trajectoryId, status, finalMetrics) {
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      logger.warn({ trajectoryId }, "Trajectory not found for endTrajectory");
+      return;
     }
-    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-    const result = await this.executeRawSql(`SELECT * FROM trajectories ${whereClause} ORDER BY created_at DESC`);
-    const trajectories = result.rows.map((row) => this.rowToTrajectory(row));
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    if (options.format === "csv") {
-      const lines = [
-        "id,agent_id,source,status,start_time,end_time,duration_ms,step_count,llm_call_count,total_reward,scenario_id"
-      ];
-      for (const t of trajectories) {
-        lines.push([
-          t.trajectoryId,
-          t.agentId,
-          t.metadata.source ?? "chat",
-          t.metrics.finalStatus,
-          t.startTime,
-          t.endTime,
-          t.durationMs,
-          t.steps.length,
-          t.steps.reduce((sum, s) => sum + s.llmCalls.length, 0),
-          t.totalReward,
-          t.scenarioId ?? ""
-        ].join(","));
-      }
-      return {
-        data: lines.join(`
-`),
-        filename: `trajectories-${timestamp}.csv`,
-        mimeType: "text/csv"
+    trajectory.endTime = Date.now();
+    trajectory.durationMs = trajectory.endTime - trajectory.startTime;
+    trajectory.metrics.finalStatus = status;
+    trajectory.metrics.episodeLength = trajectory.steps.length;
+    if (finalMetrics) {
+      trajectory.metrics = {
+        ...trajectory.metrics,
+        ...finalMetrics
       };
     }
-    let exportData = trajectories;
-    if (!options.includePrompts) {
-      exportData = trajectories.map((trajectory) => this.redactTrajectoryPrompts(trajectory));
-    }
-    return {
-      data: JSON.stringify(exportData, null, 2),
-      filename: `trajectories-${timestamp}.json`,
-      mimeType: "application/json"
-    };
-  }
-  rowToTrajectory(row) {
-    const parseJson = (cell, fallback) => {
-      if (typeof cell === "string") {
-        try {
-          return JSON.parse(cell);
-        } catch {
-          return fallback;
-        }
-      }
-      if (typeof cell === "object" && cell !== null && !Array.isArray(cell)) {
-        return cell;
-      }
-      return fallback;
-    };
-    return {
-      trajectoryId: asString(pickCell(row, "id")) ?? "",
-      agentId: asString(pickCell(row, "agent_id")) ?? "",
-      startTime: asNumber(pickCell(row, "start_time")) ?? 0,
-      endTime: asNumber(pickCell(row, "end_time")) ?? 0,
-      durationMs: asNumber(pickCell(row, "duration_ms")) ?? 0,
-      scenarioId: asString(pickCell(row, "scenario_id")) ?? undefined,
-      episodeId: asString(pickCell(row, "episode_id")) ?? undefined,
-      batchId: asString(pickCell(row, "batch_id")) ?? undefined,
-      groupIndex: asNumber(pickCell(row, "group_index")) ?? undefined,
-      steps: parseJson(pickCell(row, "steps_json", "steps"), []),
-      totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
-      rewardComponents: parseJson(pickCell(row, "reward_components_json", "reward_components"), { environmentReward: 0 }),
-      metrics: parseJson(pickCell(row, "metrics_json", "metrics"), {
-        episodeLength: 0,
-        finalStatus: "completed"
-      }),
-      metadata: parseJson(pickCell(row, "metadata_json", "metadata"), {})
-    };
+    this.activeStepIds.delete(trajectoryId);
   }
   getActiveTrajectory(trajectoryId) {
-    return null;
-  }
-  getCurrentStepId(trajectoryId) {
-    return this.activeStepIds.get(trajectoryId) || null;
-  }
-  getProviderAccessLogs() {
-    return [];
+    return this.activeTrajectories.get(trajectoryId) || null;
   }
-  getLlmCallLogs() {
-    return [];
+  findTrajectoryByStepId(stepId) {
+    for (const trajectory of this.activeTrajectories.values()) {
+      if (trajectory.steps.some((s) => s.stepId === stepId)) {
+        return trajectory;
+      }
+    }
+    return null;
   }
 }
+
 // action-interceptor.ts
 import { logger as logger2 } from "@elizaos/core";
 var trajectoryContexts = new WeakMap;
@@ -1718,8 +643,8 @@ async function buildGameStateFromDB(_trajectoryId) {
 async function recomputeTrajectoryRewards(_trajectoryIds) {}
 // integration.ts
 import { logger as logger3 } from "@elizaos/core";
-async function startAutonomousTick(trajectoryLogger, context) {
-  const trajectoryId = await trajectoryLogger.startTrajectory(context.agentId, {
+function startAutonomousTick(trajectoryLogger, context) {
+  const trajectoryId = trajectoryLogger.startTrajectory(context.agentId, {
     scenarioId: context.scenarioId,
     episodeId: context.episodeId,
     batchId: context.batchId,
@@ -1884,9 +809,7 @@ var trajectoryLoggerPlugin = {
         if (!message || !runtime)
           return;
         if (!message.metadata) {
-          message.metadata = {
-            type: "message"
-          };
+          message.metadata = { type: "message" };
         }
         const meta = message.metadata;
         const logger4 = runtime.getService("trajectory_logger");
@@ -1918,17 +841,13 @@ var trajectoryLoggerPlugin = {
             trajectoryStepId = normalizedStepId;
             meta.trajectoryStepId = trajectoryStepId;
             pendingTrajectoryEndTargetByStepId.set(trajectoryStepId, normalizedTrajectoryId);
-          } else {}
+          }
           if (message.id) {
             const replyId = createUniqueUuid(runtime, message.id);
             pendingTrajectoryStepByReplyId.set(replyId, trajectoryStepId);
           }
         } catch (err) {
-          runtime.logger?.warn({
-            err,
-            src: "plugin-trajectory-logger",
-            roomId: message.roomId
-          }, "Failed to start trajectory logging");
+          runtime.logger?.warn({ err, src: "plugin-trajectory-logger", roomId: message.roomId }, "Failed to start trajectory logging");
         }
       }
     ],
@@ -1952,11 +871,7 @@ var trajectoryLoggerPlugin = {
           const endTarget = pendingTrajectoryEndTargetByStepId.get(trajectoryStepId) ?? trajectoryStepId;
           await logger4.endTrajectory(endTarget, "completed");
         } catch (err) {
-          runtime.logger?.warn({
-            err,
-            src: "plugin-trajectory-logger",
-            trajectoryStepId
-          }, "Failed to end trajectory logging");
+          runtime.logger?.warn({ err, src: "plugin-trajectory-logger", trajectoryStepId }, "Failed to end trajectory logging");
         }
         if (inReplyTo) {
           pendingTrajectoryStepByReplyId.delete(inReplyTo);
@@ -2007,4 +922,4 @@ export {
   RewardService
 };
 
-//# debugId=C01EFBED6D31A62B64756E2164756E21
+//# debugId=F0E0006C38150F8464756E2164756E21