wolverine-ai 3.9.8 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "3.9.8",
+  "version": "4.0.0",
   "description": "Self-healing Node.js server framework powered by AI. Catches crashes, diagnoses errors, generates fixes, verifies, and restarts — automatically.",
   "main": "src/index.js",
   "bin": {

package/src/brain/brain.js

@@ -130,7 +130,7 @@ const SEED_DOCS = [
     metadata: { topic: "system-detection" },
   },
   {
-    text: "Configuration: all settings in server/config/settings.json (models, port, telemetry, rate limits, health checks, clustering, cors, logging). Secrets only in .env.local (API keys, admin key). Config loader priority: env vars > settings.json > defaults. Agent can read and edit settings.json since it's inside server/.",
+    text: "Configuration: hybrid-always architecture — no provider selection. Users pick the best model for each of 8 task roles directly in settings.json 'models' section. Mix and match: wolverine for audit, claude for reasoning, gpt for coding. Provider auto-detected from model name. Embedding is separate ('embedding' key) — always wolverine-embedding-1 billed through credits (proxies to text-embedding-3-small at 2x markup). Secrets in .env.local. Config priority: env vars > settings.json > defaults.",
     metadata: { topic: "configuration" },
   },
   {
@@ -162,7 +162,7 @@ const SEED_DOCS = [
     metadata: { topic: "smart-edit" },
   },
   {
-    text: "Token tracking: every AI call tracked with input/output tokens, USD cost, latencyMs, and success/failure. Per-model KPIs: avgLatencyMs, minLatencyMs, maxLatencyMs, tokensPerSecond, successRate, costPerCall, successes, failures. Aggregated by model, by category, by tool, by provider (openai/anthropic/wolverine). 9 analytics categories match the 9 settings.json model roles: reasoning (deep debugging), coding (fast path repair + fix sub-agents), chat (dashboard), tool (main agent with tool use), classifier (triage sub-agents: explore/plan/verify), audit (injection scan + security sub-agent), compacting (brain text compression), research (research agent + research sub-agent), embedding (brain vector embeddings). All categories tracked in byModelCategory cross-reference for per-task model comparison. Persisted to .wolverine/usage.json + .wolverine/usage-history.jsonl. Telemetry sends all per-model performance data to platform backend for fleet-wide analytics.",
+    text: "Token tracking: every AI call tracked with input/output tokens, USD cost, latencyMs, success/failure, and TPOT (time per output token). 8 task roles + embedding tracked separately. Categories by ACTIVITY: audit (injection scan), classifier (error classification), reasoning (AI analyzes error), coding (code generation without tools), tool (agent using read_file/write_file/bash_exec), research (deep investigation), chat (summaries), compacting (brain compression). Embedding billed through wolverine-embedding-1 (proxies text-embedding-3-small at 2x). Benchmark metrics: Speed (tok/s), TPOT (ms/output token), Cost/Call, Pass%. All tracked in byModelCategory for per-task model comparison.",
     metadata: { topic: "token-tracking" },
   },
   {

package/src/brain/embedder.js

@@ -1,5 +1,5 @@
 const { getClient, aiCall, detectProvider, _trackEmbedding } = require("../core/ai-client");
-const { getModel } = require("../core/models");
+const { getEmbeddingModel } = require("../core/models");
 
 /**
  * Embedder — converts text to vector embeddings using TEXT_EMBEDDING_MODEL.
@@ -41,12 +41,13 @@ async function embed(text) {
   const cached = _cacheGet(text);
   if (cached) return cached;
 
-  // Embeddings always use OpenAI (Anthropic doesn't have an embedding API)
-  const openai = getClient("openai");
-  const model = getModel("embedding");
+  const model = getEmbeddingModel();
+  const provider = detectProvider(model);
+  // wolverine-embedding-1 routes through billing proxy, others go direct
+  const client = provider === "wolverine" ? getClient("wolverine") : getClient("openai");
 
   const startMs = Date.now();
-  const response = await openai.embeddings.create({
+  const response = await client.embeddings.create({
     model,
     input: text,
   });
@@ -81,12 +82,12 @@ async function embedBatch(texts) {
 
   if (uncached.length === 0) return results;
 
-  // Embeddings always use OpenAI (Anthropic doesn't have an embedding API)
-  const openai = getClient("openai");
-  const model = getModel("embedding");
+  const model = getEmbeddingModel();
+  const provider = detectProvider(model);
+  const client = provider === "wolverine" ? getClient("wolverine") : getClient("openai");
 
   const startMs = Date.now();
-  const response = await openai.embeddings.create({
+  const response = await client.embeddings.create({
     model,
     input: uncached,
   });

package/src/core/config.js

@@ -2,11 +2,15 @@ const fs = require("fs");
 const path = require("path");
 
 /**
- * Config Loader — reads wolverine.config.js, falls back to env vars.
+ * Config Loader — simplified hybrid-always architecture.
+ *
+ * No more provider selection. Users pick the best model for each task
+ * directly in settings.json. Provider is auto-detected from model name.
+ * Embedding is always wolverine-embedding-1 (billed through credits).
  *
  * Priority:
  * 1. Environment variables (highest — for CI/Docker overrides)
- * 2. wolverine.config.js (project settings)
+ * 2. settings.json models section
  * 3. Hardcoded defaults (lowest)
  */
 
@@ -15,7 +19,6 @@ let _config = null;
 function loadConfig() {
   if (_config) return _config;
 
-  // Load from server/config/settings.json
   const configPath = path.join(process.cwd(), "server", "config", "settings.json");
   let fileConfig = {};
   if (fs.existsSync(configPath)) {
@@ -26,15 +29,17 @@ function loadConfig() {
     }
   }
 
-  // Resolve provider and model set
-  // "openai" → openai_settings, "anthropic" → anthropic_settings, "hybrid" → hybrid_settings
-  const provider = process.env.WOLVERINE_PROVIDER || fileConfig.provider || "openai";
-  const settingsKey = `${provider}_settings`;
-  const modelSource = fileConfig[settingsKey] || fileConfig.openai_settings || fileConfig.models || {};
+  // Models: read from settings.json "models" section directly.
+  // Legacy support: if old provider-based config exists, migrate it.
+  let modelSource = fileConfig.models || {};
+  if (!fileConfig.models && fileConfig.provider) {
+    // Legacy: read from {provider}_settings for backward compatibility
+    const settingsKey = `${fileConfig.provider}_settings`;
+    modelSource = fileConfig[settingsKey] || fileConfig.hybrid_settings || fileConfig.openai_settings || {};
+  }
 
   _config = {
-    provider,
-
+    // 8 task-specific model slots — user picks any model for each task
     models: {
       reasoning:  process.env.REASONING_MODEL    || modelSource.reasoning  || "gpt-4o",
       coding:     process.env.CODING_MODEL       || modelSource.coding     || "gpt-4o",
@@ -45,9 +50,11 @@ function loadConfig() {
       compacting: process.env.COMPACTING_MODEL   || modelSource.compacting || "gpt-4o-mini",
       utility:    process.env.COMPACTING_MODEL   || modelSource.compacting || "gpt-4o-mini",
       research:   process.env.RESEARCH_MODEL     || modelSource.research   || "gpt-4o",
-      embedding:  process.env.TEXT_EMBEDDING_MODEL || modelSource.embedding || "text-embedding-3-small",
     },
 
+    // Embedding: separate from task models — always billed through wolverine credits
+    embedding: process.env.TEXT_EMBEDDING_MODEL || fileConfig.embedding || "wolverine-embedding-1",
+
     server: {
       port:        parseInt(process.env.PORT, 10)                    || fileConfig.server?.port        || 3000,
       maxRetries:  parseInt(process.env.WOLVERINE_MAX_RETRIES, 10)   || fileConfig.server?.maxRetries  || 3,
@@ -90,30 +97,37 @@ function loadConfig() {
     },
   };
 
-  // Merge any missing defaults into the live settings.json
-  _ensureDefaults(fileConfig, configPath);
+  // Migrate old settings.json to new format + ensure defaults
+  _migrateAndEnsureDefaults(fileConfig, configPath);
 
   return _config;
 }
 
-/**
- * Get a config value by dot path: getConfig("models.reasoning")
- */
 function getConfig(dotPath) {
   const config = loadConfig();
   return dotPath.split(".").reduce((obj, key) => obj?.[key], config);
 }
 
-/**
- * Reset config cache (for testing).
- */
 function resetConfig() { _config = null; }
 
 /**
- * Ensure the live settings.json has all required sections.
- * If a section is missing, add it with defaults. Never overwrites existing values.
+ * Migrate old provider-based config to new flat models format.
+ * Also ensure default sections exist.
  */
-function _ensureDefaults(fileConfig, configPath) {
+function _migrateAndEnsureDefaults(fileConfig, configPath) {
+  let needsWrite = false;
+
+  // Migrate: if old provider system exists, convert to flat models
+  if (fileConfig.provider && !fileConfig.models) {
+    const settingsKey = `${fileConfig.provider}_settings`;
+    const source = fileConfig[settingsKey] || {};
+    fileConfig.models = { ...source };
+    delete fileConfig.models.embedding; // embedding is now separate
+    fileConfig.embedding = source.embedding || "wolverine-embedding-1";
+    needsWrite = true;
+  }
+
+  // Ensure default sections
   const DEFAULTS = {
     autoUpdate: { enabled: true, intervalMs: 3600000 },
     errorMonitor: { defaultThreshold: 1, windowMs: 30000, cooldownMs: 60000 },
@@ -123,7 +137,6 @@ function _ensureDefaults(fileConfig, configPath) {
     cluster: { enabled: false, workers: 0 },
   };
 
-  let needsWrite = false;
   for (const [key, defaults] of Object.entries(DEFAULTS)) {
     if (!fileConfig[key]) {
       fileConfig[key] = defaults;
@@ -136,7 +149,7 @@ function _ensureDefaults(fileConfig, configPath) {
       const tmpPath = configPath + ".tmp";
       fs.writeFileSync(tmpPath, JSON.stringify(fileConfig, null, 2), "utf-8");
       fs.renameSync(tmpPath, configPath);
-    } catch { /* non-fatal — config still works from defaults in memory */ }
+    } catch {}
   }
 }
 

package/src/core/models.js

@@ -1,18 +1,13 @@
 /**
- * Model Configuration — centralized model selection for every AI task.
+ * Model Configuration — hybrid-always architecture.
  *
- * Supports both OpenAI and Anthropic models. Provider is auto-detected from model name:
- *   claude-*  → Anthropic
- *   gpt-*, o1-*, o3-*, text-embedding-* → OpenAI
+ * No provider selection. Users pick the best model for each of the 8 task
+ * roles directly in settings.json. Provider is auto-detected from model name.
+ * Embedding is separate — always billed through wolverine credits.
  *
- * Users configure models in .env.local or server/config/settings.json.
- * Mix and match providers per role (e.g., Anthropic for reasoning, OpenAI for coding).
+ * Mix and match: wolverine for audit, claude for reasoning, gpt for coding.
  */
 
-/**
- * Detect provider from model name.
- * @returns {"anthropic"|"openai"}
- */
 function detectProvider(model) {
   if (!model) return "openai";
   if (/^wolverine/i.test(model) || /^gemma/i.test(model)) return "wolverine";
@@ -22,97 +17,78 @@ function detectProvider(model) {
   if (/^llama/i.test(model) || /^meta/i.test(model)) return "meta";
   if (/^deepseek/i.test(model)) return "deepseek";
   if (/^command/i.test(model) || /^cohere/i.test(model)) return "cohere";
-  // Default: OpenAI (gpt-*, o1-*, o3-*, o4-*, codex-*, text-embedding-*, dall-e-*, etc.)
   return "openai";
 }
 
+// 8 task-specific model roles (embedding is separate)
 const MODEL_ROLES = {
-  // Deep reasoning — used for multi-step debugging when a simple fix fails
   reasoning: {
     envKey: "REASONING_MODEL",
-    default: "gpt-5.4",
+    default: "gpt-4o",
     description: "Deep analysis and complex multi-step debugging",
-    tier: "premium",
   },
-
-  // Code generation — the main repair model
   coding: {
     envKey: "CODING_MODEL",
-    default: "gpt-5.3-codex",
-    description: "Code repair and fix generation",
-    tier: "premium",
+    default: "gpt-4o",
+    description: "Code repair and fix generation (no tools)",
   },
-
-  // Chat/explanation — used for generating human-readable explanations
   chat: {
     envKey: "CHAT_MODEL",
-    default: "gpt-5.4-mini",
-    description: "Explanations, summaries, and user-facing messages",
-    tier: "standard",
+    default: "gpt-4o-mini",
+    description: "Summaries, explanations, and user-facing messages",
   },
-
-  // Security audit — injection detection, runs on every single error
   audit: {
     envKey: "AUDIT_MODEL",
-    default: "gpt-5.4-nano",
+    default: "gpt-4o-mini",
     description: "Security scanning and prompt injection detection",
-    tier: "economy",
   },
-
-  // Compacting — compresses text before embedding into brain
-  utility: {
+  compacting: {
     envKey: "COMPACTING_MODEL",
-    default: "gpt-5.4-nano",
+    default: "gpt-4o-mini",
     description: "Text compaction before brain embedding",
-    tier: "economy",
   },
-
-  // Tool — chat responses that use function calling (call_endpoint, search_brain)
   tool: {
     envKey: "TOOL_MODEL",
     default: "gpt-4o-mini",
-    description: "Chat with tool calling (must support function calling)",
-    tier: "standard",
+    description: "Agent with tool calling (read_file, write_file, bash_exec)",
   },
-
-  // Classifier — routes commands to CHAT vs AGENT, picks tiers
   classifier: {
     envKey: "CLASSIFIER_MODEL",
     default: "gpt-4o-mini",
-    description: "Command routing and classification (CHAT/AGENT, SMALL/MEDIUM/LARGE)",
-    tier: "economy",
+    description: "Error classification and command routing",
   },
-
-  // Research — deep research for solutions when fixes fail
   research: {
     envKey: "RESEARCH_MODEL",
     default: "gpt-4o",
-    description: "Deep research for error solutions and documentation lookup",
-    tier: "premium",
-  },
-
-  // Embedding — vector representations for semantic search
-  embedding: {
-    envKey: "TEXT_EMBEDDING_MODEL",
-    default: "text-embedding-3-small",
-    description: "Text embeddings for brain vector store",
-    tier: "economy",
+    description: "Deep research for error solutions",
   },
 };
 
 /**
- * Get the configured model for a given role.
+ * Get the configured model for a task role.
  */
 function getModel(role) {
+  // Legacy: "embedding" and "utility" still supported
+  if (role === "embedding") return getEmbeddingModel();
+  if (role === "utility") role = "compacting";
+
   const config = MODEL_ROLES[role];
   if (!config) {
     throw new Error(`Unknown model role: "${role}". Valid roles: ${Object.keys(MODEL_ROLES).join(", ")}`);
   }
-  // Priority: env var → wolverine.config.js → hardcoded default
   const { getConfig } = require("./config");
   return process.env[config.envKey] || getConfig(`models.${role}`) || config.default;
 }
 
+/**
+ * Get the embedding model — separate from task roles.
+ * Always billed through wolverine credits.
+ */
+function getEmbeddingModel() {
+  const { getConfig } = require("./config");
+  return process.env.TEXT_EMBEDDING_MODEL || getConfig("embedding") || "wolverine-embedding-1";
+}
+
 /**
  * Get all model assignments for logging.
  */
@@ -125,25 +101,27 @@ function getModelConfig() {
     config[role] = {
       model: resolved,
       source: fromEnv ? "env" : fromDefault ? "default" : "settings",
-      tier: def.tier,
     };
   }
+  // Add embedding separately
+  const embModel = getEmbeddingModel();
+  config.embedding = {
+    model: embModel,
+    source: process.env.TEXT_EMBEDDING_MODEL ? "env" : embModel === "wolverine-embedding-1" ? "default" : "settings",
+  };
   return config;
 }
 
-/**
- * Log the current model configuration.
- */
 function logModelConfig(chalk) {
   const config = getModelConfig();
-  const tierColors = { premium: "cyan", standard: "blue", economy: "gray" };
-
   for (const [role, info] of Object.entries(config)) {
-    const color = tierColors[info.tier] || "white";
+    const provider = detectProvider(info.model);
+    const provColors = { wolverine: "cyan", anthropic: "yellow", openai: "blue", google: "green" };
+    const color = provColors[provider] || "gray";
     const label = `${role.padEnd(10)} → ${info.model}`;
-    const source = info.source === "env" ? "(custom)" : "(default)";
+    const source = info.source === "env" ? "(env)" : info.source === "default" ? "" : "(settings)";
     console.log(chalk[color](`    ${label} ${source}`));
   }
 }
 
-module.exports = { getModel, getModelConfig, logModelConfig, MODEL_ROLES, detectProvider };
+module.exports = { getModel, getEmbeddingModel, getModelConfig, logModelConfig, MODEL_ROLES, detectProvider };

package/src/templates/server/config/settings.json

@@ -5,55 +5,18 @@
     "env": "development"
   },
 
-  "provider": "wolverine",
-
-  "openai_settings": {
-    "reasoning": "gpt-5.4-mini",
-    "coding": "gpt-5.1-codex-mini",
-    "chat": "gpt-5-nano",
-    "tool": "gpt-5.4-mini",
+  "models": {
+    "reasoning": "gpt-4o",
+    "coding": "gpt-4o",
+    "chat": "gpt-4o-mini",
+    "tool": "gpt-4o-mini",
     "classifier": "gpt-4o-mini",
     "audit": "gpt-4o-mini",
     "compacting": "gpt-4o-mini",
-    "research": "o4-mini-deep-research",
-    "embedding": "text-embedding-3-small"
+    "research": "gpt-4o"
   },
 
-  "anthropic_settings": {
-    "reasoning": "claude-sonnet-4-6",
-    "coding": "claude-opus-4-6",
-    "chat": "claude-haiku-4-5",
-    "tool": "claude-opus-4-6",
-    "classifier": "claude-haiku-4-5",
-    "audit": "claude-haiku-4-5",
-    "compacting": "claude-haiku-4-5",
-    "research": "claude-sonnet-4-6",
-    "embedding": "text-embedding-3-small"
-  },
-
-  "hybrid_settings": {
-    "reasoning": "claude-haiku-4-5",
-    "coding": "claude-sonnet-4-6",
-    "chat": "gpt-5-nano",
-    "tool": "claude-sonnet-4-6",
-    "classifier": "gpt-4o-mini",
-    "audit": "gpt-4o-mini",
-    "compacting": "gpt-4o-mini",
-    "research": "o4-mini-deep-research",
-    "embedding": "text-embedding-3-small"
-  },
-
-  "wolverine_settings": {
-    "reasoning": "wolverine-test-1",
-    "coding": "wolverine-test-1",
-    "chat": "wolverine-test-1",
-    "tool": "wolverine-test-1",
-    "classifier": "wolverine-test-1",
-    "audit": "wolverine-test-1",
-    "compacting": "wolverine-test-1",
-    "research": "wolverine-test-1",
-    "embedding": "text-embedding-3-small"
-  },
+  "embedding": "wolverine-embedding-1",
 
   "server": {
     "port": 3000,
@@ -61,11 +24,6 @@
     "maxMemoryMB": 512
   },
 
-  "cluster": {
-    "enabled": false,
-    "workers": 0
-  },
-
   "telemetry": {
     "enabled": true,
     "heartbeatIntervalMs": 60000