docs(skills): fix broken refs in adk-workflow skill

Merge google#6044

## Summary

Fixes 5 documentation bugs in the `adk-workflow` skill on `v2`. Each is empirically verified against `google-adk==2.2.0` and `v2` source. Full verification transcript inline below.

### Fixes in this PR

1. **`advanced-patterns.md`** — Remove the hard-coded local-filesystem URL `file:///Users/deanchen/Desktop/...` left in a doc link; replace with the relative path `dynamic-nodes.md`.

2. **`testing.md`** — All examples imported from `tests.unittests.*`, which is not in the published `google-adk` wheel. Rewrite to use the public `from google.adk.runners import InMemoryRunner` plus a small inline `run()` helper. Three rewritten snippets (basic workflow, state, parallel worker) were executed end-to-end against `google-adk==2.2.0` and pass. The `MockModel` section is replaced with a `FakeLlm(BaseLlm)` pattern that uses only public symbols.

3. **`llm-agent-nodes.md`** — The doc claims "LlmAgentWrapper outputs `types.Content`, NOT `str`." The source (`_llm_agent_wrapper.process_llm_agent_output`) sets `event.output = text` (a `str`) when `output_schema` is unset, and the validated dict when set. Rewrite the section, the table, and drop the "use `Any` and extract text" workaround that depended on the wrong claim.

4. **`parallel-and-fanout.md` + `import-paths.md`** — Drop `from google.adk.workflow._parallel_worker import ParallelWorker`. The class doesn't exist under that name; only the private `_ParallelWorker` does. The same files already document the public API (`parallel_worker=True` flag on `@node` or `LlmAgent`) — rewrite samples to use it consistently.

5. **`state-and-events.md` (+ one cross-reference in `advanced-patterns.md`)** — Drop `triggered_by`, `in_nodes`, `execution_id`, `retry_count` from the `Context` property tables and code samples. None of them exist on `Context` in v2 source (verified by `grep` in `src/google/adk/agents/context.py`). Rename `retry_count` → `attempt_count` (the live name). Also drop `get_next_child_execution_id` from the methods table for the same reason.

### Scope

All five fixes target the same file tree (`.agents/skills/adk-workflow/references/`) with the same concern: "skill docs reference symbols/imports/paths that don't exist." Per CONTRIBUTING.md "small, focused PRs", they're bundled because each is a surgical edit and they share verification setup. Happy to split if reviewers prefer.

## Testing plan

Doc-only changes. No source code or behavior modified.

1. **Pip-install reproduction** of every bug claimed in a clean venv with `google-adk==2.2.0`. See "Verification details" below for the verbatim `ImportError`, `hasattr == False`, and source quotes that prove each claim.

2. **Rewritten `testing.md` snippets executed end-to-end** against `google-adk==2.2.0`:
   - `test_simple_workflow` — PASSED
   - `test_state_management` — PASSED
   - `test_parallel_worker` — PASSED

3. **Pre-commit hooks** ran clean on the changed files. `mdformat` is excluded for `.agents/` by the repo's `.pre-commit-config.yaml`, and the other hooks (`isort`, `pyink`, `addlicense`) target Python/shell files only.

## Notes for reviewers

- All claims are pinned to `2.2.0` + `v2` HEAD as of the date of this PR.
- The `testing.md` rewrite is the largest delta (~500 lines), but almost every line either drops a `tests.unittests.*` import or replaces a `testing_utils.X` call with public-API equivalents.
- A previously-considered "bug" (parallel-worker naming as `{name}__{index}`) was dropped from this PR after confirming it had already been fixed on v2 to use `{name}@{run_id}` with `run_id` starting at `"1"`.

---

## Verification details

Setup:

```bash
uv venv --python 3.13 .venv && source .venv/bin/activate
uv pip install google-adk
python -c "import google.adk; print(google.adk.__version__)"
# -> 2.2.0
```

### Bug 1 — Hard-coded `file:///` URL

```
$ grep -n 'file:///' .agents/skills/adk-workflow/references/advanced-patterns.md
38:See the dedicated [Dynamic Node Scheduling Reference](file:///Users/deanchen/Desktop/adk-workflow/.agents/skills/adk-workflow/references/dynamic-nodes.md) for detailed rules, examples, and best practices.
```

A developer's local filesystem path leaked into the published skill.

### Bug 2 — `tests.unittests...` imports unreachable from `pip install`

```python
>>> from tests.unittests.workflow import testing_utils
ModuleNotFoundError: No module named 'tests'

>>> from tests.unittests.testing_utils import InMemoryRunner, MockModel
ModuleNotFoundError: No module named 'tests'
```

The `tests/` directory ships only in the source repo, not in the installed `google-adk` wheel. Any user copying these snippets gets `ModuleNotFoundError`. The PR rewrites samples to use the public `from google.adk.runners import InMemoryRunner` and demonstrates a publicly-importable mock pattern (subclass `BaseLlm`).

The three rewritten snippets (basic, state, parallel) were run end-to-end against `google-adk==2.2.0` and all three passed.

### Bug 3 — `LlmAgentWrapper` output type doc is wrong

The skill claims: *"LlmAgentWrapper outputs `types.Content`, NOT `str`."*

The source in both `2.2.0` and `v2` says otherwise. From `src/google/adk/workflow/_llm_agent_wrapper.py`:

```python
def process_llm_agent_output(agent: Any, ctx: Context, event: Event) -> None:
    ...
    text = (
        ''.join(p.text for p in event.content.parts if p.text and not p.thought)
        if event.content.parts else ''
    )
    if agent.output_schema:
        if text.strip():
            output = validate_schema(agent.output_schema, text)
        else:
            output = None
    else:
        output = text          # <-- str, not types.Content
    ...
    event.output = output
```

When `output_schema` is unset, `event.output` is the concatenated string of the model's text parts. When `output_schema=MyModel` is set, it's the validated `model_dump()` dict. The PR rewrites the section, table, and the "use `Any` and extract text" workaround that depended on the wrong claim.

### Bug 4 — `_parallel_worker.ParallelWorker` is not importable

The class doesn't exist under that name — only the underscore-prefixed `_ParallelWorker` does, and that path is private:

```python
>>> from google.adk.workflow._parallel_worker import ParallelWorker
ImportError: cannot import name 'ParallelWorker' from 'google.adk.workflow._parallel_worker'

>>> from google.adk.workflow._parallel_worker import _ParallelWorker
>>> _ParallelWorker
<class 'google.adk.workflow._parallel_worker._ParallelWorker'>
```

The recommended public API is the `parallel_worker=True` flag — already documented as preferred in the same files. Verified end-to-end:

```python
from google.adk.workflow import node, Workflow

@node(parallel_worker=True)
def double(node_input: int) -> int:
    return node_input * 2

# Workflow constructs OK; `double` is an internal _ParallelWorker
# under the hood — no user-visible private-API surface needed.
```

PR drops the private import from `parallel-and-fanout.md` and the `import-paths.md` table, and rewrites samples to use the flag.

### Bug 5 — Removed `Context` properties documented as live

```python
>>> from google.adk.agents.context import Context
>>> for name in ['triggered_by', 'in_nodes', 'execution_id', 'retry_count', 'attempt_count']:
...     print(name, hasattr(Context, name))
triggered_by False
in_nodes False
execution_id False
retry_count False
attempt_count True
```

The same is true on `v2` source — `grep` for those names in `src/google/adk/agents/context.py` returns nothing, while `attempt_count` has 4 hits.

Code samples using `ctx.retry_count` / `ctx.triggered_by` raise `AttributeError`. PR removes the four absent properties from the docs and renames `retry_count` → `attempt_count` everywhere it's mentioned. `get_next_child_execution_id` is also gone from `Context` on v2; the PR removes it from the methods table for the same reason.

Co-authored-by: Shangjie Chen <deanchen@google.com>
COPYBARA_INTEGRATE_REVIEW=google#6044 from freddypatota:fix/adk-workflow-skill-doc-bugs 4a61d38
PiperOrigin-RevId: 932770088

Author: 2 people

.agents/skills/adk-agent-builder/references/advanced-patterns.md

@@ -4,12 +4,14 @@ Nested workflows, dynamic nodes, retry configuration, custom node types, and gra
 
 ## 📋 Agent Verification Checklist (Advanced Patterns)
 Use this checklist when implementing complex workflows:
+
 - [ ] **Validation**: Does your graph follow all 7 validation rules? (e.g., no unconditional cycles)
 - [ ] **Custom Nodes**: If creating a custom node, did you override `get_name()` and `run()`?
 - [ ] **Dynamic Execution**: If using `run_node`, did you follow the rules in the dedicated dynamic-nodes reference?
 - [ ] **Waiting State**: Did you use `wait_for_output=True` if the node should stay in WAITING state until output is yielded?
 
 ## 💡 Quick Reference
+
 - **Retry**: `RetryConfig(max_attempts=5, initial_delay=1.0)`
 - **Custom Node Fields**: `rerun_on_resume`, `wait_for_output`, `retry_config`, `timeout`
 
@@ -46,7 +48,8 @@ The inner workflow receives the predecessor's output as its START input and its
 
 Schedule nodes at runtime using `ctx.run_node()`.
 
-See the dedicated [Dynamic Node Scheduling Reference](file:///Users/deanchen/Desktop/adk-workflow/.agents/skills/adk-workflow/references/dynamic-nodes.md) for detailed rules, examples, and best practices.
+See the dedicated [Dynamic Node Scheduling Reference](dynamic-nodes.md) for
+detailed rules, examples, and best practices.
 
 ## Retry Configuration
 
@@ -80,12 +83,13 @@ delay = min(delay, max_delay)
 delay = delay * (1 + random(0, jitter))
 ```
 
-### Accessing retry count
+### Accessing the attempt count
 
 ```python
 def my_node(ctx: Context, node_input: str) -> str:
-  if ctx.retry_count > 0:
-    print(f"Retry attempt {ctx.retry_count}")
+  # attempt_count is 1 on the first try, ≥2 on retries
+  if ctx.attempt_count > 1:
+    print(f"Retry attempt {ctx.attempt_count}")
   return "result"
 ```
 
@@ -167,6 +171,7 @@ class CollectorNode(BaseNode):
 ```
 
 Nodes with `wait_for_output=True` default:
+
 - `JoinNode`: `True` (waits for all predecessors)
 - `LlmAgentWrapper` (task mode): `True` (set in `model_post_init`)
 - All other nodes: `False`

.agents/skills/adk-agent-builder/references/import-paths.md

@@ -2,6 +2,7 @@
 
 ## 📋 Agent Verification Checklist (Imports)
 Use this checklist to ensure you are using the most idiomatic import paths:
+
 - [ ] **Canonical Imports**: Did you use the short canonical imports where available (e.g., `from google.adk import Agent`) instead of the verbose ones?
 - [ ] **Avoid Deprecated**: Are you avoiding deprecated paths (e.g., use `McpToolset` instead of `MCPToolset`)?
 
@@ -34,16 +35,25 @@ from google.adk.workflow import node, RetryConfig, Edge, JoinNode
 
 ## Workflow Nodes
 
-| Component | Import |
-|-----------|--------|
-| `FunctionNode` | `from google.adk.workflow import FunctionNode` |
-| `_LlmAgentWrapper` (private, auto-used) | `from google.adk.workflow._llm_agent_wrapper import _LlmAgentWrapper` |
-| `AgentNode` | `from google.adk.workflow._agent_node import AgentNode` |
-| `_ToolNode` (private) | `from google.adk.workflow._tool_node import _ToolNode` |
-| `JoinNode` | `from google.adk.workflow import JoinNode` |
-| `ParallelWorker` | `from google.adk.workflow._parallel_worker import ParallelWorker` |
-| `BaseNode`, `START` | `from google.adk.workflow import BaseNode, START` |
-| `@node` decorator | `from google.adk.workflow import node` |
+| Component                           | Import                                 |
+| ----------------------------------- | -------------------------------------- |
+| `FunctionNode`                      | `from google.adk.workflow import       |
+:                                     : FunctionNode`                          :
+| `_LlmAgentWrapper` (private,        | `from                                  |
+: auto-used)                          : google.adk.workflow._llm_agent_wrapper :
+:                                     : import _LlmAgentWrapper`               :
+| `AgentNode`                         | `from google.adk.workflow._agent_node  |
+:                                     : import AgentNode`                      :
+| `_ToolNode` (private)               | `from google.adk.workflow._tool_node   |
+:                                     : import _ToolNode`                      :
+| `JoinNode`                          | `from google.adk.workflow import       |
+:                                     : JoinNode`                              :
+| Parallel-worker behavior (no public | Set `parallel_worker=True` on `@node`  |
+: class)                              : or `LlmAgent`; the framework wraps     :
+:                                     : with an internal `_ParallelWorker`     :
+| `BaseNode`, `START`                 | `from google.adk.workflow import       |
+:                                     : BaseNode, START`                       :
+| `@node` decorator                   | `from google.adk.workflow import node` |
 
 ## Workflow Events and Context
 

.agents/skills/adk-agent-builder/references/llm-agent-nodes.md

@@ -4,12 +4,14 @@ Embed LLM-powered agents as nodes in workflow graphs.
 
 ## 📋 Agent Verification Checklist (LLM Nodes)
 Use this checklist to verify your LLM agent configuration:
+
 - [ ] **Output Type**: If no `output_schema` is set, downstream now receives `str` (auto-extracted from `types.Content`). You can safely type-hint `node_input: str`.
 - [ ] **State Serialization**: If this agent feeds into a `JoinNode`, did you set `output_schema` to avoid non-serializable `types.Content` errors?
 - [ ] **Instructions**: Are `{var}` templates used in instructions resolving ONLY from `ctx.state`? (Not `node_input`)
 - [ ] **Config**: Are instructions, tools, and response schema set on the `LlmAgent` directly, and NOT in `generate_content_config`?
 
 ## 💡 Quick Reference
+
 - **Chat Mode**: Default. Multi-turn, keeps session history.
 - **Single-Turn Mode**: Isolated. Set `mode="single_turn"` or rely on auto-wrapping defaults.
 - **Task Mode**: Multi-turn within a task. Set `mode="task"`.
@@ -70,25 +72,25 @@ agent = Workflow(
 )
 ```
 
-## LLM Agent Output Types (Critical)
+## LLM Agent Output Types
 
-**LlmAgentWrapper auto-extracts text and outputs `str` when no `output_schema` is set.** Previously, it outputted `types.Content` causing type errors. Now, if you type-hint `node_input: str`, it will work correctly for standard text output.
+When an `LlmAgent` runs as a workflow node, `process_llm_agent_output` (in
+`_llm_agent_wrapper.py`) sets `event.output` to:
 
-**Solutions (pick one):**
+-   The **concatenated text** of the model's response (a `str`) — when
+    `output_schema` is not set.
+-   The **validated dict** (`model_dump()` of the Pydantic model) — when
+    `output_schema=MyModel` is set.
 
-1. **Use `Any` and extract text** (recommended for function nodes after LLM agents):
+A downstream function node typed `node_input: str` therefore works in the
+default case, and `node_input: dict` works when `output_schema` is set.
 
-```python
-from typing import Any
-from google.genai import types
-
-def process_llm_output(node_input: Any) -> str:
-  if isinstance(node_input, types.Content):
-    return ''.join(p.text for p in (node_input.parts or []) if p.text)
-  return str(node_input) if node_input is not None else ''
-```
-
-2. **Use `output_schema`** on the LLM agent to get a parsed `dict` instead:
+**Observability caveat:** the value above is set on the event internally and
+forwarded to the next node, but `event.output` is **`None`** when you observe it
+from `runner.run_async(...)` for the LLM agent's own event — the framework
+clears it before the event reaches user code. Don't write tests that assert on
+`event.output` for an LLM agent's event; assert on the downstream node's output,
+on `session.state[output_key]`, or on `event.content.parts[*].text` instead.
 
 ```python
 from pydantic import BaseModel
@@ -104,23 +106,28 @@ writer = LlmAgent(
     output_schema=CodeOutput,
 )
 
-# Downstream node receives dict: {"code": "...", "language": "python"}
+# Downstream node receives a dict: {"code": "...", "language": "python"}
 def process_code(node_input: dict) -> str:
   return node_input["code"]
 ```
 
 **Summary of LLM agent node output types:**
 
-| LLM Agent Config | `node_input` Type for Next Node |
-|-----------------|-------------------------------|
-| No `output_schema` | `types.Content` |
-| With `output_schema` | `dict` (parsed from Pydantic model) |
+LLM Agent Config     | `node_input` Type for Next Node
+-------------------- | -----------------------------------
+No `output_schema`   | `str` (concatenated model text)
+With `output_schema` | `dict` (parsed from Pydantic model)
 
-**State serialization warning:** When LLM agents feed into a `JoinNode`, the JoinNode stores intermediate results in session state. Without `output_schema`, this stores `types.Content` objects which are **not JSON-serializable** and will cause `TypeError` with SQLite/database session services. Always use `output_schema` on LLM agents that feed into a JoinNode.
+**Prefer `output_schema` when downstream nodes need structured access.** Strings
+are fine for pass-through text, but a typed dict is easier to consume and is
+required when the predecessor feeds a `JoinNode` whose results land in a
+persistent session service (raw text is fine; objects that aren't
+JSON-serializable break `DatabaseSessionService`).
 
 ## Auto-Wrapping Behavior
 
 When you place an `LlmAgent` in workflow edges, it is auto-wrapped as `_LlmAgentWrapper`. The wrapper:
+
 - Defaults to `single_turn` mode (agent sees only current input, not session history)
 - Sets `rerun_on_resume=True` (reruns after HITL interrupts)
 - Creates a content branch for isolation between parallel LLM agents
@@ -260,6 +267,7 @@ agent = LlmAgent(
 ```
 
 Tools can be:
+
 - Python functions (auto-wrapped as `FunctionTool`)
 - `BaseTool` instances
 - `BaseToolset` instances (e.g., MCP toolsets)

.agents/skills/adk-agent-builder/references/parallel-and-fanout.md

@@ -4,24 +4,27 @@ Execute multiple nodes concurrently and collect their results.
 
 ## 📋 Agent Verification Checklist (Parallel & Fan-Out)
 Use this checklist when implementing parallel patterns:
+
 - [ ] **JoinNode Serialization**: If LLM agents feed into a `JoinNode`, did you set `output_schema` on them to prevent JSON serialization errors?
 - [ ] **ParallelWorker Usage**: Did you avoid using `parallel_worker=True` on fan-out nodes? (It expects a list input)
 - [ ] **Multi-Trigger vs Join**: Do you understand that Multi-Trigger fires downstream once per branch, while JoinNode waits and fires once with merged dict?
 
 ## 💡 Quick Reference
+
 - **Fan-Out (Tuple)**: `('START', (node_a, node_b))`
 - **Fan-In (JoinNode)**: `((node_a, node_b), join_node)`
 - **List Worker**: `@node(parallel_worker=True)` (Takes list, outputs list)
 
 ## Imports
 
 ```python
-from google.adk.workflow import Workflow
-from google.adk.workflow._parallel_worker import ParallelWorker
-from google.adk.workflow import JoinNode
-from google.adk.workflow import node
+from google.adk.workflow import Workflow, JoinNode, node
 ```
 
+Parallel-worker behavior is opted into via the `parallel_worker=True` flag on
+`@node` or `LlmAgent`. The underlying wrapper class is internal — don't import
+it directly.
+
 ## Fan-Out: Multiple Branches
 
 Send output to multiple nodes simultaneously using tuple syntax:
@@ -91,51 +94,43 @@ def final_processor(node_input: dict) -> str:
 
 **Serialization warning:** JoinNode stores partial inputs in session state while waiting. If predecessors are LLM agents without `output_schema`, the stored values are `types.Content` objects which are **not JSON-serializable**. This causes `TypeError` with SQLite/database session services. Fix: use `output_schema` on LLM agents feeding into a JoinNode.
 
-## ParallelWorker: Process Lists in Parallel
+## Parallel workers: process lists in parallel
 
-Apply the same node to each item in a list concurrently:
+Apply the same node to each item in a list concurrently by setting the
+`parallel_worker=True` flag. The framework wraps the node internally — there is
+no public `ParallelWorker` class to import.
 
 ```python
+from google.adk.workflow import node, Workflow
+
+@node(parallel_worker=True)
 def process_item(node_input: int) -> int:
   return node_input * 2
 
-parallel = ParallelWorker(node(process_item))
-
 def produce_list(node_input: str) -> list:
   return [1, 2, 3, 4, 5]
 
 agent = Workflow(
     name="parallel_processing",
     edges=[
         ('START', produce_list),
-        (produce_list, parallel),
+        (produce_list, process_item),
     ],
 )
 # Output: [2, 4, 6, 8, 10]
 ```
 
-### ParallelWorker Details
+### Behavior
 
 - Input: a **list** (or single item, which gets wrapped in a list)
 - Output: a **list** of results in the same order as inputs
 - Empty list input produces empty list output
 - Each item is processed by a dynamically created worker node
-- Workers are named `{parent_name}__{index}` (e.g., `process_item__0`)
 - Default `rerun_on_resume=True`
 
-### ParallelWorker with @node Decorator
-
-```python
-@node(parallel_worker=True)
-def process_item(node_input: int) -> int:
-  return node_input * 2
-
-# Equivalent to: ParallelWorker(FunctionNode(process_item_fn))
-```
-
-### ParallelWorker with Agents
+### Parallel workers with Agents
 
-Set `parallel_worker=True` directly on an Agent:
+Set `parallel_worker=True` directly on an Agent — no extra wrapping needed:
 
 ```python
 from google.adk import Agent
@@ -155,12 +150,6 @@ agent = Workflow(
 )
 ```
 
-Or wrap manually:
-
-```python
-parallel_analyzer = ParallelWorker(analyzer)
-```
-
 **Do NOT use `parallel_worker=True` on fan-out nodes.** Fan-out edges `(a, (b, c, d))` already run nodes in parallel. Adding `parallel_worker=True` makes the node expect a list input and iterate over it — if it receives a single value or None, it produces no output and the JoinNode gets nothing.
 
 ## Multi-Trigger (Fan-Out to Shared Downstream)

.agents/skills/adk-agent-builder/references/state-and-events.md

@@ -4,12 +4,14 @@ Manage shared state across workflow nodes and understand the event system.
 
 ## 📋 Agent Verification Checklist (State & Events)
 Use this checklist when working with state and events:
+
 - [ ] **State Updates**: Did you use `Event(state=...)` for state updates? (Captures delta in event history)
 - [ ] **Parameter Resolution**: Are custom parameters named after keys in `ctx.state`?
 - [ ] **Output Serialization**: Is `event.output` JSON-serializable? (Required for DB session services)
 - [ ] **Web UI Display**: Did you use `Event(message=...)` for output meant for users?
 
 ## 💡 Quick Reference (Resolution Order)
+
 1. **`ctx`**: Workflow `Context` object.
 2. **`node_input`**: Predecessor output.
 3. **Other names**: Looked up from `ctx.state[param_name]`.
@@ -33,9 +35,9 @@ def my_node(ctx: Context, node_input: str) -> str:
   invocation_id = ctx.invocation_id
 
   # Get node metadata
-  node_path = ctx.node_path        # e.g., "MyWorkflow/my_node"
-  triggered_by = ctx.triggered_by  # Name of predecessor node
-  retry_count = ctx.retry_count    # 0 on first attempt
+  node_path = ctx.node_path          # e.g., "MyWorkflow/my_node"
+  run_id = ctx.run_id                # this node-run's identifier
+  attempt = ctx.attempt_count        # 1 on first attempt, ≥1 thereafter
 
   return f"Processed: {value}"
 ```
@@ -57,21 +59,21 @@ def my_node(ctx: Context, node_input: str) -> str:
 
 ### Workflow-Only Properties
 
-| Property | Type | Description |
-|----------|------|-------------|
-| `node_path` | `str` | Full path of current node (e.g., "WorkflowA/node1") |
-| `execution_id` | `str` | Unique ID for this execution |
-| `triggered_by` | `str` | Name of node that triggered current node |
-| `in_nodes` | `frozenset[str]` | Names of all predecessor nodes |
-| `resume_inputs` | `dict[str, Any]` | Inputs for resuming (keyed by interrupt_id) |
-| `retry_count` | `int` | Number of times this node has been retried |
+| Property        | Type             | Description                           |
+| --------------- | ---------------- | ------------------------------------- |
+| `node_path`     | `str`            | Full path of current node (e.g.,      |
+:                 :                  : "WorkflowA/node1")                    :
+| `run_id`        | `str`            | Identifier for this node-run (e.g.,   |
+:                 :                  : `"1"`, `"2"`)                         :
+| `attempt_count` | `int`            | Retry attempt number (1 on first try) |
+| `resume_inputs` | `dict[str, Any]` | Inputs for resuming (keyed by         |
+:                 :                  : interrupt_id)                         :
 
 ### Workflow-Only Methods
 
 | Method | Returns | Description |
 |--------|---------|-------------|
 | `run_node(node, node_input, *, name)` | `Any` | Execute a node dynamically (requires `rerun_on_resume=True`) |
-| `get_next_child_execution_id(name)` | `str` | Generate a deterministic child execution ID |
 
 ## State Management
 
@@ -92,6 +94,7 @@ def node_a(ctx: Context, node_input: str) -> str:
 ```
 
 **Why `Event(state=...)` is preferred:**
+
 - State deltas are persisted in event history as `event.actions.state_delta`
 - Non-resumable HITL can reconstruct state by replaying events
 - Makes state changes explicit and traceable
@@ -120,6 +123,7 @@ def my_node(node_input: str, user_name: str, threshold: float) -> str:
 ```
 
 Resolution order:
+
 1. `ctx` -> Context object
 2. `node_input` -> predecessor output
 3. Other names -> `ctx.state[param_name]` (with auto type conversion)