@elizaos/training 2.0.0-alpha.77 → 2.0.0-alpha.78

package/dist/training/MultiModelOrchestrator.js

@@ -1,349 +0,0 @@
-/**
- * Multi-Model Orchestrator
- *
- * Manages loading and inference for multiple archetype-specific models
- * within VRAM constraints. Optimized for 16GB GPUs (RTX 5090).
- *
- * Strategy:
- * - Use 4-bit quantization to fit 4+ models in 16GB VRAM
- * - LRU cache for model loading/unloading
- * - Batch inference per archetype for efficiency
- * - Real vLLM/OpenAI-compatible API integration
- */
-import { logger } from "../utils/logger";
-import { getModelForArchetype as getArchetypeModel, getMultiModelConfig, getQuantizedModelName, getVramRequirement, } from "./RLModelConfig";
-/**
- * Multi-Model Orchestrator
- *
- * Manages multiple quantized models for archetype-specific inference.
- * Uses LRU eviction when VRAM is constrained.
- */
-export class MultiModelOrchestrator {
-    config;
-    multiModelConfig;
-    loadedModels = new Map();
-    currentVramUsageGb = 0;
-    vllmAvailable = null;
-    constructor(config) {
-        this.config = {
-            vllmBaseUrl: process.env.VLLM_BASE_URL || "http://localhost:9001",
-            fallbackApiUrl: process.env.GROQ_API_URL || "https://api.groq.com/openai/v1",
-            fallbackApiKey: process.env.GROQ_API_KEY,
-            inferenceTimeoutMs: 30000,
-            ...config,
-        };
-        this.multiModelConfig = getMultiModelConfig(config.availableVramGb);
-        logger.info("MultiModelOrchestrator initialized", {
-            availableVram: `${config.availableVramGb}GB`,
-            maxConcurrentModels: this.multiModelConfig.maxConcurrentModels,
-            quantization: this.multiModelConfig.quantization,
-            tier: this.multiModelConfig.modelTier,
-            vllmUrl: this.config.vllmBaseUrl,
-            hasFallback: !!this.config.fallbackApiKey,
-        }, "MultiModelOrchestrator");
-    }
-    /**
-     * Check if vLLM server is available
-     */
-    async checkVllmAvailability() {
-        if (this.vllmAvailable !== null) {
-            return this.vllmAvailable;
-        }
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 5000);
-        try {
-            const response = await fetch(`${this.config.vllmBaseUrl}/v1/models`, {
-                signal: controller.signal,
-            });
-            clearTimeout(timeout);
-            this.vllmAvailable = response.ok;
-            if (this.vllmAvailable) {
-                logger.info("vLLM server is available", { url: this.config.vllmBaseUrl }, "MultiModelOrchestrator");
-            }
-            return this.vllmAvailable;
-        }
-        catch {
-            clearTimeout(timeout);
-            this.vllmAvailable = false;
-            logger.warn("vLLM server not available, will use fallback", { url: this.config.vllmBaseUrl }, "MultiModelOrchestrator");
-            return false;
-        }
-    }
-    /**
-     * Get model info for an archetype
-     */
-    getModelForArchetype(archetype) {
-        // Check if there's a trained archetype-specific model
-        const archetypeModel = getArchetypeModel(archetype);
-        if (archetypeModel) {
-            return {
-                modelId: archetypeModel.modelPath || archetypeModel.modelId,
-                tier: this.config.defaultTier,
-                quantization: this.config.defaultQuantization,
-                vramGb: getVramRequirement(this.config.defaultTier, this.config.defaultQuantization),
-            };
-        }
-        // Use default tier and quantization
-        const tier = this.config.defaultTier;
-        const quantization = this.config.defaultQuantization;
-        const modelId = getQuantizedModelName(tier, quantization);
-        const vramGb = getVramRequirement(tier, quantization);
-        return { modelId, tier, quantization, vramGb };
-    }
-    /**
-     * Check if we can load a model given current VRAM usage
-     */
-    canLoadModel(vramRequired) {
-        const availableVram = this.config.availableVramGb - this.currentVramUsageGb;
-        return availableVram >= vramRequired;
-    }
-    /**
-     * Evict least recently used model to free VRAM
-     */
-    evictLRUModel() {
-        if (this.loadedModels.size === 0)
-            return;
-        let lruArchetype = null;
-        let lruTime = Infinity;
-        for (const [archetype, model] of this.loadedModels) {
-            if (model.lastUsed < lruTime) {
-                lruTime = model.lastUsed;
-                lruArchetype = archetype;
-            }
-        }
-        if (lruArchetype) {
-            const model = this.loadedModels.get(lruArchetype);
-            if (model) {
-                this.currentVramUsageGb -= model.vramUsageGb;
-                this.loadedModels.delete(lruArchetype);
-                logger.info(`Evicted model for archetype: ${lruArchetype}`, {
-                    freedVram: `${model.vramUsageGb}GB`,
-                    currentUsage: `${this.currentVramUsageGb}GB`,
-                }, "MultiModelOrchestrator");
-            }
-        }
-    }
-    /**
-     * Load a model for an archetype (tracks VRAM usage)
-     */
-    async loadModelForArchetype(archetype) {
-        const existing = this.loadedModels.get(archetype);
-        if (existing) {
-            existing.lastUsed = Date.now();
-            return existing;
-        }
-        const modelInfo = this.getModelForArchetype(archetype);
-        // Evict models if necessary to make room
-        while (!this.canLoadModel(modelInfo.vramGb) && this.loadedModels.size > 0) {
-            this.evictLRUModel();
-        }
-        if (!this.canLoadModel(modelInfo.vramGb)) {
-            throw new Error(`Cannot load model for ${archetype}: insufficient VRAM. ` +
-                `Required: ${modelInfo.vramGb}GB, Available: ${this.config.availableVramGb - this.currentVramUsageGb}GB`);
-        }
-        const loadedModel = {
-            archetype,
-            modelId: modelInfo.modelId,
-            tier: modelInfo.tier,
-            quantization: modelInfo.quantization,
-            vramUsageGb: modelInfo.vramGb,
-            lastUsed: Date.now(),
-            inferenceCount: 0,
-        };
-        this.loadedModels.set(archetype, loadedModel);
-        this.currentVramUsageGb += modelInfo.vramGb;
-        logger.info(`Loaded model for archetype: ${archetype}`, {
-            modelId: modelInfo.modelId,
-            vramUsed: `${modelInfo.vramGb}GB`,
-            totalVramUsed: `${this.currentVramUsageGb}GB`,
-            modelsLoaded: this.loadedModels.size,
-        }, "MultiModelOrchestrator");
-        return loadedModel;
-    }
-    /**
-     * Call vLLM server for inference
-     */
-    async callVllm(modelId, prompt, systemPrompt, maxTokens, temperature) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.inferenceTimeoutMs);
-        const response = await fetch(`${this.config.vllmBaseUrl}/v1/chat/completions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                model: modelId,
-                messages: [
-                    { role: "system", content: systemPrompt },
-                    { role: "user", content: prompt },
-                ],
-                max_tokens: maxTokens,
-                temperature,
-            }),
-            signal: controller.signal,
-        });
-        clearTimeout(timeout);
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`vLLM request failed: ${response.status} - ${error}`);
-        }
-        return response.json();
-    }
-    /**
-     * Call fallback API (Groq/OpenAI) for inference
-     */
-    async callFallbackApi(prompt, systemPrompt, maxTokens, temperature) {
-        if (!this.config.fallbackApiKey) {
-            throw new Error("No fallback API key configured. Set GROQ_API_KEY environment variable.");
-        }
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.inferenceTimeoutMs);
-        // Use a fast model for fallback
-        const fallbackModel = "llama-3.1-8b-instant";
-        const response = await fetch(`${this.config.fallbackApiUrl}/chat/completions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this.config.fallbackApiKey}`,
-            },
-            body: JSON.stringify({
-                model: fallbackModel,
-                messages: [
-                    { role: "system", content: systemPrompt },
-                    { role: "user", content: prompt },
-                ],
-                max_tokens: maxTokens,
-                temperature,
-            }),
-            signal: controller.signal,
-        });
-        clearTimeout(timeout);
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Fallback API request failed: ${response.status} - ${error}`);
-        }
-        return response.json();
-    }
-    /**
-     * Run inference for an archetype
-     */
-    async inference(request) {
-        const startTime = Date.now();
-        // Ensure model is loaded (for VRAM tracking)
-        const model = await this.loadModelForArchetype(request.archetype);
-        model.inferenceCount++;
-        const systemPrompt = request.systemPrompt ||
-            `You are an AI agent with the ${request.archetype} archetype. Respond appropriately to the given situation.`;
-        const maxTokens = request.maxTokens || 512;
-        const temperature = request.temperature ?? 0.7;
-        try {
-            // Try vLLM first
-            const vllmAvailable = await this.checkVllmAvailability();
-            let completion;
-            if (vllmAvailable) {
-                completion = await this.callVllm(model.modelId, request.prompt, systemPrompt, maxTokens, temperature);
-            }
-            else {
-                // Fall back to Groq/OpenAI
-                completion = await this.callFallbackApi(request.prompt, systemPrompt, maxTokens, temperature);
-            }
-            const latencyMs = Date.now() - startTime;
-            const response = completion.choices[0]?.message.content || "";
-            const tokensGenerated = completion.usage?.completion_tokens || 0;
-            logger.debug(`Inference completed for ${request.archetype}`, {
-                modelId: model.modelId,
-                latencyMs,
-                tokensGenerated,
-                usedVllm: vllmAvailable,
-            }, "MultiModelOrchestrator");
-            return {
-                archetype: request.archetype,
-                response,
-                modelId: model.modelId,
-                latencyMs,
-                tokensGenerated,
-            };
-        }
-        catch (error) {
-            const latencyMs = Date.now() - startTime;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error(`Inference failed for ${request.archetype}`, { error: errorMessage, latencyMs }, "MultiModelOrchestrator");
-            return {
-                archetype: request.archetype,
-                response: "",
-                modelId: model.modelId,
-                latencyMs,
-                tokensGenerated: 0,
-                error: errorMessage,
-            };
-        }
-    }
-    /**
-     * Batch inference for multiple archetypes
-     */
-    async batchInference(requests) {
-        // Group requests by archetype for efficient batching
-        const byArchetype = new Map();
-        for (const req of requests) {
-            const existing = byArchetype.get(req.archetype) || [];
-            existing.push(req);
-            byArchetype.set(req.archetype, existing);
-        }
-        const results = [];
-        // Process each archetype's requests
-        for (const [archetype, archetypeRequests] of byArchetype) {
-            // Load model once per archetype
-            await this.loadModelForArchetype(archetype);
-            // Process all requests for this archetype in parallel (up to 5 concurrent)
-            const batchSize = 5;
-            for (let i = 0; i < archetypeRequests.length; i += batchSize) {
-                const batch = archetypeRequests.slice(i, i + batchSize);
-                const batchResults = await Promise.all(batch.map((req) => this.inference(req)));
-                results.push(...batchResults);
-            }
-        }
-        return results;
-    }
-    /**
-     * Get current orchestrator status
-     */
-    getStatus() {
-        const loadedModels = Array.from(this.loadedModels.values()).map((m) => ({
-            archetype: m.archetype,
-            modelId: m.modelId,
-            vramGb: m.vramUsageGb,
-            inferenceCount: m.inferenceCount,
-        }));
-        return {
-            loadedModels,
-            totalVramUsed: this.currentVramUsageGb,
-            availableVram: this.config.availableVramGb - this.currentVramUsageGb,
-            maxConcurrentModels: this.multiModelConfig.maxConcurrentModels,
-            vllmAvailable: this.vllmAvailable,
-        };
-    }
-    /**
-     * Unload all models
-     */
-    unloadAll() {
-        this.loadedModels.clear();
-        this.currentVramUsageGb = 0;
-        logger.info("Unloaded all models", {}, "MultiModelOrchestrator");
-    }
-    /**
-     * Reset vLLM availability check (force re-check on next inference)
-     */
-    resetAvailabilityCheck() {
-        this.vllmAvailable = null;
-    }
-}
-/**
- * Create a multi-model orchestrator with sensible defaults for RTX 5090 (16GB)
- */
-export function createMultiModelOrchestrator(vramGb = 16) {
-    return new MultiModelOrchestrator({
-        availableVramGb: vramGb,
-        defaultTier: "small",
-        defaultQuantization: "4bit",
-    });
-}

package/dist/training/RLModelConfig.js

@@ -1,295 +0,0 @@
-/**
- * RL Model Configuration
- *
- * Controls when and how RL-trained models are used for inference.
- * Designed to be:
- * - Enabled by default in local development
- * - Disabled by default in production
- * - Easy to toggle via environment variables
- * - Scalable to larger models when more memory is available
- * - Support quantized models for efficient multi-model loading
- */
-/**
- * Available model tiers - scale up when resources allow
- * All models have 128K context (critical requirement)
- * Quantized models reduce VRAM by ~4x (4-bit) or ~2x (8-bit)
- */
-export const MODEL_TIERS = {
-    small: {
-        name: "Small (4B)",
-        model: "unsloth/Qwen3-4B-128K",
-        quantizedModel4bit: "unsloth/Qwen3-4B-128K-bnb-4bit",
-        quantizedModel8bit: "unsloth/Qwen3-4B-128K-GGUF",
-        params: "4B",
-        context: 131072, // 128K context
-        minVramGb: 8,
-        minVramGb4bit: 3,
-        minVramGb8bit: 5,
-    },
-    medium: {
-        name: "Medium (8B)",
-        model: "unsloth/Qwen3-8B-128K",
-        quantizedModel4bit: "unsloth/Qwen3-8B-128K-bnb-4bit",
-        quantizedModel8bit: "unsloth/Qwen3-8B-128K-GGUF",
-        params: "8B",
-        context: 131072, // 128K context
-        minVramGb: 16,
-        minVramGb4bit: 5,
-        minVramGb8bit: 9,
-    },
-    large: {
-        name: "Large (14B)",
-        model: "unsloth/Qwen3-14B-128K",
-        quantizedModel4bit: "unsloth/Qwen3-14B-128K-bnb-4bit",
-        quantizedModel8bit: "unsloth/Qwen3-14B-128K-GGUF",
-        params: "14B",
-        context: 131072, // 128K context
-        minVramGb: 24,
-        minVramGb4bit: 8,
-        minVramGb8bit: 14,
-    },
-    xlarge: {
-        name: "XLarge (32B)",
-        model: "unsloth/Qwen3-32B-128K",
-        quantizedModel4bit: "unsloth/Qwen3-32B-128K-bnb-4bit",
-        quantizedModel8bit: "unsloth/Qwen3-32B-128K-GGUF",
-        params: "32B",
-        context: 131072, // 128K context
-        minVramGb: 48,
-        minVramGb4bit: 16,
-        minVramGb8bit: 28,
-    },
-};
-/**
- * Calculate optimal multi-model configuration for available VRAM
- * Optimizes for running multiple archetype models simultaneously
- */
-export function getMultiModelConfig(vramGb) {
-    // For 16GB VRAM, we want to run 4+ models using 4-bit quantization
-    // Each 4B model at 4-bit uses ~3GB VRAM
-    // Each 8B model at 4-bit uses ~5GB VRAM
-    if (vramGb >= 16) {
-        // 16GB: Can run 4x 4B models (4-bit) or 3x 8B models (4-bit)
-        // Prefer 4B for more archetype coverage
-        return {
-            totalVramGb: vramGb,
-            maxConcurrentModels: 4,
-            quantization: "4bit",
-            modelTier: "small",
-        };
-    }
-    else if (vramGb >= 12) {
-        // 12GB: Can run 3x 4B models (4-bit)
-        return {
-            totalVramGb: vramGb,
-            maxConcurrentModels: 3,
-            quantization: "4bit",
-            modelTier: "small",
-        };
-    }
-    else if (vramGb >= 8) {
-        // 8GB: Can run 2x 4B models (4-bit)
-        return {
-            totalVramGb: vramGb,
-            maxConcurrentModels: 2,
-            quantization: "4bit",
-            modelTier: "small",
-        };
-    }
-    // Less than 8GB: Single model only
-    return {
-        totalVramGb: vramGb,
-        maxConcurrentModels: 1,
-        quantization: "4bit",
-        modelTier: "small",
-    };
-}
-/**
- * Get the model name based on quantization mode
- */
-export function getQuantizedModelName(tier, quantization) {
-    const tierConfig = MODEL_TIERS[tier];
-    switch (quantization) {
-        case "4bit":
-            return tierConfig.quantizedModel4bit || tierConfig.model;
-        case "8bit":
-            return tierConfig.quantizedModel8bit || tierConfig.model;
-        default:
-            return tierConfig.model;
-    }
-}
-/**
- * Get VRAM requirement based on tier and quantization
- */
-export function getVramRequirement(tier, quantization) {
-    const tierConfig = MODEL_TIERS[tier];
-    switch (quantization) {
-        case "4bit":
-            return tierConfig.minVramGb4bit;
-        case "8bit":
-            return tierConfig.minVramGb8bit;
-        default:
-            return tierConfig.minVramGb;
-    }
-}
-/**
- * Registry of trained models per archetype
- * Maps archetype -> best available model
- */
-const archetypeModelRegistry = new Map();
-/**
- * Register a trained model for an archetype
- */
-export function registerArchetypeModel(config) {
-    const existing = archetypeModelRegistry.get(config.archetype);
-    if (!existing ||
-        (config.benchmarkScore &&
-            (!existing.benchmarkScore ||
-                config.benchmarkScore > existing.benchmarkScore))) {
-        archetypeModelRegistry.set(config.archetype, config);
-        console.log(`📦 Registered model for archetype '${config.archetype}': ${config.modelId}`);
-    }
-}
-/**
- * Get the best model for a specific archetype
- * Falls back to base model if no archetype-specific model exists
- */
-export function getModelForArchetype(archetype) {
-    const normalized = archetype.toLowerCase().trim().replace(/_/g, "-");
-    return archetypeModelRegistry.get(normalized) || null;
-}
-/**
- * Get all registered archetype models
- */
-export function getAllArchetypeModels() {
-    return Array.from(archetypeModelRegistry.values());
-}
-/**
- * Check if an archetype has a trained model
- */
-export function hasArchetypeModel(archetype) {
-    const normalized = archetype.toLowerCase().trim().replace(/_/g, "-");
-    return archetypeModelRegistry.has(normalized);
-}
-/**
- * Clear all registered models
- */
-export function clearArchetypeModels() {
-    archetypeModelRegistry.clear();
-}
-/**
- * Get the appropriate model tier based on available VRAM
- */
-export function getModelTierForVram(vramGb) {
-    if (vramGb >= MODEL_TIERS.xlarge.minVramGb)
-        return "xlarge";
-    if (vramGb >= MODEL_TIERS.large.minVramGb)
-        return "large";
-    if (vramGb >= MODEL_TIERS.medium.minVramGb)
-        return "medium";
-    return "small";
-}
-/**
- * Get model for a specific tier
- */
-export function getModelForTier(tier) {
-    return MODEL_TIERS[tier].model;
-}
-/**
- * Get RL model configuration from environment
- */
-export function getRLModelConfig() {
-    const isProduction = process.env.NODE_ENV === "production";
-    const isLocal = process.env.NODE_ENV === "development" || !isProduction;
-    // Explicit enable/disable flag
-    const explicitFlag = process.env.USE_RL_MODEL;
-    // Determine if enabled:
-    // - If USE_RL_MODEL is explicitly set, use that value
-    // - Otherwise, enabled in local, disabled in production
-    const enabled = explicitFlag ? explicitFlag === "true" : isLocal;
-    // Check for explicit tier or VRAM override
-    const explicitTier = process.env.MODEL_TIER;
-    const explicitVram = process.env.AVAILABLE_VRAM_GB
-        ? parseInt(process.env.AVAILABLE_VRAM_GB, 10)
-        : 16; // Default to 16GB (RTX 5090)
-    // Determine quantization mode: explicit or auto-detect based on VRAM
-    const explicitQuant = process.env.MODEL_QUANTIZATION;
-    const quantization = explicitQuant || "4bit"; // Default to 4-bit for efficiency
-    // Get multi-model config based on available VRAM
-    const multiModelConfig = getMultiModelConfig(explicitVram);
-    // Determine tier: explicit tier > tier from multi-model config > default small
-    let modelTier = "small";
-    if (explicitTier && MODEL_TIERS[explicitTier]) {
-        modelTier = explicitTier;
-    }
-    else {
-        modelTier = multiModelConfig.modelTier;
-    }
-    // Use explicit BASE_MODEL if set, otherwise use quantized tier-based model
-    const baseModel = process.env.BASE_MODEL || getQuantizedModelName(modelTier, quantization);
-    return {
-        enabled,
-        atroposApiUrl: process.env.ATROPOS_API_URL || "http://localhost:8000",
-        vllmPort: parseInt(process.env.VLLM_PORT || "9001", 10),
-        modelVersion: process.env.RL_MODEL_VERSION, // Optional: pin to specific version
-        fallbackToBase: process.env.RL_FALLBACK_TO_BASE !== "false", // Default: true
-        baseModel,
-        modelTier,
-        availableVramGb: explicitVram,
-        quantization,
-        multiModelConfig,
-    };
-}
-/**
- * Check if RL models are available and configured
- */
-export function isRLModelAvailable() {
-    const config = getRLModelConfig();
-    if (!config.enabled) {
-        return false;
-    }
-    // Need Atropos API URL to fetch RL models
-    if (!config.atroposApiUrl) {
-        console.warn("RL models enabled but Atropos API URL missing. Set ATROPOS_API_URL.");
-        return false;
-    }
-    return true;
-}
-/**
- * Log configuration on startup
- */
-export function logRLModelConfig() {
-    const config = getRLModelConfig();
-    const available = isRLModelAvailable();
-    const tierConfig = MODEL_TIERS[config.modelTier];
-    const vramPerModel = getVramRequirement(config.modelTier, config.quantization);
-    console.log("🤖 RL Model Configuration:", {
-        enabled: config.enabled,
-        available,
-        atroposConfigured: !!config.atroposApiUrl,
-        vllmPort: config.vllmPort,
-        pinnedVersion: config.modelVersion || "latest",
-        fallbackEnabled: config.fallbackToBase,
-        baseModel: config.baseModel,
-        modelTier: config.modelTier,
-        tierName: tierConfig.name,
-        tierParams: tierConfig.params,
-        contextWindow: tierConfig.context,
-        availableVramGb: config.availableVramGb || "auto",
-        quantization: config.quantization,
-        vramPerModel: `${vramPerModel}GB`,
-        maxConcurrentModels: config.multiModelConfig.maxConcurrentModels,
-    });
-}
-/**
- * Get all available model tiers with their configurations
- */
-export function getAvailableModelTiers() {
-    return Object.values(MODEL_TIERS);
-}
-/**
- * Check if a specific model tier is available based on VRAM
- */
-export function isTierAvailable(tier, vramGb) {
-    return vramGb >= MODEL_TIERS[tier].minVramGb;
-}