mirror of
https://github.com/bytedance/deer-flow.git
synced 2026-09-16 17:46:20 +00:00
a94b2d8897
* feat(mcp): map request-scoped secrets to HTTP/SSE headers `user_auth` binds a credential to a configured DeerFlow user, so a caller that picks the credential per request — a multi-tenant gateway, a per-run API key, one shared MCP server fronting several environments — had to register one MCP server entry per credential. Add a declarative `mcpServers.<server>.headers_from_context` block mapping HTTP header names to keys of the run request's `config.context.secrets` carrier. A new built-in interceptor resolves the mapping on every tool call and rewrites those headers, mirroring `user_scoped_auth`. The config file stores names only, never a credential, so the Gateway returns the block unmasked. Registered after OAuth and `user_auth` in the interceptor chain: the later interceptor runs closer to the transport, and the value chosen for this one request is the most specific, so it wins. Fail-closed by default — a mapped key missing from the request raises a `ToolException` naming only that key, because falling back to the server's discovery credential would send one tenant's call under another tenant's authority. `on_missing: "passthrough"` opts out. Durable background tasks are excluded: `McpTaskToolCaller` drives status and cancel polls after the Agent run ends, where no run context exists, so the fail-closed interceptor would deny every poll. Those calls keep using server-level credentials, and a server declaring both `headers_from_context` and `task_toolsets` now logs a warning. Also corrects the custom-interceptor example in docs/MCP_SERVER.md (and the matching claim in skills/AGENTS.md), which read request secrets from `langgraph.config.get_config()["context"]`. That key is `None` inside a tool call — the run context rides the LangGraph runtime, not the RunnableConfig propagated to child runnables — so interceptors written from that example never saw a value. The example now reads `request.runtime`, and tests/test_mcp_context_headers.py pins LangGraph's runtime-injection rule by driving a real langchain-mcp-adapters tool through a real graph with the ambient-runtime fallback disabled. Closes #5005 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(mcp): resolve credential headers case-insensitively, carry them on durable submit Review follow-ups on `headers_from_context`. HTTP field names are case-insensitive, but every dict on the path to the wire is not: `build_server_params` copies the operator's static `headers` spelling verbatim, and langchain-mcp-adapters merges interceptor overrides into the connection with a plain `{**connection_headers, **override_headers}` splat. A static `authorization` and an injected `Authorization` therefore both reached httpx as separate field lines, and a server reading the field with a single-value accessor got the static discovery credential — inverting the documented `headers` < `oauth` < `user_auth` < `headers_from_context` precedence and running a per-request call under the shared credential. Normalizing inside the interceptor cannot fix that on its own: the adapter builds the request with `headers=None`, so an interceptor never sees the connection's static headers and cannot displace them however it spells its own key. A new `mcp/headers.py::apply_header_overrides` therefore drops any key differing only in case and emits the spelling the connection already uses. Applied to `headers_from_context`, `user_auth`, the OAuth interceptor, the OAuth discovery-header write, and the durable-task connection merge, which all carried the same collision. `headers_from_context.headers` now also rejects one header mapped under two spellings at config load, in both the harness model and the Gateway mirror. Durable submit now carries the mapped headers, as docs/MCP_SERVER.md already promised. `McpTaskToolCaller` disabled the interceptor for the whole caller, but that caller serves submit as well as the polls, and submit is awaited inline inside the Agent's tool call — where the run's LangGraph runtime is still the ambient contextvar, so no secret has to be threaded through `TaskSubmitRequest` or reach durable storage. The caller builds one chain and keeps a second view of it without the context-headers interceptor; `call_tool` takes `request_scoped_headers`, set only by `OrdinaryMcpTaskDriver.submit`. Status and cancel keep server-level credentials, so background polls still cannot fail closed, and the startup warning now describes the half it actually covers. `_merge_preserving_secrets` restores masked extras inside `headers_from_context` instead of writing the `***` sentinel back over the stored value, matching the treatment `user_auth` extras and server-level extras already get; extras a PUT omits carry over as well, while the declared mapping still replaces verbatim so a round trip can remove an entry. `extra="allow"` plus name-based sensitivity detection means the usual casualty is a name-valued key such as `tokenHeader`, not only a credential. The existing override test seeded the static header onto `request.headers`, which production never does, so it modelled a merge that really happens one layer down; the new tests drive a real adapter tool through a real connection and assert on the headers the session is opened with, and the durable-submit test runs through a real tool node with no runtime patching. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(mcp): reject case-insensitive duplicate static header names * fix(mcp): preserve omitted headers_from_context fields on partial updates --------- Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
62 lines
2.6 KiB
Python
62 lines
2.6 KiB
Python
"""Case-insensitive header writes for MCP tool-call interceptors.
|
|
|
|
HTTP field names are case-insensitive (RFC 9110 §5.1), but every dictionary on
|
|
the path from config to the wire is case-*sensitive*: ``build_server_params``
|
|
copies the operator's static ``headers`` spelling verbatim, and
|
|
``langchain_mcp_adapters`` merges interceptor overrides with a plain
|
|
``{**connection_headers, **override_headers}`` splat. So a static
|
|
``authorization`` and an interceptor-written ``Authorization`` do not collide —
|
|
both survive, httpx puts both on the wire, and a server reading the field with a
|
|
single-value accessor sees the *first* one, which is the static entry the
|
|
override was supposed to replace.
|
|
|
|
The credential interceptors therefore write header names through
|
|
:func:`apply_header_overrides`, which drops any key differing only in case and
|
|
emits the spelling the connection already uses, so the adapter's merge replaces
|
|
the static entry instead of duplicating it.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Iterable, Mapping
|
|
|
|
|
|
def header_spellings(names: Iterable[str] | None) -> dict[str, str]:
|
|
"""Index header names by their lowercased form.
|
|
|
|
Used to pin the spelling an interceptor should emit: the connection's own
|
|
static ``headers`` keys, which the adapter merges the override into. A
|
|
server that declares none passes ``None`` here rather than being special-
|
|
cased at each call site.
|
|
"""
|
|
return {name.lower(): name for name in (names or ())}
|
|
|
|
|
|
def apply_header_overrides(
|
|
base: Mapping[str, str] | None,
|
|
overrides: Mapping[str, str],
|
|
*,
|
|
spellings: Mapping[str, str] | None = None,
|
|
) -> dict[str, str]:
|
|
"""Return ``base`` with ``overrides`` applied, case-insensitively.
|
|
|
|
``spellings`` maps a lowercased header name to the spelling to emit and
|
|
takes priority over ``base``'s own keys, so an override lands on the static
|
|
connection header it is meant to replace even when an earlier interceptor
|
|
already wrote a differently-cased variant. Any key of ``base`` that differs
|
|
from the emitted name only in case is removed, so the result never carries
|
|
one header under two spellings.
|
|
"""
|
|
merged = dict(base or {})
|
|
lookup = dict(spellings or {})
|
|
for key in merged:
|
|
lookup.setdefault(key.lower(), key)
|
|
|
|
for name, value in overrides.items():
|
|
lowered = name.lower()
|
|
canonical = lookup.get(lowered, name)
|
|
for existing in [key for key in merged if key != canonical and key.lower() == lowered]:
|
|
del merged[existing]
|
|
merged[canonical] = value
|
|
return merged
|