wolverine-ai 2.0.1 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "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/server/config/settings.json

@@ -5,9 +5,9 @@
     "env": "development"
   },
 
-  "provider": "openai",
+  "provider": "hybrid",
 
-  "models": {
+  "openai_settings": {
     "reasoning": "gpt-5.4-mini",
     "coding": "gpt-5.1-codex-mini",
     "chat": "gpt-5-nano",
@@ -19,15 +19,27 @@
     "embedding": "text-embedding-3-small"
   },
 
-  "_anthropic_models": {
-    "reasoning": "claude-sonnet-4-20250514",
-    "coding": "claude-sonnet-4-20250514",
-    "chat": "claude-haiku-4-20250414",
-    "tool": "claude-sonnet-4-20250514",
-    "classifier": "claude-haiku-4-20250414",
-    "audit": "claude-haiku-4-20250414",
-    "compacting": "claude-haiku-4-20250414",
-    "research": "claude-sonnet-4-20250514",
+  "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-sonnet-4-6",
+    "research": "claude-sonnet-4-6",
+    "embedding": "text-embedding-3-small"
+  },
+
+  "hybrid_settings": {
+    "reasoning": "claude-sonnet-4-6",
+    "coding": "claude-opus-4-6",
+    "chat": "claude-haiku-4-5",
+    "tool": "claude-opus-4-6",
+    "classifier": "gpt-4o-mini",
+    "audit": "gpt-4o-mini",
+    "compacting": "claude-sonnet-4-6",
+    "research": "claude-sonnet-4-6",
     "embedding": "text-embedding-3-small"
   },
 

package/src/core/ai-client.js

@@ -16,10 +16,10 @@ function _extractTokens(usage) {
   };
 }
 
-function _track(model, category, usage, tool) {
+function _track(model, category, usage, tool, latencyMs, success) {
   if (!_tracker) return;
   const { input, output } = _extractTokens(usage);
-  _tracker.record(model, category, input, output, tool);
+  _tracker.record(model, category, input, output, tool, latencyMs, success);
 }
 
 // ── Client Management ──
@@ -70,34 +70,50 @@ function tokenParam(model, limit) {
 
 async function aiCall({ model, systemPrompt, userPrompt, maxTokens = 2048, tools, toolChoice, category = "chat", tool }) {
   const provider = detectProvider(model);
+  const startMs = Date.now();
   let result;
 
-  if (provider === "anthropic") {
-    result = await _anthropicCall({ model, systemPrompt, userPrompt, maxTokens, tools, toolChoice });
-  } else if (isResponsesModel(model)) {
-    result = await _responsesCall(_getOpenAIClient(), { model, systemPrompt, userPrompt, maxTokens, tools });
-  } else {
-    result = await _chatCall(_getOpenAIClient(), { model, systemPrompt, userPrompt, maxTokens, tools, toolChoice });
-  }
+  try {
+    if (provider === "anthropic") {
+      result = await _anthropicCall({ model, systemPrompt, userPrompt, maxTokens, tools, toolChoice });
+    } else if (isResponsesModel(model)) {
+      result = await _responsesCall(_getOpenAIClient(), { model, systemPrompt, userPrompt, maxTokens, tools });
+    } else {
+      result = await _chatCall(_getOpenAIClient(), { model, systemPrompt, userPrompt, maxTokens, tools, toolChoice });
+    }
 
-  _track(model, category, result.usage, tool);
-  return result;
+    const latencyMs = Date.now() - startMs;
+    _track(model, category, result.usage, tool, latencyMs, true);
+    return result;
+  } catch (err) {
+    const latencyMs = Date.now() - startMs;
+    _track(model, category, {}, tool, latencyMs, false);
+    throw err;
+  }
 }
 
 async function aiCallWithHistory({ model, messages, tools, maxTokens = 4096, category = "chat", tool }) {
   const provider = detectProvider(model);
+  const startMs = Date.now();
   let result;
 
-  if (provider === "anthropic") {
-    result = await _anthropicCallWithHistory({ model, messages, tools, maxTokens });
-  } else if (isResponsesModel(model)) {
-    result = await _responsesCallWithHistory(_getOpenAIClient(), { model, messages, tools, maxTokens });
-  } else {
-    result = await _chatCallWithHistory(_getOpenAIClient(), { model, messages, tools, maxTokens });
-  }
+  try {
+    if (provider === "anthropic") {
+      result = await _anthropicCallWithHistory({ model, messages, tools, maxTokens });
+    } else if (isResponsesModel(model)) {
+      result = await _responsesCallWithHistory(_getOpenAIClient(), { model, messages, tools, maxTokens });
+    } else {
+      result = await _chatCallWithHistory(_getOpenAIClient(), { model, messages, tools, maxTokens });
+    }
 
-  _track(model, category, result.usage, tool);
-  return result;
+    const latencyMs = Date.now() - startMs;
+    _track(model, category, result.usage, tool, latencyMs, true);
+    return result;
+  } catch (err) {
+    const latencyMs = Date.now() - startMs;
+    _track(model, category, {}, tool, latencyMs, false);
+    throw err;
+  }
 }
 
 // ── Anthropic Implementation ──

package/src/core/config.js

@@ -26,25 +26,25 @@ function loadConfig() {
     }
   }
 
-  // Resolve model set: if provider is "anthropic", use _anthropic_models as base
+  // Resolve provider and model set
+  // "openai" → openai_settings, "anthropic" → anthropic_settings, "hybrid" → hybrid_settings
   const provider = process.env.WOLVERINE_PROVIDER || fileConfig.provider || "openai";
-  const modelSource = provider === "anthropic" && fileConfig._anthropic_models
-    ? fileConfig._anthropic_models
-    : fileConfig.models;
+  const settingsKey = `${provider}_settings`;
+  const modelSource = fileConfig[settingsKey] || fileConfig.openai_settings || fileConfig.models || {};
 
   _config = {
     provider,
 
     models: {
-      reasoning:  process.env.REASONING_MODEL    || modelSource?.reasoning  || "gpt-4o",
-      coding:     process.env.CODING_MODEL       || modelSource?.coding     || "gpt-4o",
-      chat:       process.env.CHAT_MODEL         || modelSource?.chat       || "gpt-4o-mini",
-      tool:       process.env.TOOL_MODEL         || modelSource?.tool       || "gpt-4o-mini",
-      classifier: process.env.CLASSIFIER_MODEL   || modelSource?.classifier || "gpt-4o-mini",
-      audit:      process.env.AUDIT_MODEL        || modelSource?.audit      || "gpt-4o-mini",
-      compacting: 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",
+      reasoning:  process.env.REASONING_MODEL    || modelSource.reasoning  || "gpt-4o",
+      coding:     process.env.CODING_MODEL       || modelSource.coding     || "gpt-4o",
+      chat:       process.env.CHAT_MODEL         || modelSource.chat       || "gpt-4o-mini",
+      tool:       process.env.TOOL_MODEL         || modelSource.tool       || "gpt-4o-mini",
+      classifier: process.env.CLASSIFIER_MODEL   || modelSource.classifier || "gpt-4o-mini",
+      audit:      process.env.AUDIT_MODEL        || modelSource.audit      || "gpt-4o-mini",
+      compacting: 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",
     },
 
     server: {

package/src/logger/token-tracker.js

@@ -64,9 +64,8 @@ class TokenTracker {
    * @param {number} outputTokens - Completion/output tokens
    * @param {string} tool - Optional tool name (e.g. "call_endpoint /time")
    */
-  record(model, category, inputTokens, outputTokens, tool) {
+  record(model, category, inputTokens, outputTokens, tool, latencyMs, success) {
     const total = (inputTokens || 0) + (outputTokens || 0);
-    if (total === 0) return;
 
     // Calculate USD cost
     const cost = calculateCost(model, inputTokens || 0, outputTokens || 0);
@@ -78,17 +77,26 @@ class TokenTracker {
       input: inputTokens || 0,
       output: outputTokens || 0,
       total,
-      cost: Math.round(cost.total * 1000000) / 1000000, // 6 decimal places
+      cost: Math.round(cost.total * 1000000) / 1000000,
       tool: tool || null,
+      latencyMs: latencyMs || 0,
+      success: success !== false,
     };
 
     // Accumulate by model
-    if (!this._byModel[model]) this._byModel[model] = { input: 0, output: 0, total: 0, calls: 0, cost: 0 };
-    this._byModel[model].input += entry.input;
-    this._byModel[model].output += entry.output;
-    this._byModel[model].total += total;
-    this._byModel[model].calls++;
-    this._byModel[model].cost += cost.total;
+    if (!this._byModel[model]) this._byModel[model] = { input: 0, output: 0, total: 0, calls: 0, cost: 0, successes: 0, failures: 0, totalLatencyMs: 0, minLatencyMs: Infinity, maxLatencyMs: 0 };
+    const m = this._byModel[model];
+    m.input += entry.input;
+    m.output += entry.output;
+    m.total += total;
+    m.calls++;
+    m.cost += cost.total;
+    if (entry.success) m.successes++; else m.failures++;
+    if (latencyMs > 0) {
+      m.totalLatencyMs += latencyMs;
+      if (latencyMs < m.minLatencyMs) m.minLatencyMs = latencyMs;
+      if (latencyMs > m.maxLatencyMs) m.maxLatencyMs = latencyMs;
+    }
 
     // Accumulate by category
     if (!this._byCategory[category]) this._byCategory[category] = { input: 0, output: 0, total: 0, calls: 0, cost: 0 };
@@ -142,7 +150,7 @@ class TokenTracker {
         duration: sessionDuration,
         tokensPerMinute,
       },
-      byModel: this._byModel,
+      byModel: this._formatModelStats(),
       byCategory: this._byCategory,
       byTool: this._byTool,
       // Recent in-memory timeline
@@ -153,10 +161,37 @@ class TokenTracker {
         output: e.output,
         cat: e.category,
         model: e.model,
+        latencyMs: e.latencyMs || 0,
+        success: e.success !== false,
       })),
     };
   }
 
+  /**
+   * Format model stats with computed performance metrics.
+   */
+  _formatModelStats() {
+    const result = {};
+    for (const [model, m] of Object.entries(this._byModel)) {
+      result[model] = {
+        input: m.input,
+        output: m.output,
+        total: m.total,
+        calls: m.calls,
+        cost: m.cost,
+        successes: m.successes || m.calls, // backwards compat
+        failures: m.failures || 0,
+        successRate: m.calls > 0 ? Math.round(((m.successes || m.calls) / m.calls) * 100) : 0,
+        avgLatencyMs: m.calls > 0 && m.totalLatencyMs ? Math.round(m.totalLatencyMs / m.calls) : 0,
+        minLatencyMs: m.minLatencyMs === Infinity ? 0 : (m.minLatencyMs || 0),
+        maxLatencyMs: m.maxLatencyMs || 0,
+        tokensPerSecond: m.totalLatencyMs > 0 ? Math.round((m.total / (m.totalLatencyMs / 1000)) * 10) / 10 : 0,
+        costPerCall: m.calls > 0 ? Math.round((m.cost / m.calls) * 1000000) / 1000000 : 0,
+      };
+    }
+    return result;
+  }
+
   /**
    * Load full history from JSONL file. For dashboard charts across sessions.
    * @param {number} limit — max entries to return (default: 500)