@elizaos/plugin-trajectory-logger 2.0.0-alpha.1

package/dist/node/index.node.js

@@ -0,0 +1,841 @@
+// action-interceptor.ts
+import { logger } from "@elizaos/core";
+var trajectoryContexts = new WeakMap;
+function setTrajectoryContext(runtime, trajectoryId, trajectoryLogger) {
+  trajectoryContexts.set(runtime, { trajectoryId, logger: trajectoryLogger });
+}
+function getTrajectoryContext(runtime) {
+  return trajectoryContexts.get(runtime) || null;
+}
+function clearTrajectoryContext(runtime) {
+  trajectoryContexts.delete(runtime);
+}
+function wrapActionWithLogging(action, _trajectoryLogger) {
+  const originalHandler = action.handler;
+  return {
+    ...action,
+    handler: async (runtime, message, state, options, callback) => {
+      const context = getTrajectoryContext(runtime);
+      if (!context) {
+        const result = await originalHandler(runtime, message, state, options, callback);
+        return result ?? undefined;
+      }
+      const { trajectoryId, logger: loggerService } = context;
+      const stepId = loggerService.getCurrentStepId(trajectoryId);
+      if (!stepId) {
+        logger.warn({ action: action.name, trajectoryId }, "No active step for action execution");
+        const result = await originalHandler(runtime, message, state, options, callback);
+        return result ?? undefined;
+      }
+      const successHandler = () => {
+        const stateSnapshot = state ? JSON.parse(JSON.stringify(state)) : null;
+        loggerService.completeStep(trajectoryId, stepId, {
+          actionType: action.name,
+          actionName: action.name,
+          parameters: {
+            message: message.content.text || "",
+            state: stateSnapshot
+          },
+          success: true,
+          result: { executed: true },
+          reasoning: `Action ${action.name} executed via ${action.description || "handler"}`
+        }, { reward: 0.1 });
+      };
+      const errorHandler = (err) => {
+        const error = err instanceof Error ? err.message : typeof err === "string" ? err : err.message || String(err);
+        logger.error({ action: action.name, trajectoryId, error }, "Action execution failed");
+        const stateSnapshot = state ? JSON.parse(JSON.stringify(state)) : null;
+        loggerService.completeStep(trajectoryId, stepId, {
+          actionType: action.name,
+          actionName: action.name,
+          parameters: {
+            message: message.content.text || "",
+            state: stateSnapshot
+          },
+          success: false,
+          result: { error },
+          reasoning: `Action ${action.name} failed: ${error}`
+        }, { reward: -0.1 });
+        throw err;
+      };
+      try {
+        const result = await originalHandler(runtime, message, state, options, callback);
+        successHandler();
+        return result ?? undefined;
+      } catch (err) {
+        if (err instanceof Error) {
+          return errorHandler(err);
+        }
+        if (typeof err === "string") {
+          return errorHandler(err);
+        }
+        return errorHandler(err);
+      }
+    }
+  };
+}
+function wrapPluginActions(plugin, trajectoryLogger) {
+  if (!plugin.actions || plugin.actions.length === 0) {
+    return plugin;
+  }
+  return {
+    ...plugin,
+    actions: plugin.actions.map((action) => wrapActionWithLogging(action, trajectoryLogger))
+  };
+}
+function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
+  const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
+  if (!stepId) {
+    logger.warn({ trajectoryId }, "No active step for LLM call from action");
+    return;
+  }
+  trajectoryLogger.logLLMCall(stepId, {
+    model: actionContext.model || "unknown",
+    systemPrompt: actionContext.systemPrompt || "",
+    userPrompt: actionContext.userPrompt || "",
+    response: actionContext.response || "",
+    reasoning: actionContext.reasoning || undefined,
+    temperature: actionContext.temperature || 0.7,
+    maxTokens: actionContext.maxTokens || 8192,
+    purpose: actionContext.purpose || "action",
+    actionType: actionContext.actionType || undefined,
+    promptTokens: actionContext.promptTokens || undefined,
+    completionTokens: actionContext.completionTokens || undefined,
+    latencyMs: actionContext.latencyMs || undefined
+  });
+}
+function logProviderFromAction(actionContext, trajectoryLogger, trajectoryId) {
+  const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
+  if (!stepId) {
+    logger.warn({ trajectoryId }, "No active step for provider access from action");
+    return;
+  }
+  trajectoryLogger.logProviderAccess(stepId, {
+    providerName: actionContext.providerName || "unknown",
+    data: actionContext.data || {},
+    purpose: actionContext.purpose || "action",
+    query: actionContext.query || undefined
+  });
+}
+function wrapProviderWithLogging(provider, _trajectoryLogger) {
+  const originalGet = provider.get;
+  return {
+    ...provider,
+    get: async (runtime, message, state) => {
+      const context = getTrajectoryContext(runtime);
+      if (!context) {
+        return originalGet?.(runtime, message, state) || { text: "" };
+      }
+      const { trajectoryId, logger: loggerService } = context;
+      const stepId = loggerService.getCurrentStepId(trajectoryId);
+      if (!stepId) {
+        logger.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
+        return originalGet?.(runtime, message, state) || { text: "" };
+      }
+      const result = await originalGet?.(runtime, message, state) || { text: "" };
+      const stateSnapshot = state ? JSON.parse(JSON.stringify(state)) : null;
+      loggerService.logProviderAccess(stepId, {
+        providerName: provider.name,
+        data: {
+          text: result.text || "",
+          success: true
+        },
+        purpose: `Provider ${provider.name} accessed for context`,
+        query: {
+          message: message.content.text || "",
+          state: stateSnapshot
+        }
+      });
+      return result;
+    }
+  };
+}
+function wrapPluginProviders(plugin, trajectoryLogger) {
+  if (!plugin.providers || plugin.providers.length === 0) {
+    return plugin;
+  }
+  return {
+    ...plugin,
+    providers: plugin.providers.map((provider) => wrapProviderWithLogging(provider, trajectoryLogger))
+  };
+}
+// art-format.ts
+function toARTMessages(trajectory) {
+  const messages = [];
+  const systemMessage = buildSystemMessage(trajectory);
+  if (systemMessage) {
+    messages.push(systemMessage);
+  }
+  for (const step of trajectory.steps) {
+    const userContent = buildUserMessage(step);
+    if (userContent) {
+      messages.push({ role: "user", content: userContent });
+    }
+    const assistantContent = buildAssistantMessage(step);
+    if (assistantContent) {
+      messages.push({ role: "assistant", content: assistantContent });
+    }
+  }
+  return messages;
+}
+function buildSystemMessage(trajectory) {
+  const firstStep = trajectory.steps[0];
+  const firstLLMCall = firstStep?.llmCalls?.[0];
+  if (firstLLMCall?.systemPrompt) {
+    return { role: "system", content: firstLLMCall.systemPrompt };
+  }
+  const agentName = trajectory.metadata.agentName || "Agent";
+  const goal = trajectory.metadata.goalDescription || "make good decisions";
+  return {
+    role: "system",
+    content: `You are ${agentName}, an autonomous agent. Your goal is to ${goal}.`
+  };
+}
+function buildUserMessage(step) {
+  const llmCall = step.llmCalls.find((call) => call.purpose === "action");
+  if (llmCall?.userPrompt) {
+    return llmCall.userPrompt;
+  }
+  const parts = [];
+  parts.push("Current state:");
+  parts.push(`- Balance: $${step.environmentState.agentBalance}`);
+  parts.push(`- P&L: $${step.environmentState.agentPnL}`);
+  parts.push(`- Open Positions: ${step.environmentState.openPositions}`);
+  for (const provider of step.providerAccesses) {
+    parts.push(`
+${provider.providerName} data:`);
+    parts.push(JSON.stringify(provider.data, null, 2));
+  }
+  parts.push(`
+What action should you take?`);
+  return parts.join(`
+`);
+}
+function buildAssistantMessage(step) {
+  const llmCall = step.llmCalls.find((call) => call.purpose === "action");
+  if (llmCall?.response) {
+    return llmCall.response;
+  }
+  const action = step.action;
+  const parts = [];
+  parts.push(`I will ${action.actionType}.`);
+  if (action.reasoning) {
+    parts.push(`Reasoning: ${action.reasoning}`);
+  }
+  parts.push(`Parameters: ${JSON.stringify(action.parameters)}`);
+  return parts.join(`
+`);
+}
+function toARTTrajectory(trajectory) {
+  return {
+    messages: toARTMessages(trajectory),
+    reward: trajectory.totalReward,
+    metadata: {
+      trajectoryId: trajectory.trajectoryId,
+      agentId: trajectory.agentId,
+      scenarioId: trajectory.scenarioId,
+      groupIndex: trajectory.groupIndex,
+      environmentContext: {
+        initialBalance: trajectory.steps[0]?.environmentState.agentBalance || 0,
+        finalBalance: trajectory.metrics.finalBalance || 0,
+        initialPnL: trajectory.steps[0]?.environmentState.agentPnL || 0,
+        finalPnL: trajectory.metrics.finalPnL || 0,
+        actionsTaken: trajectory.steps.map((s) => s.action.actionType),
+        errors: trajectory.steps.filter((s) => !s.action.success).map((s) => s.action.error || "Unknown error")
+      },
+      gameKnowledge: extractGameKnowledge(trajectory),
+      metrics: JSON.parse(JSON.stringify(trajectory.metrics))
+    },
+    metrics: filterNumericMetrics(trajectory.metrics)
+  };
+}
+function filterNumericMetrics(metrics) {
+  const numericMetrics = {};
+  for (const [key, value] of Object.entries(metrics)) {
+    if (typeof value === "number" && !Number.isNaN(value)) {
+      numericMetrics[key] = value;
+    }
+  }
+  return numericMetrics;
+}
+function extractGameKnowledge(trajectory) {
+  const knowledge = {};
+  if (trajectory.metadata.trueProbabilities) {
+    knowledge.trueProbabilities = trajectory.metadata.trueProbabilities;
+  }
+  if (trajectory.metadata.futureOutcomes) {
+    knowledge.actualOutcomes = trajectory.metadata.futureOutcomes;
+  }
+  if (trajectory.metadata.hiddenVariables) {
+    knowledge.hiddenVariables = trajectory.metadata.hiddenVariables;
+  }
+  const gameEvents = trajectory.steps.map((s) => s.metadata?.gameEvent).filter((e) => !!e);
+  if (gameEvents.length > 0) {
+    knowledge.gameEvents = gameEvents;
+  }
+  return knowledge;
+}
+function groupTrajectories(trajectories) {
+  const groups = new Map;
+  for (const traj of trajectories) {
+    const scenarioId = traj.scenarioId || "default";
+    if (!groups.has(scenarioId)) {
+      groups.set(scenarioId, []);
+    }
+    groups.get(scenarioId)?.push(traj);
+  }
+  return Array.from(groups.entries()).map(([scenarioId, trajs], idx) => ({
+    groupId: `group-${idx}`,
+    scenarioId,
+    trajectories: trajs,
+    sharedPrefix: extractSharedPrefix(trajs),
+    createdAt: Date.now()
+  }));
+}
+function extractSharedPrefix(trajectories) {
+  if (trajectories.length === 0)
+    return [];
+  const allMessages = trajectories.map((t) => toARTMessages(t));
+  if (allMessages.length === 0)
+    return [];
+  const firstMessages = allMessages[0];
+  if (!firstMessages)
+    return [];
+  const sharedPrefix = [];
+  for (let i = 0;i < firstMessages.length; i++) {
+    const message = firstMessages[i];
+    if (!message)
+      break;
+    const allMatch = allMessages.every((msgs) => msgs[i] && msgs[i]?.role === message.role && msgs[i]?.content === message.content);
+    if (allMatch) {
+      sharedPrefix.push(message);
+    } else {
+      break;
+    }
+  }
+  return sharedPrefix;
+}
+function removeSharedPrefix(messages, sharedPrefix) {
+  return messages.slice(sharedPrefix.length);
+}
+function prepareForRULER(group) {
+  const artTrajs = group.trajectories.map((t) => toARTTrajectory(t));
+  const sharedPrefix = group.sharedPrefix || extractSharedPrefix(group.trajectories);
+  return {
+    sharedPrefix,
+    suffixes: artTrajs.map((art) => removeSharedPrefix(art.messages, sharedPrefix)),
+    metadata: artTrajs.map((art) => art.metadata)
+  };
+}
+function toARTJSONL(trajectory) {
+  return JSON.stringify(toARTTrajectory(trajectory));
+}
+function validateARTCompatibility(trajectory) {
+  const errors = [];
+  const warnings = [];
+  if (trajectory.steps.length === 0) {
+    errors.push("Trajectory has no steps");
+  }
+  for (const [idx, step] of trajectory.steps.entries()) {
+    if (step.llmCalls.length === 0) {
+      errors.push(`Step ${idx} has no LLM calls - can't extract messages`);
+    }
+    for (const llmCall of step.llmCalls) {
+      if (!llmCall.userPrompt || llmCall.userPrompt.length < 10) {
+        warnings.push(`Step ${idx} has very short user prompt`);
+      }
+      if (!llmCall.response || llmCall.response.length < 5) {
+        warnings.push(`Step ${idx} has very short response`);
+      }
+    }
+  }
+  if (trajectory.totalReward === undefined || Number.isNaN(trajectory.totalReward)) {
+    errors.push("Trajectory has no valid reward");
+  }
+  const artTraj = toARTTrajectory(trajectory);
+  if (artTraj.messages.length < 2) {
+    warnings.push("Trajectory converts to very few messages (< 2)");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+// export.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+async function exportToHuggingFace(options) {
+  return exportForOpenPipeART(options);
+}
+async function exportGroupedByScenario(options) {
+  const trajectories = filterTrajectories(options.trajectories || [], options);
+  const outPath = resolveOutputPath(options, "grouped-by-scenario.json");
+  const grouped = {};
+  for (const t of trajectories) {
+    const scenarioId = t.scenarioId || "default";
+    if (!grouped[scenarioId])
+      grouped[scenarioId] = [];
+    grouped[scenarioId]?.push(t);
+  }
+  await writeJson(outPath, grouped);
+  return { success: true, trajectoriesExported: trajectories.length, datasetUrl: outPath };
+}
+async function exportForOpenPipeART(options) {
+  const trajectories = filterTrajectories(options.trajectories || [], options);
+  const outPath = resolveOutputPath(options, "trajectories.art.jsonl");
+  const lines = `${trajectories.map((t) => toARTJSONL(t)).join(`
+`)}
+`;
+  await writeText(outPath, lines);
+  return { success: true, trajectoriesExported: trajectories.length, datasetUrl: outPath };
+}
+async function exportGroupedForGRPO(options) {
+  const trajectories = filterTrajectories(options.trajectories || [], options);
+  const outPath = resolveOutputPath(options, "trajectories.grpo.groups.json");
+  const groups = groupTrajectories(trajectories);
+  await writeJson(outPath, groups);
+  return { success: true, trajectoriesExported: trajectories.length, datasetUrl: outPath };
+}
+function filterTrajectories(trajectories, options) {
+  let out = trajectories.slice();
+  if (options.startDate) {
+    const startMs = options.startDate.getTime();
+    out = out.filter((t) => t.startTime >= startMs);
+  }
+  if (options.endDate) {
+    const endMs = options.endDate.getTime();
+    out = out.filter((t) => t.startTime <= endMs);
+  }
+  if (options.agentIds && options.agentIds.length > 0) {
+    const set = new Set(options.agentIds);
+    out = out.filter((t) => set.has(t.agentId));
+  }
+  if (options.scenarioIds && options.scenarioIds.length > 0) {
+    const set = new Set(options.scenarioIds);
+    out = out.filter((t) => t.scenarioId && set.has(t.scenarioId));
+  }
+  if (typeof options.minReward === "number") {
+    const minReward = options.minReward;
+    out = out.filter((t) => t.totalReward >= minReward);
+  }
+  if (typeof options.maxReward === "number") {
+    const maxReward = options.maxReward;
+    out = out.filter((t) => t.totalReward <= maxReward);
+  }
+  const limit = options.maxTrajectories || out.length;
+  return out.slice(0, limit);
+}
+function resolveOutputPath(options, fallbackFileName) {
+  if (options.outputPath)
+    return options.outputPath;
+  if (options.outputDir)
+    return join(options.outputDir, fallbackFileName);
+  const safeName = options.datasetName.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  return join(process.cwd(), `${safeName}.${fallbackFileName}`);
+}
+async function writeText(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, content, "utf8");
+}
+async function writeJson(path, data) {
+  await writeText(path, `${JSON.stringify(data, null, 2)}
+`);
+}
+// game-rewards.ts
+function computeTrajectoryReward(trajectory) {
+  return trajectory.totalReward;
+}
+function computeStepReward(step) {
+  return step.reward || 0;
+}
+async function buildGameStateFromDB(_trajectoryId) {
+  return {};
+}
+async function recomputeTrajectoryRewards(_trajectoryIds) {}
+// integration.ts
+import { logger as logger2 } from "@elizaos/core";
+function startAutonomousTick(trajectoryLogger, context) {
+  const trajectoryId = trajectoryLogger.startTrajectory(context.agentId, {
+    scenarioId: context.scenarioId,
+    episodeId: context.episodeId,
+    batchId: context.batchId,
+    metadata: context.metadata
+  });
+  const envState = {
+    timestamp: Date.now(),
+    agentBalance: 0,
+    agentPoints: 0,
+    agentPnL: 0,
+    openPositions: 0
+  };
+  trajectoryLogger.startStep(trajectoryId, envState);
+  logger2.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
+  return trajectoryId;
+}
+async function endAutonomousTick(trajectoryLogger, trajectoryId, status = "completed", finalMetrics) {
+  await trajectoryLogger.endTrajectory(trajectoryId, status, finalMetrics);
+  logger2.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
+}
+async function loggedLLMCall(trajectoryLogger, trajectoryId, options, llmCallFn) {
+  const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
+  if (!stepId) {
+    logger2.warn({ trajectoryId }, "No active step for LLM call");
+    const result2 = await llmCallFn();
+    return result2.text;
+  }
+  const startTime = Date.now();
+  const result = await llmCallFn();
+  const latencyMs = Date.now() - startTime;
+  trajectoryLogger.logLLMCall(stepId, {
+    model: options.model,
+    modelVersion: options.modelVersion,
+    systemPrompt: options.systemPrompt,
+    userPrompt: options.userPrompt,
+    response: result.text,
+    reasoning: result.reasoning,
+    temperature: options.temperature || 0.7,
+    maxTokens: options.maxTokens || 8192,
+    purpose: options.purpose || "action",
+    actionType: options.actionType,
+    promptTokens: result.tokens?.prompt,
+    completionTokens: result.tokens?.completion,
+    latencyMs: result.latencyMs || latencyMs
+  });
+  return result.text;
+}
+function logProviderAccess(trajectoryLogger, trajectoryId, access) {
+  trajectoryLogger.logProviderAccessByTrajectoryId(trajectoryId, access);
+}
+function withTrajectoryLogging(fn, trajectoryLogger, trajectoryId, context = {}) {
+  return async (...args) => {
+    const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
+    if (!stepId) {
+      return fn(...args);
+    }
+    const result = await fn(...args);
+    trajectoryLogger.completeStep(trajectoryId, stepId, {
+      actionType: context.actionType || "function_call",
+      actionName: fn.name || "anonymous",
+      parameters: { args },
+      success: true,
+      result: result !== undefined ? { result } : { result: null }
+    }, { reward: 0.05 });
+    return result;
+  };
+}
+// reward-service.ts
+class RewardService {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async scoreTrajectory(trajectory) {
+    if (this.options.useHeuristics !== false) {
+      return this.computeHeuristicReward(trajectory);
+    }
+    return this.computeHeuristicReward(trajectory);
+  }
+  async scoreTrajectoryGroup(trajectories) {
+    if (trajectories.length === 0) {
+      return [];
+    }
+    if (trajectories.length === 1) {
+      const first = trajectories[0];
+      if (!first)
+        return [];
+      const score = await this.scoreTrajectory(first);
+      return [this.normalizeScore(score)];
+    }
+    const rawScores = await Promise.all(trajectories.map((t) => this.scoreTrajectory(t)));
+    return this.normalizeScoresForGroup(rawScores);
+  }
+  computeHeuristicReward(trajectory) {
+    const components = trajectory.rewardComponents;
+    const metrics = trajectory.metrics;
+    let reward = 0;
+    let weightSum = 0;
+    if (metrics.finalPnL !== undefined) {
+      const pnlScore = this.normalizePnL(metrics.finalPnL);
+      reward += pnlScore * 0.4;
+      weightSum += 0.4;
+    }
+    if (metrics.successRate !== undefined) {
+      const successScore = metrics.successRate * 2 - 1;
+      reward += successScore * 0.3;
+      weightSum += 0.3;
+    }
+    const completionScore = metrics.finalStatus === "completed" ? 1 : -0.5;
+    reward += completionScore * 0.2;
+    weightSum += 0.2;
+    if (components.environmentReward !== undefined) {
+      const envScore = Math.max(-1, Math.min(1, components.environmentReward));
+      reward += envScore * 0.1;
+      weightSum += 0.1;
+    }
+    if (weightSum > 0) {
+      reward = reward / weightSum;
+    }
+    return Math.max(-1, Math.min(1, reward));
+  }
+  normalizePnL(pnl) {
+    return Math.tanh(pnl / 500);
+  }
+  normalizeScore(score) {
+    return (score + 1) / 2;
+  }
+  normalizeScoresForGroup(scores) {
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const range = max - min;
+    if (range === 0) {
+      return scores.map(() => 0.5);
+    }
+    return scores.map((s) => (s - min) / range);
+  }
+}
+function createRewardService(options = {}) {
+  return new RewardService(options);
+}
+async function scoreTrajectory(trajectory) {
+  const service = new RewardService;
+  return service.scoreTrajectory(trajectory);
+}
+async function scoreTrajectoryGroup(trajectories) {
+  const service = new RewardService;
+  return service.scoreTrajectoryGroup(trajectories);
+}
+// TrajectoryLoggerService.ts
+import { asUUID, logger as logger3 } from "@elizaos/core";
+import { v4 as uuidv4 } from "uuid";
+
+class TrajectoryLoggerService {
+  activeTrajectories = new Map;
+  activeStepIds = new Map;
+  startTrajectory(agentId, options = {}) {
+    const trajectoryId = uuidv4();
+    const now = Date.now();
+    const trajectory = {
+      trajectoryId: asUUID(trajectoryId),
+      agentId: asUUID(agentId),
+      startTime: now,
+      endTime: now,
+      durationMs: 0,
+      episodeId: options.episodeId,
+      scenarioId: options.scenarioId,
+      batchId: options.batchId,
+      groupIndex: options.groupIndex,
+      steps: [],
+      totalReward: 0,
+      rewardComponents: {
+        environmentReward: 0
+      },
+      metrics: {
+        episodeLength: 0,
+        finalStatus: "completed"
+      },
+      metadata: options.metadata || {}
+    };
+    this.activeTrajectories.set(trajectoryId, trajectory);
+    return trajectoryId;
+  }
+  startStep(trajectoryId, envState) {
+    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);
+    return stepId;
+  }
+  logLLMCall(stepId, llmCall) {
+    const trajectory = this.findTrajectoryByStepId(stepId);
+    if (!trajectory) {
+      logger3.warn({ stepId }, "Trajectory not found for LLM call");
+      return;
+    }
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger3.warn({ stepId }, "Step not found for LLM call");
+      return;
+    }
+    const fullLLMCall = {
+      callId: uuidv4(),
+      timestamp: Date.now(),
+      ...llmCall
+    };
+    step.llmCalls.push(fullLLMCall);
+  }
+  logProviderAccess(stepId, access) {
+    const trajectory = this.findTrajectoryByStepId(stepId);
+    if (!trajectory) {
+      logger3.warn({ stepId }, "Trajectory not found for provider access");
+      return;
+    }
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger3.warn({ stepId }, "Step not found for provider access");
+      return;
+    }
+    const fullAccess = {
+      providerId: uuidv4(),
+      timestamp: Date.now(),
+      ...access
+    };
+    step.providerAccesses.push(fullAccess);
+  }
+  logLLMCallByTrajectoryId(trajectoryId, llmCall) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger3.warn({ trajectoryId }, "No active step for trajectory");
+      return;
+    }
+    this.logLLMCall(stepId, llmCall);
+  }
+  logProviderAccessByTrajectoryId(trajectoryId, access) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger3.warn({ trajectoryId }, "No active step for trajectory");
+      return;
+    }
+    this.logProviderAccess(stepId, access);
+  }
+  getCurrentStepId(trajectoryId) {
+    return this.activeStepIds.get(trajectoryId) || null;
+  }
+  completeStep(trajectoryId, stepId, action, rewardInfo) {
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      logger3.warn({ trajectoryId }, "Trajectory not found for completeStep");
+      return;
+    }
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger3.warn({ trajectoryId, stepId }, "Step not found for completeStep");
+      return;
+    }
+    step.action = {
+      attemptId: uuidv4(),
+      timestamp: Date.now(),
+      ...action
+    };
+    if (rewardInfo?.reward !== undefined) {
+      step.reward = rewardInfo.reward;
+      trajectory.totalReward += rewardInfo.reward;
+    }
+    if (rewardInfo?.components) {
+      trajectory.rewardComponents = {
+        ...trajectory.rewardComponents,
+        ...rewardInfo.components
+      };
+    }
+    this.activeStepIds.delete(trajectoryId);
+  }
+  completeCurrentStep(trajectoryId, action, rewardInfo) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger3.warn({ trajectoryId }, "No active step for trajectory");
+      return;
+    }
+    this.completeStep(trajectoryId, stepId, action, rewardInfo);
+  }
+  async endTrajectory(trajectoryId, status, finalMetrics) {
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      logger3.warn({ trajectoryId }, "Trajectory not found for endTrajectory");
+      return;
+    }
+    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
+      };
+    }
+    this.activeStepIds.delete(trajectoryId);
+  }
+  getActiveTrajectory(trajectoryId) {
+    return this.activeTrajectories.get(trajectoryId) || null;
+  }
+  findTrajectoryByStepId(stepId) {
+    for (const trajectory of this.activeTrajectories.values()) {
+      if (trajectory.steps.some((s) => s.stepId === stepId)) {
+        return trajectory;
+      }
+    }
+    return null;
+  }
+}
+
+// index.ts
+var trajectoryLoggerPlugin = {
+  name: "@elizaos/plugin-trajectory-logger",
+  description: "Collects complete agent interaction trajectory data for RL training. Records LLM calls, provider access, actions, environment state, and computes rewards.",
+  dependencies: [],
+  services: []
+};
+var typescript_default = trajectoryLoggerPlugin;
+export {
+  wrapProviderWithLogging,
+  wrapPluginProviders,
+  wrapPluginActions,
+  wrapActionWithLogging,
+  withTrajectoryLogging,
+  validateARTCompatibility,
+  trajectoryLoggerPlugin,
+  toARTTrajectory,
+  toARTMessages,
+  toARTJSONL,
+  startAutonomousTick,
+  setTrajectoryContext,
+  scoreTrajectoryGroup,
+  scoreTrajectory,
+  removeSharedPrefix,
+  recomputeTrajectoryRewards,
+  prepareForRULER,
+  loggedLLMCall,
+  logProviderFromAction,
+  logProviderAccess,
+  logLLMCallFromAction,
+  groupTrajectories,
+  getTrajectoryContext,
+  extractSharedPrefix,
+  exportToHuggingFace,
+  exportGroupedForGRPO,
+  exportGroupedByScenario,
+  exportForOpenPipeART,
+  endAutonomousTick,
+  typescript_default as default,
+  createRewardService,
+  computeTrajectoryReward,
+  computeStepReward,
+  clearTrajectoryContext,
+  buildGameStateFromDB,
+  TrajectoryLoggerService,
+  RewardService
+};
+
+//# debugId=8E8ACF830258000B64756E2164756E21