Fixing a Silent 400: Forced tool_choice Under Claude Thinking in LangChain

• 2026-03-03 · A community user files issue #35539 with a self-contained repro and an accurate root cause: create_agent with a response_format hardcodes tool_choice="any" for the structured-output tool, which Claude rejects under extended thinking. The diagnosis and the repro are the reporter's.
• 2026-03 · Hermes Labs engineers the fix one layer down, at the ChatAnthropic.bind_tools() binding, so any caller that forces a tool, not just create_agent, is covered. The work confirms the reporter's cause against the code, proves which tool_choice values must be dropped versus preserved, verifies the guard is inert when thinking is off, and adds regression tests. Hermes opens PR #35544.
• 2026-03-05 · LangChain maintainers merge PR #35544 to master, closing #35539.

The same binary-gated discipline Hermes Labs runs as a diagnostic pipeline on private client stacks also governs how it produces a public upstream fix: pass a gate, or stop. No gate is skippable. No gate is judgment-graded. The intent is that an opinionated process produces a falsifiable artifact at each step, so the diff at the end is one a maintainer can adopt without re-deriving the reasoning. The gates below describe that discipline as it bears on this fix.

The internal artifact set for this fix is on file. Sharing the relevant slices is a service deliverable on request.

The cause sits at a specific seam: bind_tools() passed a forcing tool_choice through to a thinking-enabled request with no guard. The fix is the minimum change that closes that seam. After tool_choice normalization, if thinking is enabled and the choice forces tool use, drop the choice and warn. The precedent surfaced in Gate 2 set the shape of the fix: the structured-output path already omits tool_choice under thinking for the same API reason, so reviewers could check the guard against code already in the repo rather than against a novel pattern.

if (
    self.thinking is not None
    and self.thinking.get("type") == "enabled"
    and "tool_choice" in kwargs
    and kwargs["tool_choice"].get("type") in ("any", "tool")
):
    warnings.warn(
        "tool_choice is forced but thinking is enabled. The Anthropic "
        "API does not support forced tool use with thinking. "
        "Dropping tool_choice to avoid an API error. ...",
        stacklevel=2,
    )
    del kwargs["tool_choice"]

The production change is roughly twenty lines in chat_models.py (the warnings module was already imported there; the only added import was import warnings in the test file). It is paired with eight regression test cases across the forced variants, the "auto" passthrough, and the thinking-off, None, and disabled cases. The warning matters as much as the guard: dropping tool_choice means tool calls are no longer guaranteed on that request, so the caller is told explicitly rather than left to discover it. Credit to the reporter for the accurate root cause and clean repro, and to the LangChain maintainers for the structured-output guard that gave the fix its shape. Hermes's contribution was the engineering: generalizing the guard to the binding boundary so every forcing caller is covered, proving which tool_choice values had to be dropped versus preserved, showing the change was inert for every unaffected agent, and landing it through review.

For a team running Claude agents, this is the failure shape that is most expensive to diagnose in-house: a provider constraint, enforced at the API boundary, triggered by a value set two layers up in a framework you did not write. Nothing static catches it. The types are sound, the unit tests pass, the linter is quiet; the only signal is a live request that comes back 400. And the error message, while accurate, is misleading, because it names tool_choice and not the binding that forced it. Teams burn hours bisecting their own agent graph before the cause turns out to be a one-line interaction between two correct-looking settings, one of which can only be observed against the real endpoint.

This case is public, so the credit is shared. The reporter supplied the diagnosis. The engineering held up in a maintainer's review and merged. When Hermes Labs audits a private stack, the same discipline turns to discovery, and the deliverable is the receipts: the reproduction, the falsification log that rules out competing causes, the failing-then-passing regression tests, and an explicit list of what was checked — that auto stays untouched, that thinking-off agents see no change, and that the change is inert everywhere the failure does not apply. A buyer can read it cold and decide whether the failure applies to their stack and whether the audit checked the right things, without re-running the investigation.

This is the same pipeline Hermes Labs runs whether the target is a model binding, a prompt template, an agent harness, a retrieval layer, or a tool definition. The systematic failure categories vary; the gate structure does not.

If you run Claude agents in production, the failures that cost the most are the ones that look like your code but live in a framework binding or a provider constraint. We run this diagnostic pipeline against production AI stacks under NDA.

References: #35539 · #35544 · PR filed under our founder's GitHub handle, roli-lpci · Upstream contributions: /open-source/contributions