fix: integration audit — 6 fixes across LiteLLM, n8n, LangChain, Vercel AI, OpenRouter (#118)

P0 (broken at runtime):
- LiteLLM BudgetTracker: replace broken BudgetManager API calls with
  internal _user_budgets dict for reliable budget tracking
- n8n node: replace nonexistent DomainDetector with DomainRouter,
  remove nonexistent CircuitBreaker (use direct model.invoke)

P1 (significant user impact):
- LangChain Python + TS: add modern models to MODEL_PRICING (GPT-5,
  GPT-5-mini, Claude Sonnet 4, Claude Opus 4.5, Claude Haiku 3.5/4.5,
  DeepSeek)
- Vercel AI: forward request.extra.tools in generate() and stream(),
  extract tool_calls from generate() result
- OpenRouter: parse tool call arguments from JSON string to dict with
  fallback

P2 (consistency):
- Add openrouter and deepseek to PROVIDER_CAPABILITIES in base.py

Author: saschabuehrle

cascadeflow/integrations/langchain/utils.py

@@ -8,17 +8,27 @@
 # Model pricing per 1M tokens (input/output)
 MODEL_PRICING: dict[str, dict[str, float]] = {
     # OpenAI
+    "gpt-5": {"input": 10.00, "output": 30.00},
+    "gpt-5-mini": {"input": 0.20, "output": 0.80},
     "gpt-4o-mini": {"input": 0.150, "output": 0.600},
     "gpt-4o": {"input": 2.50, "output": 10.00},
     "gpt-4-turbo": {"input": 10.00, "output": 30.00},
     "gpt-3.5-turbo": {"input": 0.50, "output": 1.50},
-    # Anthropic
+    # Anthropic (4.x)
+    "claude-opus-4-5": {"input": 5.00, "output": 25.00},
+    "claude-sonnet-4": {"input": 3.00, "output": 15.00},
     "claude-sonnet-4-5-20250929": {"input": 3.00, "output": 15.00},
+    "claude-haiku-3-5": {"input": 1.00, "output": 5.00},
+    "claude-haiku-4-5": {"input": 1.00, "output": 5.00},
+    # Anthropic (3.x)
     "claude-3-5-sonnet-20241022": {"input": 3.00, "output": 15.00},
     "claude-3-5-haiku-20241022": {"input": 0.80, "output": 4.00},
     "claude-3-opus-20240229": {"input": 15.00, "output": 75.00},
     "claude-3-sonnet-20240229": {"input": 3.00, "output": 15.00},
     "claude-3-haiku-20240307": {"input": 0.25, "output": 1.25},
+    # DeepSeek
+    "deepseek-chat": {"input": 0.14, "output": 0.28},
+    "deepseek-coder": {"input": 0.14, "output": 0.28},
 }
 
 

cascadeflow/integrations/litellm.py

@@ -601,6 +601,7 @@ def __init__(self, fallback_to_cascadeflow: bool = True):
         self.fallback_to_cascadeflow = fallback_to_cascadeflow
         self.budget_manager = None
         self.cost_provider = LiteLLMCostProvider()
+        self._user_budgets: dict[str, dict] = {}
 
         if BUDGET_MANAGER_AVAILABLE:
             self.budget_manager = BudgetManager(project_name="cascadeflow")
@@ -633,11 +634,18 @@ def set_user_budget(self, user: str, max_budget: float) -> None:
         Example:
             >>> tracker.set_user_budget("user_123", max_budget=10.0)
         """
+        self._user_budgets[user] = {
+            "max_budget": max_budget,
+            "current_cost": 0.0,
+        }
+
         if self.budget_manager:
-            self.budget_manager.create_budget(user=user, max_budget=max_budget)
-            logger.info(f"Set budget for {user}: ${max_budget:.2f}")
-        else:
-            logger.warning(f"Cannot set budget for {user} - BudgetManager unavailable")
+            try:
+                self.budget_manager.create_budget(user=user, total_budget=max_budget)
+            except Exception as e:
+                logger.debug(f"BudgetManager.create_budget failed for {user}: {e}")
+
+        logger.info(f"Set budget for {user}: ${max_budget:.2f}")
 
     def update_cost(
         self,
@@ -677,51 +685,36 @@ def update_cost(
             ...     response=api_response
             ... )
         """
-        if self.budget_manager:
-            try:
-                # If we have actual API response, use it
-                if response:
-                    cost = self.budget_manager.update_cost(completion_obj=response, user=user)
-                else:
-                    # Calculate cost from tokens
-                    cost = self.cost_provider.calculate_cost(
-                        model=model,
-                        input_tokens=prompt_tokens,
-                        output_tokens=completion_tokens,
-                    )
-
-                    # Update budget manager
-                    self.budget_manager.update_cost(user=user, cost=cost)
-
-                logger.debug(f"Updated cost for {user}: ${cost:.6f}")
-                return cost
-
-            except Exception as e:
-                logger.error(f"Error updating cost for {user}: {e}")
-                # Fall through to fallback
-
-        # Fallback to cascadeflow CostTracker
-        if self.fallback_to_cascadeflow and hasattr(self, "cost_tracker"):
+        # Calculate cost from tokens or response
+        if response:
+            cost = self.cost_provider.calculate_cost(
+                model=model,
+                input_tokens=prompt_tokens,
+                output_tokens=completion_tokens,
+            )
+        else:
             cost = self.cost_provider.calculate_cost(
                 model=model,
                 input_tokens=prompt_tokens,
                 output_tokens=completion_tokens,
             )
+
+        # Track in internal budget dict
+        if user in self._user_budgets:
+            self._user_budgets[user]["current_cost"] += cost
+
+        # Also track in cascadeflow CostTracker if available
+        if self.fallback_to_cascadeflow and hasattr(self, "cost_tracker") and self.cost_tracker:
             self.cost_tracker.add_cost(
                 model=model,
                 provider="",
                 tokens=prompt_tokens + completion_tokens,
                 cost=cost,
                 user_id=user,
             )
-            return cost
 
-        # Just calculate cost without tracking
-        return self.cost_provider.calculate_cost(
-            model=model,
-            input_tokens=prompt_tokens,
-            output_tokens=completion_tokens,
-        )
+        logger.debug(f"Updated cost for {user}: ${cost:.6f}")
+        return cost
 
     def get_user_budget(self, user: str) -> dict:
         """
@@ -742,23 +735,19 @@ def get_user_budget(self, user: str) -> dict:
             >>> print(f"Spent: ${info['current_cost']:.2f}")
             >>> print(f"Remaining: ${info['remaining']:.2f}")
         """
-        if self.budget_manager:
-            try:
-                budget = self.budget_manager.get_budget(user)
-
-                max_budget = budget.get("max_budget", 0)
-                current_cost = budget.get("current_cost", 0)
-                remaining = max_budget - current_cost
-                exceeded = current_cost > max_budget
-
-                return {
-                    "max_budget": max_budget,
-                    "current_cost": current_cost,
-                    "remaining": remaining,
-                    "exceeded": exceeded,
-                }
-            except Exception as e:
-                logger.error(f"Error getting budget for {user}: {e}")
+        budget = self._user_budgets.get(user)
+        if budget:
+            max_budget = budget["max_budget"]
+            current_cost = budget["current_cost"]
+            remaining = max_budget - current_cost
+            exceeded = current_cost > max_budget
+
+            return {
+                "max_budget": max_budget,
+                "current_cost": current_cost,
+                "remaining": remaining,
+                "exceeded": exceeded,
+            }
 
         return {
             "max_budget": 0,
@@ -805,12 +794,9 @@ def reset_user_budget(self, user: str) -> None:
         Example:
             >>> tracker.reset_user_budget("user_123")
         """
-        if self.budget_manager:
-            try:
-                self.budget_manager.reset_cost(user=user)
-                logger.info(f"Reset budget for {user}")
-            except Exception as e:
-                logger.error(f"Error resetting budget for {user}: {e}")
+        if user in self._user_budgets:
+            self._user_budgets[user]["current_cost"] = 0.0
+            logger.info(f"Reset budget for {user}")
 
 
 # ============================================================================

cascadeflow/providers/base.py

@@ -1623,6 +1623,20 @@ def _calculate_confidence_legacy(
         "max_top_logprobs": 20,
         "has_cost_tracking": True,
     },
+    "openrouter": {
+        "supports_logprobs": True,
+        "supports_streaming": True,
+        "supports_tools": True,
+        "max_top_logprobs": 20,
+        "has_cost_tracking": True,
+    },
+    "deepseek": {
+        "supports_logprobs": False,
+        "supports_streaming": True,
+        "supports_tools": True,
+        "max_top_logprobs": 0,
+        "has_cost_tracking": True,
+    },
 }
 
 

cascadeflow/providers/openrouter.py

@@ -556,11 +556,19 @@ def _parse_tool_calls(self, choice: dict[str, Any]) -> Optional[list[dict[str, A
         tool_calls = []
         for tc in raw_tool_calls:
             func = tc.get("function", {})
+            raw_args = func.get("arguments", "{}")
+            if isinstance(raw_args, str):
+                try:
+                    parsed_args = json.loads(raw_args)
+                except (json.JSONDecodeError, TypeError):
+                    parsed_args = raw_args
+            else:
+                parsed_args = raw_args
             tool_calls.append(
                 {
                     "id": tc.get("id", ""),
                     "name": func.get("name", ""),
-                    "arguments": func.get("arguments", "{}"),
+                    "arguments": parsed_args,
                 }
             )
 

packages/core/src/providers/vercel-ai.ts

@@ -217,6 +217,7 @@ export class VercelAISDKProvider extends BaseProvider {
       messages,
       maxTokens: request.maxTokens,
       temperature: request.temperature,
+      ...(request.extra?.tools ? { tools: request.extra.tools } : {}),
       ...(request.extra?.aiSdkOptions ?? {}),
     });
 
@@ -225,6 +226,7 @@ export class VercelAISDKProvider extends BaseProvider {
       model: request.model,
       usage: buildUsage(result.usage),
       finish_reason: result.finishReason,
+      tool_calls: (result as any).toolCalls,
       raw: result,
     };
   }
@@ -239,6 +241,7 @@ export class VercelAISDKProvider extends BaseProvider {
       messages,
       maxTokens: request.maxTokens,
       temperature: request.temperature,
+      ...(request.extra?.tools ? { tools: request.extra.tools } : {}),
       ...(request.extra?.aiSdkOptions ?? {}),
     });
 

packages/integrations/n8n/nodes/CascadeFlowAgent/CascadeFlowAgent.node.ts

@@ -446,14 +446,6 @@ export class CascadeFlowAgent implements INodeType {
         default: true,
         description: 'Whether to route complex queries directly to the verifier',
       },
-      {
-        displayName: 'Enable Circuit Breaker',
-        name: 'useCircuitBreaker',
-        type: 'boolean',
-        default: true,
-        description:
-          'Whether to use circuit breaker for fault tolerance (auto-fallback on repeated failures)',
-      },
       {
         displayName: 'Max Tool Iterations',
         name: 'maxIterations',
@@ -513,7 +505,6 @@ export class CascadeFlowAgent implements INodeType {
     const useAlignmentScoring = this.getNodeParameter('useAlignmentScoring', 0, true) as boolean;
     const useComplexityRouting = this.getNodeParameter('useComplexityRouting', 0, true) as boolean;
     const useComplexityThresholds = this.getNodeParameter('useComplexityThresholds', 0, true) as boolean;
-    const useCircuitBreaker = this.getNodeParameter('useCircuitBreaker', 0, true) as boolean;
     const maxIterations = this.getNodeParameter('maxIterations', 0, 3) as number;
 
     const confidenceThresholds = useComplexityThresholds
@@ -575,7 +566,6 @@ export class CascadeFlowAgent implements INodeType {
       [],
       new Map(),
       new Map(),
-      useCircuitBreaker,
       confidenceThresholds
     );