How I Fixed DeepSeek's Tool Call Failures in 30 Lines

"How I Fixed DeepSeek's Tool Call Failures in 30 Lines"

Posted by: [Your name]

The Problem

Running Hermes with DeepSeek V4 Pro/Flash. Tool calls fail 50+ times in a row. Same error looped. Context window fills with garbage. Session dies.

Sound familiar? It's not the model. It's the harness.

What Actually Happens

DeepSeek (and GLM, Qwen, etc.) makes the same 4 mistakes on tool calls:

Table

Mistake Example What Schema Wants

null for optional {"file": null} omit the key entirely

JSON string as array {"items": '["a","b"]'} {"items": ["a","b"]}

Empty {} placeholder {"args": {}} {"args": []}

Bare string for array {"name": "foo"} {"name": ["foo"]}

Your validator (Zod, Pydantic) rejects it. Error goes back to model. Model sends same bad call again. 56 times average. Then it gives up or hallucinates.

The Fix: Repair Harness

Don't send the error back. Fix it deterministically, run it, and teach the model what it should have done.

This is 4 small repair functions. ~30 lines each. Ordered carefully.

Python

# repairs/plugin.py — Drop this into your agent

import json

from dataclasses import dataclass

from typing import Dict, Any, List, Optional

@dataclass

class RepairResult:

changed: bool

tool_call: Dict[str, Any]

repair_id: str

description: str

before: Optional[str]

after: Optional[str]

class ToolRepairHarness:

def __init__(self):

self.repair_stats = {}

def repair(self, tool_call: Dict[str, Any], schema: Dict[str, Any]):

fixed = json.loads(json.dumps(tool_call)) # deep copy

applied = []

# REPAIR 001: null → omit (optional fields)

before = json.dumps(fixed.get("arguments", {}))

args = dict(fixed.get("arguments", {}))

required = schema.get("required", [])

for key, value in list(args.items()):

if value is None and key not in required:

del args[key]

if json.dumps(args) != before:

fixed["arguments"] = args

applied.append(RepairResult(True, fixed, "001",

"Removed null for optional field", before, json.dumps(args)))

# REPAIR 002: string array → actual array

before = json.dumps(fixed.get("arguments", {}))

args = dict(fixed.get("arguments", {}))

for key, value in list(args.items()):

if schema.get("properties", {}).get(key, {}).get("type") == "array" and isinstance(value, str):

cleaned = value.strip()

if cleaned.startswith('"') and cleaned.endswith('"'):

cleaned = json.loads(cleaned)

if cleaned.startswith('['):

try: args[key] = json.loads(cleaned); continue

except: pass

args[key] = [value]

if json.dumps(args) != before:

fixed["arguments"] = args

applied.append(RepairResult(True, fixed, "002",

"Parsed JSON string to array", before, json.dumps(args)))

# REPAIR 003: empty {} → []

before = json.dumps(fixed.get("arguments", {}))

args = dict(fixed.get("arguments", {}))

for key, value in list(args.items()):

if (schema.get("properties", {}).get(key, {}).get("type") == "array" and

isinstance(value, dict) and len(value) == 0):

args[key] = []

if json.dumps(args) != before:

fixed["arguments"] = args

applied.append(RepairResult(True, fixed, "003",

"Replaced empty {} with []", before, json.dumps(args)))

# REPAIR 004: bare string → [string]

before = json.dumps(fixed.get("arguments", {}))

args = dict(fixed.get("arguments", {}))

for key, value in list(args.items()):

if (schema.get("properties", {}).get(key, {}).get("type") == "array" and

isinstance(value, str) and not value.startswith('[')):

args[key] = [value]

if json.dumps(args) != before:

fixed["arguments"] = args

applied.append(RepairResult(True, fixed, "004",

"Wrapped bare string in array", before, json.dumps(args)))

# Build repair note for LLM

note = ""

if applied:

lines = [f"[REPAIR] Fixed {len(applied)} issue(s) in '{tool_call.get('name')}':"]

for r in applied:

lines.append(f" [{r.repair_id}] {r.description}")

lines.append("Use this format in future calls.")

note = "\n".join(lines)

return fixed, applied, note

# Singleton

harness = ToolRepairHarness()

How to Wire It

Find where your agent validates tool calls. Insert repair BEFORE validation.

Python

# In your tool executor

from repairs.plugin import harness

async def execute_tool(tool_call, schema):

# STEP 1: Repair before validation

fixed, repairs, note = harness.repair(tool_call, schema)

# STEP 2: Now validate (should pass)

validation = validate(fixed, schema)

if not validation.success:

return {"error": "Still broken after repair"}

# STEP 3: Execute

result = await run_tool(fixed)

# STEP 4: Return result + repair note (teaches the model)

return {

"result": result,

"repair_note": note # ← This goes back to LLM context

}

Why This Works

Table

Without Repair With Repair

Error → model → same error × 56 Fix silently → run → teach model

Context window dies Session continues

Model "loops" on same solution Model learns in-context, stops repeating

You blame the model You fix the harness

The repair note is the secret. After 2-3 notes, DeepSeek stops making that mistake. It's like saying "you mean this?" and the model going "yeah yeah" and continuing.

Results

DeepSeek V4 Pro now beats Opus 4.7 on our internal evals (6/10)

Tool calls that failed 56× now pass first time

Long sessions (12+ hours) stay stable

Token cost drops because no error spiral

The Bigger Picture

This is Layer 1 of 3:

Repairs (this post) — fix bad tool calls

Hooks — deterministic guardrails (block dangerous ops)

Loops — self-triggering, compounding agent systems

All three together = agent that runs 24/7 without breaking.

Credit

Inspired by @MrAhmadAwais who discovered these 4 repair patterns and proved DeepSeek's "tool call problem" was actually a harness problem. Full video: [link if you want]

Try It

Drop the code in. Test with one tool. Watch your repair log. Report back.

Who's running open-source models with tool calling? What failures are you seeing?

Want me to adjust the tone (more technical, more story, shorter), add a diagram, or write a follow-up post for Hooks?

99+

How I Fixed DeepSeek's Tool Call Failures in 30 Lines · AI Product Academy

0 comments

How I Fixed DeepSeek's Tool Call Failures in 30 Lines