libs/partners/openai/tests/unit_tests/chat_models/test_base.py PYTHON 6,445 lines View on github.com → Search inside
File is large — showing lines 1–2,000 of 6,445.
1"""Test OpenAI Chat API wrapper."""23from __future__ import annotations45import copy6import json7import warnings8from functools import partial9from types import TracebackType10from typing import Any, Literal, Self, cast11from unittest.mock import AsyncMock, MagicMock, patch1213import httpx14import httpx215import openai16import pytest17from langchain_core.exceptions import (18    ContextOverflowError,19    ModelAPIError,20    ModelAuthenticationError,21    ModelConnectionError,22    ModelError,23    ModelInvalidRequestError,24    ModelNotFoundError,25    ModelPermissionDeniedError,26    ModelRateLimitError,27    ModelRefusalError,28    ModelTimeoutError,29)30from langchain_core.load import dumpd, dumps, loads31from langchain_core.messages import (32    AIMessage,33    AIMessageChunk,34    BaseMessage,35    FunctionMessage,36    HumanMessage,37    InvalidToolCall,38    SystemMessage,39    ToolCall,40    ToolMessage,41    message_chunk_to_message,42)43from langchain_core.messages import content as types44from langchain_core.messages.ai import UsageMetadata45from langchain_core.messages.block_translators.openai import (46    _convert_from_v03_ai_message,47)48from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult49from langchain_core.runnables import RunnableLambda50from langchain_core.runnables.base import RunnableBinding, RunnableSequence51from langchain_core.tracers.base import BaseTracer52from langchain_core.tracers.schemas import Run53from langchain_core.utils._gateway import (54    GATEWAY_METADATA_RESPONSE_KEY,55    langsmith_gateway,56)57from langchain_core.utils.pydantic import PYDANTIC_VERSION58from openai.types.responses import (59    ResponseApplyPatchToolCall,60    ResponseApplyPatchToolCallOutput,61    ResponseOutputMessage,62    ResponseReasoningItem,63    ResponseTextDeltaEvent,64)65from openai.types.responses.response import IncompleteDetails, Response66from openai.types.responses.response_apply_patch_tool_call import OperationCreateFile67from openai.types.responses.response_error import ResponseError68from openai.types.responses.response_file_search_tool_call import (69    ResponseFileSearchToolCall,70    Result,71)72from openai.types.responses.response_function_tool_call import ResponseFunctionToolCall73from openai.types.responses.response_function_web_search import (74    ActionSearch,75    ResponseFunctionWebSearch,76)77from openai.types.responses.response_output_refusal import ResponseOutputRefusal78from openai.types.responses.response_output_text import ResponseOutputText79from openai.types.responses.response_reasoning_item import Summary80from openai.types.responses.response_usage import (81    InputTokensDetails,82    OutputTokensDetails,83    ResponseUsage,84)85from pydantic import BaseModel, Field, SecretStr86from typing_extensions import TypedDict8788from langchain_openai import ChatOpenAI89from langchain_openai.chat_models._compat import (90    _FUNCTION_CALL_IDS_MAP_KEY,91    _convert_from_v1_to_chat_completions,92    _convert_from_v1_to_responses,93    _convert_to_v03_ai_message,94)95from langchain_openai.chat_models.base import (96    OpenAIRefusalError,97    OpenAIStreamServerError,98    _construct_lc_result_from_responses_api,99    _construct_responses_api_input,100    _convert_dict_to_message,101    _convert_message_to_dict,102    _convert_responses_chunk_to_generation_chunk,103    _convert_to_openai_response_format,104    _create_usage_metadata,105    _create_usage_metadata_responses,106    _format_message_content,107    _get_last_messages,108    _make_computer_call_output_from_message,109    _model_prefers_responses_api,110    _oai_structured_outputs_parser,111    _resize,112)113114OPENAI_TEST_MODEL = "gpt-5.5"115OPENAI_TEMPERATURE_CAPABLE_TEST_MODEL = "gpt-4o-mini"116117118def test_openai_model_param() -> None:119    llm = ChatOpenAI(model="foo")120    assert llm.model_name == "foo"121    assert llm.model == "foo"122    llm = ChatOpenAI(model_name="foo")  # type: ignore[call-arg]123    assert llm.model_name == "foo"124    assert llm.model == "foo"125126    llm = ChatOpenAI(max_tokens=10)  # type: ignore[call-arg]127    assert llm.max_tokens == 10128    llm = ChatOpenAI(max_completion_tokens=10)129    assert llm.max_tokens == 10130131132@pytest.mark.parametrize("async_api", [True, False])133def test_streaming_attribute_should_stream(async_api: bool) -> None:134    llm = ChatOpenAI(model="foo", streaming=True)135    assert llm._should_stream(async_api=async_api)136137138def test_openai_client_caching() -> None:139    """Test that the OpenAI client is cached."""140    llm1 = ChatOpenAI(model=OPENAI_TEST_MODEL)141    llm2 = ChatOpenAI(model=OPENAI_TEST_MODEL)142    assert llm1.root_client._client is llm2.root_client._client143144    llm3 = ChatOpenAI(model=OPENAI_TEST_MODEL, base_url="foo")145    assert llm1.root_client._client is not llm3.root_client._client146147    llm4 = ChatOpenAI(model=OPENAI_TEST_MODEL, timeout=None)148    assert llm1.root_client._client is llm4.root_client._client149150    llm5 = ChatOpenAI(model=OPENAI_TEST_MODEL, timeout=3)151    assert llm1.root_client._client is not llm5.root_client._client152153    llm6 = ChatOpenAI(154        model=OPENAI_TEST_MODEL, timeout=httpx.Timeout(timeout=60.0, connect=5.0)155    )156    assert llm1.root_client._client is not llm6.root_client._client157158    llm7 = ChatOpenAI(model=OPENAI_TEST_MODEL, timeout=(5, 1))159    assert llm1.root_client._client is not llm7.root_client._client160161162def test_profile() -> None:163    model = ChatOpenAI(model="gpt-5.2-pro")164    assert model.profile165    assert not model.profile["structured_output"]166167    model = ChatOpenAI(model="gpt-5")168    assert model.profile169    assert model.profile["structured_output"]170    assert model.profile["tool_calling"]171172    # Test overwriting a field173    model.profile["tool_calling"] = False174    assert not model.profile["tool_calling"]175176    # Test we didn't mutate177    model = ChatOpenAI(model="gpt-5")178    assert model.profile179    assert model.profile["tool_calling"]180181    # Test passing in profile182    model = ChatOpenAI(model="gpt-5", profile={"tool_calling": False})183    assert model.profile == {"tool_calling": False}184185    # Test overrides for gpt-5 input tokens186    model = ChatOpenAI(model="gpt-5")187    assert model.profile["max_input_tokens"] == 272_000188189190def test_gpt_5_reasoning_effort_levels() -> None:191    """GPT-5 and GPT-5.1 predate `xhigh`, and GPT-5 supports `minimal`."""192    for model_name in ("gpt-5", "gpt-5-mini", "gpt-5-nano"):193        model = ChatOpenAI(model=model_name)194        assert model.profile195        assert model.profile["reasoning_effort_levels"] == [196            "minimal",197            "low",198            "medium",199            "high",200        ]201202    model = ChatOpenAI(model="gpt-5.1")203    assert model.profile204    assert model.profile["reasoning_effort_levels"] == ["none", "low", "medium", "high"]205206207def test_gpt_6_astra_reasoning_effort_levels() -> None:208    model = ChatOpenAI(model="gpt-6-astra")209210    assert model.profile211    assert model.profile["reasoning_effort_levels"] == [212        "low",213        "medium",214        "high",215        "xhigh",216        "max",217    ]218    assert "reasoning_effort_default" not in model.profile219220221@pytest.mark.parametrize(222    ("kwargs", "expected"),223    [224        ({"use_responses_api": True}, True),225        # Routes every request to the Responses API.226        ({"reasoning": {"effort": "low"}}, True),227        ({"use_responses_api": False}, False),228        # Routing is decided per request, so it can't be claimed up front.229        ({}, False),230    ],231)232def test_profile_mid_conversation_tools_follow_responses_api(233    kwargs: dict[str, Any], expected: bool234) -> None:235    """Only the Responses API carries an `additional_tools` input item."""236    model = ChatOpenAI(model="gpt-5.6", **kwargs)237238    assert model.profile239    assert model.profile["mid_conversation_tools"] is expected240    assert model.profile["mid_conversation_system_messages"] is True241242243def test_function_message_dict_to_function_message() -> None:244    content = json.dumps({"result": "Example #1"})245    name = "test_function"246    result = _convert_dict_to_message(247        {"role": "function", "name": name, "content": content}248    )249    assert isinstance(result, FunctionMessage)250    assert result.name == name251    assert result.content == content252253254def test__convert_dict_to_message_human() -> None:255    message = {"role": "user", "content": "foo"}256    result = _convert_dict_to_message(message)257    expected_output = HumanMessage(content="foo")258    assert result == expected_output259    assert _convert_message_to_dict(expected_output) == message260261262def test__convert_dict_to_message_human_with_name() -> None:263    message = {"role": "user", "content": "foo", "name": "test"}264    result = _convert_dict_to_message(message)265    expected_output = HumanMessage(content="foo", name="test")266    assert result == expected_output267    assert _convert_message_to_dict(expected_output) == message268269270def test__convert_dict_to_message_ai() -> None:271    message = {"role": "assistant", "content": "foo"}272    result = _convert_dict_to_message(message)273    expected_output = AIMessage(content="foo")274    assert result == expected_output275    assert _convert_message_to_dict(expected_output) == message276277278def test__convert_dict_to_message_ai_with_name() -> None:279    message = {"role": "assistant", "content": "foo", "name": "test"}280    result = _convert_dict_to_message(message)281    expected_output = AIMessage(content="foo", name="test")282    assert result == expected_output283    assert _convert_message_to_dict(expected_output) == message284285286def test__convert_dict_to_message_system() -> None:287    message = {"role": "system", "content": "foo"}288    result = _convert_dict_to_message(message)289    expected_output = SystemMessage(content="foo")290    assert result == expected_output291    assert _convert_message_to_dict(expected_output) == message292293294def test__convert_dict_to_message_developer() -> None:295    message = {"role": "developer", "content": "foo"}296    result = _convert_dict_to_message(message)297    expected_output = SystemMessage(298        content="foo", additional_kwargs={"__openai_role__": "developer"}299    )300    assert result == expected_output301    assert _convert_message_to_dict(expected_output) == message302303304def test__convert_dict_to_message_system_with_name() -> None:305    message = {"role": "system", "content": "foo", "name": "test"}306    result = _convert_dict_to_message(message)307    expected_output = SystemMessage(content="foo", name="test")308    assert result == expected_output309    assert _convert_message_to_dict(expected_output) == message310311312def test__convert_dict_to_message_tool() -> None:313    message = {"role": "tool", "content": "foo", "tool_call_id": "bar"}314    result = _convert_dict_to_message(message)315    expected_output = ToolMessage(content="foo", tool_call_id="bar")316    assert result == expected_output317    assert _convert_message_to_dict(expected_output) == message318319320def test__convert_dict_to_message_tool_call() -> None:321    raw_tool_call = {322        "id": "call_wm0JY6CdwOMZ4eTxHWUThDNz",323        "function": {324            "arguments": '{"name": "Sally", "hair_color": "green"}',325            "name": "GenerateUsername",326        },327        "type": "function",328    }329    message = {"role": "assistant", "content": None, "tool_calls": [raw_tool_call]}330    result = _convert_dict_to_message(message)331    expected_output = AIMessage(332        content="",333        tool_calls=[334            ToolCall(335                name="GenerateUsername",336                args={"name": "Sally", "hair_color": "green"},337                id="call_wm0JY6CdwOMZ4eTxHWUThDNz",338                type="tool_call",339            )340        ],341    )342    assert result == expected_output343    assert _convert_message_to_dict(expected_output) == message344345    # Test malformed tool call346    raw_tool_calls: list = [347        {348            "id": "call_wm0JY6CdwOMZ4eTxHWUThDNz",349            "function": {"arguments": "oops", "name": "GenerateUsername"},350            "type": "function",351        },352        {353            "id": "call_abc123",354            "function": {355                "arguments": '{"name": "Sally", "hair_color": "green"}',356                "name": "GenerateUsername",357            },358            "type": "function",359        },360    ]361    raw_tool_calls = sorted(raw_tool_calls, key=lambda x: x["id"])362    message = {"role": "assistant", "content": None, "tool_calls": raw_tool_calls}363    result = _convert_dict_to_message(message)364    expected_output = AIMessage(365        content="",366        invalid_tool_calls=[367            InvalidToolCall(368                name="GenerateUsername",369                args="oops",370                id="call_wm0JY6CdwOMZ4eTxHWUThDNz",371                error=(372                    "Function GenerateUsername arguments:\n\noops\n\nare not "373                    "valid JSON. Received JSONDecodeError Expecting value: line 1 "374                    "column 1 (char 0)\nFor troubleshooting, visit: https://docs"375                    ".langchain.com/oss/python/langchain/errors/OUTPUT_PARSING_FAILURE "376                ),377                type="invalid_tool_call",378            )379        ],380        tool_calls=[381            ToolCall(382                name="GenerateUsername",383                args={"name": "Sally", "hair_color": "green"},384                id="call_abc123",385                type="tool_call",386            )387        ],388    )389    assert result == expected_output390    reverted_message_dict = _convert_message_to_dict(expected_output)391    reverted_message_dict["tool_calls"] = sorted(392        reverted_message_dict["tool_calls"], key=lambda x: x["id"]393    )394    assert reverted_message_dict == message395396397class MockAsyncContextManager:398    def __init__(self, chunk_list: list) -> None:399        self.current_chunk = 0400        self.chunk_list = chunk_list401        self.chunk_num = len(chunk_list)402403    async def __aenter__(self) -> Self:404        return self405406    async def __aexit__(407        self,408        exc_type: type[BaseException] | None,409        exc: BaseException | None,410        tb: TracebackType | None,411    ) -> None:412        pass413414    def __aiter__(self) -> MockAsyncContextManager:415        return self416417    async def __anext__(self) -> dict:418        if self.current_chunk < self.chunk_num:419            chunk = self.chunk_list[self.current_chunk]420            self.current_chunk += 1421            return chunk422        raise StopAsyncIteration423424425class MockSyncContextManager:426    def __init__(self, chunk_list: list) -> None:427        self.current_chunk = 0428        self.chunk_list = chunk_list429        self.chunk_num = len(chunk_list)430431    def __enter__(self) -> Self:432        return self433434    def __exit__(435        self,436        exc_type: type[BaseException] | None,437        exc: BaseException | None,438        tb: TracebackType | None,439    ) -> None:440        pass441442    def __iter__(self) -> MockSyncContextManager:443        return self444445    def __next__(self) -> dict:446        if self.current_chunk < self.chunk_num:447            chunk = self.chunk_list[self.current_chunk]448            self.current_chunk += 1449            return chunk450        raise StopIteration451452453GLM4_STREAM_META = """{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"delta":{"role":"assistant","content":"\u4eba\u5de5\u667a\u80fd"}}]}454{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"delta":{"role":"assistant","content":"\u52a9\u624b"}}]}455{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"delta":{"role":"assistant","content":","}}]}456{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"delta":{"role":"assistant","content":"\u4f60\u53ef\u4ee5"}}]}457{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"delta":{"role":"assistant","content":"\u53eb\u6211"}}]}458{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"delta":{"role":"assistant","content":"AI"}}]}459{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"delta":{"role":"assistant","content":"\u52a9\u624b"}}]}460{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"delta":{"role":"assistant","content":"。"}}]}461{"id":"20240722102053e7277a4f94e848248ff9588ed37fb6e6","created":1721614853,"model":"glm-4","choices":[{"index":0,"finish_reason":"stop","delta":{"role":"assistant","content":""}}],"usage":{"prompt_tokens":13,"completion_tokens":10,"total_tokens":23}}462[DONE]"""  # noqa: E501463464465@pytest.fixture466def mock_glm4_completion() -> list:467    list_chunk_data = GLM4_STREAM_META.split("\n")468    result_list = []469    for msg in list_chunk_data:470        if msg != "[DONE]":471            result_list.append(json.loads(msg))472473    return result_list474475476async def test_glm4_astream(mock_glm4_completion: list) -> None:477    llm_name = "glm-4"478    llm = ChatOpenAI(model=llm_name, stream_usage=True)479    mock_client = AsyncMock()480481    async def mock_create(*args: Any, **kwargs: Any) -> MockAsyncContextManager:482        return MockAsyncContextManager(mock_glm4_completion)483484    mock_client.create = mock_create485    usage_chunk = mock_glm4_completion[-1]486487    usage_metadata: UsageMetadata | None = None488    with patch.object(llm, "async_client", mock_client):489        async for chunk in llm.astream("你的名字叫什么?只回答名字"):490            assert isinstance(chunk, AIMessageChunk)491            if chunk.usage_metadata is not None:492                usage_metadata = chunk.usage_metadata493494    assert usage_metadata is not None495496    assert usage_metadata["input_tokens"] == usage_chunk["usage"]["prompt_tokens"]497    assert usage_metadata["output_tokens"] == usage_chunk["usage"]["completion_tokens"]498    assert usage_metadata["total_tokens"] == usage_chunk["usage"]["total_tokens"]499500501def test_glm4_stream(mock_glm4_completion: list) -> None:502    llm_name = "glm-4"503    llm = ChatOpenAI(model=llm_name, stream_usage=True)504    mock_client = MagicMock()505506    def mock_create(*args: Any, **kwargs: Any) -> MockSyncContextManager:507        return MockSyncContextManager(mock_glm4_completion)508509    mock_client.create = mock_create510    usage_chunk = mock_glm4_completion[-1]511512    usage_metadata: UsageMetadata | None = None513    with patch.object(llm, "client", mock_client):514        for chunk in llm.stream("你的名字叫什么?只回答名字"):515            assert isinstance(chunk, AIMessageChunk)516            if chunk.usage_metadata is not None:517                usage_metadata = chunk.usage_metadata518519    assert usage_metadata is not None520521    assert usage_metadata["input_tokens"] == usage_chunk["usage"]["prompt_tokens"]522    assert usage_metadata["output_tokens"] == usage_chunk["usage"]["completion_tokens"]523    assert usage_metadata["total_tokens"] == usage_chunk["usage"]["total_tokens"]524525526DEEPSEEK_STREAM_DATA = """{"id":"d3610c24e6b42518a7883ea57c3ea2c3","choices":[{"index":0,"delta":{"content":"","role":"assistant"},"finish_reason":null,"logprobs":null}],"created":1721630271,"model":"deepseek-chat","system_fingerprint":"fp_7e0991cad4","object":"chat.completion.chunk","usage":null}527{"choices":[{"delta":{"content":"我是","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}528{"choices":[{"delta":{"content":"Deep","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}529{"choices":[{"delta":{"content":"Seek","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}530{"choices":[{"delta":{"content":" Chat","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}531{"choices":[{"delta":{"content":",","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}532{"choices":[{"delta":{"content":"一个","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}533{"choices":[{"delta":{"content":"由","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}534{"choices":[{"delta":{"content":"深度","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}535{"choices":[{"delta":{"content":"求","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}536{"choices":[{"delta":{"content":"索","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}537{"choices":[{"delta":{"content":"公司","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}538{"choices":[{"delta":{"content":"开发的","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}539{"choices":[{"delta":{"content":"智能","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}540{"choices":[{"delta":{"content":"助手","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}541{"choices":[{"delta":{"content":"。","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":null}542{"choices":[{"delta":{"content":"","role":null},"finish_reason":"stop","index":0,"logprobs":null}],"created":1721630271,"id":"d3610c24e6b42518a7883ea57c3ea2c3","model":"deepseek-chat","object":"chat.completion.chunk","system_fingerprint":"fp_7e0991cad4","usage":{"completion_tokens":15,"prompt_tokens":11,"total_tokens":26}}543[DONE]"""  # noqa: E501544545546@pytest.fixture547def mock_deepseek_completion() -> list[dict]:548    list_chunk_data = DEEPSEEK_STREAM_DATA.split("\n")549    result_list = []550    for msg in list_chunk_data:551        if msg != "[DONE]":552            result_list.append(json.loads(msg))553554    return result_list555556557async def test_deepseek_astream(mock_deepseek_completion: list) -> None:558    llm_name = "deepseek-chat"559    llm = ChatOpenAI(model=llm_name, stream_usage=True)560    mock_client = AsyncMock()561562    async def mock_create(*args: Any, **kwargs: Any) -> MockAsyncContextManager:563        return MockAsyncContextManager(mock_deepseek_completion)564565    mock_client.create = mock_create566    usage_chunk = mock_deepseek_completion[-1]567    usage_metadata: UsageMetadata | None = None568    with patch.object(llm, "async_client", mock_client):569        async for chunk in llm.astream("你的名字叫什么?只回答名字"):570            assert isinstance(chunk, AIMessageChunk)571            if chunk.usage_metadata is not None:572                usage_metadata = chunk.usage_metadata573574    assert usage_metadata is not None575576    assert usage_metadata["input_tokens"] == usage_chunk["usage"]["prompt_tokens"]577    assert usage_metadata["output_tokens"] == usage_chunk["usage"]["completion_tokens"]578    assert usage_metadata["total_tokens"] == usage_chunk["usage"]["total_tokens"]579580581def test_deepseek_stream(mock_deepseek_completion: list) -> None:582    llm_name = "deepseek-chat"583    llm = ChatOpenAI(model=llm_name, stream_usage=True)584    mock_client = MagicMock()585586    def mock_create(*args: Any, **kwargs: Any) -> MockSyncContextManager:587        return MockSyncContextManager(mock_deepseek_completion)588589    mock_client.create = mock_create590    usage_chunk = mock_deepseek_completion[-1]591    usage_metadata: UsageMetadata | None = None592    with patch.object(llm, "client", mock_client):593        for chunk in llm.stream("你的名字叫什么?只回答名字"):594            assert isinstance(chunk, AIMessageChunk)595            if chunk.usage_metadata is not None:596                usage_metadata = chunk.usage_metadata597598    assert usage_metadata is not None599600    assert usage_metadata["input_tokens"] == usage_chunk["usage"]["prompt_tokens"]601    assert usage_metadata["output_tokens"] == usage_chunk["usage"]["completion_tokens"]602    assert usage_metadata["total_tokens"] == usage_chunk["usage"]["total_tokens"]603604605OPENAI_STREAM_DATA = """{"id":"chatcmpl-9nhARrdUiJWEMd5plwV1Gc9NCjb9M","object":"chat.completion.chunk","created":1721631035,"model":"gpt-5.5","system_fingerprint":"fp_18cc0f1fa0","choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}],"usage":null}606{"id":"chatcmpl-9nhARrdUiJWEMd5plwV1Gc9NCjb9M","object":"chat.completion.chunk","created":1721631035,"model":"gpt-5.5","system_fingerprint":"fp_18cc0f1fa0","choices":[{"index":0,"delta":{"content":"我是"},"logprobs":null,"finish_reason":null}],"usage":null}607{"id":"chatcmpl-9nhARrdUiJWEMd5plwV1Gc9NCjb9M","object":"chat.completion.chunk","created":1721631035,"model":"gpt-5.5","system_fingerprint":"fp_18cc0f1fa0","choices":[{"index":0,"delta":{"content":"助手"},"logprobs":null,"finish_reason":null}],"usage":null}608{"id":"chatcmpl-9nhARrdUiJWEMd5plwV1Gc9NCjb9M","object":"chat.completion.chunk","created":1721631035,"model":"gpt-5.5","system_fingerprint":"fp_18cc0f1fa0","choices":[{"index":0,"delta":{"content":"。"},"logprobs":null,"finish_reason":null}],"usage":null}609{"id":"chatcmpl-9nhARrdUiJWEMd5plwV1Gc9NCjb9M","object":"chat.completion.chunk","created":1721631035,"model":"gpt-5.5","system_fingerprint":"fp_18cc0f1fa0","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}],"usage":null}610{"id":"chatcmpl-9nhARrdUiJWEMd5plwV1Gc9NCjb9M","object":"chat.completion.chunk","created":1721631035,"model":"gpt-5.5","system_fingerprint":"fp_18cc0f1fa0","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":3,"total_tokens":17}}611[DONE]"""  # noqa: E501612613614@pytest.fixture615def mock_openai_completion() -> list[dict]:616    list_chunk_data = OPENAI_STREAM_DATA.split("\n")617    result_list = []618    for msg in list_chunk_data:619        if msg != "[DONE]":620            result_list.append(json.loads(msg))621622    return result_list623624625async def test_openai_astream(mock_openai_completion: list) -> None:626    llm_name = OPENAI_TEST_MODEL627    llm = ChatOpenAI(model=llm_name, stream_usage=True)628    assert llm.stream_usage629    mock_client = AsyncMock()630631    async def mock_create(*args: Any, **kwargs: Any) -> MockAsyncContextManager:632        return MockAsyncContextManager(mock_openai_completion)633634    mock_client.create = mock_create635    usage_chunk = mock_openai_completion[-1]636    usage_metadata: UsageMetadata | None = None637    with patch.object(llm, "async_client", mock_client):638        async for chunk in llm.astream("你的名字叫什么?只回答名字"):639            assert isinstance(chunk, AIMessageChunk)640            if chunk.usage_metadata is not None:641                usage_metadata = chunk.usage_metadata642643    assert usage_metadata is not None644645    assert usage_metadata["input_tokens"] == usage_chunk["usage"]["prompt_tokens"]646    assert usage_metadata["output_tokens"] == usage_chunk["usage"]["completion_tokens"]647    assert usage_metadata["total_tokens"] == usage_chunk["usage"]["total_tokens"]648649650def test_openai_stream(mock_openai_completion: list) -> None:651    llm_name = OPENAI_TEST_MODEL652    llm = ChatOpenAI(model=llm_name, stream_usage=True)653    assert llm.stream_usage654    mock_client = MagicMock()655656    call_kwargs = []657658    def mock_create(*args: Any, **kwargs: Any) -> MockSyncContextManager:659        call_kwargs.append(kwargs)660        return MockSyncContextManager(mock_openai_completion)661662    mock_client.create = mock_create663    usage_chunk = mock_openai_completion[-1]664    usage_metadata: UsageMetadata | None = None665    with patch.object(llm, "client", mock_client):666        for chunk in llm.stream("你的名字叫什么?只回答名字"):667            assert isinstance(chunk, AIMessageChunk)668            if chunk.usage_metadata is not None:669                usage_metadata = chunk.usage_metadata670671    assert call_kwargs[-1]["stream_options"] == {"include_usage": True}672    assert usage_metadata is not None673    assert usage_metadata["input_tokens"] == usage_chunk["usage"]["prompt_tokens"]674    assert usage_metadata["output_tokens"] == usage_chunk["usage"]["completion_tokens"]675    assert usage_metadata["total_tokens"] == usage_chunk["usage"]["total_tokens"]676677    # Verify no streaming outside of default base URL or clients678    for param, value in {679        "stream_usage": False,680        "openai_proxy": "http://localhost:7890",681        "openai_api_base": "https://example.com/v1",682        "base_url": "https://example.com/v1",683        "client": mock_client,684        "root_client": mock_client,685        "async_client": mock_client,686        "root_async_client": mock_client,687        "http_client": httpx.Client(),688        "http_async_client": httpx.AsyncClient(),689    }.items():690        llm = ChatOpenAI(model=llm_name, **{param: value})  # type: ignore[arg-type]691        assert not llm.stream_usage692        with patch.object(llm, "client", mock_client):693            _ = list(llm.stream("..."))694        assert "stream_options" not in call_kwargs[-1]695696697def test_openai_stream_events_v3_lifecycle(mock_openai_completion: list) -> None:698    """`stream_events(version="v3")` on chat completions emits a valid lifecycle."""699    from langchain_tests.utils.stream_lifecycle import assert_valid_event_stream700701    llm = ChatOpenAI(model=OPENAI_TEST_MODEL)702    mock_client = MagicMock()703704    def mock_create(*args: Any, **kwargs: Any) -> MockSyncContextManager:705        return MockSyncContextManager(mock_openai_completion)706707    mock_client.create = mock_create708    with patch.object(llm, "client", mock_client):709        events = list(llm.stream_events("你的名字叫什么?只回答名字", version="v3"))710711    assert_valid_event_stream(events)712    # At minimum, a text block with the accumulated answer.713    finishes = [e for e in events if e["event"] == "content-block-finish"]714    assert len(finishes) >= 1715    text_finishes = [f for f in finishes if f["content"]["type"] == "text"]716    assert len(text_finishes) == 1717718719@pytest.fixture720def mock_completion() -> dict:721    return {722        "id": "chatcmpl-7fcZavknQda3SQ",723        "object": "chat.completion",724        "created": 1689989000,725        "model": OPENAI_TEST_MODEL,726        "choices": [727            {728                "index": 0,729                "message": {"role": "assistant", "content": "Bar Baz", "name": "Erick"},730                "finish_reason": "stop",731            }732        ],733    }734735736@pytest.fixture737def mock_client(mock_completion: dict) -> MagicMock:738    rtn = MagicMock()739740    mock_create = MagicMock()741742    mock_resp = MagicMock()743    mock_resp.headers = {"content-type": "application/json"}744    mock_resp.parse.return_value = mock_completion745    mock_create.return_value = mock_resp746747    rtn.with_raw_response.create = mock_create748    rtn.create.return_value = mock_completion749    return rtn750751752@pytest.fixture753def mock_async_client(mock_completion: dict) -> AsyncMock:754    rtn = AsyncMock()755756    mock_create = AsyncMock()757    mock_resp = MagicMock()758    mock_resp.parse.return_value = mock_completion759    mock_create.return_value = mock_resp760761    rtn.with_raw_response.create = mock_create762    rtn.create.return_value = mock_completion763    return rtn764765766def test_openai_invoke(mock_client: MagicMock) -> None:767    llm = ChatOpenAI()768769    with patch.object(llm, "client", mock_client):770        res = llm.invoke("bar")771        assert res.content == "Bar Baz"772773        # headers are not in response_metadata if include_response_headers not set774        assert "headers" not in res.response_metadata775    assert mock_client.with_raw_response.create.called776777778async def test_openai_ainvoke(mock_async_client: AsyncMock) -> None:779    llm = ChatOpenAI()780781    with patch.object(llm, "async_client", mock_async_client):782        res = await llm.ainvoke("bar")783        assert res.content == "Bar Baz"784785        # headers are not in response_metadata if include_response_headers not set786        assert "headers" not in res.response_metadata787    assert mock_async_client.with_raw_response.create.called788789790class _GatewayMetadataTracer(BaseTracer):791    """Captures gateway metadata promoted onto completed LLM runs."""792793    def __init__(self) -> None:794        super().__init__()795        self.gateway_metadata: dict | None = None796797    def _persist_run(self, run: Run) -> None:798        """No-op; runs are inspected as they complete."""799800    def _on_llm_end(self, run: Run) -> None:801        metadata = run.extra.get("metadata", {})802        if "ls_gateway_info" in metadata:803            self.gateway_metadata = metadata["ls_gateway_info"]804805806_GATEWAY_METADATA_HEADERS = httpx2.Headers(807    {"x-langsmith-gateway-metadata": '{"provider": "openai"}'}808)809810_RESPONSES_API_COMPLETION = Response(811    id="resp_123",812    created_at=1234567890,813    model=OPENAI_TEST_MODEL,814    object="response",815    parallel_tool_calls=True,816    tools=[],817    tool_choice="auto",818    output=[819        ResponseOutputMessage(820            type="message",821            id="msg_123",822            content=[823                ResponseOutputText(type="output_text", text="Bar Baz", annotations=[])824            ],825            role="assistant",826            status="completed",827        )828    ],829)830831_RESPONSES_API_STREAM = [832    ResponseTextDeltaEvent(833        content_index=0,834        delta="Bar Baz",835        item_id="msg_123",836        output_index=0,837        sequence_number=0,838        logprobs=[],839        type="response.output_text.delta",840    ),841]842843844@pytest.mark.parametrize("use_responses_api", [False, True])845def test_openai_invoke_surfaces_gateway_metadata(846    mock_completion: dict, *, use_responses_api: bool847) -> None:848    """Gateway metadata header is surfaced on `generation_info`, not the message."""849    llm = ChatOpenAI(use_responses_api=use_responses_api)850    mock_client = MagicMock()851    mock_resp = MagicMock()852    mock_resp.headers = _GATEWAY_METADATA_HEADERS853    if use_responses_api:854        mock_resp.parse.return_value = _RESPONSES_API_COMPLETION855        mock_client.responses.with_raw_response.create.return_value = mock_resp856        client_attr = "root_client"857    else:858        mock_resp.parse.return_value = mock_completion859        mock_client.with_raw_response.create.return_value = mock_resp860        client_attr = "client"861862    tracer = _GatewayMetadataTracer()863    with patch.object(llm, client_attr, mock_client):864        res = llm.invoke("bar", config={"callbacks": [tracer]})865866    # Gateway metadata reaches the tracer via `generation_info`...867    assert tracer.gateway_metadata == {"provider": "openai"}868    # ...but is kept off the user-facing message `response_metadata`.869    assert GATEWAY_METADATA_RESPONSE_KEY not in res.response_metadata870871872@pytest.mark.parametrize("use_responses_api", [False, True])873def test_openai_stream_surfaces_gateway_metadata(874    mock_openai_completion: list, *, use_responses_api: bool875) -> None:876    """Gateway metadata reaches the tracer for a gateway-routed stream."""877    # A LangSmith API key signals gateway routing, so streaming fetches raw878    # headers.879    llm = ChatOpenAI(880        model=OPENAI_TEST_MODEL,881        api_key="lsv2_pt_example",  # type: ignore[arg-type]882        use_responses_api=use_responses_api,883    )884    mock_client = MagicMock()885    mock_resp = MagicMock()886    mock_resp.headers = _GATEWAY_METADATA_HEADERS887    if use_responses_api:888        mock_resp.parse.return_value = MockSyncContextManager(_RESPONSES_API_STREAM)889        mock_client.with_raw_response.responses.create.return_value = mock_resp890        mock_client.responses.create.return_value = MockSyncContextManager(891            _RESPONSES_API_STREAM892        )893        client_attr = "root_client"894    else:895        mock_resp.parse.return_value = MockSyncContextManager(mock_openai_completion)896        mock_client.with_raw_response.create.return_value = mock_resp897        client_attr = "client"898899    tracer = _GatewayMetadataTracer()900    with patch.object(llm, client_attr, mock_client):901        for chunk in llm.stream("what is your name?", config={"callbacks": [tracer]}):902            # Gateway metadata is kept off the user-facing chunk metadata.903            assert GATEWAY_METADATA_RESPONSE_KEY not in chunk.response_metadata904905    assert tracer.gateway_metadata == {"provider": "openai"}906907908@pytest.mark.parametrize("use_responses_api", [False, True])909async def test_openai_astream_surfaces_gateway_metadata(910    mock_openai_completion: list, *, use_responses_api: bool911) -> None:912    """Gateway metadata reaches the tracer for a gateway-routed async stream."""913    llm = ChatOpenAI(914        model=OPENAI_TEST_MODEL,915        api_key="lsv2_pt_example",  # type: ignore[arg-type]916        use_responses_api=use_responses_api,917    )918    mock_client = AsyncMock()919    mock_resp = MagicMock()920    mock_resp.headers = _GATEWAY_METADATA_HEADERS921    if use_responses_api:922        mock_resp.parse.return_value = MockAsyncContextManager(_RESPONSES_API_STREAM)923        mock_client.with_raw_response.responses.create.return_value = mock_resp924        mock_client.responses.create.return_value = MockAsyncContextManager(925            _RESPONSES_API_STREAM926        )927        client_attr = "root_async_client"928    else:929        mock_resp.parse.return_value = MockAsyncContextManager(mock_openai_completion)930        mock_client.with_raw_response.create.return_value = mock_resp931        client_attr = "async_client"932933    tracer = _GatewayMetadataTracer()934    with patch.object(llm, client_attr, mock_client):935        async for chunk in llm.astream(936            "what is your name?", config={"callbacks": [tracer]}937        ):938            # Gateway metadata is kept off the user-facing chunk metadata.939            assert GATEWAY_METADATA_RESPONSE_KEY not in chunk.response_metadata940941    assert tracer.gateway_metadata == {"provider": "openai"}942943944@pytest.mark.parametrize(945    "model",946    [947        OPENAI_TEST_MODEL,948        "gpt-5-nano",949        "o3",950        "gpt-5.2",951    ],952)953def test__get_encoding_model(model: str) -> None:954    ChatOpenAI(model=model)._get_encoding_model()955956957def test_openai_invoke_name(mock_client: MagicMock) -> None:958    llm = ChatOpenAI()959960    with patch.object(llm, "client", mock_client):961        messages = [HumanMessage(content="Foo", name="Katie")]962        res = llm.invoke(messages)963        call_args, call_kwargs = mock_client.with_raw_response.create.call_args964        assert len(call_args) == 0  # no positional args965        call_messages = call_kwargs["messages"]966        assert len(call_messages) == 1967        assert call_messages[0]["role"] == "user"968        assert call_messages[0]["content"] == "Foo"969        assert call_messages[0]["name"] == "Katie"970971        # check return type has name972        assert res.content == "Bar Baz"973        assert res.name == "Erick"974975976def test_function_calls_with_tool_calls(mock_client: MagicMock) -> None:977    # Test that we ignore function calls if tool_calls are present978    llm = ChatOpenAI(model=OPENAI_TEST_MODEL)979    tool_call_message = AIMessage(980        content="",981        additional_kwargs={982            "function_call": {983                "name": "get_weather",984                "arguments": '{"location": "Boston"}',985            }986        },987        tool_calls=[988            {989                "name": "get_weather",990                "args": {"location": "Boston"},991                "id": "abc123",992                "type": "tool_call",993            }994        ],995    )996    messages = [997        HumanMessage("What's the weather in Boston?"),998        tool_call_message,999        ToolMessage(content="It's sunny.", name="get_weather", tool_call_id="abc123"),1000    ]1001    with patch.object(llm, "client", mock_client):1002        _ = llm.invoke(messages)1003        _, call_kwargs = mock_client.with_raw_response.create.call_args1004        call_messages = call_kwargs["messages"]1005        tool_call_message_payload = call_messages[1]1006        assert "tool_calls" in tool_call_message_payload1007        assert "function_call" not in tool_call_message_payload10081009    # Test we don't ignore function calls if tool_calls are not present1010    cast(AIMessage, messages[1]).tool_calls = []1011    with patch.object(llm, "client", mock_client):1012        _ = llm.invoke(messages)1013        _, call_kwargs = mock_client.with_raw_response.create.call_args1014        call_messages = call_kwargs["messages"]1015        tool_call_message_payload = call_messages[1]1016        assert "function_call" in tool_call_message_payload1017        assert "tool_calls" not in tool_call_message_payload101810191020def test_custom_token_counting() -> None:1021    def token_encoder(text: str) -> list[int]:1022        return [1, 2, 3]10231024    llm = ChatOpenAI(custom_get_token_ids=token_encoder)1025    assert llm.get_token_ids("foo") == [1, 2, 3]102610271028def test_format_message_content() -> None:1029    content: Any = "hello"1030    assert content == _format_message_content(content)10311032    content = None1033    assert content == _format_message_content(content)10341035    content = []1036    assert content == _format_message_content(content)10371038    content = [1039        {"type": "text", "text": "What is in this image?"},1040        {"type": "image_url", "image_url": {"url": "url.com"}},1041    ]1042    assert content == _format_message_content(content)10431044    content = [1045        {"type": "text", "text": "hello"},1046        {1047            "type": "tool_use",1048            "id": "toolu_01A09q90qw90lq917835lq9",1049            "name": "get_weather",1050            "input": {"location": "San Francisco, CA", "unit": "celsius"},1051        },1052    ]1053    assert _format_message_content(content) == [{"type": "text", "text": "hello"}]10541055    # Standard multi-modal inputs1056    contents = [1057        {"type": "image", "source_type": "url", "url": "https://..."},  # v01058        {"type": "image", "url": "https://..."},  # v11059    ]1060    expected = [{"type": "image_url", "image_url": {"url": "https://..."}}]1061    for content in contents:1062        assert expected == _format_message_content([content])10631064    contents = [1065        {1066            "type": "image",1067            "source_type": "base64",1068            "data": "<base64 data>",1069            "mime_type": "image/png",1070        },1071        {"type": "image", "base64": "<base64 data>", "mime_type": "image/png"},1072    ]1073    expected = [1074        {1075            "type": "image_url",1076            "image_url": {"url": "data:image/png;base64,<base64 data>"},1077        }1078    ]1079    for content in contents:1080        assert expected == _format_message_content([content])10811082    contents = [1083        {1084            "type": "file",1085            "source_type": "base64",1086            "data": "<base64 data>",1087            "mime_type": "application/pdf",1088            "filename": "my_file",1089        },1090        {1091            "type": "file",1092            "base64": "<base64 data>",1093            "mime_type": "application/pdf",1094            "filename": "my_file",1095        },1096    ]1097    expected = [1098        {1099            "type": "file",1100            "file": {1101                "filename": "my_file",1102                "file_data": "data:application/pdf;base64,<base64 data>",1103            },1104        }1105    ]1106    for content in contents:1107        assert expected == _format_message_content([content])11081109    # Test warn if PDF is missing a filename and that we add a default filename1110    pdf_block = {1111        "type": "file",1112        "base64": "<base64 data>",1113        "mime_type": "application/pdf",1114    }1115    expected = [1116        {1117            "type": "file",1118            "file": {1119                "file_data": "data:application/pdf;base64,<base64 data>",1120                "filename": "LC_AUTOGENERATED",1121            },1122        }1123    ]1124    with pytest.warns(match="filename"):1125        assert expected == _format_message_content([pdf_block])11261127    contents = [1128        {"type": "file", "source_type": "id", "id": "file-abc123"},1129        {"type": "file", "file_id": "file-abc123"},1130    ]1131    expected = [{"type": "file", "file": {"file_id": "file-abc123"}}]1132    for content in contents:1133        assert expected == _format_message_content([content])113411351136class GenerateUsername(BaseModel):1137    "Get a username based on someone's name and hair color."11381139    name: str1140    hair_color: str114111421143class MakeASandwich(BaseModel):1144    "Make a sandwich given a list of ingredients."11451146    bread_type: str1147    cheese_type: str1148    condiments: list[str]1149    vegetables: list[str]115011511152@pytest.mark.parametrize(1153    "tool_choice",1154    [1155        "any",1156        "none",1157        "auto",1158        "required",1159        "GenerateUsername",1160        {"type": "function", "function": {"name": "MakeASandwich"}},1161        False,1162        None,1163    ],1164)1165@pytest.mark.parametrize("strict", [True, False, None])1166def test_bind_tools_tool_choice(tool_choice: Any, strict: bool | None) -> None:1167    """Test passing in manually construct tool call message."""1168    llm = ChatOpenAI(model=OPENAI_TEST_MODEL, temperature=0)1169    llm.bind_tools(1170        tools=[GenerateUsername, MakeASandwich], tool_choice=tool_choice, strict=strict1171    )117211731174def test_bind_tools_response_format_defaults_strict() -> None:1175    """Test that strict defaults to True when response_format is provided."""1176    llm = ChatOpenAI(model=OPENAI_TEST_MODEL, temperature=0)1177    bound = llm.bind_tools(1178        tools=[GenerateUsername],1179        response_format=MakeASandwich,1180    )1181    tools = bound.kwargs["tools"]  # type: ignore[attr-defined]1182    assert tools[0]["function"]["strict"] is True118311841185def test_bind_tools_response_format_respects_strict_false() -> None:1186    """Test that strict=False is respected even when response_format is provided."""1187    llm = ChatOpenAI(model=OPENAI_TEST_MODEL, temperature=0)1188    bound = llm.bind_tools(1189        tools=[GenerateUsername],1190        response_format=MakeASandwich,1191        strict=False,1192    )1193    tools = bound.kwargs["tools"]  # type: ignore[attr-defined]1194    assert tools[0]["function"]["strict"] is False119511961197def test_bind_tools_no_response_format_keeps_strict_none() -> None:1198    """Test that strict stays None when response_format is not provided."""1199    llm = ChatOpenAI(model=OPENAI_TEST_MODEL, temperature=0)1200    bound = llm.bind_tools(tools=[GenerateUsername])1201    tools = bound.kwargs["tools"]  # type: ignore[attr-defined]1202    assert "strict" not in tools[0]["function"]120312041205@pytest.mark.parametrize(1206    "schema", [GenerateUsername, GenerateUsername.model_json_schema()]1207)1208@pytest.mark.parametrize("method", ["json_schema", "function_calling", "json_mode"])1209@pytest.mark.parametrize("include_raw", [True, False])1210@pytest.mark.parametrize("strict", [True, False, None])1211def test_with_structured_output(1212    schema: type | dict[str, Any] | None,1213    method: Literal["function_calling", "json_mode", "json_schema"],1214    include_raw: bool,1215    strict: bool | None,1216) -> None:1217    """Test passing in manually construct tool call message."""1218    if method == "json_mode":1219        strict = None1220    llm = ChatOpenAI(model=OPENAI_TEST_MODEL, temperature=0)1221    llm.with_structured_output(1222        schema, method=method, strict=strict, include_raw=include_raw1223    )122412251226def test_get_num_tokens_from_messages() -> None:1227    llm = ChatOpenAI(model=OPENAI_TEST_MODEL)1228    messages = [1229        SystemMessage("you're a good assistant"),1230        HumanMessage("how are you"),1231        HumanMessage(1232            [1233                {"type": "text", "text": "what's in this image"},1234                {"type": "image_url", "image_url": {"url": "https://foobar.com"}},1235                {1236                    "type": "image_url",1237                    "image_url": {"url": "https://foobar.com", "detail": "low"},1238                },1239            ]1240        ),1241        AIMessage("a nice bird"),1242        AIMessage(1243            "",1244            tool_calls=[1245                ToolCall(id="foo", name="bar", args={"arg1": "arg1"}, type="tool_call")1246            ],1247        ),1248        AIMessage(1249            "",1250            additional_kwargs={1251                "function_call": {1252                    "arguments": json.dumps({"arg1": "arg1"}),1253                    "name": "fun",1254                }1255            },1256        ),1257        AIMessage(1258            "text",1259            tool_calls=[1260                ToolCall(id="foo", name="bar", args={"arg1": "arg1"}, type="tool_call")1261            ],1262        ),1263        ToolMessage("foobar", tool_call_id="foo"),1264    ]1265    expected = 431  # Updated to match token count with mocked 100x100 image12661267    # Mock _url_to_size to avoid PIL dependency in unit tests1268    with patch("langchain_openai.chat_models.base._url_to_size") as mock_url_to_size:1269        mock_url_to_size.return_value = (100, 100)  # 100x100 pixel image1270        actual = llm.get_num_tokens_from_messages(messages)12711272    assert expected == actual12731274    # Test file inputs1275    messages = [1276        HumanMessage(1277            [1278                "Summarize this document.",1279                {1280                    "type": "file",1281                    "file": {1282                        "filename": "my file",1283                        "file_data": "data:application/pdf;base64,<data>",1284                    },1285                },1286            ]1287        )1288    ]1289    actual = 01290    with pytest.warns(match="file inputs are not supported"):1291        actual = llm.get_num_tokens_from_messages(messages)1292    assert actual == 1312931294    # Test Responses1295    messages = [1296        AIMessage(1297            [1298                {1299                    "type": "function_call",1300                    "name": "multiply",1301                    "arguments": '{"x":5,"y":4}',1302                    "call_id": "call_abc123",1303                    "id": "fc_abc123",1304                    "status": "completed",1305                },1306            ],1307            tool_calls=[1308                {1309                    "type": "tool_call",1310                    "name": "multiply",1311                    "args": {"x": 5, "y": 4},1312                    "id": "call_abc123",1313                }1314            ],1315        )1316    ]1317    actual = llm.get_num_tokens_from_messages(messages)1318    assert actual131913201321@pytest.mark.parametrize(1322    "model", ["o1", "o1-preview", "o1-mini", "o3", "o3-mini", "o4-mini"]1323)1324def test_get_num_tokens_from_messages_o_series(model: str) -> None:1325    """o-series models use the same message token format as gpt-4/gpt-5.13261327    Regression test: these raised NotImplementedError.1328    """1329    llm = ChatOpenAI(model=model)1330    messages = [1331        SystemMessage("you're a good assistant"),1332        HumanMessage("how are you"),1333    ]1334    actual = llm.get_num_tokens_from_messages(messages)1335    expected = ChatOpenAI(model=OPENAI_TEST_MODEL).get_num_tokens_from_messages(1336        messages1337    )1338    assert actual == expected133913401341def test_get_num_tokens_from_messages_gpt_6() -> None:1342    llm = ChatOpenAI(model="gpt-6-astra")1343    messages = [HumanMessage("how are you")]13441345    assert llm._get_encoding_model()[1].name == "o200k_base"1346    assert llm.get_num_tokens_from_messages(messages) > 0134713481349class Foo(BaseModel):1350    bar: int135113521353# class FooV1(BaseModelV1):1354#     bar: int135513561357@pytest.mark.parametrize(1358    "schema",1359    [1360        Foo1361        # FooV11362    ],1363)1364def test_schema_from_with_structured_output(schema: type) -> None:1365    """Test schema from with_structured_output."""13661367    llm = ChatOpenAI(model=OPENAI_TEST_MODEL)13681369    structured_llm = llm.with_structured_output(1370        schema, method="json_schema", strict=True1371    )13721373    expected = {1374        "properties": {"bar": {"title": "Bar", "type": "integer"}},1375        "required": ["bar"],1376        "title": schema.__name__,1377        "type": "object",1378    }1379    output_schema = cast("type[BaseModel]", structured_llm.get_output_schema())1380    actual = output_schema.model_json_schema()1381    assert actual == expected138213831384def test__create_usage_metadata() -> None:1385    usage_metadata = {1386        "completion_tokens": 15,1387        "prompt_tokens_details": None,1388        "completion_tokens_details": None,1389        "prompt_tokens": 11,1390        "total_tokens": 26,1391    }1392    result = _create_usage_metadata(usage_metadata)1393    assert result == UsageMetadata(1394        output_tokens=15,1395        input_tokens=11,1396        total_tokens=26,1397        input_token_details={},1398        output_token_details={},1399    )140014011402def test__create_usage_metadata_zero_total_tokens() -> None:1403    """Test that explicit total_tokens=0 is preserved, not replaced by sum."""1404    usage_metadata = {1405        "prompt_tokens": 10,1406        "completion_tokens": 5,1407        "total_tokens": 0,1408        "prompt_tokens_details": None,1409        "completion_tokens_details": None,1410    }1411    result = _create_usage_metadata(usage_metadata)1412    assert result["total_tokens"] == 0141314141415def test__create_usage_metadata_cache_write_tokens() -> None:1416    """`cache_write_tokens` is surfaced under the standard `cache_creation` key."""1417    usage_metadata = {1418        "completion_tokens": 15,1419        # OpenAI's `cache_write_tokens` maps to core's `cache_creation`1420        "prompt_tokens_details": {"cached_tokens": 50, "cache_write_tokens": 25},1421        "completion_tokens_details": None,1422        "prompt_tokens": 100,1423        "total_tokens": 115,1424    }1425    result = _create_usage_metadata(usage_metadata)1426    assert result["input_token_details"] == {1427        "cache_read": 50,1428        "cache_creation": 25,1429    }143014311432def test__create_usage_metadata_cache_read_only() -> None:1433    """Responses without `cache_write_tokens` emit no `cache_creation` key."""1434    usage_metadata = {1435        "completion_tokens": 15,1436        "prompt_tokens_details": {"cached_tokens": 50},1437        "completion_tokens_details": None,1438        "prompt_tokens": 100,1439        "total_tokens": 115,1440    }1441    result = _create_usage_metadata(usage_metadata)1442    assert result["input_token_details"] == {"cache_read": 50}144314441445def test__create_usage_metadata_cache_tokens_zero_retained() -> None:1446    """Explicit zero cache counts are retained (filtered on `None`, not falsiness)."""1447    usage_metadata = {1448        "completion_tokens": 15,1449        "prompt_tokens_details": {"cached_tokens": 0, "cache_write_tokens": 0},1450        "completion_tokens_details": None,1451        "prompt_tokens": 100,1452        "total_tokens": 115,1453    }1454    result = _create_usage_metadata(usage_metadata)1455    assert result["input_token_details"] == {1456        "cache_read": 0,1457        "cache_creation": 0,1458    }145914601461def test__create_usage_metadata_service_tier_excludes_cache_read_tokens() -> None:1462    """Tier counts exclude cache reads but not overlapping cache writes."""1463    usage_metadata = {1464        "completion_tokens": 50,1465        "prompt_tokens_details": {1466            "cached_tokens": 256,1467            "cache_write_tokens": 3072,1468        },1469        "completion_tokens_details": {"reasoning_tokens": 10},1470        "prompt_tokens": 2304,1471        "total_tokens": 2354,1472    }1473    result = _create_usage_metadata(usage_metadata, service_tier="priority")1474    assert result["input_token_details"] == {1475        "priority_cache_read": 256,1476        "priority_cache_creation": 3072,1477        "priority": 2048,1478    }1479    assert result["output_token_details"] == {1480        "priority_reasoning": 10,1481        "priority": 40,  # 50 - 10 (reasoning)1482    }148314841485def test__create_usage_metadata_service_tier_without_detail_fields() -> None:1486    """Tier arithmetic tolerates missing cache/reasoning fields (no TypeError)."""1487    usage_metadata = {1488        "completion_tokens": 50,1489        "prompt_tokens_details": None,1490        "completion_tokens_details": None,1491        "prompt_tokens": 100,1492        "total_tokens": 150,1493    }1494    result = _create_usage_metadata(usage_metadata, service_tier="flex")1495    assert result["input_token_details"] == {"flex": 100}1496    assert result["output_token_details"] == {"flex": 50}149714981499def test__create_usage_metadata_responses() -> None:1500    response_usage_metadata = {1501        "input_tokens": 100,1502        "input_tokens_details": {"cached_tokens": 50},1503        "output_tokens": 50,1504        "output_tokens_details": {"reasoning_tokens": 10},1505        "total_tokens": 150,1506    }1507    result = _create_usage_metadata_responses(response_usage_metadata)15081509    assert result == UsageMetadata(1510        output_tokens=50,1511        input_tokens=100,1512        total_tokens=150,1513        input_token_details={"cache_read": 50},1514        output_token_details={"reasoning": 10},1515    )151615171518def test__create_usage_metadata_responses_cache_write_tokens() -> None:1519    """Responses usage maps `cache_write_tokens` to the `cache_creation` key."""1520    response_usage_metadata = {1521        "input_tokens": 100,1522        "input_tokens_details": {"cached_tokens": 50, "cache_write_tokens": 25},1523        "output_tokens": 50,1524        "output_tokens_details": {"reasoning_tokens": 10},1525        "total_tokens": 150,1526    }1527    result = _create_usage_metadata_responses(response_usage_metadata)15281529    assert result == UsageMetadata(1530        output_tokens=50,1531        input_tokens=100,1532        total_tokens=150,1533        input_token_details={"cache_read": 50, "cache_creation": 25},1534        output_token_details={"reasoning": 10},1535    )153615371538def test__create_usage_metadata_responses_service_tier_cache_write_overlap() -> None:1539    """Tier counts exclude cache reads but not overlapping cache writes."""1540    response_usage_metadata = {1541        "input_tokens": 2304,1542        "input_tokens_details": {1543            "cached_tokens": 256,1544            "cache_write_tokens": 3072,1545        },1546        "output_tokens": 50,1547        "output_tokens_details": {"reasoning_tokens": 10},1548        "total_tokens": 2354,1549    }1550    result = _create_usage_metadata_responses(1551        response_usage_metadata, service_tier="flex"1552    )1553    assert result["input_token_details"] == {1554        "flex_cache_read": 256,1555        "flex_cache_creation": 3072,1556        "flex": 2048,1557    }1558    assert result["output_token_details"] == {1559        "flex_reasoning": 10,1560        "flex": 40,  # 50 - 10 (reasoning)1561    }156215631564def test__create_usage_metadata_responses_service_tier_without_detail_fields() -> None:1565    """Tier arithmetic tolerates missing cache/reasoning fields (no TypeError)."""1566    response_usage_metadata = {1567        "input_tokens": 100,1568        "input_tokens_details": None,1569        "output_tokens": 50,1570        "output_tokens_details": None,1571        "total_tokens": 150,1572    }1573    result = _create_usage_metadata_responses(1574        response_usage_metadata, service_tier="priority"1575    )1576    assert result["input_token_details"] == {"priority": 100}1577    assert result["output_token_details"] == {"priority": 50}157815791580def test__resize_caps_dimensions_preserving_ratio() -> None:1581    """Larger side capped at 2048 then smaller at 768 keeping aspect ratio."""1582    assert _resize(2048, 4096) == (768, 1536)1583    assert _resize(4096, 2048) == (1536, 768)158415851586def test__convert_to_openai_response_format() -> None:1587    # Test response formats that aren't tool-like.1588    response_format: dict = {1589        "type": "json_schema",1590        "json_schema": {1591            "name": "math_reasoning",1592            "schema": {1593                "type": "object",1594                "properties": {1595                    "steps": {1596                        "type": "array",1597                        "items": {1598                            "type": "object",1599                            "properties": {1600                                "explanation": {"type": "string"},1601                                "output": {"type": "string"},1602                            },1603                            "required": ["explanation", "output"],1604                            "additionalProperties": False,1605                        },1606                    },1607                    "final_answer": {"type": "string"},1608                },1609                "required": ["steps", "final_answer"],1610                "additionalProperties": False,1611            },1612            "strict": True,1613        },1614    }16151616    actual = _convert_to_openai_response_format(response_format)1617    assert actual == response_format16181619    actual = _convert_to_openai_response_format(response_format["json_schema"])1620    assert actual == response_format16211622    actual = _convert_to_openai_response_format(response_format, strict=True)1623    assert actual == response_format16241625    with pytest.raises(ValueError):1626        _convert_to_openai_response_format(response_format, strict=False)162716281629@pytest.mark.parametrize("method", ["function_calling", "json_schema"])1630@pytest.mark.parametrize("strict", [True, None])1631def test_structured_output_strict(1632    method: Literal["function_calling", "json_schema"], strict: bool | None1633) -> None:1634    """Test to verify structured output with strict=True."""16351636    llm = ChatOpenAI(model=OPENAI_TEST_MODEL)16371638    class Joke(BaseModel):1639        """Joke to tell user."""16401641        setup: str = Field(description="question to set up a joke")1642        punchline: str = Field(description="answer to resolve the joke")16431644    llm.with_structured_output(Joke, method=method, strict=strict)1645    # Schema1646    llm.with_structured_output(Joke.model_json_schema(), method=method, strict=strict)164716481649def test_nested_structured_output_strict() -> None:1650    """Test to verify structured output with strict=True for nested object."""16511652    llm = ChatOpenAI(model=OPENAI_TEST_MODEL)16531654    class SelfEvaluation(TypedDict):1655        score: int1656        text: str16571658    class JokeWithEvaluation(TypedDict):1659        """Joke to tell user."""16601661        setup: str1662        punchline: str1663        _evaluation: SelfEvaluation16641665    llm.with_structured_output(JokeWithEvaluation, method="json_schema")166616671668def test__get_request_payload() -> None:1669    llm = ChatOpenAI(model=OPENAI_TEST_MODEL)1670    messages: list = [1671        SystemMessage("hello"),1672        SystemMessage("bye", additional_kwargs={"__openai_role__": "developer"}),1673        SystemMessage(content=[{"type": "text", "text": "hello!"}]),1674        {"role": "human", "content": "how are you"},1675        {"role": "user", "content": [{"type": "text", "text": "feeling today"}]},1676    ]1677    expected = {1678        "messages": [1679            {"role": "system", "content": "hello"},1680            {"role": "developer", "content": "bye"},1681            {"role": "system", "content": [{"type": "text", "text": "hello!"}]},1682            {"role": "user", "content": "how are you"},1683            {"role": "user", "content": [{"type": "text", "text": "feeling today"}]},1684        ],1685        "model": OPENAI_TEST_MODEL,1686        "stream": False,1687    }1688    payload = llm._get_request_payload(messages)1689    assert payload == expected16901691    # Test we coerce to developer role for o-series models1692    llm = ChatOpenAI(model="o3")1693    payload = llm._get_request_payload(messages)1694    expected = {1695        "messages": [1696            {"role": "developer", "content": "hello"},1697            {"role": "developer", "content": "bye"},1698            {"role": "developer", "content": [{"type": "text", "text": "hello!"}]},1699            {"role": "user", "content": "how are you"},1700            {"role": "user", "content": [{"type": "text", "text": "feeling today"}]},1701        ],1702        "model": "o3",1703        "stream": False,1704    }1705    assert payload == expected17061707    # Test we ignore reasoning blocks from other providers1708    reasoning_messages: list = [1709        {1710            "role": "user",1711            "content": [1712                {"type": "reasoning_content", "reasoning_content": "reasoning..."},1713                {"type": "text", "text": "reasoned response"},1714            ],1715        },1716        {1717            "role": "user",1718            "content": [1719                {"type": "thinking", "thinking": "thinking..."},1720                {"type": "text", "text": "thoughtful response"},1721            ],1722        },1723    ]1724    expected = {1725        "messages": [1726            {1727                "role": "user",1728                "content": [{"type": "text", "text": "reasoned response"}],1729            },1730            {1731                "role": "user",1732                "content": [{"type": "text", "text": "thoughtful response"}],1733            },1734        ],1735        "model": "o3",1736        "stream": False,1737    }1738    payload = llm._get_request_payload(reasoning_messages)1739    assert payload == expected174017411742def test_sanitize_chat_completions_text_blocks() -> None:1743    messages = [1744        ToolMessage(1745            content=[{"type": "text", "text": "foo", "id": "lc_abc123"}],1746            tool_call_id="def456",1747        ),1748    ]1749    payload = ChatOpenAI(model="gpt-5.2")._get_request_payload(messages)1750    assert payload["messages"] == [1751        {1752            "content": [{"type": "text", "text": "foo"}],1753            "role": "tool",1754            "tool_call_id": "def456",1755        }1756    ]175717581759def test_init_o1() -> None:1760    with warnings.catch_warnings(record=True) as record:1761        warnings.simplefilter("error")  # Treat warnings as errors1762        ChatOpenAI(model=OPENAI_TEST_MODEL, reasoning_effort="medium")17631764    assert len(record) == 0176517661767def test_init_minimal_reasoning_effort() -> None:1768    with warnings.catch_warnings(record=True) as record:1769        warnings.simplefilter("error")1770        ChatOpenAI(model="gpt-5", reasoning_effort="minimal")17711772    assert len(record) == 0177317741775@pytest.mark.parametrize("use_responses_api", [False, True])1776@pytest.mark.parametrize("use_max_completion_tokens", [True, False])1777def test_minimal_reasoning_effort_payload(1778    use_max_completion_tokens: bool, use_responses_api: bool1779) -> None:1780    """Test that minimal reasoning effort is included in request payload."""1781    if use_max_completion_tokens:1782        kwargs = {"max_completion_tokens": 100}1783    else:1784        kwargs = {"max_tokens": 100}17851786    init_kwargs: dict[str, Any] = {1787        "model": "gpt-5",1788        "reasoning_effort": "minimal",1789        "use_responses_api": use_responses_api,1790        **kwargs,1791    }17921793    llm = ChatOpenAI(**init_kwargs)17941795    messages = [1796        {"role": "developer", "content": "respond with just 'test'"},1797        {"role": "user", "content": "hello"},1798    ]17991800    payload = llm._get_request_payload(messages, stop=None)18011802    # When using responses API, reasoning_effort becomes reasoning.effort1803    if use_responses_api:1804        assert "reasoning" in payload1805        assert payload["reasoning"] == {"effort": "minimal"}1806        # For responses API, tokens param becomes max_output_tokens1807        assert payload["max_output_tokens"] == 1001808    else:1809        # For non-responses API, reasoning_effort remains as is1810        assert payload["reasoning_effort"] == "minimal"1811        if use_max_completion_tokens:1812            assert payload["max_completion_tokens"] == 1001813        else:1814            # max_tokens gets converted to max_completion_tokens in non-responses API1815            assert payload["max_completion_tokens"] == 100181618171818@pytest.mark.parametrize("via_invoke", [False, True])1819def test_responses_api_payload_excludes_stop(via_invoke: bool) -> None:1820    """The Responses API rejects `stop`, so it must be dropped from the payload.18211822    Covers `stop` supplied both at construction time and at invoke time, since1823    they reach the payload through different code paths.1824    """1825    if via_invoke:1826        llm = ChatOpenAI(model=OPENAI_TEST_MODEL, use_responses_api=True)1827        payload = llm._get_request_payload(1828            [HumanMessage(content="Hello")], stop=["END"]1829        )1830    else:1831        llm = ChatOpenAI(  # type: ignore[call-arg]1832            model=OPENAI_TEST_MODEL, stop=["END"], use_responses_api=True1833        )1834        payload = llm._get_request_payload([HumanMessage(content="Hello")])18351836    assert "stop" not in payload183718381839def test_chat_completions_payload_includes_stop() -> None:1840    """`stop` must be preserved for the Chat Completions API, which supports it.18411842    Guards against an over-broad change dropping `stop` outside the Responses API.1843    """1844    llm = ChatOpenAI(model=OPENAI_TEST_MODEL, stop=["END"])  # type: ignore[call-arg]18451846    payload = llm._get_request_payload([HumanMessage(content="Hello")])18471848    assert payload["stop"] == ["END"]184918501851def test_output_version_compat() -> None:1852    llm = ChatOpenAI(model="gpt-5", output_version="responses/v1")1853    assert llm._use_responses_api({}) is True185418551856def test_convert_chunk_to_generation_chunk_v1_keeps_string_content() -> None:1857    """v1 streaming keeps content as '' (not []) and stamps output_version.18581859    Covers both the usage-only (empty-choices) chunk and a content-bearing1860    chunk carrying a tool-call delta; the latter pins the per-content-chunk1861    `output_version` propagation.1862    """1863    llm = ChatOpenAI(model="gpt-4o", output_version="v1")18641865    # Empty-choices chunk (usage-only)1866    empty_chunk: dict[str, Any] = {1867        "id": "chatcmpl-test",1868        "object": "chat.completion.chunk",1869        "created": 0,1870        "model": "gpt-4o",1871        "choices": [],1872        "usage": {"prompt_tokens": 5, "completion_tokens": 3, "total_tokens": 8},1873    }1874    gen = llm._convert_chunk_to_generation_chunk(empty_chunk, AIMessageChunk, None)1875    assert gen is not None1876    assert gen.message.content == ""  # NOT []1877    assert gen.message.response_metadata.get("output_version") == "v1"18781879    # Content-bearing chunk with tool_call delta1880    tool_chunk: dict[str, Any] = {1881        "id": "chatcmpl-test",1882        "object": "chat.completion.chunk",1883        "created": 0,1884        "model": "gpt-4o",1885        "choices": [1886            {1887                "index": 0,1888                "delta": {1889                    "role": "assistant",1890                    "content": "",1891                    "tool_calls": [1892                        {1893                            "index": 0,1894                            "id": "call_abc",1895                            "function": {"name": "get_weather", "arguments": ""},1896                        }1897                    ],1898                },1899                "logprobs": None,1900                "finish_reason": None,1901            }1902        ],1903        "usage": None,1904    }1905    gen = llm._convert_chunk_to_generation_chunk(tool_chunk, AIMessageChunk, None)1906    assert gen is not None1907    assert isinstance(gen.message.content, str)1908    assert gen.message.response_metadata.get("output_version") == "v1"1909    assert gen.message.response_metadata.get("model_provider") == "openai"191019111912def test_v1_streaming_tool_calls_in_content_blocks() -> None:1913    """End-to-end: streaming chunks with tool calls produce correct content_blocks."""1914    stream_chunks: list[dict[str, Any]] = [1915        # Initial empty-choices chunk1916        {1917            "id": "chatcmpl-test",1918            "object": "chat.completion.chunk",1919            "created": 0,1920            "model": "gpt-4o",1921            "choices": [1922                {1923                    "index": 0,1924                    "delta": {"role": "assistant", "content": ""},1925                    "logprobs": None,1926                    "finish_reason": None,1927                }1928            ],1929            "usage": None,1930        },1931        # Text token streamed before the tool call1932        {1933            "id": "chatcmpl-test",1934            "object": "chat.completion.chunk",1935            "created": 0,1936            "model": "gpt-4o",1937            "choices": [1938                {1939                    "index": 0,1940                    "delta": {"content": "Let me check the weather."},1941                    "logprobs": None,1942                    "finish_reason": None,1943                }1944            ],1945            "usage": None,1946        },1947        # Tool call start1948        {1949            "id": "chatcmpl-test",1950            "object": "chat.completion.chunk",1951            "created": 0,1952            "model": "gpt-4o",1953            "choices": [1954                {1955                    "index": 0,1956                    "delta": {1957                        "tool_calls": [1958                            {1959                                "index": 0,1960                                "id": "call_abc",1961                                "function": {1962                                    "name": "get_weather",1963                                    "arguments": '{"loc',1964                                },1965                            }1966                        ]1967                    },1968                    "logprobs": None,1969                    "finish_reason": None,1970                }1971            ],1972            "usage": None,1973        },1974        # Tool call args continuation1975        {1976            "id": "chatcmpl-test",1977            "object": "chat.completion.chunk",1978            "created": 0,1979            "model": "gpt-4o",1980            "choices": [1981                {1982                    "index": 0,1983                    "delta": {1984                        "tool_calls": [1985                            {1986                                "index": 0,1987                                "function": {"arguments": 'ation": "SF"}'},1988                            }1989                        ]1990                    },1991                    "logprobs": None,1992                    "finish_reason": None,1993                }1994            ],1995            "usage": None,1996        },1997        # Finish1998        {1999            "id": "chatcmpl-test",2000            "object": "chat.completion.chunk",

Findings

✓ No findings reported for this file.

Get this view in your editor

Same data, no extra tab — call code_get_file + code_get_findings over MCP from Claude/Cursor/Copilot.

Generated by searchcode.com · powered by code_get_file + code_get_findings