fix: skip tools with langgraph-injected args in bind_tools MCP bridge

[jasoncarreira]

Summary

`ClaudeCodeChatModel.bind_tools` wraps each LangChain tool into an SDK MCP server tool by invoking `tool._arun(**user_args)` directly inside `_wrap_langchain_tool`. This bypasses LangChain's normal tool-invocation pipeline — including the langgraph injection step that populates `ToolRuntime` and other `InjectedToolArg`-marked parameters.

The result: any tool whose underlying function takes a runtime-injected arg raises on every invocation through the bridge:

```
TypeError: missing 1 required positional argument: 'runtime'
```

Where this bites

Applications built on `deepagents` (and other langgraph-based frameworks) routinely declare middleware-injected tools — `read_file`, `write_file`, `edit_file`, `ls`, `glob`, `grep` from `deepagents.middleware.filesystem.FilesystemMiddleware` all take a `runtime: ToolRuntime[...]` parameter. When such an app is bound through `ClaudeCodeChatModel`, every one of those tools fails on every invocation. The agent typically retries a couple of times then falls back to a same-named framework-native path that works — at the cost of wasted turns and confusing traces in logs.

Real-world failure observed in a deepagents 0.6-based agent calling `mcp__langchain-tools__read_file` three times before falling back to the framework's native `Read` tool.

Fix

Detect tools with runtime-injected args at bind time and skip them. The new `_has_runtime_injected_args` helper:

• Walks the tool's underlying callable (`coroutine` / `func` for StructuredTool, `_arun` / `_run` for BaseTool subclasses).
• Checks each parameter's annotation against:
  • `_DirectlyInjectedToolArg` base class from `langgraph.prebuilt.tool_node` — covers `ToolRuntime[X, Y]` bare-type annotations.
  • `InjectedToolArg` from `langchain_core.tools.base` — covers `Annotated[T, InjectedToolArg(...)]` form.
• Both imports are guarded by try/except so the helper degrades to a no-op when langgraph isn't installed.

Skipped tools log an INFO line but the bind is otherwise silent — the framework's native tool path still serves them when the model needs them.

Why skip rather than fix the bridge

The MCP transport doesn't carry langgraph state (no access to the graph runtime, channels, store, etc.). Even if we constructed a synthetic `ToolRuntime` and passed it in, the tool body would then call `_get_backend(runtime)` and fail because the synthetic runtime has no backend wired up. The right answer is: don't bridge tools that need state they can't get over MCP. Frameworks like deepagents already expose these tools natively to the model through their own middleware, so the bridge wrapping was redundant in the first place.

Tests

New `test_bind_tools_skips_runtime_injected_args`:

• Asserts the helper returns True for a tool whose `_run` takes `ToolRuntime[Any, dict]`.
• Asserts the helper returns False for a plain tool with no injection.
• Asserts `bind_tools` filters the injected tool out of `allowed_tools` while keeping the plain tool.

`langgraph>=0.2` added to dev dependencies (only used in the new test; production runtime stays optional via import guards).

All 12 existing tests pass.

🤖 Generated with Claude Code