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.