用得最多、也最简单的 StrOutputParser（libs/core/langchain_core/output_parsers/string.py:8）：

# libs/core/langchain_core/output_parsers/string.py:8
class StrOutputParser(BaseTransformOutputParser[str]):
    """Extract text content from model outputs as a string.

    Converts model outputs (such as `AIMessage` or `AIMessageChunk` objects)
    into plain text strings. ...
    Supports streaming, yielding text chunks as they're generated."""

    @override
    def parse(self, text: str) -> str:          # string.py:61
        """Returns the input text with no changes."""
        return text                              # ★没错，就一行

JsonOutputParser（libs/core/langchain_core/output_parsers/json.py:31）的核心在 parse_result（json.py:61）：

# libs/core/langchain_core/output_parsers/json.py:31
class JsonOutputParser(BaseCumulativeTransformOutputParser[Any]):
    """Parse the output of an LLM call to a JSON object.
    Probably the most reliable output parser for getting structured data
    that does *not* use function calling.
    When used in streaming mode, it will yield partial JSON objects..."""

    def parse_result(self, result, *, partial=False):    # json.py:61
        text = result[0].text
        text = text.strip()
        if partial:                                # 流式中途：解析失败不报错
            try:
                return parse_json_markdown(text)   # ★从 markdown 围栏里抠 JSON
            except JSONDecodeError:
                return None                        #    没拼完整呢，先返回 None
        try:
            return parse_json_markdown(text)
        except JSONDecodeError as e:               # 最终结果：失败就诚实报错
            msg = f"Invalid json output: {text}"
            raise OutputParserException(msg, llm_output=text) from e

dict 还不够——业务想要强类型对象。PydanticOutputParser（libs/core/langchain_core/output_parsers/pydantic.py:19）直接继承 JsonOutputParser，再加一道校验：

# libs/core/langchain_core/output_parsers/pydantic.py:19
class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
    """Parse an output using a Pydantic model."""

    pydantic_object: Annotated[type[TBaseModel], SkipValidation()]   # 你的"图纸"

    def _parse_obj(self, obj: Any) -> TBaseModel:        # pydantic.py:25
        try:
            if issubclass(self.pydantic_object, pydantic.BaseModel):
                return self.pydantic_object.model_validate(obj)   # ★Pydantic v2 校验
            if issubclass(self.pydantic_object, pydantic.v1.BaseModel):
                return self.pydantic_object.parse_obj(obj)        #   兼容 v1
            ...
        except (pydantic.ValidationError, pydantic.v1.ValidationError) as e:
            raise self._parser_exception(e, obj) from e   # 不合格 → 打回并说明原因

    def parse_result(self, result, *, partial=False):     # pydantic.py:57
        try:
            json_object = super().parse_result(result, partial=partial)  # ① 先按 L03 抠出 JSON
            return self._parse_obj(json_object)                          # ② 再按图纸验收
        except OutputParserException:
            if partial:
                return None
            raise

压轴戏在 BaseChatModel.with_structured_output（libs/core/langchain_core/language_models/chat_models.py:2357）。跳过长长的 docstring，实现主体在 chat_models.py:2502-2537，惊人地短：

# libs/core/langchain_core/language_models/chat_models.py:2502
_ = kwargs.pop("method", None)
_ = kwargs.pop("strict", None)
if type(self).bind_tools is BaseChatModel.bind_tools:
    msg = "with_structured_output is not implemented for this model."
    raise NotImplementedError(msg)              # 模型必须支持工具调用

llm = self.bind_tools(                          # ① ★把 schema 伪装成一个"工具"绑上
    [schema],
    tool_choice="any",                          # ② ★强制：必须调用工具（必须填表）
    ls_structured_output_format={...},
)
if isinstance(schema, type) and is_basemodel_subclass(schema):
    output_parser = PydanticToolsParser(tools=[schema], first_tool_only=True)  # ③ Pydantic 图纸
else:
    key_name = convert_to_openai_tool(schema)["function"]["name"]
    output_parser = JsonOutputKeyToolsParser(key_name=key_name, first_tool_only=True)
...
return llm | output_parser                      # ④ ★返回的还是一条 LCEL 链！

这就是 include_raw=True 分支（libs/core/langchain_core/language_models/chat_models.py:2529）：

# libs/core/langchain_core/language_models/chat_models.py:2529
if include_raw:
    parser_assign = RunnablePassthrough.assign(
        parsed=itemgetter("raw") | output_parser, parsing_error=lambda _: None
    )
    parser_none = RunnablePassthrough.assign(parsed=lambda _: None)
    parser_with_fallback = parser_assign.with_fallbacks(
        [parser_none], exception_key="parsing_error"     # ★解析炸了 → 走备胎，异常装进字段
    )
    return RunnableMap(raw=llm) | parser_with_fallback
return llm | output_parser