子图有两种接法，今天讲第一种（共享状态），明天讲第二种（隔离转换）：

from langgraph.graph import StateGraph, START, END
from typing import TypedDict

class State(TypedDict):
    foo: str            # 父子图都有 foo → 共享

# 子图
sub = StateGraph(State)
sub.add_node("s1", lambda s: {"foo": s["foo"] + "|sub"})
sub.add_edge(START, "s1"); sub.add_edge("s1", END)
subgraph = sub.compile()

# 父图：把编译好的子图直接当节点
parent = StateGraph(State)
parent.add_node("p1", lambda s: {"foo": s["foo"] + "|p1"})
parent.add_node("sub", subgraph)          # ← 子图当节点！
parent.add_edge(START, "p1"); parent.add_edge("p1", "sub"); parent.add_edge("sub", END)
app = parent.compile()
app.invoke({"foo": "start"})              # {'foo': 'start|p1|sub'}

秘密在类型继承链。编译后的图是 Pregel，而 Pregel 实现了 PregelProtocol，后者直接继承 Runnable pregel/protocol.py:25：

# pregel/protocol.py:25
class PregelProtocol(Runnable[InputT, Any], Generic[StateT, ContextT, InputT, OutputT]):
    ...
# pregel/main.py:450
class Pregel(PregelProtocol[StateT, ContextT, InputT, OutputT], ...):
    ...

而 add_node 对 action 的处理，就是一句 coerce_to_runnable graph/state.py:874：

# graph/state.py:872
self.nodes[node] = StateNodeSpec(
    coerce_to_runnable(action, name=node, trace=False),   # 把 action 归一成 Runnable
    metadata, input_schema=..., retry_policy=..., cache_policy=..., ...
)

虽然子图当节点靠的是 Runnable 抽象，但引擎有时需要知道"这里面藏着一张图"（比如流式要下钻、get_state 要展开子图状态）。PregelNode 构造时会自动探测 pregel/_read.py:182：

# pregel/_read.py:182
if subgraphs is not None:
    self.subgraphs = subgraphs
elif self.bound is not DEFAULT_BOUND:
    try:
        subgraph = find_subgraph_pregel(self.bound)   # 从 bound 里挖有没有 Pregel
    except Exception:
        subgraph = None
    if subgraph:
        self.subgraphs = [subgraph]
    else:
        self.subgraphs = []
else:
    self.subgraphs = []

find_subgraph_pregel 会顺着 Runnable 的结构往里挖 pregel/_utils.py:47：

# pregel/_utils.py:47
def find_subgraph_pregel(candidate: Runnable) -> PregelProtocol | None:
    from langgraph.pregel import Pregel
    candidates: list[Runnable] = [candidate]
    for c in candidates:
        if (isinstance(c, PregelProtocol)
                and (not isinstance(c, Pregel) or c.checkpointer is not False)):
            return c                                   # 找到一张图！
        elif isinstance(c, RunnableSequence) or isinstance(c, RunnableSeq):
            candidates.extend(c.steps)                 # 是链 → 挖每一步
        elif isinstance(c, RunnableLambda):
            candidates.extend(c.deps)                  # 是 lambda → 挖它依赖的对象
        elif isinstance(c, RunnableCallable):
            if c.func is not None:
                candidates.extend(                     # 是函数 → 挖闭包里引用的对象
                    nl.__self__ if hasattr(nl, "__self__") else nl
                    for nl in get_function_nonlocals(c.func))
            ...
    return None

为什么 L01 例子里父图改 foo、子图也改 foo，二者能接上？因为父图把整个 state 传给子图当输入，子图读它认识的字段、写回同名字段，父图再用同名通道的 reducer 合并。共享的前提就是字段名相同。

状态字段可以共享，但存档（checkpoint）是分层的。父图执行子图节点时，给子图分配一个嵌套的 checkpoint 命名空间 pregel/_algo.py:624：

# pregel/_algo.py:624
task_checkpoint_ns = f"{checkpoint_ns}{NS_END}{task_id}"
# ...
# 传给子图执行的 config 里（同函数体 :746）
CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,

L03 探测出的 node.subgraphs 在这里派上用场——get_subgraphs 遍历所有节点，把子图（可递归）列出来 pregel/main.py:1076：

# pregel/main.py:1089
for name, node in self.nodes.items():
    ...
    graph = node.subgraphs[0] if node.subgraphs else None   # 用探测结果
    if graph:
        if namespace is None:
            yield name, graph                                # 产出 (节点名, 子图)
        if recurse and isinstance(graph, Pregel):            # recurse=True 继续下钻
            yield from ((f"{name}{NS_SEP}{n}", s)
                        for n, s in graph.get_subgraphs(namespace=namespace, recurse=recurse))

✋ 10 分钟动手

# 1. 读三段
sed -n '47,75p'    libs/langgraph/langgraph/pregel/_utils.py   # find_subgraph_pregel
sed -n '150,195p'  libs/langgraph/langgraph/pregel/_read.py    # PregelNode 探测
sed -n '1076,1114p' libs/langgraph/langgraph/pregel/main.py    # get_subgraphs

# 2. 亲手验证共享 + 列子图
python - <<'PY'
from langgraph.graph import StateGraph, START, END
from typing import TypedDict
class S(TypedDict):
    foo: str
sub = StateGraph(S); sub.add_node("s1", lambda s: {"foo": s["foo"]+"|sub"})
sub.add_edge(START,"s1"); sub.add_edge("s1",END)
subgraph = sub.compile()
p = StateGraph(S)
p.add_node("p1", lambda s: {"foo": s["foo"]+"|p1"}); p.add_node("sub", subgraph)
p.add_edge(START,"p1"); p.add_edge("p1","sub"); p.add_edge("sub",END)
app = p.compile()
print(app.invoke({"foo":"start"}))                 # {'foo': 'start|p1|sub'}
print([name for name,_ in app.get_subgraphs()])    # ['sub']
PY