@elizaos/training 2.0.0-alpha.21 → 2.0.0-alpha.22

package/dist/dependencies.js

@@ -0,0 +1,197 @@
+/**
+ * External Dependencies for Training Package
+ *
+ * Defines interfaces for external dependencies that must be provided
+ * by the consuming application (e.g., apps/web). The training package
+ * is decoupled from specific implementations to maintain clean
+ * package boundaries.
+ *
+ * Usage:
+ * ```typescript
+ * import { configureTrainingDependencies } from '@elizaos/training';
+ *
+ * configureTrainingDependencies({
+ *   agentService,
+ *   agentRuntimeManager,
+ *   autonomousCoordinator,
+ *   llmCaller,
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+/**
+ * Global configuration for external dependencies
+ * This should be initialized before using the training package
+ */
+let _agentService = null;
+let _agentRuntimeManager = null;
+let _autonomousCoordinator = null;
+let _llmCaller = null;
+let _exportGroupedForGRPO = null;
+let _exportToHuggingFace = null;
+let _toTrainingMessages = null;
+/**
+ * Validate that a dependency has the expected shape at runtime.
+ * Throws immediately on misconfiguration instead of failing at call time.
+ */
+function assertFn(dep, name, methods) {
+    if (dep == null)
+        return; // allow explicit null/undefined (means "skip")
+    for (const method of methods) {
+        if (typeof dep[method] !== "function") {
+            throw new TypeError(`configureTrainingDependencies: ${name}.${method} must be a function, got ${typeof dep[method]}`);
+        }
+    }
+}
+/**
+ * Configure external dependencies.
+ *
+ * Performs runtime shape validation so mismatched adapters fail early with a
+ * clear error instead of silently producing broken behavior downstream.
+ */
+export function configureTrainingDependencies(config) {
+    // Runtime shape checks – catch adapter mismatches early
+    assertFn(config.agentService, "agentService", ["createAgent"]);
+    assertFn(config.agentRuntimeManager, "agentRuntimeManager", [
+        "getRuntime",
+        "resetRuntime",
+    ]);
+    assertFn(config.autonomousCoordinator, "autonomousCoordinator", [
+        "executeAutonomousTick",
+    ]);
+    assertFn(config.llmCaller, "llmCaller", ["callGroqDirect"]);
+    if (config.exportGroupedForGRPO !== undefined &&
+        config.exportGroupedForGRPO !== null &&
+        typeof config.exportGroupedForGRPO !== "function") {
+        throw new TypeError("configureTrainingDependencies: exportGroupedForGRPO must be a function");
+    }
+    if (config.exportToHuggingFace !== undefined &&
+        config.exportToHuggingFace !== null &&
+        typeof config.exportToHuggingFace !== "function") {
+        throw new TypeError("configureTrainingDependencies: exportToHuggingFace must be a function");
+    }
+    if (config.toTrainingMessages !== undefined &&
+        config.toTrainingMessages !== null &&
+        typeof config.toTrainingMessages !== "function") {
+        throw new TypeError("configureTrainingDependencies: toTrainingMessages must be a function");
+    }
+    if (config.agentService) {
+        _agentService = config.agentService;
+    }
+    if (config.agentRuntimeManager) {
+        _agentRuntimeManager = config.agentRuntimeManager;
+    }
+    if (config.autonomousCoordinator) {
+        _autonomousCoordinator = config.autonomousCoordinator;
+    }
+    if (config.llmCaller) {
+        _llmCaller = config.llmCaller;
+    }
+    if (config.exportGroupedForGRPO) {
+        _exportGroupedForGRPO = config.exportGroupedForGRPO;
+    }
+    if (config.exportToHuggingFace) {
+        _exportToHuggingFace = config.exportToHuggingFace;
+    }
+    if (config.toTrainingMessages) {
+        _toTrainingMessages = config.toTrainingMessages;
+    }
+}
+/**
+ * Get the agent service
+ * @throws Error if not configured
+ */
+export function getAgentService() {
+    if (!_agentService) {
+        throw new Error("AgentService not configured. Call configureTrainingDependencies() first.");
+    }
+    return _agentService;
+}
+/**
+ * Get the agent runtime manager
+ * @throws Error if not configured
+ */
+export function getAgentRuntimeManager() {
+    if (!_agentRuntimeManager) {
+        throw new Error("AgentRuntimeManager not configured. Call configureTrainingDependencies() first.");
+    }
+    return _agentRuntimeManager;
+}
+/**
+ * Get the autonomous coordinator
+ * @throws Error if not configured
+ */
+export function getAutonomousCoordinator() {
+    if (!_autonomousCoordinator) {
+        throw new Error("AutonomousCoordinator not configured. Call configureTrainingDependencies() first.");
+    }
+    return _autonomousCoordinator;
+}
+/**
+ * Get the LLM caller
+ * @throws Error if not configured
+ */
+export function getLLMCaller() {
+    if (!_llmCaller) {
+        throw new Error("LLMCaller not configured. Call configureTrainingDependencies() first.");
+    }
+    return _llmCaller;
+}
+/**
+ * Get the export function for GRPO
+ * @throws Error if not configured
+ */
+export function getExportGroupedForGRPO() {
+    if (!_exportGroupedForGRPO) {
+        throw new Error("exportGroupedForGRPO not configured. Call configureTrainingDependencies() first.");
+    }
+    return _exportGroupedForGRPO;
+}
+/**
+ * Get the export function for HuggingFace
+ * @throws Error if not configured
+ */
+export function getExportToHuggingFace() {
+    if (!_exportToHuggingFace) {
+        throw new Error("exportToHuggingFace not configured. Call configureTrainingDependencies() first.");
+    }
+    return _exportToHuggingFace;
+}
+/**
+ * Get the toTrainingMessages function
+ * @throws Error if not configured
+ */
+export function getToTrainingMessages() {
+    if (!_toTrainingMessages) {
+        throw new Error("toTrainingMessages not configured. Call configureTrainingDependencies() first.");
+    }
+    return _toTrainingMessages;
+}
+/**
+ * Check if dependencies are configured
+ */
+export function areDependenciesConfigured() {
+    return (_agentService !== null &&
+        _agentRuntimeManager !== null &&
+        _autonomousCoordinator !== null);
+}
+/**
+ * Check if specific agent dependencies are configured for parallel generation
+ */
+export function areAgentDependenciesConfigured() {
+    return (_agentService !== null &&
+        _agentRuntimeManager !== null &&
+        _autonomousCoordinator !== null);
+}
+let _taskInteractor = null;
+export function configureTaskInteractor(interactor) {
+    assertFn(interactor, "taskInteractor", ["executeTask"]);
+    _taskInteractor = interactor;
+}
+export function getTaskInteractor() {
+    if (!_taskInteractor) {
+        throw new Error("TaskInteractor not configured. Call configureTaskInteractor() first.");
+    }
+    return _taskInteractor;
+}

package/dist/generation/TrajectoryGenerator.js

@@ -0,0 +1,244 @@
+/**
+ * TrajectoryGenerator
+ *
+ * Generates real trajectories using real agents running in parallel.
+ * Uses AutonomousCoordinator with trajectory recording enabled.
+ *
+ * Requires dependencies via configureTrainingDependencies() before use.
+ *
+ * @packageDocumentation
+ */
+import { getTrainingDataAdapter } from "../adapter";
+import { ArchetypeConfigService } from "../archetypes/ArchetypeConfigService";
+import { areAgentDependenciesConfigured, getAgentRuntimeManager, getAgentService, getAutonomousCoordinator, } from "../dependencies";
+import { logger } from "../utils/logger";
+/**
+ * Ensure dependencies are configured before use
+ */
+function ensureDependencies() {
+    if (!areAgentDependenciesConfigured()) {
+        throw new Error("Training dependencies not configured. Call configureTrainingDependencies() with agentService, agentRuntimeManager, and autonomousCoordinator first.");
+    }
+}
+/**
+ * Generator that creates and runs real agents in parallel
+ */
+export class TrajectoryGenerator {
+    config;
+    agents = new Map();
+    constructor(config) {
+        this.config = {
+            ...config,
+            recordTrajectories: true, // Always record for training
+            parallelAgents: Math.min(config.parallelAgents || 5, 10), // Cap at 10 for safety
+        };
+    }
+    /**
+     * Create agents based on archetypes
+     */
+    async createArchetypeAgents() {
+        ensureDependencies();
+        const agentService = getAgentService();
+        logger.info("Creating archetype-based agents...", {
+            archetypes: this.config.archetypes,
+            perArchetype: this.config.agentsPerArchetype,
+        }, "TrajectoryGenerator");
+        for (const archetype of this.config.archetypes) {
+            const archetypeConfig = ArchetypeConfigService.getConfig(archetype);
+            for (let i = 0; i < this.config.agentsPerArchetype; i++) {
+                // Create agent using the actual AgentService
+                // Use small initial deposit to avoid insufficient points errors
+                const agent = await agentService.createAgent({
+                    userId: this.config.managerId,
+                    name: `${archetypeConfig.name} ${i + 1}`,
+                    description: archetypeConfig.description,
+                    bio: archetypeConfig.bio,
+                    personality: archetypeConfig.personality,
+                    tradingStrategy: archetypeConfig.tradingStrategy,
+                    system: archetypeConfig.system,
+                    initialDeposit: 100, // Small deposit for training agents
+                });
+                // Update autonomous settings in agent config based on archetype
+                // Disable A2A to allow offline training without localhost server
+                await getTrainingDataAdapter().updateAgentConfig(agent.id, {
+                    autonomousTrading: archetypeConfig.actionWeights.trade > 0.3,
+                    autonomousPosting: archetypeConfig.postFrequency !== "low",
+                    autonomousCommenting: archetypeConfig.engagementStyle === "helpful" ||
+                        archetypeConfig.engagementStyle === "analytical",
+                    autonomousDMs: archetypeConfig.dmActivity,
+                    autonomousGroupChats: archetypeConfig.groupChatActivity,
+                    maxActionsPerTick: 5,
+                    a2aEnabled: false, // Disable A2A for training
+                    updatedAt: new Date(),
+                });
+                this.agents.set(agent.id, { user: agent, archetype });
+                logger.info(`Created ${archetype} agent: ${agent.username}`, {}, "TrajectoryGenerator");
+            }
+        }
+        logger.info(`Created ${this.agents.size} agents total`, {}, "TrajectoryGenerator");
+    }
+    /**
+     * Run agents in parallel batches
+     */
+    async runParallelBatch(agentIds) {
+        ensureDependencies();
+        const agentRuntimeManager = getAgentRuntimeManager();
+        const autonomousCoordinator = getAutonomousCoordinator();
+        const trajectoryIds = [];
+        const errors = [];
+        // Create promises for parallel execution
+        const promises = agentIds.map(async (agentId) => {
+            const agentInfo = this.agents.get(agentId);
+            if (!agentInfo)
+                return;
+            // Get agent runtime - disable A2A for training to avoid connection errors
+            let runtime;
+            const runtimeResult = await agentRuntimeManager.getRuntime(agentId);
+            // If runtime creation returns null/undefined, skip
+            if (!runtimeResult) {
+                logger.warn(`Runtime creation returned null for ${agentId}, skipping`, {}, "TrajectoryGenerator");
+                return;
+            }
+            runtime = runtimeResult;
+            // Apply archetype configuration to runtime character if available
+            const archetypeConfig = ArchetypeConfigService.getConfig(agentInfo.archetype);
+            const character = runtime.character;
+            if (character) {
+                character.name = archetypeConfig.name;
+                character.bio = archetypeConfig.bio.join(" ");
+                if (!character.topics) {
+                    character.topics = [];
+                }
+                // Add archetype-specific topics
+                if (archetypeConfig.preferredMarkets.includes("perpetual")) {
+                    character.topics.push("perpetual_trading", "leverage");
+                }
+                if (archetypeConfig.preferredMarkets.includes("prediction")) {
+                    character.topics.push("prediction_markets", "forecasting");
+                }
+            }
+            // Run ticks for this agent
+            for (let tick = 0; tick < this.config.ticksPerAgent; tick++) {
+                logger.debug(`Agent ${agentInfo.user.username} - Tick ${tick + 1}/${this.config.ticksPerAgent}`);
+                // Execute autonomous tick with trajectory recording
+                const result = await autonomousCoordinator.executeAutonomousTick(agentId, runtime, true);
+                if (result.trajectoryId) {
+                    trajectoryIds.push(result.trajectoryId);
+                    logger.debug(`Recorded trajectory ${result.trajectoryId} for ${agentInfo.user.username}`);
+                }
+                // Small delay between ticks
+                await new Promise((resolve) => setTimeout(resolve, 500));
+            }
+            logger.info(`Completed ${this.config.ticksPerAgent} ticks for ${agentInfo.user.username}`, {
+                trajectories: trajectoryIds.length,
+                archetype: agentInfo.archetype,
+            }, "TrajectoryGenerator");
+        });
+        // Wait for all agents in batch to complete
+        await Promise.allSettled(promises).then((results) => {
+            for (const result of results) {
+                if (result.status === "rejected") {
+                    const errorMsg = `Agent batch error: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`;
+                    logger.error(errorMsg, { error: result.reason }, "TrajectoryGenerator");
+                    errors.push(errorMsg);
+                }
+            }
+        });
+        return { trajectoryIds, errors };
+    }
+    /**
+     * Generate trajectories with parallel agent execution
+     */
+    async generate() {
+        const startTime = Date.now();
+        const result = {
+            agentsCreated: [],
+            trajectoryIds: [],
+            totalTicks: 0,
+            duration: 0,
+            errors: [],
+            archetypeStats: {},
+        };
+        // Create agents
+        await this.createArchetypeAgents();
+        result.agentsCreated = Array.from(this.agents.keys());
+        // Initialize stats
+        for (const archetype of this.config.archetypes) {
+            result.archetypeStats[archetype] = {
+                agents: 0,
+                trajectories: 0,
+                avgTicksPerAgent: 0,
+            };
+        }
+        // Count agents per archetype
+        for (const [_, agentInfo] of this.agents) {
+            const stat = result.archetypeStats[agentInfo.archetype];
+            if (stat) {
+                stat.agents++;
+            }
+        }
+        logger.info("Starting parallel trajectory generation", {
+            totalAgents: this.agents.size,
+            parallelBatches: Math.ceil(this.agents.size / this.config.parallelAgents),
+            ticksPerAgent: this.config.ticksPerAgent,
+        }, "TrajectoryGenerator");
+        // Process agents in parallel batches
+        const agentIds = Array.from(this.agents.keys());
+        for (let i = 0; i < agentIds.length; i += this.config.parallelAgents) {
+            const batch = agentIds.slice(i, i + this.config.parallelAgents);
+            logger.info(`Processing batch ${Math.floor(i / this.config.parallelAgents) + 1}/${Math.ceil(agentIds.length / this.config.parallelAgents)}`, {
+                agents: batch.length,
+            }, "TrajectoryGenerator");
+            const batchResult = await this.runParallelBatch(batch);
+            result.trajectoryIds.push(...batchResult.trajectoryIds);
+            result.errors.push(...batchResult.errors);
+            result.totalTicks += batch.length * this.config.ticksPerAgent;
+        }
+        // Calculate stats
+        for (const trajId of result.trajectoryIds) {
+            // Get trajectory to determine archetype
+            const trajectory = await getTrainingDataAdapter().getTrajectoryById(trajId);
+            if (trajectory) {
+                const agentInfo = this.agents.get(trajectory.agentId);
+                if (agentInfo) {
+                    const stat = result.archetypeStats[agentInfo.archetype];
+                    if (stat) {
+                        stat.trajectories++;
+                    }
+                }
+            }
+        }
+        // Calculate averages
+        for (const stats of Object.values(result.archetypeStats)) {
+            if (stats.agents > 0) {
+                stats.avgTicksPerAgent = stats.trajectories / stats.agents;
+            }
+        }
+        result.duration = Date.now() - startTime;
+        logger.info("Parallel generation complete", {
+            agents: result.agentsCreated.length,
+            trajectories: result.trajectoryIds.length,
+            totalTicks: result.totalTicks,
+            durationSeconds: result.duration / 1000,
+            errors: result.errors.length,
+        }, "TrajectoryGenerator");
+        return result;
+    }
+    /**
+     * Cleanup created agents (for testing)
+     */
+    async cleanup() {
+        logger.info(`Cleaning up ${this.agents.size} agents...`, {}, "TrajectoryGenerator");
+        const adapter = getTrainingDataAdapter();
+        for (const [agentId] of this.agents) {
+            await adapter.deleteUser(agentId);
+        }
+        logger.info("Cleanup complete", {}, "TrajectoryGenerator");
+    }
+}
+/**
+ * Factory function for creating parallel generator
+ */
+export async function createParallelGenerator(config) {
+    return new TrajectoryGenerator(config);
+}

package/dist/generation/index.js

@@ -0,0 +1,6 @@
+/**
+ * Generation Module
+ *
+ * Tools for generating training trajectories at scale.
+ */
+export { createParallelGenerator, TrajectoryGenerator, } from "./TrajectoryGenerator";