@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.333

package/packages/typescript/src/features/trajectories/action-interceptor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Action-Level Instrumentation
+ *
+ * Wraps actions and providers with trajectory logging.
+ */
+import type { Action, IAgentRuntime, Plugin, Provider } from "../../types";
+import type { TrajectoriesService } from "./TrajectoriesService";
+import type { JsonValue } from "./types";
+interface TrajectoryContext {
+    trajectoryId: string;
+    logger: TrajectoriesService;
+}
+export declare function setTrajectoryContext(runtime: IAgentRuntime, trajectoryId: string, trajectoryLogger: TrajectoriesService): void;
+export declare function getTrajectoryContext(runtime: IAgentRuntime): TrajectoryContext | null;
+export declare function clearTrajectoryContext(runtime: IAgentRuntime): void;
+export declare function wrapActionWithLogging(action: Action, _trajectoryLogger: TrajectoriesService): Action;
+export declare function wrapPluginActions(plugin: Plugin, trajectoryLogger: TrajectoriesService): Plugin;
+export declare function logLLMCallFromAction(actionContext: Record<string, JsonValue | undefined>, trajectoryLogger: TrajectoriesService, trajectoryId: string): void;
+export declare function logProviderFromAction(actionContext: Record<string, JsonValue | undefined>, trajectoryLogger: TrajectoriesService, trajectoryId: string): void;
+export declare function wrapProviderWithLogging(provider: Provider, _trajectoryLogger: TrajectoriesService): Provider;
+export declare function wrapPluginProviders(plugin: Plugin, trajectoryLogger: TrajectoriesService): Plugin;
+export {};
+//# sourceMappingURL=action-interceptor.d.ts.map

package/packages/typescript/src/features/trajectories/action-interceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-interceptor.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/trajectories/action-interceptor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACX,MAAM,EAIN,aAAa,EAEb,MAAM,EACN,QAAQ,EAGR,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,UAAU,iBAAiB;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;CAC5B;AAID,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,mBAAmB,GACnC,IAAI,CAEN;AAED,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,aAAa,GACpB,iBAAiB,GAAG,IAAI,CAE1B;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAEnE;AAID,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,mBAAmB,GACpC,MAAM,CA2HR;AAED,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,mBAAmB,GACnC,MAAM,CAWR;AAED,wBAAgB,oBAAoB,CACnC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC,EACpD,gBAAgB,EAAE,mBAAmB,EACrC,YAAY,EAAE,MAAM,GAClB,IAAI,CA2BN;AAED,wBAAgB,qBAAqB,CACpC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC,EACpD,gBAAgB,EAAE,mBAAmB,EACrC,YAAY,EAAE,MAAM,GAClB,IAAI,CAgBN;AAED,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,QAAQ,EAClB,iBAAiB,EAAE,mBAAmB,GACpC,QAAQ,CAkDV;AAED,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,mBAAmB,GACnC,MAAM,CAWR"}

package/packages/typescript/src/features/trajectories/action-interceptor.js

@@ -0,0 +1,178 @@
+/**
+ * Action-Level Instrumentation
+ *
+ * Wraps actions and providers with trajectory logging.
+ */
+import { logger } from "../../logger";
+const trajectoryContexts = new WeakMap();
+export function setTrajectoryContext(runtime, trajectoryId, trajectoryLogger) {
+    trajectoryContexts.set(runtime, { trajectoryId, logger: trajectoryLogger });
+}
+export function getTrajectoryContext(runtime) {
+    return trajectoryContexts.get(runtime) || null;
+}
+export function clearTrajectoryContext(runtime) {
+    trajectoryContexts.delete(runtime);
+}
+export 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);
+            }
+        },
+    };
+}
+export function wrapPluginActions(plugin, trajectoryLogger) {
+    if (!plugin.actions || plugin.actions.length === 0) {
+        return plugin;
+    }
+    return {
+        ...plugin,
+        actions: plugin.actions.map((action) => wrapActionWithLogging(action, trajectoryLogger)),
+    };
+}
+export 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,
+    });
+}
+export 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,
+    });
+}
+export 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;
+        },
+    };
+}
+export function wrapPluginProviders(plugin, trajectoryLogger) {
+    if (!plugin.providers || plugin.providers.length === 0) {
+        return plugin;
+    }
+    return {
+        ...plugin,
+        providers: plugin.providers.map((provider) => wrapProviderWithLogging(provider, trajectoryLogger)),
+    };
+}

package/packages/typescript/src/features/trajectories/art-format.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ART Format Conversion
+ *
+ * Converts our rich trajectory format to ART-compatible format.
+ *
+ * Key insight from ART examples:
+ * - Trajectories are MESSAGE ARRAYS (system/user/assistant)
+ * - Metadata is separate (for judge context)
+ * - Single reward per trajectory
+ * - Grouping by scenario for GRPO
+ */
+import type { ARTTrajectory, ChatMessage, Trajectory, TrajectoryGroup } from "./types";
+/**
+ * Convert rich trajectory to ART message format.
+ */
+export declare function toARTMessages(trajectory: Trajectory): ChatMessage[];
+export declare function toARTTrajectory(trajectory: Trajectory): ARTTrajectory;
+export declare function groupTrajectories(trajectories: Trajectory[]): TrajectoryGroup[];
+export declare function extractSharedPrefix(trajectories: Trajectory[]): ChatMessage[];
+export declare function removeSharedPrefix(messages: ChatMessage[], sharedPrefix: ChatMessage[]): ChatMessage[];
+export declare function prepareForRULER(group: TrajectoryGroup): {
+    sharedPrefix: ChatMessage[];
+    suffixes: ChatMessage[][];
+    metadata: ARTTrajectory["metadata"][];
+};
+export declare function toARTJSONL(trajectory: Trajectory): string;
+export declare function validateARTCompatibility(trajectory: Trajectory): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+//# sourceMappingURL=art-format.d.ts.map

package/packages/typescript/src/features/trajectories/art-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"art-format.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/trajectories/art-format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACX,aAAa,EACb,WAAW,EAEX,UAAU,EACV,eAAe,EAEf,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,WAAW,EAAE,CAqBnE;AA0DD,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,CA2BrE;AA2DD,wBAAgB,iBAAiB,CAChC,YAAY,EAAE,UAAU,EAAE,GACxB,eAAe,EAAE,CAkBnB;AAED,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,UAAU,EAAE,GAAG,WAAW,EAAE,CA4B7E;AAED,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,WAAW,EAAE,EACvB,YAAY,EAAE,WAAW,EAAE,GACzB,WAAW,EAAE,CAEf;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG;IACxD,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,QAAQ,EAAE,WAAW,EAAE,EAAE,CAAC;IAC1B,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,CAAC;CACtC,CAYA;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAEzD;AAED,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,UAAU,GAAG;IACjE,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACnB,CAwCA"}

package/packages/typescript/src/features/trajectories/art-format.js

@@ -0,0 +1,221 @@
+/**
+ * ART Format Conversion
+ *
+ * Converts our rich trajectory format to ART-compatible format.
+ *
+ * Key insight from ART examples:
+ * - Trajectories are MESSAGE ARRAYS (system/user/assistant)
+ * - Metadata is separate (for judge context)
+ * - Single reward per trajectory
+ * - Grouping by scenario for GRPO
+ */
+/**
+ * Convert rich trajectory to ART message format.
+ */
+export 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(`\n${provider.providerName} data:`);
+        parts.push(JSON.stringify(provider.data, null, 2));
+    }
+    parts.push("\nWhat action should you take?");
+    return parts.join("\n");
+}
+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("\n");
+}
+export 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;
+}
+export 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(),
+    }));
+}
+export 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;
+}
+export function removeSharedPrefix(messages, sharedPrefix) {
+    return messages.slice(sharedPrefix.length);
+}
+export 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),
+    };
+}
+export function toARTJSONL(trajectory) {
+    return JSON.stringify(toARTTrajectory(trajectory));
+}
+export 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,
+    };
+}

package/packages/typescript/src/features/trajectories/export.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Trajectory Export Utilities
+ *
+ * The original implementation targeted a Babylon-specific database + HuggingFace upload pipeline.
+ * In elizaOS core, this module is storage-agnostic and focuses on preparing files for downstream
+ * training (JSONL / grouped JSON).
+ */
+import type { Trajectory } from "./types";
+export interface ExportOptions {
+    datasetName: string;
+    huggingFaceToken?: string;
+    startDate?: Date;
+    endDate?: Date;
+    agentIds?: string[];
+    scenarioIds?: string[];
+    minReward?: number;
+    maxReward?: number;
+    includeJudged?: boolean;
+    maxTrajectories?: number;
+    format?: "jsonl" | "parquet" | "arrow";
+    splitRatio?: {
+        train: number;
+        validation: number;
+        test: number;
+    };
+    trajectories?: Trajectory[];
+    outputPath?: string;
+    outputDir?: string;
+}
+export interface ExportResult {
+    success: boolean;
+    trajectoriesExported: number;
+    datasetUrl?: string;
+    error?: string;
+}
+export declare function exportToHuggingFace(options: ExportOptions): Promise<ExportResult>;
+export declare function exportGroupedByScenario(options: ExportOptions): Promise<ExportResult>;
+export declare function exportForOpenPipeART(options: ExportOptions): Promise<ExportResult>;
+export declare function exportGroupedForGRPO(options: ExportOptions): Promise<ExportResult>;
+//# sourceMappingURL=export.d.ts.map

package/packages/typescript/src/features/trajectories/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/trajectories/export.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,SAAS,CAAC;AAE3D,MAAM,WAAW,aAAa;IAE7B,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAG1B,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IAGxB,eAAe,CAAC,EAAE,MAAM,CAAC;IAGzB,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;IACvC,UAAU,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAGjE,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC;IAG5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,CAKvB;AAED,wBAAsB,uBAAuB,CAC5C,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,CAiBvB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,CAYvB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,CAYvB"}

package/packages/typescript/src/features/trajectories/export.js

@@ -0,0 +1,99 @@
+/**
+ * Trajectory Export Utilities
+ *
+ * The original implementation targeted a Babylon-specific database + HuggingFace upload pipeline.
+ * In elizaOS core, this module is storage-agnostic and focuses on preparing files for downstream
+ * training (JSONL / grouped JSON).
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { groupTrajectories, toARTJSONL } from "./art-format";
+export async function exportToHuggingFace(options) {
+    // In this repo we don't couple to a DB or HuggingFace API.
+    // We still keep the function name/signature so existing callers can migrate by
+    // passing `trajectories` + `outputPath`.
+    return exportForOpenPipeART(options);
+}
+export 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,
+    };
+}
+export 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("\n")}\n`;
+    await writeText(outPath, lines);
+    return {
+        success: true,
+        trajectoriesExported: trajectories.length,
+        datasetUrl: outPath,
+    };
+}
+export 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)}\n`);
+}

package/packages/typescript/src/features/trajectories/game-rewards.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Game-Knowledge Rewards
+ *
+ * Compute rewards using perfect game information for RL training.
+ *
+ * @remarks These helpers are intentionally lightweight; environments can provide richer
+ * reward computation by writing into `trajectory.totalReward` and `step.reward`.
+ */
+import type { JsonValue, Trajectory, TrajectoryStep } from "./types";
+export declare function computeTrajectoryReward(trajectory: Trajectory): number;
+export declare function computeStepReward(step: TrajectoryStep): number;
+export declare function buildGameStateFromDB(_trajectoryId: string): Promise<Record<string, JsonValue>>;
+export declare function recomputeTrajectoryRewards(_trajectoryIds: string[]): Promise<void>;
+//# sourceMappingURL=game-rewards.d.ts.map

package/packages/typescript/src/features/trajectories/game-rewards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-rewards.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/trajectories/game-rewards.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAErE,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAEtE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAE9D;AAED,wBAAsB,oBAAoB,CACzC,aAAa,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAEpC;AAED,wBAAsB,0BAA0B,CAC/C,cAAc,EAAE,MAAM,EAAE,GACtB,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/packages/typescript/src/features/trajectories/game-rewards.js

@@ -0,0 +1,20 @@
+/**
+ * Game-Knowledge Rewards
+ *
+ * Compute rewards using perfect game information for RL training.
+ *
+ * @remarks These helpers are intentionally lightweight; environments can provide richer
+ * reward computation by writing into `trajectory.totalReward` and `step.reward`.
+ */
+export function computeTrajectoryReward(trajectory) {
+    return trajectory.totalReward;
+}
+export function computeStepReward(step) {
+    return step.reward || 0;
+}
+export async function buildGameStateFromDB(_trajectoryId) {
+    return {};
+}
+export async function recomputeTrajectoryRewards(_trajectoryIds) {
+    // Intentionally a no-op placeholder; reward recomputation is environment-specific.
+}

package/packages/typescript/src/features/trajectories/index.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin } from "../../types";
+/**
+ * Native trajectories plugin.
+ *
+ * Captures complete agent interaction trajectories for:
+ * - Debugging and analysis (UI viewing)
+ * - RL training data collection
+ * - Export to various formats (JSON, ART, CSV)
+ *
+ * Registers the native "trajectories" service so the runtime can automatically
+ * log LLM calls and provider accesses when trajectory capture is active.
+ */
+export declare const trajectoriesPlugin: Plugin;
+export default trajectoriesPlugin;
+export * from "./action-interceptor";
+export * from "./art-format";
+export * from "./export";
+export * from "./game-rewards";
+export * from "./integration";
+export * from "./reward-service";
+export type { TrajectoryExportOptions, TrajectoryListItem, TrajectoryListOptions, TrajectoryListResult, TrajectoryStats, TrajectoryZipEntry, TrajectoryZipExportOptions, TrajectoryZipExportResult, } from "./TrajectoriesService";
+export { TrajectoriesService } from "./TrajectoriesService";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map