wolverine-ai 1.8.0 → 2.0.1

package/README.md

@@ -288,23 +288,35 @@ Secured with `WOLVERINE_ADMIN_KEY` + IP allowlist (localhost + `WOLVERINE_ADMIN_
 
 ---
 
-## 10-Model Configuration
+## 10-Model Configuration (OpenAI + Anthropic)
 
-Every AI task has its own model slot. Customize in `.env.local`:
+Every AI task has its own model slot. **Mix and match providers** — set any slot to a `claude-*` model for Anthropic or `gpt-*` for OpenAI. Provider is auto-detected from the model name.
 
-| Env Variable | Role | Needs Tools? | Cost Impact |
+```bash
+# .env.local — use Anthropic for reasoning, OpenAI for coding
+REASONING_MODEL=claude-sonnet-4-20250514
+CODING_MODEL=gpt-5.3-codex
+CHAT_MODEL=claude-haiku-4-20250414
+AUDIT_MODEL=claude-haiku-4-20250414
+```
+
+| Env Variable | Role | Needs Tools? | Example Models |
 |---|---|---|---|
-| `REASONING_MODEL` | Multi-file agent | Yes | High (agent loop) |
-| `CODING_MODEL` | Code repair/generation | Responses API | Medium-high |
-| `CHAT_MODEL` | Simple text responses | No | Low |
-| `TOOL_MODEL` | Chat with function calling | **Yes** | Medium |
-| `CLASSIFIER_MODEL` | SIMPLE/TOOLS/AGENT routing | No | ~10 tokens |
-| `AUDIT_MODEL` | Injection detection (every error) | No | Low |
-| `COMPACTING_MODEL` | Text compression for brain | No | Low |
-| `RESEARCH_MODEL` | Deep research on failures | No | High (rare) |
-| `TEXT_EMBEDDING_MODEL` | Brain vector embeddings | No | Very low |
-
-Reasoning models (`o-series`, `gpt-5-nano`) automatically get 4x token limits to accommodate chain-of-thought.
+| `REASONING_MODEL` | Multi-file agent | Yes | `claude-sonnet-4`, `gpt-5.4` |
+| `CODING_MODEL` | Code repair/generation | Yes | `claude-sonnet-4`, `gpt-5.3-codex` |
+| `CHAT_MODEL` | Simple text responses | No | `claude-haiku-4`, `gpt-5.4-mini` |
+| `TOOL_MODEL` | Chat with function calling | **Yes** | `claude-sonnet-4`, `gpt-4o-mini` |
+| `CLASSIFIER_MODEL` | SIMPLE/TOOLS/AGENT routing | No | `claude-haiku-4`, `gpt-4o-mini` |
+| `AUDIT_MODEL` | Injection detection (every error) | No | `claude-haiku-4`, `gpt-5.4-nano` |
+| `COMPACTING_MODEL` | Text compression for brain | No | `claude-haiku-4`, `gpt-5.4-nano` |
+| `RESEARCH_MODEL` | Deep research on failures | No | `claude-opus-4`, `gpt-4o` |
+| `TEXT_EMBEDDING_MODEL` | Brain vector embeddings | No | `text-embedding-3-small` (OpenAI only) |
+
+**Notes:**
+- Embeddings always use OpenAI (Anthropic doesn't have an embedding API)
+- Tools (all 18) work identically on both providers — normalized at the client level
+- Telemetry tracks usage by model AND by provider (`openai` / `anthropic`)
+- Any future model from either provider works automatically — just set the model name
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "1.8.0",
+  "version": "2.0.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": {
@@ -55,6 +55,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.82.0",
     "chalk": "^4.1.2",
     "diff": "^7.0.0",
     "dotenv": "^16.4.7",

package/server/config/settings.json

@@ -5,6 +5,8 @@
     "env": "development"
   },
 
+  "provider": "openai",
+
   "models": {
     "reasoning": "gpt-5.4-mini",
     "coding": "gpt-5.1-codex-mini",
@@ -17,6 +19,18 @@
     "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",
+    "embedding": "text-embedding-3-small"
+  },
+
   "server": {
     "port": 3000,
     "maxRetries": 3,

package/src/brain/brain.js

@@ -44,7 +44,7 @@ const SEED_DOCS = [
     metadata: { topic: "security" },
   },
   {
-    text: "Wolverine model tiers: REASONING_MODEL for deep multi-step debugging. CODING_MODEL for code repair generation. CHAT_MODEL for explanations and summaries. AUDIT_MODEL for security scans (runs every error, keep cheap). UTILITY_MODEL for JSON formatting and thought compaction. TEXT_EMBEDDING_MODEL for brain vector embeddings.",
+    text: "Wolverine supports both OpenAI and Anthropic models. Provider auto-detected from model name: claude-* → Anthropic, gpt-*/o1-*/o3-* → OpenAI. Mix and match per role: e.g., Anthropic for reasoning (claude-sonnet-4), OpenAI for coding (gpt-5.3-codex). 10 model slots: REASONING_MODEL, CODING_MODEL, CHAT_MODEL, TOOL_MODEL, CLASSIFIER_MODEL, AUDIT_MODEL, COMPACTING_MODEL, RESEARCH_MODEL, TEXT_EMBEDDING_MODEL (always OpenAI — Anthropic has no embeddings). Configure in .env.local or settings.json. Tools work identically on both providers — ai-client.js normalizes all responses to same {content, toolCalls, usage} shape. Telemetry tracks usage byModel AND byProvider (openai/anthropic) automatically.",
     metadata: { topic: "model-config" },
   },
   {

package/src/brain/embedder.js

@@ -1,4 +1,4 @@
-const { getClient, aiCall } = require("../core/ai-client");
+const { getClient, aiCall, detectProvider } = require("../core/ai-client");
 const { getModel } = require("../core/models");
 
 /**
@@ -41,7 +41,8 @@ async function embed(text) {
   const cached = _cacheGet(text);
   if (cached) return cached;
 
-  const openai = getClient();
+  // Embeddings always use OpenAI (Anthropic doesn't have an embedding API)
+  const openai = getClient("openai");
   const model = getModel("embedding");
 
   const response = await openai.embeddings.create({
@@ -78,7 +79,8 @@ async function embedBatch(texts) {
 
   if (uncached.length === 0) return results;
 
-  const openai = getClient();
+  // Embeddings always use OpenAI (Anthropic doesn't have an embedding API)
+  const openai = getClient("openai");
   const model = getModel("embedding");
 
   const response = await openai.embeddings.create({

package/src/core/ai-client.js

@@ -1,17 +1,13 @@
 const OpenAI = require("openai");
-const { getModel } = require("./models");
+const Anthropic = require("@anthropic-ai/sdk");
+const { getModel, detectProvider } = require("./models");
 
-let client = null;
+let _openaiClient = null;
+let _anthropicClient = null;
 let _tracker = null;
 
-/**
- * Set the global token tracker. Called once from runner on startup.
- */
 function setTokenTracker(tracker) { _tracker = tracker; }
 
-/**
- * Extract token counts from any OpenAI response usage object.
- */
 function _extractTokens(usage) {
   if (!usage) return { input: 0, output: 0 };
   return {
@@ -20,92 +16,254 @@ function _extractTokens(usage) {
   };
 }
 
-/**
- * Track a call if tracker is set.
- */
 function _track(model, category, usage, tool) {
   if (!_tracker) return;
   const { input, output } = _extractTokens(usage);
   _tracker.record(model, category, input, output, tool);
 }
 
-function getClient() {
-  if (!client) {
+// ── Client Management ──
+
+function getClient(provider) {
+  if (provider === "anthropic") return _getAnthropicClient();
+  return _getOpenAIClient();
+}
+
+function _getOpenAIClient() {
+  if (!_openaiClient) {
     const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new Error(
-        "OPENAI_API_KEY is not set. Add it to .env.local or set it as an environment variable."
-      );
-    }
-    client = new OpenAI({ apiKey });
+    if (!apiKey) throw new Error("OPENAI_API_KEY is not set. Add it to .env.local");
+    _openaiClient = new OpenAI({ apiKey });
   }
-  return client;
+  return _openaiClient;
 }
 
-/**
- * Detect if a model uses the Responses API vs Chat Completions.
- * Codex models and some newer models use /v1/responses.
- */
-function isResponsesModel(model) {
-  return /codex/i.test(model);
+function _getAnthropicClient() {
+  if (!_anthropicClient) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) throw new Error("ANTHROPIC_API_KEY is not set. Add it to .env.local");
+    _anthropicClient = new Anthropic({ apiKey });
+  }
+  return _anthropicClient;
 }
 
-/**
- * Detect if a model uses internal reasoning tokens (o-series, gpt-5-nano, etc.)
- * These models need higher token limits because reasoning consumes most of the budget.
- */
+// ── Model Detection Helpers ──
+
+function isResponsesModel(model) { return /codex/i.test(model); }
+
 function isReasoningModel(model) {
   return /^o[1-9]|^gpt-5-nano|^gpt-5\.4-nano/.test(model);
 }
 
-/**
- * Build the token limit param for Chat Completions API.
- * Reasoning models get 4x the limit to accommodate thinking tokens.
- */
+function isAnthropicModel(model) { return detectProvider(model) === "anthropic"; }
+
 function tokenParam(model, limit) {
-  // Reasoning models need headroom for chain-of-thought
   const effectiveLimit = isReasoningModel(model) ? Math.max(limit * 4, 4096) : limit;
-
-  if (isResponsesModel(model)) {
-    return { max_output_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 };
-  }
+  if (usesNewParam) return { max_completion_tokens: effectiveLimit };
   return { max_tokens: limit };
 }
 
-/**
- * Unified AI call — automatically routes to Responses API or Chat Completions
- * based on the model name.
- *
- * @param {object} params
- * @param {string} params.model - Model name
- * @param {string} params.systemPrompt - System/instructions prompt
- * @param {string} params.userPrompt - User message
- * @param {number} params.maxTokens - Max response tokens
- * @param {Array}  params.tools - Tool definitions (optional)
- * @param {string} params.toolChoice - Tool choice strategy (optional)
- * @returns {{ content: string, toolCalls: Array|null, usage: object }}
- */
+// ── Unified AI Call ──
+// Routes to OpenAI or Anthropic based on model name. Returns same shape regardless.
+
 async function aiCall({ model, systemPrompt, userPrompt, maxTokens = 2048, tools, toolChoice, category = "chat", tool }) {
-  const openai = getClient();
+  const provider = detectProvider(model);
+  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 });
+  }
+
+  _track(model, category, result.usage, tool);
+  return result;
+}
 
+async function aiCallWithHistory({ model, messages, tools, maxTokens = 4096, category = "chat", tool }) {
+  const provider = detectProvider(model);
   let result;
-  if (isResponsesModel(model)) {
-    result = await _responsesCall(openai, { model, systemPrompt, userPrompt, maxTokens, tools });
+
+  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 _chatCall(openai, { model, systemPrompt, userPrompt, maxTokens, tools, toolChoice });
+    result = await _chatCallWithHistory(_getOpenAIClient(), { model, messages, tools, maxTokens });
   }
 
   _track(model, category, result.usage, tool);
   return result;
 }
 
+// ── Anthropic Implementation ──
+// Normalizes Anthropic's response format to match our {content, toolCalls, usage} interface.
+
+async function _anthropicCall({ model, systemPrompt, userPrompt, maxTokens, tools, toolChoice }) {
+  const client = _getAnthropicClient();
+
+  const params = {
+    model,
+    max_tokens: maxTokens,
+    messages: [{ role: "user", content: userPrompt }],
+  };
+
+  if (systemPrompt) params.system = systemPrompt;
+
+  // Convert OpenAI-style tools to Anthropic format
+  if (tools && tools.length > 0) {
+    params.tools = tools.map(_toAnthropicTool).filter(Boolean);
+    if (toolChoice === "required") params.tool_choice = { type: "any" };
+    else if (toolChoice && toolChoice !== "auto") params.tool_choice = { type: "auto" };
+  }
+
+  const response = await client.messages.create(params);
+  return _normalizeAnthropicResponse(response);
+}
+
+async function _anthropicCallWithHistory({ model, messages, tools, maxTokens }) {
+  const client = _getAnthropicClient();
+
+  // Extract system message and convert rest to Anthropic format
+  let systemPrompt = "";
+  const anthropicMessages = [];
+
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      systemPrompt += (systemPrompt ? "\n" : "") + msg.content;
+      continue;
+    }
+    if (msg.role === "user") {
+      anthropicMessages.push({ role: "user", content: msg.content });
+    } else if (msg.role === "assistant") {
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        // Assistant message with tool calls
+        const content = [];
+        if (msg.content) content.push({ type: "text", text: msg.content });
+        for (const tc of msg.tool_calls) {
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments || "{}"),
+          });
+        }
+        anthropicMessages.push({ role: "assistant", content });
+      } else {
+        anthropicMessages.push({ role: "assistant", content: msg.content || "" });
+      }
+    } else if (msg.role === "tool") {
+      // Tool result → Anthropic tool_result block
+      anthropicMessages.push({
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: msg.tool_call_id,
+          content: msg.content,
+        }],
+      });
+    }
+  }
+
+  // Merge consecutive same-role messages (Anthropic requires alternating roles)
+  const merged = [];
+  for (const msg of anthropicMessages) {
+    if (merged.length > 0 && merged[merged.length - 1].role === msg.role) {
+      const prev = merged[merged.length - 1];
+      if (typeof prev.content === "string" && typeof msg.content === "string") {
+        prev.content += "\n" + msg.content;
+      } else {
+        // Convert to array format and merge
+        const prevArr = Array.isArray(prev.content) ? prev.content : [{ type: "text", text: prev.content }];
+        const msgArr = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
+        prev.content = [...prevArr, ...msgArr];
+      }
+    } else {
+      merged.push({ ...msg });
+    }
+  }
+
+  const params = {
+    model,
+    max_tokens: maxTokens,
+    messages: merged,
+  };
+
+  if (systemPrompt) params.system = systemPrompt;
+
+  if (tools && tools.length > 0) {
+    params.tools = tools.map(_toAnthropicTool).filter(Boolean);
+  }
+
+  const response = await client.messages.create(params);
+
+  // Return in chat-compatible format
+  const normalized = _normalizeAnthropicResponse(response);
+  const message = { role: "assistant", content: normalized.content || null };
+  if (normalized.toolCalls) message.tool_calls = normalized.toolCalls;
+
+  return {
+    choices: [{ message }],
+    usage: normalized.usage,
+  };
+}
+
+/**
+ * Convert OpenAI tool definition to Anthropic format.
+ */
+function _toAnthropicTool(tool) {
+  if (tool.type === "function" && tool.function) {
+    return {
+      name: tool.function.name,
+      description: tool.function.description || "",
+      input_schema: tool.function.parameters || { type: "object", properties: {} },
+    };
+  }
+  return null;
+}
+
 /**
- * Responses API call — for codex and responses-only models.
+ * Normalize Anthropic response to our standard {content, toolCalls, usage} shape.
  */
+function _normalizeAnthropicResponse(response) {
+  let content = "";
+  let toolCalls = null;
+
+  for (const block of (response.content || [])) {
+    if (block.type === "text") {
+      content += block.text;
+    } else if (block.type === "tool_use") {
+      if (!toolCalls) toolCalls = [];
+      toolCalls.push({
+        id: block.id,
+        type: "function",
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input || {}),
+        },
+      });
+    }
+  }
+
+  return {
+    content: content.trim(),
+    toolCalls,
+    usage: {
+      input_tokens: response.usage?.input_tokens || 0,
+      output_tokens: response.usage?.output_tokens || 0,
+      prompt_tokens: response.usage?.input_tokens || 0,
+      completion_tokens: response.usage?.output_tokens || 0,
+    },
+    _raw: response,
+  };
+}
+
+// ── OpenAI: Responses API ──
+
 async function _responsesCall(openai, { model, systemPrompt, userPrompt, maxTokens, tools }) {
   const params = {
     model,
@@ -116,228 +274,101 @@ async function _responsesCall(openai, { model, systemPrompt, userPrompt, maxToke
     max_output_tokens: maxTokens,
   };
 
-  // Convert chat-style tools to responses-style tools
   if (tools && tools.length > 0) {
     params.tools = tools.map(t => {
       if (t.type === "function" && t.function) {
-        // Chat Completions style → Responses style
-        return {
-          type: "function",
-          name: t.function.name,
-          description: t.function.description,
-          parameters: t.function.parameters,
-          strict: true,
-        };
+        return { type: "function", name: t.function.name, description: t.function.description, parameters: t.function.parameters, strict: true };
       }
       return t;
     });
   }
 
   const response = await openai.responses.create(params);
-
-  // Extract text content and tool calls from response output
   let content = "";
   let toolCalls = null;
 
   if (response.output) {
     for (const item of response.output) {
       if (item.type === "message" && item.content) {
-        for (const block of item.content) {
-          if (block.type === "output_text") {
-            content += block.text;
-          }
-        }
+        for (const block of item.content) { if (block.type === "output_text") content += block.text; }
       } else if (item.type === "function_call") {
         if (!toolCalls) toolCalls = [];
-        toolCalls.push({
-          id: item.call_id || item.id,
-          type: "function",
-          function: {
-            name: item.name,
-            arguments: item.arguments,
-          },
-        });
+        toolCalls.push({ id: item.call_id || item.id, type: "function", function: { name: item.name, arguments: item.arguments } });
       }
     }
   }
+  if (!content && response.output_text) content = response.output_text;
 
-  // Fallback: some responses have output_text directly
-  if (!content && response.output_text) {
-    content = response.output_text;
-  }
-
-  return {
-    content: content.trim(),
-    toolCalls,
-    usage: response.usage || {},
-    _raw: response,
-  };
+  return { content: content.trim(), toolCalls, usage: response.usage || {}, _raw: response };
 }
 
-/**
- * Chat Completions API call — for standard chat models.
- */
+// ── OpenAI: Chat Completions ──
+
 async function _chatCall(openai, { model, systemPrompt, userPrompt, maxTokens, tools, toolChoice }) {
   const messages = [];
   if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
   messages.push({ role: "user", content: userPrompt });
 
-  // Some models (gpt-5-nano, o-series) don't support temperature
   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) };
+  if (tools && tools.length > 0) { params.tools = tools; params.tool_choice = toolChoice || "auto"; }
 
   const response = await 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 };
 }
 
-/**
- * Build a Responses API conversation continuation with tool results.
- * For multi-turn agent loops with codex models.
- */
-async function aiCallWithHistory({ model, messages, tools, maxTokens = 4096, category = "chat", tool }) {
-  const openai = getClient();
-
-  let result;
-  if (isResponsesModel(model)) {
-    result = await _responsesCallWithHistory(openai, { model, messages, tools, maxTokens });
-  } else {
-    result = await _chatCallWithHistory(openai, { model, messages, tools, maxTokens });
-  }
-
-  _track(model, category, result.usage, tool);
-  return result;
-}
+// ── OpenAI: Multi-turn (Responses + Chat) ──
 
 async function _responsesCallWithHistory(openai, { model, messages, tools, maxTokens }) {
-  // Convert chat-style messages to responses input format
   const input = messages.map(msg => {
-    if (msg.role === "system") {
-      return { role: "developer", content: msg.content };
-    }
-    if (msg.role === "tool") {
-      return {
-        type: "function_call_output",
-        call_id: msg.tool_call_id,
-        output: msg.content,
-      };
-    }
+    if (msg.role === "system") return { role: "developer", content: msg.content };
+    if (msg.role === "tool") return { type: "function_call_output", call_id: msg.tool_call_id, output: msg.content };
     if (msg.role === "assistant" && msg.tool_calls) {
-      // Emit function_call items for each tool call
-      return msg.tool_calls.map(tc => ({
-        type: "function_call",
-        call_id: tc.id,
-        name: tc.function.name,
-        arguments: tc.function.arguments,
-      }));
-    }
-    if (msg.role === "assistant") {
-      return { role: "assistant", content: msg.content || "" };
+      return msg.tool_calls.map(tc => ({ type: "function_call", call_id: tc.id, name: tc.function.name, arguments: tc.function.arguments }));
     }
+    if (msg.role === "assistant") return { role: "assistant", content: msg.content || "" };
     return { role: msg.role, content: msg.content };
   }).flat();
 
-  const params = {
-    model,
-    input,
-    max_output_tokens: maxTokens,
-  };
-
+  const params = { model, input, max_output_tokens: maxTokens };
   if (tools && tools.length > 0) {
     params.tools = tools.map(t => {
       if (t.type === "function" && t.function) {
-        return {
-          type: "function",
-          name: t.function.name,
-          description: t.function.description,
-          parameters: t.function.parameters,
-          strict: true,
-        };
+        return { type: "function", name: t.function.name, description: t.function.description, parameters: t.function.parameters, strict: true };
       }
       return t;
     });
   }
 
   const response = await openai.responses.create(params);
-
-  // Build a chat-compatible response
   let content = "";
   let toolCalls = null;
 
   if (response.output) {
     for (const item of response.output) {
-      if (item.type === "message" && item.content) {
-        for (const block of item.content) {
-          if (block.type === "output_text") content += block.text;
-        }
-      } else if (item.type === "function_call") {
-        if (!toolCalls) toolCalls = [];
-        toolCalls.push({
-          id: item.call_id || item.id,
-          type: "function",
-          function: {
-            name: item.name,
-            arguments: item.arguments,
-          },
-        });
-      }
+      if (item.type === "message" && item.content) { for (const block of item.content) { if (block.type === "output_text") content += block.text; } }
+      else if (item.type === "function_call") { if (!toolCalls) toolCalls = []; toolCalls.push({ id: item.call_id || item.id, type: "function", function: { name: item.name, arguments: item.arguments } }); }
     }
   }
-
   if (!content && response.output_text) content = response.output_text;
 
-  // Return in chat-compatible format so the agent engine doesn't need to change
   const message = { role: "assistant", content: content.trim() || null };
   if (toolCalls) message.tool_calls = toolCalls;
-
-  return {
-    choices: [{ message }],
-    usage: response.usage || {},
-  };
+  return { choices: [{ message }], usage: response.usage || {} };
 }
 
 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";
-  }
-
+  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);
 }
 
-/**
- * Send an error context to OpenAI and get a repair patch back.
- * Uses CODING_MODEL — routes to correct API automatically.
- */
+// ── Fast Path Repair ──
+
 async function requestRepair({ filePath, sourceCode, backupSourceCode, errorMessage, stackTrace, extraContext }) {
   const model = getModel("coding");
-
   const systemPrompt = "You are a Node.js debugging expert. Respond with ONLY valid JSON, no markdown fences.";
   const userPrompt = `A server crashed with the following error. Analyze and produce a fix.
 
@@ -393,4 +424,4 @@ Include both if needed, or just one.`;
   }
 }
 
-module.exports = { requestRepair, getClient, tokenParam, aiCall, aiCallWithHistory, isResponsesModel, setTokenTracker };
+module.exports = { requestRepair, getClient, tokenParam, aiCall, aiCallWithHistory, isResponsesModel, isAnthropicModel, setTokenTracker, detectProvider };

package/src/core/config.js

@@ -26,17 +26,25 @@ function loadConfig() {
     }
   }
 
+  // Resolve model set: if provider is "anthropic", use _anthropic_models as base
+  const provider = process.env.WOLVERINE_PROVIDER || fileConfig.provider || "openai";
+  const modelSource = provider === "anthropic" && fileConfig._anthropic_models
+    ? fileConfig._anthropic_models
+    : fileConfig.models;
+
   _config = {
+    provider,
+
     models: {
-      reasoning:  process.env.REASONING_MODEL    || fileConfig.models?.reasoning  || "gpt-4o",
-      coding:     process.env.CODING_MODEL       || fileConfig.models?.coding     || "gpt-4o",
-      chat:       process.env.CHAT_MODEL         || fileConfig.models?.chat       || "gpt-4o-mini",
-      tool:       process.env.TOOL_MODEL         || fileConfig.models?.tool       || "gpt-4o-mini",
-      classifier: process.env.CLASSIFIER_MODEL   || fileConfig.models?.classifier || "gpt-4o-mini",
-      audit:      process.env.AUDIT_MODEL        || fileConfig.models?.audit      || "gpt-4o-mini",
-      compacting: process.env.COMPACTING_MODEL   || fileConfig.models?.compacting || "gpt-4o-mini",
-      research:   process.env.RESEARCH_MODEL     || fileConfig.models?.research   || "gpt-4o",
-      embedding:  process.env.TEXT_EMBEDDING_MODEL || fileConfig.models?.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/core/models.js

@@ -1,17 +1,24 @@
 /**
  * Model Configuration — centralized model selection for every AI task.
  *
- * Users configure models in .env.local to optimize spend:
+ * Supports both OpenAI and Anthropic models. Provider is auto-detected from model name:
+ *   claude-*  → Anthropic
+ *   gpt-*, o1-*, o3-*, text-embedding-* → OpenAI
  *
- *   REASONING_MODEL   — Deep analysis, complex debugging (most expensive, most capable)
- *   CODING_MODEL      — Code repair generation (important, needs strong coding ability)
- *   CHAT_MODEL        — Explanations, summaries (good but cheaper)
- *   AUDIT_MODEL       — Security scans, injection detection (runs on every error)
- *   UTILITY_MODEL     — JSON formatting, regex validation, simple classification (cheapest)
- *
- * Defaults use gpt-4o tiers. Users can swap in any OpenAI-compatible model.
+ * 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).
  */
 
+/**
+ * Detect provider from model name.
+ * @returns {"anthropic"|"openai"}
+ */
+function detectProvider(model) {
+  if (!model) return "openai";
+  if (/^claude/i.test(model)) return "anthropic";
+  return "openai";
+}
+
 const MODEL_ROLES = {
   // Deep reasoning — used for multi-step debugging when a simple fix fails
   reasoning: {
@@ -129,4 +136,4 @@ function logModelConfig(chalk) {
   }
 }
 
-module.exports = { getModel, getModelConfig, logModelConfig, MODEL_ROLES };
+module.exports = { getModel, getModelConfig, logModelConfig, MODEL_ROLES, detectProvider };

package/src/logger/pricing.js

@@ -36,6 +36,16 @@ const DEFAULT_PRICING = {
   "text-embedding-3-small": { input: 0.02,  output: 0.00 },
   "text-embedding-3-large": { input: 0.13,  output: 0.00 },
 
+  // Anthropic Claude family
+  "claude-opus-4":          { input: 15.00, output: 75.00 },
+  "claude-sonnet-4":        { input: 3.00,  output: 15.00 },
+  "claude-haiku-4":         { input: 0.80,  output: 4.00 },
+  "claude-3-5-sonnet":      { input: 3.00,  output: 15.00 },
+  "claude-3-5-haiku":       { input: 0.80,  output: 4.00 },
+  "claude-3-opus":          { input: 15.00, output: 75.00 },
+  "claude-3-sonnet":        { input: 3.00,  output: 15.00 },
+  "claude-3-haiku":         { input: 0.25,  output: 1.25 },
+
   // Fallback for unknown models
   "_default":               { input: 1.00,  output: 4.00 },
 };

package/src/platform/telemetry.js

@@ -54,6 +54,7 @@ function collectHeartbeat(subsystems) {
       byCategory: usage?.byCategory || {},
       byModel: usage?.byModel || {},
       byTool: usage?.byTool || {},
+      byProvider: _aggregateByProvider(usage?.byModel || {}),
     },
 
     brain: { totalMemories: brain?.getStats()?.totalEntries || 0 },
@@ -77,4 +78,23 @@ function collectHeartbeat(subsystems) {
   return redactObj(payload);
 }
 
+/**
+ * Aggregate usage by provider (openai vs anthropic) from byModel data.
+ * Any new model/provider automatically flows through — no code changes needed.
+ */
+function _aggregateByProvider(byModel) {
+  const { detectProvider } = require("../core/models");
+  const byProvider = {};
+  for (const [model, stats] of Object.entries(byModel || {})) {
+    const provider = detectProvider(model);
+    if (!byProvider[provider]) byProvider[provider] = { input: 0, output: 0, total: 0, calls: 0, cost: 0 };
+    byProvider[provider].input += stats.input || 0;
+    byProvider[provider].output += stats.output || 0;
+    byProvider[provider].total += stats.total || 0;
+    byProvider[provider].calls += stats.calls || 0;
+    byProvider[provider].cost += stats.cost || 0;
+  }
+  return byProvider;
+}
+
 module.exports = { collectHeartbeat, INSTANCE_ID };