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

package/dist/huggingface/shared/HuggingFaceUploadUtil.js

@@ -0,0 +1,144 @@
+/**
+ * HuggingFace Upload Utility
+ *
+ * Shared utility for uploading files to HuggingFace Hub.
+ * Consolidates upload logic used across different services.
+ */
+import { exec } from "node:child_process";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import * as hubModule from "@huggingface/hub";
+import { logger } from "../../utils/logger";
+/**
+ * Get HuggingFace token from environment variables
+ *
+ * Checks both HUGGING_FACE_TOKEN and HF_TOKEN for compatibility
+ * with different HuggingFace tooling conventions.
+ *
+ * @returns Token string or undefined if not set
+ */
+export function getHuggingFaceToken() {
+    return process.env.HUGGING_FACE_TOKEN || process.env.HF_TOKEN;
+}
+/**
+ * Get HuggingFace token or throw error if not set
+ *
+ * @throws Error if token is not configured
+ * @returns Token string
+ */
+export function requireHuggingFaceToken() {
+    const token = getHuggingFaceToken();
+    if (!token) {
+        throw new Error("HuggingFace token not configured. Set HUGGING_FACE_TOKEN or HF_TOKEN environment variable.");
+    }
+    return token;
+}
+/**
+ * Upload a single file to HuggingFace Hub
+ */
+export async function uploadFileToHub(repoName, repoType, filePath, fileContent, token) {
+    const uploadFile = hubModule.uploadFile;
+    await uploadFile({
+        repo: { type: repoType, name: repoName },
+        file: {
+            path: filePath,
+            content: new Blob([fileContent]),
+        },
+        credentials: {
+            accessToken: token,
+        },
+    });
+    logger.info(`Uploaded ${filePath} to ${repoName}`, {
+        repo: repoName,
+        type: repoType,
+    });
+}
+/**
+ * Upload directory to HuggingFace Hub
+ */
+export async function uploadDirectoryToHub(repoName, repoType, localDir, token) {
+    const files = await fs.readdir(localDir);
+    let uploadCount = 0;
+    for (const file of files) {
+        const filePath = path.join(localDir, file);
+        const stats = await fs.stat(filePath);
+        if (stats.isFile()) {
+            const content = await fs.readFile(filePath, "utf-8");
+            await uploadFileToHub(repoName, repoType, file, content, token);
+            uploadCount++;
+        }
+    }
+    logger.info(`Uploaded ${uploadCount} files to ${repoName}`, {
+        repo: repoName,
+        count: uploadCount,
+    });
+    return uploadCount;
+}
+/**
+ * Ensure repository exists (create if needed)
+ */
+export async function ensureHubRepository(repoName, repoType, token, isPrivate = false) {
+    const createRepo = hubModule.createRepo;
+    try {
+        await createRepo({
+            repo: { type: repoType, name: repoName },
+            credentials: { accessToken: token },
+            private: isPrivate,
+        });
+        logger.info("Created new repository", { repo: repoName, type: repoType });
+    }
+    catch (error) {
+        // Repository might already exist, which is fine
+        if (error instanceof Error &&
+            (error.message.includes("already exists") ||
+                error.message.includes("Repository not found"))) {
+            logger.info("Repository already exists or accessible", {
+                repo: repoName,
+            });
+        }
+        else {
+            logger.warn("Could not ensure repository exists", {
+                error,
+                repo: repoName,
+            });
+        }
+    }
+}
+/**
+ * Upload using huggingface-cli (fallback method)
+ */
+export async function uploadViaCLI(repoName, repoType, localDir, token) {
+    try {
+        const execAsync = promisify(exec);
+        // Set token as environment variable
+        process.env.HUGGINGFACE_HUB_TOKEN = token;
+        console.log(`Uploading ${localDir} to ${repoName} via huggingface-cli...`);
+        await execAsync(`huggingface-cli upload ${repoName} ${localDir} --repo-type ${repoType}`);
+        logger.info("Successfully uploaded via huggingface-cli", {
+            repo: repoName,
+        });
+    }
+    catch (error) {
+        logger.error("CLI upload failed", { error });
+        throw error;
+    }
+}
+/**
+ * Provide manual upload instructions
+ */
+export function getManualUploadInstructions(repoName, repoType, localDir) {
+    return [
+        "1. Install huggingface-cli: pip install huggingface_hub",
+        "2. Login: huggingface-cli login",
+        `3. Upload: huggingface-cli upload ${repoName} ${localDir} --repo-type ${repoType}`,
+    ];
+}
+/** @deprecated Use uploadFileToHub, uploadDirectoryToHub, etc. instead */
+export const HuggingFaceUploadUtil = {
+    uploadFile: uploadFileToHub,
+    uploadDirectory: uploadDirectoryToHub,
+    ensureRepository: ensureHubRepository,
+    uploadViaCLI,
+    getManualUploadInstructions,
+};

package/dist/index.js

@@ -0,0 +1,41 @@
+/**
+ * ElizaOS Training Package
+ *
+ * A reusable RL training pipeline for agent trajectories including:
+ * - Benchmarking and evaluation
+ * - Automated training orchestration
+ * - HuggingFace publishing helpers
+ * - Archetype-aware scoring utilities
+ *
+ * ## Setup
+ *
+ * Before using training operations, register a data adapter:
+ *
+ * ```ts
+ * import { setTrainingDataAdapter } from '@elizaos/training';
+ * setTrainingDataAdapter(myDrizzleAdapter);
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Data adapter (must be registered before DB-dependent operations)
+export { getLlmLogAdapter, getMarketDataAdapter, getTrainingDataAdapter, isDataAdapterRegistered, resetAdapters, setLlmLogAdapter, setMarketDataAdapter, setTrainingDataAdapter, } from "./adapter";
+// Archetypes
+export * from "./archetypes";
+// Re-export all sub-modules
+export * from "./benchmark";
+// Dependencies configuration
+export { areAgentDependenciesConfigured, areDependenciesConfigured, configureTrainingDependencies, getAgentRuntimeManager, getAgentService, getAutonomousCoordinator, getExportGroupedForGRPO, getExportToHuggingFace, getLLMCaller, getToTrainingMessages, } from "./dependencies";
+// Generation
+export * from "./generation";
+export * from "./huggingface";
+// Training initialization
+export { initializeTrainingPackage, isTrainingInitialized, resetTrainingInitialization, } from "./init-training";
+// Metrics (re-export for backwards compatibility, prefer import from './metrics')
+export * from "./metrics";
+export * from "./rubrics";
+export * from "./scoring";
+export * from "./training";
+export { benchmarkAndMaybeDeployModel, checkTrainingReadiness, deployModelVersion, getAutomationPipelineStatus, getNextTrainingModelSelection, monitorTrainingJob, rollbackModelVersion, triggerTraining, } from "./training/pipeline";
+// Utilities
+export * from "./utils";

package/dist/init-training.js

@@ -0,0 +1,43 @@
+/**
+ * Training Package Initialization
+ *
+ * This module sets up all dependencies required by the training package.
+ * Import this before using TrajectoryGenerator or other training services.
+ *
+ * Usage:
+ *   import { configureTrainingDependencies, initializeTrainingPackage } from '@elizaos/training';
+ *   configureTrainingDependencies({ ... });
+ *   await initializeTrainingPackage();
+ */
+import { areDependenciesConfigured } from "./dependencies";
+import { logger } from "./utils/logger";
+let initialized = false;
+/**
+ * Initialize training package.
+ *
+ * External dependencies must be configured first via `configureTrainingDependencies`.
+ */
+export async function initializeTrainingPackage() {
+    if (initialized) {
+        logger.debug("Training package already initialized", {}, "TrainingInit");
+        return;
+    }
+    logger.info("Initializing training package...", {}, "TrainingInit");
+    if (!areDependenciesConfigured()) {
+        throw new Error("Training dependencies not configured. Call configureTrainingDependencies() first.");
+    }
+    initialized = true;
+    logger.info("Training package initialized successfully", {}, "TrainingInit");
+}
+/**
+ * Check if training package is initialized
+ */
+export function isTrainingInitialized() {
+    return initialized;
+}
+/**
+ * Reset initialization state (for testing)
+ */
+export function resetTrainingInitialization() {
+    initialized = false;
+}