map_debug_tasks now copies the task config's metadata dict into the
emitted TaskPayload (when non-empty). Mirrors how MessagesStreamPart
already forwards metadata. Enables downstream transformers to project
specific keys onto typed wire surfaces.

When a tool declares BaseTool.subagent_name (static string or callable),
ToolNode resolves it at dispatch time and stamps the resolved value
plus the LLM tool_call_id into the runtime config's metadata. The
metadata then flows through TaskPayload.metadata to downstream
transformers, which project it onto LifecyclePayload.graphName and
LifecyclePayload.cause (the existing wire fields for nested-run
identity and dispatch origin).

ToolNode itself does not interpret the keys — it only resolves and
stamps. Semantic interpretation happens at the transformer layer.

Callable resolvers are invoked best-effort: any exception returns
None (no stamping) rather than failing dispatch.

LifecycleTransformer now reads two specific metadata keys from observed
tasks events and projects them onto typed wire fields:

- metadata.subagent_name -> LifecyclePayload.graph_name (overrides the
  parser-derived segment name like "tools")
- metadata.tool_call_id -> LifecyclePayload.cause as a
  LifecycleCauseToolCall variant ({"type": "toolCall",
  "toolCallId": <id>}) matching the langchain-protocol CDDL spec

cause is gated on subagent_name being present. subagent_name is the
discriminator for "this is a subagent dispatch"; populating cause from
a stray tool_call_id without that signal would mislead frontends that
can't otherwise distinguish subagent runs from arbitrary nested-graph
dispatches.

langgraph treats both keys as opaque strings. The values are produced
by upstream code (ToolNode, in the common case) and projected onto
typed wire fields here, surfacing on the supervisor's depth-1
lifecycle event.

Also exports LifecycleCause and LifecycleCauseToolCall from
langgraph.stream so downstream consumers can type-check against the
projected shape.

Temporary git-URL pin to the BaseTool.subagent_name branch in
langchain-ai/langchain#37721. Once that PR merges and a langchain-core
release ships, this pin should be replaced with a version constraint
like "langchain-core>=X.Y.Z".

Required so CI on this PR can resolve the new BaseTool attribute that
the rest of this branch depends on.

ToolNode previously stamped subagent_name and tool_call_id onto
tool_runtime.config["metadata"] inside the tool body. That mutation
happens AFTER Pregel has already emitted the start `tasks` event for
the tools node, so the lifecycle event arrives at downstream
transformers with metadata=None and the projection chain never sees
the resolved name.

Adds a new Pregel extension point: PregelNode.dynamic_metadata, a
property that proxies to the bound runnable's pregel_dynamic_metadata
attribute when present. prepare_single_task (PULL) and
prepare_push_task_send (Send-dispatched PUSH) call it with the task
input and merge the returned dict into task.config["metadata"]
before the start event fires. Exceptions are swallowed so a buggy
resolver cannot block dispatch.

ToolNode implements pregel_dynamic_metadata: it parses the input,
iterates the dispatched tool calls, and returns
{"subagent_name": ..., "tool_call_id": ...} from the first call
whose tool declares subagent_name. The in-body stamping is removed.

Tests rewritten to call pregel_dynamic_metadata directly with the
input shape rather than asserting on the side-effect inside the tool
body. Adds a mixed-batch test documenting that the first resolved
match wins (one lifecycle payload per task, so a single cause /
graph_name can surface).

map_debug_tasks previously filtered task.config["metadata"] through
a frozen allowlist of two keys (subagent_name, tool_call_id). The
allowlist undermined the extensibility story we want for the
pregel_dynamic_metadata hook: a node that stamps a new key would need
to upstream a change to langgraph's internal constant before
downstream consumers could see it on TaskPayload.metadata, even
though the same dict already flows through to stream_mode='messages'
consumers without any filtering (see StreamMessagesHandler).

Drop the filter; forward the metadata dict (copied, for safety).
Framework keys (langgraph_step, langgraph_node, ...) ride along the
same way they already do on the messages-mode surface; consumers that
don't want them can filter client-side. Any key a user stamps via
proc.metadata or the dynamic_metadata hook now flows through to
v3 lifecycle events without further plumbing.

Tests updated to reflect the new shape and to verify the dict is
defensively copied so post-emission mutations of task.config do not
poison the payload.

map_debug_tasks now forwards task.config['metadata'] whole, so every
'type': 'task' debug-stream event carries a metadata dict with the
framework keys (langgraph_step, langgraph_node, langgraph_triggers,
langgraph_path, langgraph_checkpoint_ns). Inline payload expectations
in test_pregel and test_large_cases assumed no metadata key and
diffed on the extra field.

Anchor each task-payload assertion with AnyObject() rather than
pinning specific framework key values so future framework metadata
additions don't ripple through these tests again.

The subagent-name stamping hook is unnecessary: lc_agent_name is bound
onto the inner agent's config by create_agent and already flows into
task.config metadata. Drops the PregelNode.dynamic_metadata property and
its two application sites in prepare_single_task/prepare_push_task_send.

Drops _resolve_subagent_name and ToolNode.pregel_dynamic_metadata. Subagent
identity now comes from the inner agent's own lc_agent_name, not a tool-level
declaration stamped at dispatch.

_TasksLifecycleBase now tracks lc_agent_name per namespace and treats a
nested task as a subagent when its lc_agent_name differs from its parent's.
graph_name becomes that name; the triggering tool_call_id (for cause) is
recovered by joining the child segment's task-id to the parent task's tool
calls. Replaces the subagent_name metadata discriminator.

Current langgraph schedules each tool call as its own push task whose
input is a `tool_call_with_context` dict (tool_call_id at
input["tool_call"]["id"]), not a list of tool calls. _record_pending_tool_calls
now handles both the dict shape and the legacy/batched list shape, so
cause recovery fires on the production path. Synthetic tests updated to
use the real dict input shape, with an added test for the legacy list.

The _pending_tool_calls __init__ comment now describes the current
tool_call_with_context dict shape first and the legacy list shape as
fallback. _record_identity's docstring frames the parent-before-child
ordering as a Pregel emission assumption rather than an invariant. Adds
a terminal-roundtrip test that closes a detected subagent on its parent
push task's result and asserts the started payload's graph_name/cause
survive.

…gent_name

…gent_name

This reverts commit c94009e.

Clearer that it returns the user-facing tags (dropping internal seq:step
tags), per review feedback.