回顾 D03 的 __init__——三个 schema 在这里定下并各自解析：

        self.state_schema = state_schema
        self.input_schema = cast(type[InputT], input_schema or state_schema)   # 没给→=state
        self.output_schema = cast(type[OutputT], output_schema or state_schema)
        self.context_schema = context_schema
        self._node_defaults = _NodeDefaults()

        self._add_schema(self.state_schema)                       # 完整状态
        self._add_schema(self.input_schema, allow_managed=False)  # 输入（禁托管字段）
        self._add_schema(self.output_schema, allow_managed=False) # 输出（禁托管字段）

这个 allow_managed=False 在 _add_schema 里真会拦人：

            if managed and not allow_managed:
                names = ", ".join(managed)
                raise ValueError(
                    f"Invalid managed channels detected in {schema_name}: {names}."
                    " Managed channels are not permitted in Input/Output schema.")

LangGraph 没有 private 关键字。私有字段是差集算出来的——在 state 里、但不在 input 也不在 output 里的字段，天然只在内部流转。看个例子：

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

class InputS(TypedDict):
    question: str                 # 调用方只需给这个

class OutputS(TypedDict):
    answer: str                   # 调用方只拿到这个

class OverallS(TypedDict):
    question: str
    docs: list                    # ← 私有：检索中间结果
    draft: str                    # ← 私有：草稿
    answer: str

g = StateGraph(OverallS, input_schema=InputS, output_schema=OutputS)

图的入口是一个特殊的 START 节点。编译时它的"能写哪些通道"只取 input_schema 的字段：

    def attach_node(self, key, node):
        if key == START:
            output_keys = [
                k
                for k, v in self.builder.schemas[self.builder.input_schema].items()
                if not is_managed_value(v)                # ★只要 input_schema 的字段
            ]
        else:
            output_keys = list(self.builder.channels) + [...]   # 普通节点能写全部字段

而这个 output_keys 会被用来过滤写入——多余的键直接丢弃：

        def _get_updates(input):
            if input is None: return None
            elif isinstance(input, dict):
                return [(k, v) for k, v in input.items() if k in output_keys]   # ★过滤

出口对称。编译时算出 output_channels——只取 output_schema 的非托管字段：

        output_channels = (
            "__root__"
            if len(self.schemas[self.output_schema]) == 1
            and "__root__" in self.schemas[self.output_schema]
            else [
                key
                for key, val in self.schemas[self.output_schema].items()
                if not is_managed_value(val)              # ★只要 output_schema 的字段
            ]
        )

对比同处的 stream_channels——流式默认吐的是全部通道：

        stream_channels = (
            "__root__"
            if len(self.channels) == 1 and "__root__" in self.channels
            else [key for key, val in self.channels.items() if not is_managed_value(val)]
        )

✋ 10 分钟动手

# 1. 看三个 schema 的初始化
sed -n '260,269p' libs/langgraph/langgraph/graph/state.py

# 2. 看输入过滤（START 只写 input_schema 的键）
sed -n '1431,1449p' libs/langgraph/langgraph/graph/state.py

# 3. 看输出/流式通道的差异
sed -n '1256,1273p' libs/langgraph/langgraph/graph/state.py

# 4. 亲手验证"多传的键被丢弃 + 私有字段不返回"
python3 -c "
from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict
class I(TypedDict): question:str
class O(TypedDict): answer:str
class S(TypedDict):
    question:str; docs:list; answer:str
def work(s): return {'docs':['d1'], 'answer':'42'}
g=StateGraph(S, input_schema=I, output_schema=O)
g.add_node('w', work); g.add_edge(START,'w'); g.add_edge('w',END)
app=g.compile()
print(app.invoke({'question':'q','docs':['偷塞']}))  # docs 被丢弃, 返回只含 answer
"