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

package/dist/training/logRLConfig.js

@@ -0,0 +1,29 @@
+/**
+ * RL Configuration Logger
+ *
+ * Logs RL model configuration and availability on server startup.
+ * Used for diagnostics and verification during deployment.
+ */
+import { isRLModelAvailable, logRLModelConfig } from "./RLModelConfig";
+/**
+ * Log RL model configuration and verify setup
+ *
+ * Call this on server startup to display configuration details
+ * and verify that the RL training system is properly configured.
+ */
+export async function logRLConfigOnStartup() {
+    console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("🚀 RL Training System Configuration");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+    // Log RL configuration
+    logRLModelConfig();
+    // Check if RL models are available
+    const available = isRLModelAvailable();
+    if (available) {
+        console.log("\n✅ RL Model system available");
+    }
+    else {
+        console.log("\nℹ️  RL models not available - using base model");
+    }
+    console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+}

package/dist/training/pipeline.js

@@ -0,0 +1,80 @@
+/**
+ * Training Pipeline – public helpers
+ *
+ * IMPORTANT: All heavy modules (AutomationPipeline, ModelDeployer) are loaded
+ * lazily so that importing this file does NOT trigger a database connection.
+ * Consumers that only need types or lightweight utilities can import
+ * "@elizaos/training" without side-effects.
+ */
+// ---------------------------------------------------------------------------
+// Lazy singletons – only resolved on first call to avoid DB side-effects at
+// module-load time.
+// ---------------------------------------------------------------------------
+let _pipeline = null;
+async function getPipeline() {
+    if (!_pipeline) {
+        const mod = await import("./AutomationPipeline");
+        _pipeline = mod.automationPipeline;
+    }
+    return _pipeline;
+}
+async function getDeployer() {
+    const mod = await import("./ModelDeployer");
+    return mod.modelDeployer;
+}
+/**
+ * Check whether the current trajectory set is ready for training.
+ */
+export async function checkTrainingReadiness() {
+    const pipeline = await getPipeline();
+    return pipeline.checkTrainingReadiness();
+}
+/**
+ * Trigger a new training job.
+ */
+export async function triggerTraining(options = {}) {
+    const pipeline = await getPipeline();
+    return pipeline.triggerTraining(options);
+}
+/**
+ * Monitor a training batch by its batch id.
+ */
+export async function monitorTrainingJob(batchId) {
+    const pipeline = await getPipeline();
+    return pipeline.monitorTraining(batchId);
+}
+/**
+ * Get summarized status for automation, jobs, and model health.
+ */
+export async function getAutomationPipelineStatus() {
+    const pipeline = await getPipeline();
+    return pipeline.getStatus();
+}
+/**
+ * Get model-selection metadata for the next run.
+ */
+export async function getNextTrainingModelSelection() {
+    const pipeline = await getPipeline();
+    return pipeline.getModelSelectionInfo();
+}
+/**
+ * Run benchmark and deploy the model only if it passes thresholds.
+ */
+export async function benchmarkAndMaybeDeployModel(batchId, autoDeploy = true) {
+    const pipeline = await getPipeline();
+    return pipeline.benchmarkAndDeploy(batchId, autoDeploy);
+}
+/**
+ * Deploy a specific model version using the deployment strategy options.
+ */
+export async function deployModelVersion(options) {
+    const deployer = await getDeployer();
+    return deployer.deploy(options);
+}
+/**
+ * Roll back from one version to another.
+ */
+export async function rollbackModelVersion(currentVersion, targetVersion) {
+    const deployer = await getDeployer();
+    return deployer.rollback(currentVersion, targetVersion);
+}

package/dist/training/storage/ModelStorageService.js

@@ -0,0 +1,190 @@
+/**
+ * Model Storage Service (Vercel Blob)
+ *
+ * Handles model versioning and storage using Vercel Blob.
+ * Stores trained models with metadata for easy deployment.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { del, list, put } from "@vercel/blob";
+import { getTrainingDataAdapter } from "../../adapter";
+import { logger } from "../../utils/logger";
+export class ModelStorageService {
+    blobPrefix = "models/";
+    /**
+     * Upload trained model to Vercel Blob
+     */
+    async uploadModel(options) {
+        logger.info("Uploading model to Vercel Blob", {
+            version: options.version,
+            path: options.modelPath,
+        });
+        // Read model file
+        const modelData = await fs.readFile(options.modelPath);
+        const fileName = path.basename(options.modelPath);
+        // Upload to Vercel Blob
+        const blob = await put(`${this.blobPrefix}${options.version}/${fileName}`, modelData, {
+            access: "public", // Models can be publicly downloaded
+            addRandomSuffix: false,
+        });
+        // Upload metadata
+        await put(`${this.blobPrefix}${options.version}/metadata.json`, JSON.stringify(options.metadata || {}, null, 2), {
+            access: "public",
+            addRandomSuffix: false,
+        });
+        logger.info("Model uploaded to Vercel Blob", {
+            version: options.version,
+            url: blob.url,
+            size: blob.size || 0,
+        });
+        const metadataModelIdPrefix = typeof options.metadata?.modelIdPrefix === "string"
+            ? options.metadata.modelIdPrefix
+            : undefined;
+        const modelIdPrefix = options.modelIdPrefix ||
+            metadataModelIdPrefix ||
+            process.env.TRAINING_MODEL_ID_PREFIX ||
+            "eliza-agent";
+        // Save to database via adapter
+        const adapter = getTrainingDataAdapter();
+        await adapter.insertModel({
+            id: `model-${Date.now()}`,
+            modelId: `${modelIdPrefix}-${options.version}`,
+            version: options.version,
+            baseModel: options.metadata?.baseModel || "unsloth/Qwen3-4B-128K",
+            trainingBatch: options.metadata?.trainingBatch || null,
+            status: "ready",
+            deployedAt: null,
+            archivedAt: null,
+            storagePath: blob.url,
+            benchmarkScore: null,
+            accuracy: options.metadata?.accuracy || null,
+            avgReward: options.metadata?.avgReward || null,
+            evalMetrics: null,
+            wandbRunId: null,
+            wandbArtifactId: null,
+            huggingFaceRepo: null,
+            agentsUsing: 0,
+            totalInferences: 0,
+            lastBenchmarked: null,
+            benchmarkCount: 0,
+            updatedAt: new Date(),
+        });
+        return {
+            version: options.version,
+            baseModel: options.metadata?.baseModel || "unsloth/Qwen3-4B-128K",
+            blobUrl: blob.url,
+            size: blob.size || 0,
+            uploadedAt: new Date(),
+            metadata: options.metadata || {},
+        };
+    }
+    /**
+     * Download model from Vercel Blob
+     */
+    async downloadModel(version) {
+        const adapter = getTrainingDataAdapter();
+        const model = await adapter.getModelByVersion(version);
+        if (!model) {
+            throw new Error(`Model version ${version} not found`);
+        }
+        // Download model file
+        const modelResponse = await fetch(model.storagePath);
+        const modelData = Buffer.from(await modelResponse.arrayBuffer());
+        // Download metadata
+        const metadataUrl = model.storagePath.replace(/\/[^/]+$/, "/metadata.json");
+        const metadataResponse = await fetch(metadataUrl);
+        const metadata = (await metadataResponse.json());
+        return {
+            modelData,
+            metadata,
+        };
+    }
+    /**
+     * List all model versions
+     */
+    async listModels() {
+        const { blobs } = await list({
+            prefix: this.blobPrefix,
+        });
+        const versions = new Map();
+        for (const blob of blobs) {
+            const parts = blob.pathname.split("/");
+            const version = parts[1];
+            if (!version)
+                continue;
+            if (!versions.has(version)) {
+                versions.set(version, {
+                    version,
+                    blobs: [],
+                });
+            }
+            // Convert uploadedAt to string if it's a Date
+            const blobInfo = {
+                ...blob,
+                uploadedAt: blob.uploadedAt instanceof Date
+                    ? blob.uploadedAt.toISOString()
+                    : blob.uploadedAt,
+            };
+            versions.get(version)?.blobs.push(blobInfo);
+        }
+        // Get metadata for each version
+        const models = [];
+        for (const [version, data] of versions) {
+            const modelBlob = data.blobs.find((b) => b.pathname.endsWith(".safetensors") || b.pathname.endsWith(".bin"));
+            if (modelBlob) {
+                // Try to get metadata
+                let metadata = {};
+                try {
+                    const metadataBlob = data.blobs.find((b) => b.pathname.endsWith("metadata.json"));
+                    if (metadataBlob) {
+                        const response = await fetch(metadataBlob.url);
+                        metadata = (await response.json());
+                    }
+                }
+                catch {
+                    // No metadata, use defaults
+                }
+                models.push({
+                    version,
+                    baseModel: metadata.baseModel || "unknown",
+                    blobUrl: modelBlob.url,
+                    size: modelBlob.size,
+                    uploadedAt: modelBlob.uploadedAt instanceof Date
+                        ? modelBlob.uploadedAt
+                        : new Date(modelBlob.uploadedAt),
+                    metadata,
+                });
+            }
+        }
+        return models.sort((a, b) => b.uploadedAt.getTime() - a.uploadedAt.getTime());
+    }
+    /**
+     * Delete model version
+     */
+    async deleteModel(version) {
+        const { blobs } = await list({
+            prefix: `${this.blobPrefix}${version}/`,
+        });
+        for (const blob of blobs) {
+            await del(blob.url);
+        }
+        // Update database via adapter
+        const adapter = getTrainingDataAdapter();
+        const model = await adapter.getModelByVersion(version);
+        if (model) {
+            await adapter.updateModelStatus(model.modelId, "archived", {
+                archivedAt: new Date(),
+            });
+        }
+        logger.info("Model deleted from Vercel Blob", { version });
+    }
+    /**
+     * Get latest model version
+     */
+    async getLatestVersion() {
+        const models = await this.listModels();
+        return models[0] || null;
+    }
+}
+// Singleton
+export const modelStorage = new ModelStorageService();

package/dist/training/storage/TrainingDataArchiver.js

@@ -0,0 +1,136 @@
+/**
+ * Training Data Archiver (Vercel Blob)
+ *
+ * Archives training data (exported trajectories, RULER scores) to Vercel Blob
+ * for long-term storage and reproducibility.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { del, list, put } from "@vercel/blob";
+import { logger } from "../../utils/logger";
+export class TrainingDataArchiver {
+    blobPrefix = "training-data/";
+    /**
+     * Archive training data for a window
+     */
+    async archiveWindow(options) {
+        logger.info("Archiving training data", { windowId: options.windowId });
+        const prefix = `${this.blobPrefix}${options.windowId}/`;
+        const urls = {
+            trajectories: "",
+            metadata: "",
+        };
+        let totalSize = 0;
+        // Upload trajectories
+        const trajData = await fs.readFile(options.trajectoriesPath);
+        const trajBlob = await put(`${prefix}trajectories.jsonl`, trajData, {
+            access: "public",
+            addRandomSuffix: false,
+        });
+        urls.trajectories = trajBlob.url;
+        totalSize += trajData.length;
+        // Upload groups if provided
+        if (options.groupsPath) {
+            const groupsData = await fs.readFile(options.groupsPath);
+            const groupsBlob = await put(`${prefix}groups.jsonl`, groupsData, {
+                access: "public",
+                addRandomSuffix: false,
+            });
+            urls.groups = groupsBlob.url;
+            totalSize += groupsData.length;
+        }
+        // Upload RULER scores if provided
+        if (options.rulerScoresPath) {
+            const scoresData = await fs.readFile(options.rulerScoresPath);
+            const scoresBlob = await put(`${prefix}ruler_scores.json`, scoresData, {
+                access: "public",
+                addRandomSuffix: false,
+            });
+            urls.rulerScores = scoresBlob.url;
+            totalSize += scoresData.length;
+        }
+        // Upload metadata
+        const metadataJson = JSON.stringify(options.metadata || {}, null, 2);
+        const metadataBlob = await put(`${prefix}metadata.json`, metadataJson, {
+            access: "public",
+            addRandomSuffix: false,
+        });
+        urls.metadata = metadataBlob.url;
+        totalSize += Buffer.byteLength(metadataJson, "utf8");
+        logger.info("Training data archived", {
+            windowId: options.windowId,
+            size: totalSize,
+        });
+        return {
+            windowId: options.windowId,
+            trajectoryCount: options.metadata?.trajectoryCount || 0,
+            blobUrls: urls,
+            archivedAt: new Date(),
+            size: totalSize,
+        };
+    }
+    /**
+     * Retrieve archived training data
+     */
+    async getWindowData(windowId) {
+        const prefix = `${this.blobPrefix}${windowId}/`;
+        const { blobs } = await list({ prefix });
+        if (blobs.length === 0) {
+            return null;
+        }
+        const result = {};
+        for (const blob of blobs) {
+            const response = await fetch(blob.url);
+            const filename = path.basename(blob.pathname);
+            if (filename === "trajectories.jsonl") {
+                result.trajectories = await response.text();
+            }
+            else if (filename === "groups.jsonl") {
+                result.groups = await response.text();
+            }
+            else if (filename === "ruler_scores.json") {
+                result.rulerScores = (await response.json());
+            }
+            else if (filename === "metadata.json") {
+                result.metadata = (await response.json());
+            }
+        }
+        // Ensure required fields are present
+        if (!result.trajectories || !result.metadata) {
+            return null;
+        }
+        return {
+            trajectories: result.trajectories,
+            groups: result.groups,
+            rulerScores: result.rulerScores,
+            metadata: result.metadata,
+        };
+    }
+    /**
+     * List all archived windows
+     */
+    async listWindows() {
+        const { blobs } = await list({ prefix: this.blobPrefix });
+        const windows = new Set();
+        for (const blob of blobs) {
+            const parts = blob.pathname.split("/");
+            if (parts[1]) {
+                windows.add(parts[1]);
+            }
+        }
+        return Array.from(windows).sort().reverse();
+    }
+    /**
+     * Delete archived window
+     */
+    async deleteWindow(windowId) {
+        const prefix = `${this.blobPrefix}${windowId}/`;
+        const { blobs } = await list({ prefix });
+        for (const blob of blobs) {
+            await del(blob.url);
+        }
+        logger.info("Deleted archived window", { windowId });
+    }
+}
+// Singleton
+export const trainingDataArchiver = new TrainingDataArchiver();

package/dist/training/storage/index.js

@@ -0,0 +1,7 @@
+/**
+ * Storage Module
+ *
+ * Services for storing models and training data to Vercel Blob.
+ */
+export { ModelStorageService, modelStorage, } from "./ModelStorageService";
+export { TrainingDataArchiver, trainingDataArchiver, } from "./TrainingDataArchiver";

package/dist/training/types.js

@@ -0,0 +1,6 @@
+/**
+ * TypeScript types for Training Pipeline
+ *
+ * Proper types to replace 'any' usage throughout the training system
+ */
+export {};

package/dist/training/window-utils.js

@@ -0,0 +1,100 @@
+/**
+ * Window Utility Functions
+ * Helper functions for time-window based RL training
+ */
+/**
+ * Get current window ID (hourly timestamp)
+ * Format: YYYY-MM-DDTHH:00
+ *
+ * Example: "2025-01-15T10:00"
+ */
+export function getCurrentWindowId() {
+    const now = new Date();
+    // Round down to the start of the current hour
+    const windowStart = new Date(Math.floor(now.getTime() / (60 * 60 * 1000)) * (60 * 60 * 1000));
+    // Format as ISO string, take first 13 chars + :00
+    return `${windowStart.toISOString().slice(0, 13)}:00`;
+}
+/**
+ * Get previous window ID (N hours ago)
+ *
+ * @param offset - How many hours ago (default: 1)
+ */
+export function getPreviousWindowId(offset = 1) {
+    const now = new Date();
+    const windowStart = new Date(Math.floor(now.getTime() / (60 * 60 * 1000)) * (60 * 60 * 1000));
+    // Go back N hours
+    windowStart.setHours(windowStart.getHours() - offset);
+    return `${windowStart.toISOString().slice(0, 13)}:00`;
+}
+/**
+ * Parse window ID to Date object
+ *
+ * @param windowId - Window ID string (YYYY-MM-DDTHH:00)
+ */
+export function parseWindowId(windowId) {
+    return new Date(windowId);
+}
+/**
+ * Check if a window is complete (current time is past window end)
+ *
+ * @param windowId - Window ID to check
+ * @param windowDurationHours - Window duration (default: 1 hour)
+ */
+export function isWindowComplete(windowId, windowDurationHours = 1) {
+    const windowStart = parseWindowId(windowId);
+    const windowEnd = new Date(windowStart.getTime() + windowDurationHours * 60 * 60 * 1000);
+    return Date.now() > windowEnd.getTime();
+}
+/**
+ * Get window range (start and end times)
+ *
+ * @param windowId - Window ID
+ * @param windowDurationHours - Window duration (default: 1 hour)
+ */
+export function getWindowRange(windowId, windowDurationHours = 1) {
+    const start = parseWindowId(windowId);
+    const end = new Date(start.getTime() + windowDurationHours * 60 * 60 * 1000);
+    return { start, end };
+}
+/**
+ * Generate list of window IDs for a time range
+ *
+ * @param startTime - Start time
+ * @param endTime - End time
+ * @param windowDurationHours - Window duration (default: 1 hour)
+ */
+export function generateWindowIds(startTime, endTime, windowDurationHours = 1) {
+    const windows = [];
+    const windowMs = windowDurationHours * 60 * 60 * 1000;
+    // Round start time down to window boundary
+    const currentWindowStart = new Date(Math.floor(startTime.getTime() / windowMs) * windowMs);
+    while (currentWindowStart.getTime() <= endTime.getTime()) {
+        windows.push(`${currentWindowStart.toISOString().slice(0, 13)}:00`);
+        currentWindowStart.setTime(currentWindowStart.getTime() + windowMs);
+    }
+    return windows;
+}
+/**
+ * Get window ID for a specific timestamp
+ *
+ * @param timestamp - Timestamp to get window for
+ * @param windowDurationHours - Window duration (default: 1 hour)
+ */
+export function getWindowIdForTimestamp(timestamp, windowDurationHours = 1) {
+    const windowMs = windowDurationHours * 60 * 60 * 1000;
+    const windowStart = new Date(Math.floor(timestamp.getTime() / windowMs) * windowMs);
+    return `${windowStart.toISOString().slice(0, 13)}:00`;
+}
+/**
+ * Check if a timestamp falls within a window
+ *
+ * @param timestamp - Timestamp to check
+ * @param windowId - Window ID
+ * @param windowDurationHours - Window duration (default: 1 hour)
+ */
+export function isTimestampInWindow(timestamp, windowId, windowDurationHours = 1) {
+    const { start, end } = getWindowRange(windowId, windowDurationHours);
+    const time = timestamp.getTime();
+    return time >= start.getTime() && time < end.getTime();
+}

package/dist/utils/index.js

@@ -0,0 +1,73 @@
+/**
+ * Training Package Utilities
+ */
+export { logger } from "./logger";
+export { generateSnowflakeId } from "./snowflake";
+export { assertHasLLMCalls, validateLLMCalls } from "./synthetic-detector";
+/**
+ * Split an array into batches of a specified size
+ *
+ * @param items - Array to split
+ * @param batchSize - Maximum size of each batch
+ * @returns Array of batches
+ */
+export function splitIntoBatches(items, batchSize) {
+    const batches = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+        batches.push(items.slice(i, i + batchSize));
+    }
+    return batches;
+}
+/**
+ * Calculate statistics for an array of numbers
+ *
+ * @param values - Array of numbers
+ * @returns Statistics object with mean, median, std, min, max
+ */
+export function calculateArrayStats(values) {
+    if (values.length === 0) {
+        return { mean: 0, median: 0, std: 0, min: 0, max: 0 };
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const median = sorted[Math.floor(values.length / 2)] ?? 0;
+    const variance = values.reduce((sum, val) => sum + (val - mean) ** 2, 0) / values.length;
+    const std = Math.sqrt(variance);
+    const min = sorted[0] ?? 0;
+    const max = sorted[sorted.length - 1] ?? 0;
+    return { mean, median, std, min, max };
+}
+/**
+ * Format a decimal value as a percentage string
+ *
+ * @param value - Decimal value (e.g., 0.75 for 75%)
+ * @param decimals - Number of decimal places (default: 1)
+ * @returns Formatted percentage string (e.g., "75.0%")
+ */
+export function formatPercent(value, decimals = 1) {
+    return `${(value * 100).toFixed(decimals)}%`;
+}
+/**
+ * Format a number as currency string
+ *
+ * @param value - Number value
+ * @param decimals - Number of decimal places (default: 2)
+ * @param prefix - Currency prefix (default: "$")
+ * @returns Formatted currency string (e.g., "$1,234.56")
+ */
+export function formatCurrency(value, decimals = 2, prefix = "$") {
+    const sign = value >= 0 ? "" : "-";
+    return `${sign}${prefix}${Math.abs(value).toFixed(decimals)}`;
+}
+/**
+ * Format a number as currency with explicit sign
+ *
+ * @param value - Number value
+ * @param decimals - Number of decimal places (default: 2)
+ * @param prefix - Currency prefix (default: "$")
+ * @returns Formatted currency string with sign (e.g., "+$123.45" or "-$67.89")
+ */
+export function formatCurrencyWithSign(value, decimals = 2, prefix = "$") {
+    const sign = value >= 0 ? "+" : "-";
+    return `${sign}${prefix}${Math.abs(value).toFixed(decimals)}`;
+}

package/dist/utils/logger.js

@@ -0,0 +1,55 @@
+/**
+ * Training Package Logger
+ *
+ * Simple console-based logger for the training package.
+ * Provides consistent logging format across all training services.
+ */
+function formatData(data) {
+    if (data instanceof Error) {
+        return data.message;
+    }
+    if (typeof data === "object" && data !== null) {
+        return JSON.stringify(data, null, 2);
+    }
+    return String(data);
+}
+export const logger = {
+    info: (message, data, context) => {
+        const prefix = context ? `[${context}] ` : "";
+        if (data !== undefined) {
+            console.log(`${prefix}[INFO] ${message}`, formatData(data));
+        }
+        else {
+            console.log(`${prefix}[INFO] ${message}`);
+        }
+    },
+    error: (message, data, context) => {
+        const prefix = context ? `[${context}] ` : "";
+        if (data !== undefined) {
+            console.error(`${prefix}[ERROR] ${message}`, formatData(data));
+        }
+        else {
+            console.error(`${prefix}[ERROR] ${message}`);
+        }
+    },
+    warn: (message, data, context) => {
+        const prefix = context ? `[${context}] ` : "";
+        if (data !== undefined) {
+            console.warn(`${prefix}[WARN] ${message}`, formatData(data));
+        }
+        else {
+            console.warn(`${prefix}[WARN] ${message}`);
+        }
+    },
+    debug: (message, data, context) => {
+        if (process.env.DEBUG) {
+            const prefix = context ? `[${context}] ` : "";
+            if (data !== undefined) {
+                console.log(`${prefix}[DEBUG] ${message}`, formatData(data));
+            }
+            else {
+                console.log(`${prefix}[DEBUG] ${message}`);
+            }
+        }
+    },
+};