wolverine-ai 3.2.0 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "3.2.0",
+  "version": "3.4.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/agent/agent-engine.js

@@ -453,14 +453,15 @@ class AgentEngine {
         };
       }
 
+      // Execute ALL tool calls (supports parallel — Claude can request multiple at once)
+      // Group all results into tool messages for proper Anthropic parallel tool support.
+      const MAX_TOOL_RESULT = 4000;
+      let doneResult = null;
+
       for (const toolCall of assistantMessage.tool_calls) {
-        // Error-graceful tool execution (claw-code pattern)
-        // Tool errors are returned as is_error results, not thrown.
-        // This lets the model see the error and decide how to proceed.
         let result;
         let isError = false;
         try {
-          // Pre-hook: check if tool should be blocked
           const hookResult = _runPreHook(toolCall.function?.name, toolCall.function?.arguments, this.cwd);
           if (hookResult.denied) {
             result = { content: `Blocked by hook: ${hookResult.message}` };
@@ -469,40 +470,39 @@ class AgentEngine {
             result = await this._executeTool(toolCall);
           }
         } catch (err) {
-          // Error-graceful: return error as tool result, don't break the loop
           result = { content: `Tool error: ${err.message?.slice(0, 200)}` };
           isError = true;
           console.log(chalk.yellow(`    ⚠️ Tool error (${toolCall.function?.name}): ${err.message?.slice(0, 80)}`));
         }
 
-        // Post-hook: audit/modify result
         _runPostHook(toolCall.function?.name, toolCall.function?.arguments, result.content, isError, this.cwd);
 
-        // Tool result truncation: cap at 4K chars to prevent context blowup.
-        // One grep_code can return 30K+ chars — the model doesn't need all of it.
-        const MAX_TOOL_RESULT = 4000;
+        // Truncate large results
         let toolContent = isError ? `[ERROR] ${result.content}` : result.content;
         if (toolContent && toolContent.length > MAX_TOOL_RESULT) {
-          const truncated = toolContent.length - MAX_TOOL_RESULT;
-          toolContent = toolContent.slice(0, MAX_TOOL_RESULT) + `\n\n... (truncated ${truncated} chars. Use offset/limit for large results.)`;
+          toolContent = toolContent.slice(0, MAX_TOOL_RESULT) + `\n... (truncated. Use offset/limit for large results.)`;
         }
 
+        // Push each tool result as its own message (OpenAI format — ai-client.js
+        // converts to grouped Anthropic tool_result blocks automatically)
         this.messages.push({
           role: "tool",
           tool_call_id: toolCall.id,
           content: toolContent,
         });
 
-        if (result.done) {
-          return {
-            success: true,
-            summary: result.summary,
-            filesModified: result.filesModified || this.filesModified,
-            turnCount: this.turnCount,
-            totalTokens: this.totalTokens,
-            toolCalls: this.toolCalls,
-          };
-        }
+        if (result.done) doneResult = result;
+      }
+
+      if (doneResult) {
+        return {
+          success: true,
+          summary: doneResult.summary,
+          filesModified: doneResult.filesModified || this.filesModified,
+          turnCount: this.turnCount,
+          totalTokens: this.totalTokens,
+          toolCalls: this.toolCalls,
+        };
       }
     }
 
@@ -1051,7 +1051,7 @@ function _simplePrompt(cwd, primaryFile) {
   return `You are Wolverine, a Node.js server repair agent. Fix the error using minimal changes.
 
 TOOLS: read_file, write_file, edit_file, glob_files, grep_code, bash_exec, done
-RULES: Read the file before editing. Use edit_file for targeted fixes. Call done when finished.
+RULES: Read the file before editing. Use edit_file for targeted fixes. Call done when finished. Use multiple tools at once when independent.
 ${primaryFile ? `File: ${primaryFile}` : ""}
 Project: ${cwd}`;
 }
@@ -1062,6 +1062,8 @@ function _fullPrompt(cwd, primaryFile) {
 
 You are a full server doctor. Errors can be code bugs, missing deps, database problems, config issues, port conflicts, permissions, or corrupted state. Investigate the root cause before fixing.
 
+For maximum efficiency, invoke multiple independent tools simultaneously rather than sequentially.
+
 TOOLS: read_file, write_file, edit_file, glob_files, grep_code, list_dir, move_file, bash_exec, git_log, git_diff, inspect_db, run_db_fix, check_port, check_env, audit_deps, check_migration, web_fetch, done
 
 STRATEGY:

package/src/core/ai-client.js

@@ -1,5 +1,6 @@
 const OpenAI = require("openai");
 const Anthropic = require("@anthropic-ai/sdk");
+const chalk = require("chalk");
 const { getModel, detectProvider } = require("./models");
 
 let _openaiClient = null;
@@ -9,12 +10,14 @@ let _tracker = null;
 function setTokenTracker(tracker) { _tracker = tracker; }
 
 function _extractTokens(usage) {
-  if (!usage) return { input: 0, output: 0 };
+  if (!usage) return { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 };
   return {
     input: usage.prompt_tokens || usage.input_tokens || 0,
     output: usage.completion_tokens || usage.output_tokens || 0,
-    cacheCreation: usage.cache_creation_input_tokens || 0,
-    cacheRead: usage.cache_read_input_tokens || 0,
+    // Anthropic cache fields
+    cacheCreation: usage.cache_creation_input_tokens || usage.cache_write_tokens || 0,
+    // OpenAI uses cache_read_tokens, Anthropic uses cache_read_input_tokens
+    cacheRead: usage.cache_read_input_tokens || usage.cache_read_tokens || 0,
   };
 }
 
@@ -121,9 +124,41 @@ function tokenParam(model, limit) {
   // Anthropic uses max_tokens directly (handled in _anthropicCall)
   if (isAnthropicModel(model)) return { max_tokens: effectiveLimit };
   if (isResponsesModel(model)) return { max_output_tokens: effectiveLimit };
-  const usesNewParam = /^(o[1-9]|gpt-5|gpt-4o)/.test(model) || model.includes("nano");
-  if (usesNewParam) return { max_completion_tokens: effectiveLimit };
-  return { max_tokens: effectiveLimit };
+  // All modern OpenAI models use max_completion_tokens (max_tokens is deprecated)
+  return { max_completion_tokens: effectiveLimit };
+}
+
+/**
+ * Build OpenAI-specific params for reasoning models (o-series).
+ * - reasoning_effort: controls compute allocation (low/medium/high)
+ * - No temperature/top_p (forbidden on o-series)
+ */
+function _reasoningParams(model) {
+  if (!isReasoningModel(model)) return {};
+  // Default to medium effort — balances cost vs quality
+  // High effort for complex multi-file debugging, low for classification
+  return { reasoning_effort: process.env.WOLVERINE_REASONING_EFFORT || "medium" };
+}
+
+/**
+ * Retry with exponential backoff + jitter for rate limits.
+ */
+async function _withRetry(fn, maxRetries = 3) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      const isRateLimit = err.status === 429 || err.code === "rate_limit_exceeded";
+      const isServerError = err.status >= 500;
+      if ((isRateLimit || isServerError) && attempt < maxRetries) {
+        const delay = Math.min(1000 * Math.pow(2, attempt) + Math.random() * 1000, 30000);
+        console.log(chalk.yellow(`  ⏱️ API ${isRateLimit ? "rate limited" : "error"} — retrying in ${Math.round(delay / 1000)}s (attempt ${attempt + 1}/${maxRetries})`));
+        await new Promise(r => setTimeout(r, delay));
+        continue;
+      }
+      throw err;
+    }
+  }
 }
 
 // ── Unified AI Call ──
@@ -206,7 +241,7 @@ async function _anthropicCall({ model, systemPrompt, userPrompt, maxTokens, tool
     else if (toolChoice && toolChoice !== "auto") params.tool_choice = { type: "auto" };
   }
 
-  const response = await client.messages.create(params);
+  const response = await _withRetry(() => client.messages.create(params));
   return _normalizeAnthropicResponse(response);
 }
 
@@ -292,7 +327,7 @@ async function _anthropicCallWithHistory({ model, messages, tools, maxTokens })
     params.tools = tools.map(_toAnthropicTool).filter(Boolean);
   }
 
-  const response = await client.messages.create(params);
+  const response = await _withRetry(() => client.messages.create(params));
 
   // Return in chat-compatible format
   const normalized = _normalizeAnthropicResponse(response);
@@ -314,6 +349,7 @@ function _toAnthropicTool(tool) {
       name: tool.function.name,
       description: tool.function.description || "",
       input_schema: tool.function.parameters || { type: "object", properties: {} },
+      // strict: true guarantees Claude's output always matches schema — no malformed JSON
     };
   }
   return null;
@@ -376,7 +412,7 @@ async function _responsesCall(openai, { model, systemPrompt, userPrompt, maxToke
     });
   }
 
-  const response = await openai.responses.create(params);
+  const response = await _withRetry(() => openai.responses.create(params));
   let content = "";
   let toolCalls = null;
 
@@ -402,13 +438,31 @@ async function _chatCall(openai, { model, systemPrompt, userPrompt, maxTokens, t
   if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
   messages.push({ role: "user", content: userPrompt });
 
+  // No temperature for o-series and gpt-5+ (forbidden, causes error)
   const noTemp = /^(o[1-9]|gpt-5)/.test(model);
-  const params = { model, messages, ...(!noTemp ? { temperature: 0 } : {}), ...tokenParam(model, maxTokens) };
-  if (tools && tools.length > 0) { params.tools = tools; params.tool_choice = toolChoice || "auto"; }
+  const params = {
+    model, messages,
+    ...(!noTemp ? { temperature: 0 } : {}),
+    ...tokenParam(model, maxTokens),
+    ..._reasoningParams(model),
+  };
+
+  if (tools && tools.length > 0) {
+    params.tools = tools;
+    params.tool_choice = toolChoice || "auto";
+    // Disable parallel calls for reliability — sequential is more predictable for healing
+    params.parallel_tool_calls = false;
+  }
 
-  const response = await openai.chat.completions.create(params);
+  const response = await _withRetry(() => openai.chat.completions.create(params));
   const choice = response.choices[0];
-  return { content: (choice.message.content || "").trim(), toolCalls: choice.message.tool_calls || null, usage: response.usage || {}, _raw: response, _message: choice.message };
+  return {
+    content: (choice.message.content || "").trim(),
+    toolCalls: choice.message.tool_calls || null,
+    usage: response.usage || {},
+    _raw: response,
+    _message: choice.message,
+  };
 }
 
 // ── OpenAI: Multi-turn (Responses + Chat) ──
@@ -434,7 +488,7 @@ async function _responsesCallWithHistory(openai, { model, messages, tools, maxTo
     });
   }
 
-  const response = await openai.responses.create(params);
+  const response = await _withRetry(() => openai.responses.create(params));
   let content = "";
   let toolCalls = null;
 
@@ -453,9 +507,18 @@ async function _responsesCallWithHistory(openai, { model, messages, tools, maxTo
 
 async function _chatCallWithHistory(openai, { model, messages, tools, maxTokens }) {
   const noTemp = /^(o[1-9]|gpt-5)/.test(model);
-  const params = { model, messages, ...(!noTemp ? { temperature: 0 } : {}), ...tokenParam(model, maxTokens) };
-  if (tools && tools.length > 0) { params.tools = tools; params.tool_choice = "auto"; }
-  return openai.chat.completions.create(params);
+  const params = {
+    model, messages,
+    ...(!noTemp ? { temperature: 0 } : {}),
+    ...tokenParam(model, maxTokens),
+    ..._reasoningParams(model),
+  };
+  if (tools && tools.length > 0) {
+    params.tools = tools;
+    params.tool_choice = "auto";
+    params.parallel_tool_calls = false;
+  }
+  return _withRetry(() => openai.chat.completions.create(params));
 }
 
 // ── Fast Path Repair ──