ޠjV %SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK J r J r JrJrJrJr SSKJr SSKJr SSKJr SSKJr SS KJr SS KJrJrJrJrJ r J!r! SS K"J#r# SSK$r$SSK%r%SSK&r&SS K'J(r(J)r) SS K*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3 SSK4J5r5J6r6 SSK7J8r8J9r9 SSK:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrK SSK:JLrM SSKNJOrOJPrPJQrQ SSKRJSrSJTrT SSKUJVrV SSKWJXrXJYrY SSKZJ[r[J\r\J]r]J^r^ SSK_J`r`JaraJbrb SSKcJdrdJereJfrfJgrg SSKhJiri SSKjJkrk SSKlJmrm SSKnJoro SSKpJqrqJrrrJsrs SSKtJuruJvrv SSKwJxrxJyryJzrz SS K{J|r|J}r}J~r~ SS!KJrJrJrJrJrJrJr SS"KJr SS#KJr SS$KJr SS%KJrJrJrJrJrJrJrJrJrJrJr SS&KJrJrJr SS'KJr \(aSSKrSS(K4Jr SS)KJr \GRF"\5r\GRL"\$GRN"5S*9rSqS+\S,'SzS-jr\!"\6\5rS{S.jrS/rS0rS|S1jrS}S2jrS~S3jrSSS4jjrSSS5jjrSS6jrSS7jr"S8S9\%GRn\+5r"S:S;\%GRr\+5r"S<S=\%GRv\-5r"S>S?\%GRz\15r"S@SA\%GRn\/5r"SBSC\%GR\05r"SDSE\%GR\25r"SFSG\%GR\,5r"SHSI\%GR\.5r"SJSK\%GR\35rSSLjrSSMjrSSNjrSOrSSPjr\ "SQ\SR9r\\\4\\-\-rSS\ST'\\-rSS\SU'"SVSW\85r"SXSY\5rSSZjrSS[jrSS\jrSS]jrSS^jrSS_jrSS`jrSSajrSSb.SScjjrSSdjr"SeSf\5rSSSgjjrSSShjjrSSijrSSjjrSSkjrSSljrSSmjrSSnjrSSojrSSpjrSSqjrSSrjrSSsjrSSt.SSujjrSSvjrSSSwjjrSSxjrSSSyjjrg)a"OpenAI chat wrapper. !!! warning "API scope" `ChatOpenAI` targets [official OpenAI API specifications](https://github.com/openai/openai-openapi) only. Non-standard response fields added by third-party providers (e.g., `reasoning_content`, `reasoning_details`) are **not** extracted or preserved. If you are pointing `base_url` at a provider such as OpenRouter, vLLM, or DeepSeek, use the corresponding provider-specific LangChain package instead (e.g., `ChatDeepSeek`, `ChatOpenRouter`). ) annotationsN) AsyncIterator AwaitableCallableIteratorMappingSequence)partial)BytesIO)JSONDecodeError)ceil) itemgetter) TYPE_CHECKINGAnyLiteral TypeAliasTypeVarcast)urlparse)AsyncCallbackManagerForLLMRunCallbackManagerForLLMRun) ContextOverflowError ModelAPIErrorModelAuthenticationErrorModelConnectionErrorModelInvalidRequestErrorModelNotFoundErrorModelPermissionDeniedErrorModelRateLimitErrorModelTimeoutError)LanguageModelInputModelProfileRegistry) BaseChatModelLangSmithParams) AIMessageAIMessageChunk BaseMessageBaseMessageChunk ChatMessageChatMessageChunkFunctionMessageFunctionMessageChunk HumanMessageHumanMessageChunkInvalidToolCall SystemMessageSystemMessageChunkToolCall ToolMessageToolMessageChunkis_data_content_block)content)InputTokenDetailsOutputTokenDetails UsageMetadata)_convert_from_v03_ai_messageconvert_to_openai_data_block)tool_call_chunk)JsonOutputParserPydanticOutputParser)JsonOutputKeyToolsParserPydanticToolsParsermake_invalid_tool_callparse_tool_call)ChatGenerationChatGenerationChunk ChatResult)RunnableRunnableLambda RunnableMapRunnablePassthrough)run_in_executor)BaseTool) _stringify)get_pydantic_field_names)GATEWAY_METADATA_RESPONSE_KEY_parse_gateway_metadata_resolve_gateway_config)convert_to_openai_functionconvert_to_openai_tool)PydanticBaseModel TypeBaseModelis_basemodel_subclass)LC_AUTO_PREFIX_build_model_kwargsfrom_env) BaseModel ConfigDictField SecretStrValidationErrorfield_validatormodel_validator)rY)Self) __version__) _astream_with_chunk_timeout!_build_proxied_async_httpx_client _build_proxied_sync_httpx_client _float_env_get_default_async_httpx_client_get_default_httpx_client_log_proxy_env_bypass_once_resolve_socket_options _resolve_sync_and_async_api_keys+_should_bypass_socket_options_for_proxy_env_warn_if_proxy_env_shadowed)$_convert_from_v1_to_chat_completions_convert_from_v1_to_responses_convert_to_v03_ai_message) _PROFILES) ModelProfileResponse)cafilezhttpx.Client | None _ssrf_clientc>[cSSKJn U"[SS9q[$)Nrssrf_safe_clientF)verifyfollow_redirects)ru#langchain_core._security._transportrxglobal_ssl_contextrws [/var/www/html/gaurav/venv/lib/python3.13/site-packages/langchain_openai/chat_models/base.py_get_ssrf_safe_clientr~s"H'%  c^[RU5=(d 0nUR5$N)_MODEL_PROFILESgetcopy) model_namedefaults r}_get_default_model_profilers#!!*-3G <<>r) file_searchweb_search_preview web_searchcomputer_use_previewcode_interpretermcpimage_generation tool_search apply_patch) defer_loadingasyncc 2URS5nURS5nURS5nUS:Xa[URSS5X2S9$US:XaURSS5=(d Sn0nURS 5=n(a[U5US '/n/nURS 5=n (a#U Hn UR[ U S S 95 M URS5=n (aXS'[UUUUUUS9$US;a(US:XaSU0O0n[URSS5UUUS9$US:Xa8[URSS5[[URS55US9$US:XaJ0nSU;aUSUS'[URSS5[[URS55UUUS9$[URSS5XS9$![ a0n UR[ U [U 555 S n A GMVS n A ff=f)ztConvert a dictionary to a LangChain message. Args: _dict: The dictionary. Returns: The LangChain message. rolenameiduserr6)r6rr assistant function_call tool_callsT) return_idNaudio)r6additional_kwargsrrrinvalid_tool_callssystem developerr__openai_role__)r6rrrfunctionr6rrtool tool_call_id)r6rrrrr6rr)rr-dictappendrB ExceptionrAstrr%r0r+rr3r)) _dictrrid_r6rrrrraw_tool_calls raw_tool_callers r}_convert_dict_to_messagers> 99V D 99V D ))D/C v~EIIi$<PP {))Ir*0b"$!IIo6 6= 615m1D o . "YY|4 4> 4!/ %%omt&TU"0IIg& &5 &).g &/!1    &&9=9L.5RTIIi,/    zIIi,4UYYv=N3OTW   v~ U?(-f f %IIi,c599^#<=/    uyyB7d KKK!&--.}c!fEs?G H&$HHcSU;a USUS'U$[URS5=n[5(aSU;aUSUS'U$)aApply an OpenAI prompt cache breakpoint to a formatted content block. A breakpoint set directly on the block takes precedence over one nested in `extras`. Membership (not truthiness) decides whether to copy it, so a present-but-falsy value (e.g. `None`) is still preserved. prompt_cache_breakpointextras) isinstancerr) source_blockformatted_blockrs r}_apply_prompt_cache_breakpointrse!L05A %6 12  l..x88F$ ? ?!V+5;u"N!((25J5$''IIf%/eO8)<rrrrrrrrrrrrr>rr6rzGot unknown type )rr6rrrrrr)rr-r%rr!_lc_tool_call_to_openai_tool_call)_lc_invalid_tool_call_to_openai_tool_callitemsrr0r+r3rr TypeError)messager message_dictrtctool_call_supported_props tool_callkvrrr raw_audiosupported_propsmsgs r}_convert_message_to_dictrs *7??,,W$L E 9 9 = =f EER#V';''&|| VD C G\ * *% V@  GY ' '* V   !;!;@G@R@R*@R"1"5@R*"444B:"=4*L & W66 6)0)B)B<)PL &(B %".l!;*!;I#,//"3V"3$!q7U"3V!;*L & 9 9 9-4,E,Eo,VL )  l *ll.J&29&=&EL #'+__E5$''IIf%0!IIdO+S+;&s %G$=$==11':I9$w009$?@  $) !$ # G] + +&88<< x V  G_ - -) V  G[ ) )% V'.';'; ^$"D  ## Y>)5););)=V)=AU)= V "'+nw*W*^Ws6#MMM%+ M9M?M%, M,:M,M%c URS5n[[URS55n[[URS5=(d S5n0nURS5(a#[US5nSU;a UScSUS'XeS'/nURS5=n(aRUV s/sHEn [ U SRS5U SRS 5U RS5U S S 9PMG nn US :Xd U[ :Xa [ XBS 9$US:Xd U[:Xa [UUUUS9$US;d U[:XaUS:XaSS0nO0n[XBUS9$US:Xd U[:Xa [X@SUS9$US:Xd U[:Xa [X@SUS9$U(d U[:Xa [XCUS9$U"XBS 9$s sn f![ a Nf=f)z%Convert to a LangChain message chunk.rrr6rrrrr argumentsindex)rargsrrr)r6rr)r6rrtool_call_chunksrrr)r6rrrrr)r6rrr) rrrrr<KeyErrorr.r&r1r,r4r*) r default_classrrr6rrrrrtcs r}_convert_delta_to_message_chunkrs ))D/C UYYv& 'D3 ),23G  yy!!U?34 ] "}V'<'D$&M& !-:/*<00~0 * *C  Z,,V4Z,,[9wwt}g,  *   v~*;; 99 {m~=/-    &&-;M*M ; !2K @  " !7H   z].BB#G-CPP v~*::*?C   } 00sCC  11K    s%/F<3A F7>F<7F<< G G c [U[5(a>[U[5(d%S[U5S[U53n[U5eX-$[U[5(ay[U[5(d%S[U5S[U53n[U5eUR 5VVs0sH"up4U[ URUS5U5_M$ snn$[R"S[U535 U$s snnf)Nz%Got different types for token usage: z and rz!Unexpected type for token usage: ) rintr ValueErrorrr_update_token_usagerwarningswarn)overall_token_usage new_usagerrrs r}rrs )S!!-s337 ?#5.A)B(CE S/ !..)T""-t447 ?#5.A)B(CE S/ !") ) "#6#:#:1a#@!D D)   MM5d9o5FGH   s6(Dc\rSrSrSrSrg)OpenAIContextOverflowErrori:zABadRequestError raised when input exceeds OpenAI's context limit.N__name__ __module__ __qualname____firstlineno____doc____static_attributes__rrr}rr:sKrrc\rSrSrSrSrg)OpenAIAPIContextOverflowErrori>z:APIError raised when input exceeds OpenAI's context limit.rNrrrr}rr>Drrc\rSrSrSrSrg)OpenAIAuthenticationErroriBzBOpenAI authentication error classified as a LangChain model error.rNrrrr}rrBsLrrc\rSrSrSrSrg)OpenAIPermissionDeniedErroriFz>OpenAI permission error classified as a LangChain model error.rNrrrr}r r FsIrr c\rSrSrSrSrg)OpenAIInvalidRequestErroriLz?OpenAI bad-request error classified as a LangChain model error.rNrrrr}r r LsIrr c\rSrSrSrSrg)OpenAIModelNotFoundErroriPz=OpenAI not-found error classified as a LangChain model error.rNrrrr}rrPsGrrc\rSrSrSrSrg)OpenAIRateLimitErroriTz>OpenAI rate-limit error classified as a LangChain model error.rNrrrr}rrTHrrc\rSrSrSrSrg)OpenAIAPIErroriXz:OpenAI server error classified as a LangChain model error.rNrrrr}rrXrrrc\rSrSrSrSrg)OpenAIConnectionErrori\z>OpenAI connection error classified as a LangChain model error.rNrrrr}rr\rrrc\rSrSrSrSrg)OpenAITimeoutErrori`z;OpenAI timeout error classified as a LangChain model error.rNrrrr}rr`sErrcS[U5;d0SUR;d SUR;dSUR;a*[URURURS9UeSUR;aBSn[ R "U5 [URURURS9UeSUR;aS n[ R "U5 [URURURS9Ue) Ncontext_length_exceededz(Input tokens exceed the configured limitzprompt is too longContextWindowExceededErrorrresponsebodyzH'response_format' of type 'json_schema' is not supported with this modelzThis model does not support OpenAI's structured output feature, which is the default method for `with_structured_output` as of langchain-openai==0.3. To use `with_structured_output` with this model, specify `method="function_calling"`.z"Invalid schema for response_formata3Invalid schema for OpenAI's structured output feature, which is the default method for `with_structured_output` as of langchain-openai==0.3. Specify `method="function_calling"` instead or update your schema. See supported schemas: https://platform.openai.com/docs/guides/structured-outputs#supported-schemas)rrrrrrrr )rrs r}_handle_openai_bad_requestrds!SV+ 5 B 199 , '199 4(II    S  3   g'II   ,qyy8 [   g # AJJQVV   rc:[U5nSU;a*[URURURS9Ue[ U[ R5(a*[URURURS9Ue[ U[ R5(a*[URURURS9Ue[ U[ R5(a*[URURURS9Ue[ U[ R5(a*[URURURS9Ue[ U[ R 5(a*[#URURURS9Ue[ U[ R$5(a['UR5Ue[ U[ R(5(a[+URURS9Uee)Nzexceeds the context window)rrequestrr)rr )rrrr rropenaiAuthenticationErrorrrPermissionDeniedErrorr  NotFoundErrorrRateLimitErrorrInternalServerErrorrAPITimeoutErrorrAPIConnectionErrorr)r error_messages r}_handle_openai_api_errorr*sFM#}4+IIqyyqvv  !V//00'II   !V1122)II   !V))**&II   !V**++"II   !V//00QYY!&&QWXX!V++,, +2!V..//#AIIqyyIqP rcT[USS5nUcg[U5nUb X0['gg)zAdd parsed LangSmith gateway metadata to `generation_info`, if present. Args: generation_info: Generation info to mutate in place. raw_response: The raw provider response, or None. headersN)getattrrOrN)generation_info raw_responser,gateway_metadatas r}_add_gateway_metadatar1s9lIt4G.w7#9I56$r)z gpt-5-proz gpt-5.2-proz gpt-5.4-proz gpt-5.5-proz gpt-5.6-solcTU(dgUR[5=(d SU;$)NFcodex)r_RESPONSES_API_ONLY_PREFIXESrs r}_model_prefers_responses_apir6s$   != > W'ZBWWr_BM)boundr_DictOrPydanticClass_DictOrPydanticc|^\rSrSr%Sr\"SSS9rS\S'\"SSS9rS\S'\"SSS9r S\S '\"SSS9r S\S '\"S S S 9r S\S'Sr S\S'\"\ S9rS\S'\"SSS9rS\S'\"SSS 9rS\S'\"SSS 9rS\S'\"\"SSS9S9rS\S '\"SS!S 9rS"\S#'SrS$\S%'SrS&\S''SrS\S('SrS\S)'SrS&\S*'SrS$\S+'SrS&\S,'SrS-\S.'S/rS0\S1'SrS&\S2'SrS\S3'\"SS9r S&\S4'Sr!S\S5'Sr"S6\S7'Sr#S\S8'Sr$S\S9'Sr%S:\S;'Sr&S<\S='\"SSS9r'S>\S?'\"SSS9r(S>\S@'\"SSS9r)SA\SB'\"SCSSD9r*S\SE'\"SSFS 9r+SG\SH'Sr,SI\SJ'S/r-S0\SK'\"SS9r.S6\SL'Sr/SM\SN'Sr0SO\SP'Sr1S6\SQ'Sr2S\SR'Sr3S$\SS'Sr4S\ST'S/r5S0\SU'Sr6S$\SV'\"\"SWSS9S9r7S\SX'\8"SSY9r9\:SSZj5r;\:SS[j5r<\="S\S]9\>SS^j55r?\@"SES_S]9\>SS`j55rA\="S\S]9\>SSaj55rB\="S_S]9SSbj5rC\="S_S]9SScj5rDSSdjrE\:SSej5rFSSfjrGSSgjrHSShjrISSSijjrJSSSjjjrKSSSkjjrLSSSl.SSmjjjrMSSSnjjrNSSojrOSSp.SSqjjrPSSSrjjrQSSSl.SSsjjjrRSSStjjrS\:SSuj5rTSSU4SvjjjrUSSSwjjrV\:SSxj5rWSSyjrXSU4SzjjrYSSS{.SU4S|jjjjrZSSSSS}.SU4S~jjjr[SSS/SSS.SSjjjr\SSjr]SSjr^Sr_U=r`$)BaseChatOpenAIiaPBase wrapper around OpenAI large language models for chat. This base class targets [official OpenAI API specifications](https://github.com/openai/openai-openapi) only. Non-standard response fields added by third-party providers (e.g., `reasoning_content`) are not extracted. Use a provider-specific subclass for full provider support. NT)rexcluderclient async_client root_clientroot_async_client gpt-3.5-turbomodelraliasrr float | None temperature)default_factorydict[str, Any] model_kwargsapi_key)rErzCSecretStr | None | Callable[[], str] | Callable[[], Awaitable[str]]openai_api_keybase_url str | Noneopenai_api_base organizationopenai_organization OPENAI_PROXY)r openai_proxytimeoutz(float | tuple[float, float] | Any | Nonerequest_timeout bool | None stream_usage int | None max_retriespresence_penaltyfrequency_penaltyseedlogprobs top_logprobszdict[int, int] | None logit_biasFbool streamingntop_p max_tokensreasoning_effortdict[str, Any] | None reasoning verbositytiktoken_model_namezMapping[str, str] | Nonedefault_headerszMapping[str, object] | None default_queryz Any | None http_clienthttp_async_clientz%Sequence[tuple[int, int, int]] | Nonehttp_socket_optionsc[SS5$)N'LANGCHAIN_OPENAI_STREAM_CHUNK_TIMEOUT_S^@)rerrr}BaseChatOpenAI. s 5u! r)rHr=stream_chunk_timeoutstop_sequenceszlist[str] | str | NonestopzMapping[str, Any] | None extra_bodyinclude_response_headersdisabled_paramszlist[dict[str, Any]] | Nonecontext_managementlist[str] | Noneincludeprompt_cache_options service_tierstore truncationuse_previous_response_iduse_responses_apiLC_OUTPUT_VERSIONoutput_version)populate_by_namecURn[U[5(aUR5R S5$g)a Whether requests are routed through the LangSmith gateway. Detected from the resolved API key: LangSmith keys (used to authenticate to the gateway) carry the `lsv2_` prefix. Callable keys cannot be inspected without invoking them, so they are treated as non-gateway. lsv2_F)rLrr\get_secret_valuer)selfrKs r} _uses_gatewayBaseChatOpenAI._uses_gateways9%% gy ) )++-88A ArcUR$)zSame as model_name.r5rs r}rCBaseChatOpenAI.modelsrbefore)modec.[U5n[X5$)z>Build extra kwargs from additional params that were passed in.)rMrW)clsvaluesall_required_field_namess r} build_extraBaseChatOpenAI.build_extras$U S9TlTR*=(d! [ATRTR U 5US.n [BRD"S0UDU D6TlTR:RFRHTlTRJ(dTR((a/TR,(d[MTR([>U S9TlTR,=(d! [OTRTR U 5US.n [BRP"S0UDU D6Tl)TRRRFRHTl%T$)z?Validate that api key and python package exists in environment.Nrzn must be at least 1.zn must be 1 when streaming. OPENAI_ORG_IDOPENAI_ORGANIZATIONz openai/v1OPENAI_API_BASEOPENAI_API_KEY)rMrK provider_path base_url_env api_key_envc3@># UHn[TUS5SLv M g7fr)r-).0keyrs r} 6BaseChatOpenAI.validate_environment..Os*    D#t $ , s)rWrSr>r@r?rArlrmOPENAI_BASE_URLT)rPrMrTrjrkrYzwCannot specify 'openai_proxy' if one of 'http_client'/'http_async_client' is already specified. Received: openai_proxy=z http_client=z http_async_client=)rnrlrmrSr)rS)proxyrysocket_options)rlrK)*rbrrarQosgetenvrPrOrLrMrKbase_url_from_gatewayallenvironrWrjrUrjrkrYrSrlrmrkrnrhrirlr>r@rdr|rgr!OpenAIr completionsr?rcrf AsyncOpenAIrA) rr_gateway_config_base_url_from_gatewaysync_api_key_valueasync_api_key_value client_paramsrSrlrmresolved_socket_options sync_specificasync_specifics ` r}validate_environment#BaseChatOpenAI.validate_environment0s 66 $&&1*)CS/ ! 66 $&&1*/CS/ !  $ $ 0yy) 0yy./  2))''%*(   /77-55!0!F!F       #$$,1B"**1T $D >BIM    *7W##7 3  !44,,++#33!//      '+/+;+;M- (   $"2"2d6L6L,,L**K $ 6 6 !/K>1F4E3GI  S/ ! 6 $ 8 8(("44**  IK # & (&=d>V>V&W # ''d6G6G {{!)# #' $$T-=-='G"//1'>(D$ $(#3#3$0,,,,/ 2! $*==#R=#RM#R "..33??     )?)?)J++-#:*& $55 2((((+ /N&,%7%7&& &D "!% 6 6 ; ; G GD  rc>[UR5=(d S$r)rrrs r}_resolve_model_profile%BaseChatOpenAI._resolve_model_profiles)$//:BdBrc0SUR_SUR_SUR_SUR_SUR_SUR _SUR _SUR=(d S _S UR_S UR_S UR_S UR_SUR_SUR_SUR_SUR_SUR _UR"UR$UR&UR(S.EnUR*UR,S.UR/5VVs0sH up#UcM X#_M snnEUR0E$s snnf)2Get the default parameters for calling OpenAI API.rZr[r\rcr]r^r_rvNrdrwrbrGrergrhrzr|)r}r~rr)rCstream)rZr[r\rcr]r^r_rvrdrwrbrGrergrhrzr|r}r~rrrrarrJ)rexclude_if_nonerrs r}_default_paramsBaseChatOpenAI._default_paramss  5 5 !7!7  DII  TZZ    D--   $//  DII%  $//  $//    4++   5 5     !$"9"9! " t||# $%)$=$= --//ZZ+ 2__nn !0 5 5 7I 71tqt 7I    Js E&E&c"0nSnUHknUcMURS5nUb9UR5H%upgUcM Xb;a[X&U5X&'M!XrU'M' UbMZURS5nMm X RS.nU(aX8S'U$)N token_usagesystem_fingerprint)rr)rrrr) r llm_outputsrroutputrrrcombineds r}_combine_llm_outputs#BaseChatOpenAI._combine_llm_outputss$&!!F~ **]3K&'--/DAy /1D/2A2+.23A.0")%+ZZ0D%E"!""$7ooV -?) *rcURS5S:XagURS5nURS/5=(d" URS05RS/5nU(a[XARS55OSn[U5S:Xa:[U"SUS 9US 9nURS :XaS UR R S 'U$USnUS cg[US U5n U(a0UEO0n URS5=n (aXXS'URS5=n (aXS'URS5=n (aXS'URS5=n(aXS'URS5nU(aXS'U(a[U [5(aXil SU R S'URS :XaS U R S '[X=(d SS 9$)Nrz content.deltausagechoiceschunkr~rr)r6usage_metadatarr.v1rdelta finish_reasonrCrrr]r!model_provider) r_create_usage_metadatalenrDrrresponse_metadatarrr&r)rrdefault_chunk_classbase_generation_inforrrgeneration_chunkchoice message_chunkr.rrrr~r]s r}"_convert_chunk_to_generation_chunk1BaseChatOpenAI._convert_chunk_to_generation_chunks 99V  /ii( IIi $ 9yy"%)))R8  #; .0I J  w<1 2+B~V 4  ""d*OS ((::;KL# # '? "7 7O0 7K212PR"JJ7 7= 7//::j) *2J ' jGG+9 (r)rrs r}_ensure_sync_client_available,BaseChatOpenAI._ensure_sync_client_availableEs( ;; Q  S/ ! rc +L# UR5 SUS'UR"U4SU0UD6n0n0nUR(dUR(atURR R R"S 0UD6nUR5n UR(aS[UR50n[Xx5 O&URR R"S 0UD6n URS5n U n Sn Sn SnSnSnU HnU (aUO0n[UU UUU UUURS9un nnnU(dM6U (a%U(a0UEUR=(d 0EUlU(aUR!UR"US 9 Sn S UR$R&;aSnUv M SSS5 g!,(df  g=f![(R*an[-U5 SnAgSnAf[(R.an[1U5 SnAgSnAff=f7f) NTrrvr,response_formatFschemametadata has_reasoningrrrgr)r_get_request_payloadrxrr@with_raw_responsercreateparserr,r1r,_convert_responses_chunk_to_generation_chunkrr.on_llm_new_tokenrrrr!BadRequestErrorrAPIErrorr*rmessagesrv run_managerkwargspayloadr,rraw_context_managercontext_manageroriginal_schema_objris_first_chunk current_indexcurrent_output_indexcurrent_sub_indexrrrrrs r}_stream_responses BaseChatOpenAI._stream_responsesOs **,x++HJ4J6J%'5 (,,0B0B$$66@@GGR'R$#6";";"=00($/B/J/J*KLG%&:P"&"2"2"<"<"C"C"Ng"N"(**->"?  H!% " ')$$&! % %E*8wbH E%,)2!)&3'+':':  %,)((').B@"6@#3#C#C#Ir@,<''88 0 5 5=M9*/&*:*B*B*T*TT,0M..=& !J%% * &q ) ) ( $Q ' ' (sl/H$CG?GA3G7G?H$ G G H$GH!% G50H$5H! HH$H!!H$c # SUS'UR"U4SU0UD6n0n0nUR(dUR(a|URRR R "S 0UD6IShvN nUR5n UR(aS[UR50n[Xx5 O.URR R "S 0UD6IShvN n URS5n U IShvN n Sn Sn SnSnSn[U URURS9ShvN nU (aUO0n[UU UUU UUUR S 9un nnnU(dM<U (a%U(a0UEUR"=(d 0EUlU(a"UR%UR&US 9IShvN Sn S UR(R*;aSnU7v MGNrGNNNN3 SSS5IShvN g!,IShvN (df  g=f![,R.an[1U5 SnAgSnAf[,R2an[5U5 SnAgSnAff=f7f) NTrrvr,rrFr5rrrgr)rrxrrArrrrrr,r1rrbrtrrrr.rrrrr!rrrr*rs r}_astream_responses!BaseChatOpenAI._astream_responsesso x++HJ4J6J%'= (,,0B0B00BBLLSS!$ #6";";"=00($/B/J/J*KLG%&:P(,(>(>(H(H(O(O))##)**->"? &(!% " ')$$&! % #>--#$"/% +9wbH E%,)2!)&3'+':':  %,)((').B@"6@#3#C#C#Ir@,<'"-">"> 0 5 5=M#?#*/&*:*B*B*T*TT,0M..m# ' "/89$ 'R%% * &q ) ) ( $Q ' ' (sI5AH"7G)8A1H")G,*H"G/H" *H3G57G18G5;0H/AH?G3)H)H",H"/H"1G53H5H6 H"HH"I5HH  HH"I5H""I26 II5I2 I-(I5-I22I5c  UURS05RS5URRS05RS5UR/nUHn[U[5(dMUs $ UR=(d S$)zDetermine whether to include usage metadata in streaming output. For backwards compatibility, we check for `stream_options` passed explicitly to kwargs or in the `model_kwargs` and override `self.stream_usage`. stream_options include_usageF)rrJrWrr`)rrWr stream_usage_sourcesrs r}_should_stream_usage#BaseChatOpenAI._should_stream_usages  JJ' , 0 0 A    ! !"2B 7 ; ;O L      +F&$'' +  )E)r)rWc+# UR5 SUS'UR"U40UD6nU(aSU0US'UR"U4SU0UD6n[n0nSU;auUR(a[ R "S5 URS5 URRRRR"S0UD6n U n OUR(dUR(ajURRR "S0UD6n U R#5n UR(aS[%U R&50n[)X5 OURR "S0UD6n U n U n Sn U Hn[+U[$5(dUR-5nUR/UUU (aUO05nUcMIUR0R2nUR4=(d 0R7S 5nU(aUR9UR:UUS 9 S n Uv M SSS5 [GW S 5(aNSU;aGU RI5nURKU5nU(aUR9UR:US 9 Uv ggg!,(df  Nn=f![<R>an[AU5 SnANSnAf[<RBan[EU5 SnANSnAff=f7f)NTrrrrvrLCannot currently include response headers when response_format is specified.r,r]rr]Fget_final_completionrr)&rrrr&rxrrrr@betarrrrr>rrrrr,r1r model_dumprr __class__r.rrrr!rrrr*hasattrr"%_get_generation_chunk_from_completionrr rvr rWr r rrresponse_streamrr/rrrrr]rfinal_completions r}_streamBaseChatOpenAI._streams **,x00HH (7'FF# $++HJ4J6J6D!/ ( G+00MM8 H%"&"2"2"7"7"<"<"H"H"O"O###200D4F4F#';;#@#@#G#G#R'#RL+113H44094 @T@T;U/V,)*>M#{{11,B($ (/ *:*B*B*L*L' 0 @ @ FBKKJWH"#44,11"2%-5 &+N**'&!4 83 4 49Jg9U'<<> #II   ,,$))1A-# ":V 45!,%% * &q ) ) ( $Q ' ' (siAK>D'J+>B4J2J+:A K> J($J+'K>(J++K;? K K>K;& K61K>6K;;K>c UR5 UR"U4SU0UD6nSnSnSU;a]URS5 URRR R R"S0UD6nUR5nGOURU5(GaHURS5n U (aA[U 5(a1URRR R"S0UD6nO0URRR R"S0UD6nUR5nUR(aS[UR50nU=(d 0n[!Xg5 UR["S5n [%UU UUR&S9n U b@U R(H0n U R*=(d 0U lU U R*["'M2 U $UR,R R"S0UD6nUR5nUR(a+Ub([;US5(aS[UR50nU=(d 0n[!Xg5 URAWU5$![.R0an [3U 5 Sn A NSn A f[.R4an [7U 5 Sn A NSn A f[8a,n Ub"[;US5(aUR<U lU eSn A ff=fNrvrrr,)rrr http_responser)!rrrr@rrrr_use_responses_apir_is_pydantic_classrrrxrr,r1rN'_construct_lc_result_from_responses_apir generationsr.r>r!rrrr*rr&r/r_create_chat_resultrr rvr r r r.r/rrr0result generationrs r} _generateBaseChatOpenAI._generate<s **,++HJ4J6J 2  G+ H%$$))55GGMMXPWX(--/((11&,jj1B&C#&+=>Q+R+R#'#3#3#=#=#O#O#U#U$!$L$(#3#3#=#=#O#O#V#V$!$L(--/00'0$|7K7K2L&MO"1"7R%oD$3#6#614$ A.,#'#6#6  $/&,&8&8 5?5O5O5USU 2,#223PQ'9  #{{<<CCNgN '--/  ) )( i00($|/C/C*DEO)/Ro<''/BB!%% * &q ) ) ( $Q ' ' 'GL/,R,R)77 G s=A!JEJ-6JL  J,,L  K L  'LL cN[UR[5(a UR$URS:Xd_URcRUR cEUR c8URc+UR(d[UR5(ag[U5$)N responses/v1T) rrr`rrzr|rgrrr6rr0)rr s r}r0!BaseChatOpenAI._use_responses_apis d,,d 3 3)) )   > 1&&2||'~~)*,,+DOO<<!'**rrvc URU5R5nUbX#S'0UREUEnURU5(aOUR(a0[ U5upgU(aUOUnU(aXuS'[ X5nU$[ XE5nU$UV s/sH7n [U [5(a[[U 55O [U 5PM9 sn US'U$s sn f)Nrvprevious_response_idr ) _convert_input to_messagesrr0r_get_last_messages _construct_responses_api_payloadrr%rrm) rinput_rvr r r  last_messagesr?payload_to_usems r}r#BaseChatOpenAI._get_request_payloads&&v.::<  !6N4T))4V4  " "7 + +,,6H6R3 2FH'6J23:>S;8M" #"Aa++))Ma)PQ-a01" #GJ   #s =C%c/n[U[[R-5(dH[ U5n[ U5S:aUSSS3nS[ U5RSU3n[U5e[U[5(aUOURSSSS1000S S 9nURS 5(a[URS 55eUSnUc'S [UR553n[U5eURS5n URS5n UHn [U S5n U (a%[U [ 5(a[#X5U lU=(d 0nU RS5bU RS5OURS5US'SU ;aU SUS'['XS9n UR)U 5 M U SURSUR*5URSS5S.nSU;aUSUS'U (aXS'[U[R5(a[-USS5(aUR.SR0n [3U S5(a&U R4USR0R6S'[3U S5(a&U R8USR0R6S'[;X>S9$![a$nS UR53n[U5UeSnAff=f)Nz...zcUnexpected response type from OpenAI-compatible endpoint. Expected a dict or openai.BaseModel, got z: r__all__rparsedF)r=rerrorz Response missing 'choices' key: zReceived response with null value for 'choices'. This can happen when using OpenAI-compatible APIs (e.g., vLLM) that return a response in an unexpected format. Full response keys: rr~rr]rr!rCrr)rrrrrrrefusal)r3 llm_output)rrr!rYreprrrrrr$rrkeysrrrr%rrrCrrr-rrr&rLrrNrE)rrr.r3previewr response_dictrrrr~resrgenrOs r}r4"BaseChatOpenAI._create_chat_results'  (D6+;+;$;<<8nG7|c!$Tc]O3/<>**+2gY8  S/ !(D)) $$"YXJ0G$HI%    W % %]..w78 8 '#I.G ? '(,M,>,>,@'A&BD  C. #''0 $((8 C.s9~>Gz'9==)?*&.3O77?+7($((9 O , S .1*o + RC   s #"'&'++GT__E"/"3"34H""M  = ,T2Jt  )5~ & h 0 0 1 1g i7 7 &&q)11Gw))EL^^ A&&88Bw **FMoo A&&88CkIIo '4]5G5G5I4JKC3-Q & 'sK L#LLc # SUS'UR"U40UD6nU(aSU0US'UR"U4SU0UD6n[n0nSU;auUR(a[R "S5 UR S5 URRRRR"S0UD6n U n OUR(dUR(arURRR"S0UD6IShvN n U R!5n UR(aS[#U R$50n['X5 O$URR"S0UD6IShvN n U n U IShvN n Sn [)U UR*UR,S 9ShvN n[/U["5(dUR15nUR3UUU (aUO05nUcMOUR4R6nUR8=(d 0R;S 5nU(a#UR=UR>UUS 9IShvN S n U7v MGNWNNNN SSS5IShvN Om!,IShvN (df  OV=f![@RBan[EU5 SnAO/SnAf[@RFan[IU5 SnAOSnAff=f[KW S 5(aaSU;aZU RM5IShvN nUROU5nU(a#UR=UR>US9IShvN U7v ggg7f)NTrrrrvrr r,r5r]r!Fr"rr)(rrr&rxrrrrAr#rrrrr?rrrrr,r1rbrtrrr$rrr%r.rrrr!rrrr*r&r"r'r(s r}_astreamBaseChatOpenAI._astreams" x00HH (7'FF# $++HJ4J6J6D!5 ( G+00MM8 H%"&"8"8"="="B"B"N"N"U"U###200D4F4F)-):):)L)L)S)S*!*$L ,113H44094 @T@T;U/V,)*>M%)%6%6%=%=%H%HHH"*&(!%#>--#$+% &eT22 % 0 0 2'+'N'N+0>,B($ (/ *:*B*B*L*L' 0 @ @ FBKKJWH")::,11"2%-; &+N**G$ I&+"#$'4%% * &q ) ) ( $Q ' ' ( 83 4 49Jg9U%-%B%B%DDD #II   !22$))1A3# ":V 4sAM"CJ I$A'J5I'6 JI)J"J(I/,I+-I/0B&JI- J$J'J)J+I/-J/J0 J;I><JM"JJ JJM"JK,0 K;M"K, K'"M"'K,,-M"L:M"M M"cP# UR"U4SU0UD6n0nSnSU;aeURS5 URRRR R "S0UD6IShvN nUR 5nGOURU5(GaMURS5n U (aI[U 5(a9URRR R "S0UD6IShvN nO8URRR R"S0UD6IShvN nUR 5nUR(aS[UR50n[Xg5 UR[ S5n [#UU UUR$S9n U b@U R&H0n U R(=(d 0U lU U R([ 'M2 U $UR*R R"S0UD6IShvN nUR 5nUR(a+Ub([9US5(aS[UR50n[Xg5 [?SUR@WU5IShvN $GN!GNGNeN![,R.an [1U 5 Sn A NSn A f[,R2an [5U 5 Sn A NSn A f[6a,n Ub"[9US5(aUR:U lU eSn A ff=fN7fr.)!rrrArrrrr0rr1rrrxrr,r1rNr2rr3r.r?r!rrrr*rr&r/rrJr4r5s r} _agenerateBaseChatOpenAI._ageneratees++HJ4J6J 7  G+ H%%)%;%;%@%@%L%L%^%^%d%d&&  (--/((11&,jj1B&C#&+=>Q+R+R"44>>PPVV%!#44>>PPWW%! (--/00'0$|7K7K2L&MO%oD$3#6#614$ A.,#'#6#6  $/&,&8&8 5?5O5O5USU 2,#223PQ'9  %)%6%6%H%H%O%O&&  (--/  ) )( i00($|/C/C*DEOo<$ $**Ho   y  6 %% * &q ) ) ( $Q ' ' 'GL/,R,R)77 G  sL&AJ1J2JL&A2J:J;8J3J4B7J+L&,)JJJ*A#L& L$L&JJJJL!1 K<L&L! K(#L&( L!5'LL!!L&c6SUR0URE$)zGet the identifying parameters.r)rrrs r}_identifying_params"BaseChatOpenAI._identifying_paramssdooF1E1EFFrc >SUR0[TU] US9EUREUEnUR S5=n(av[ U[ 5(aaSnUVVs/sHMn[ U[5(a3UR S5S:Xa0UEUVs0sH nXv;dM US_M snEOUPMO snnUS'U$s snfs snnf)z,Get the parameters used to invoke the model.rCr=tools)r, authorizationrrz **REDACTED**)rsuper_get_invocation_paramsrrrrr) rrvr paramsrasensitive_fieldsrfieldr%s r}rd%BaseChatOpenAI._get_invocation_paramss T__ g,$,7 ""   ZZ( (E (j.E.E; " "DdD))dhhv.>%.G&6%5E =.~-%5 " F7O  s6CB;!B;( C;Cc UR"S SU0UD6n[SURSUR5SURSUR5S9nURSUR 5=(d URSUR 5=n(aXTS 'U=(d URSS 5=n(aXdS 'U$) z Get standard params for tracing.rvr!rCrrG) ls_provider ls_model_name ls_model_typels_temperaturerdmax_completion_tokens ls_max_tokensNls_stopr)rdr$rrrGrd)rrvr re ls_paramsrorps r}_get_ls_paramsBaseChatOpenAI._get_ls_paramss,,A$A&A#  **Wdoo> !::mT5E5EF  #JJ|T__E  #T__J  = *7o &6fjj6 67 6#*i rcg)zfReturn type of chat model. Will always return `'openai-chat'` regardless of the specific model name. z openai-chatrrs r} _llm_typeBaseChatOpenAI._llm_types rc&URb URnO URn[R"U5nX4$![aE UR 5nSnUR S5(aSn[R"U5nX4$f=f)N cl100k_base)zgpt-4ozgpt-4.1r o200k_base)rirtiktokenencoding_for_modelrrr get_encoding)rrCencodingrencoders r}_get_encoding_model"BaseChatOpenAI._get_encoding_models  # # /,,EOOE 62259H  6++-K#G%%&DEE&,,W5H  6sAA BBc>URbURU5$[RSS::a[TU]U5$UR 5up#UR U5$)z9Get the tokens present in the text with tiktoken package.r)custom_get_token_idssys version_inforc get_token_idsrencode)rr_encoding_modelr%s r}rBaseChatOpenAI.get_token_idsse  $ $ 0,,T2 2   A ! #7(. . 446$$T**r)allow_fetching_imagesc >Ub[R"S5 [RSS::a[TU]U5$UR 5upEURS5(aSnSnO,URS5(aSnSnOS US 3n[U5eS n UV s/sHn [U 5PM n n U GHn X- n U R5GHupU S :XaU S- n M[U[5(Ga>UGH6n[U[5(d US S:Xa;[U[5(aUSOUnU [UR!U55- n M]US S:XaOUSR#S5S:XaU S- n MU(a'[%USS5nU(dMU ['U6- n MMUS S:XaIU [UR!USS55- n U [UR!USS55- n GMUS S:Xa[R"S5 GM)SU3n[)U5e O0U(dGMqU [UR![U555- n U S:XdGMX- n GM GM U S- n U $s sn f)aCalculate num tokens for supported OpenAI chat models. !!! warning You must have the `pillow` installed if you want to count image tokens if you are specifying the image as a base64 string, and you must have both `pillow` and `httpx` installed if you are specifying the image as a URL. If these aren't installed image inputs will be ignored in token counting. [OpenAI reference](https://github.com/openai/openai-cookbook/blob/main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb). Args: messages: The message inputs to tokenize. tools: If provided, sequence of `dict`, `BaseModel`, function, or `BaseTool` to be converted to tool schemas. allow_fetching_images: Whether to allow fetching images for token counting. zECounting tokens in tool schemas is not yet supported. Ignoring tools.rrzgpt-3.5-turbo-0301r)rBgpt-4rro3o4zFget_num_tokens_from_messages() is not presently implemented for model z. See https://platform.openai.com/docs/guides/text-generation/managing-tokens for information on how messages are converted to tokens.rrrrrdetaillowUrrrrfilezEToken counts for file inputs are not supported. Ignoring file inputs.z!Unrecognized content block type )rrrrrcget_num_tokens_from_messagesrrNotImplementedErrorrrrrrrrrr _url_to_size_count_image_tokensr)rr rarrCr}tokens_per_messagetokens_per_namer num_tokensrG messages_dictrrrvalr image_sizer%s r}r+BaseChatOpenAI.get_num_tokens_from_messages s0   MMW    A ! #77A A224   0 1 1!"  O   S T T!" O"G$LL  &c* * >FGh1!4h G$G  ,J%mmo .(!OJeT**$%c3//3v;&3H2U.V*WWJ [F2$MM!8 %Hu"MC",S/19 %:#hooc%j&A"BBJ&=1JY.%` a eHs J) tool_choicestrictparallel_tool_callsrc X>UbXFS'U(aUSLaUR(dSnUVs/sH n[XsS9PM nn[XSS9Hup[U [5(dM[ U S5(dM/[U R [5(dMP[H%n XR ;dMU R U X'M' M /n UH>nSU;aU RUSS5 M"SU;aU RUS5 M>M@ U(a}[U[5(a&X,;aSSU0S .nOWU[;aS U0nOHUS :XaS nO?O>[U[5(aS nO&[U[5(aOS U3n [U 5eX&S'U(aw[U[5(aVURS 5S:XaASURS05;a+USRSS5n[[USS5n[!XSS9US'["TU]H"SSU0UD6$s snf)aBind tool-like objects to this chat model. Assumes model is compatible with OpenAI tool-calling API. Args: tools: A list of tool definitions to bind to this chat model. Supports any tool definition handled by [`convert_to_openai_tool`][langchain_core.utils.function_calling.convert_to_openai_tool]. tool_choice: Which tool to require the model to call. Options are: - `str` of the form `'<>'`: calls `<>` tool. - `'auto'`: automatically selects a tool (including no tool). - `'none'`: does not call a tool. - `'any'` or `'required'` or `True`: force at least one tool to be called. - `dict` of the form `{"type": "function", "function": {"name": <>}}`: calls `<>` tool. - `False` or `None`: no effect, default OpenAI behavior. strict: If `True`, model output is guaranteed to exactly match the JSON Schema provided in the tool definition. The input schema will also be validated according to the [supported schemas](https://platform.openai.com/docs/guides/structured-outputs/supported-schemas?api-mode=responses#supported-schemas). If `False`, input schema will not be validated and model output will not be validated. If `None`, `strict` argument will not be passed to the model. parallel_tool_calls: Set to `False` to disable parallel tool use. Defaults to `None` (no specification, which allows parallel tool use). response_format: Optional schema to format model response. If provided and the model does not call a tool, the model will generate a [structured response](https://platform.openai.com/docs/guides/structured-outputs). kwargs: Any additional parameters are passed directly to `bind`. NrFTrrrrrrranyrequiredzEUnrecognized tool_choice type. Expected str, bool or dict. Received: r json_schemarrrrar)rrRziprrKr&rr_TOOL_EXTRAS_PASSTHROUGHrrWellKnownToolsr`rrr"_convert_to_openai_response_formatrcbind)rrarrrrr rformatted_toolsoriginal formattedr tool_namesrr%s r} bind_toolsBaseChatOpenAI.bind_toolsm s6L  *,?( ) vU24;Q;QFDI DID "4 7E  $'ue#L H8X..Hh//x553Coo-)1)= 4 $M #DT!!!$z"26":;4!!$v,/ $ +s++, *%+[$9#K!N2#);"7K!E)",KK..( K..!!, /!o%$/= ! ?D11#''/=@ 3 3M2 FF)7;;HdK"&t_]-KH-U"V(J)F$ %w| str: """Get weather at a location.""" pass model = init_chat_model("openai:gpt-5.5") structured_model = model.with_structured_output( ResponseSchema, tools=[get_weather], strict=True, include_raw=True, ) structured_model.invoke("What's the weather in Boston?") ``` ```python { "raw": AIMessage(content="", tool_calls=[...], ...), "parsing_error": None, "parsed": None, } ``` kwargs: Additional keyword args are passed through to the model. Returns: A `Runnable` that takes same inputs as a `langchain_core.language_models.chat.BaseChatModel`. If `include_raw` is `False` and `schema` is a Pydantic class, `Runnable` outputs an instance of `schema` (i.e., a Pydantic object). Otherwise, if `include_raw` is `False` then `Runnable` outputs a `dict`. If `include_raw` is `True`, then `Runnable` outputs a `dict` with keys: - `'raw'`: `BaseMessage` - `'parsed'`: `None` if there was a parsing error, otherwise the type depends on the `schema` as described above. - `'parsing_error'`: `BaseException | None` !!! warning "Behavior changed in `langchain-openai` 0.3.12" Support for `tools` added. !!! warning "Behavior changed in `langchain-openai` 0.3.21" Pass `kwargs` through to the model. json_modez. sRVr)rL parsing_errorcgrrrs r}rrr sdr)rLr) exception_key)rr)rr1 issubclass BaseModelV1rrrrrR_filter_disabled_paramsrr@r?rr>r=rrrGr _oai_structured_outputs_parserrr with_typesrIassignrwith_fallbacksrH)rrrrrrar ris_pydantic_schema tool_name bind_kwargsllm output_parserrt parser_assign parser_noneparser_with_fallbacks r}with_structured_output%BaseChatOpenAI.with_structured_output sJR  &K"7PCS/ !/7 ] "#z&+'F'F ? ,**733??--h77??g- A$//ARS??, ' '~%!o%.v6zB6JI66 #,+0$-3"F"(4   K//6(:k:C!*=!($(+ !9&! { ")) (. '>#+V"4"(4   C&%V<%'  } $~%!o%@WO $3-3"F"8"@1   KFK(FK*1> >""5(s#Kc UR(dU$0nUR5H<up4X0R;a$URUbX@RU;aM8XBU'M> U$r)ryr)rr filteredrrs r}r&BaseChatOpenAI._filter_disabled_params se##MLLNDA((($$Q'/18L8LQ8O3OQK#rcDURU5nURSRn[U[5(a8UR nSUR ;aUR RS5 OSn[SUR US9n[XRRS9$)zDGet chunk from completion (e.g., from final completion of a stream).rrNr)r6rrr) r4r3rrr%rrrr&rDrO)r completion chat_result chat_messagerrs r}r'4BaseChatOpenAI._get_generation_chunk_from_completion s..z: "..q199 lI . .)88N|===..22<@!N *<<)  #-C-C  r) r?r>rmrlrOrLrQrAr@rWreturnr`)rr)rrIrr)rrFrrF)rr`)rzModelProfile | NonerrI)rzlist[dict | None]rr)rrrrr dict | NonerzChatGenerationChunk | None)rNone)NN) r list[BaseMessage]rvr{r CallbackManagerForLLMRun | Noner rrIterator[ChatGenerationChunk]) r rrvr{r $AsyncCallbackManagerForLLMRun | Noner rr"AsyncIterator[ChatGenerationChunk]r)rWrVr rrr`) r rrvr{r rrWrVr rrr) r rrvr{r rr rrrEr rrr`rDr!rvr{r rrr)rzdict | openai.BaseModelr.rrrE) r rrvr{r rrWrVr rrr) r rrvr{r rr rrrE)rvr{r rrrI)rvr{r rrr$)rztuple[str, tiktoken.Encoding])rrrz list[int])r Sequence[BaseMessage]raz__annotations__r?r@rArrGrrJrLrOrQrXrSrUrWrYrZr[r\r]r^r_rarbrcrdrergrhrirjrkrlrmrnrtrvrwrxryrzr|r}r~rrrrrrZ model_configpropertyrrCr_ classmethodrr^rrrrrrrrrrrrr+r8r0rr4rXr[r^rdrrrurrrrrrr'r __classcell__r%s@r}r<r<sd3FC3dD9L#9T48K8"4>s>O7CJC $K$+#(#>L.>V It,K-/b#(J"GOZG ',D&OON % > L*AFIAO= !%L+$ #K"<%)l)$&*|*;D* Hk %#L*# )-J%,PIt/AzAE<D"40J 0/#'j'<(,I$+ !Iz '+* 15O-415M.5$D$?K? %*$$EzE BGdB><|*/  *, "H$)=M#ND N!+/J(/(&+d* .34-@O*@ 7;3:!%G $ 37/6 $L*#E;"J !&+d*<&*{)"' !4dC"NJ"t4L   (#E$E +':;&(#$<'" # '"M#M^C  B2E E "E * E $ E N""&7; A(#A(A(5 A(  A( ' A(L"&<@ H(#H(H(: H(  H( , H(V+/*'*:=* *,"&7; K# %) K##K#K#5 K# " K#K# 'K#`"&7; FC#FCFC5 FC  FC  FCP +&"& "     D(,_J)_J%_J  _JH"&<@ P# %) P##P#P#: P# " P#P# ,P#j"&<@ K #K K : K  K  K ZGG (,$7: <(,$7: & +OSb '+ b'bLb $ b bbP15"+/7;k=Dk=. k=  k= ) k=5k=k= 1k=k=^/3F# !"!F#+F# F#F#F#F#F# 7F#P  *   rr<c6^\rSrSr%Sr\"SSS9rS\S'\SSj5r \ SS j5r \SS j5r \ SS j5r \SU4S jj5rSS .SU4SjjjrSU4SjjrSU4SjjrSSSSSS.SU4SjjjjrSrU=r$) ChatOpenAIi ukInterface to OpenAI chat model APIs. !!! warning "API scope" `ChatOpenAI` targets [official OpenAI API specifications](https://github.com/openai/openai-openapi) only. Non-standard response fields added by third-party providers (e.g., `reasoning_content`, `reasoning_details`) are **not** extracted or preserved. If you are pointing `base_url` at a provider such as OpenRouter, vLLM, or DeepSeek, use the corresponding provider-specific LangChain package instead (e.g., `ChatDeepSeek`, `ChatOpenRouter`). ???+ info "Setup" Install `langchain-openai` and set environment variable `OPENAI_API_KEY`. ```bash pip install -U langchain-openai # or using uv uv add langchain-openai ``` ```bash export OPENAI_API_KEY="your-api-key" ``` ??? info "Key init args — completion params" | Param | Type | Description | | ------------------- | ------------- | ----------------------------------------------------------------------------------------------------------- | | `model` | `str` | Name of OpenAI model to use. | | `temperature` | `float` | Sampling temperature. | | `max_tokens` | `int | None` | Max number of tokens to generate. | | `logprobs` | `bool | None` | Whether to return logprobs. | | `stream_options` | `dict` | Configure streaming outputs, like whether to return token usage when streaming (`{"include_usage": True}`). | | `use_responses_api` | `bool | None` | Whether to use the responses API. | See full list of supported init args and their descriptions below. ??? info "Key init args — client params" | Param | Type | Description | | -------------- | ------------------------------------------ | ----------------------------------------------------------------------------------- | | `timeout` | `float | Tuple[float, float] | Any | None` | Timeout for requests. | | `max_retries` | `int | None` | Max number of retries. | | `api_key` | `str | None` | OpenAI API key. If not passed in will be read from env var `OPENAI_API_KEY`. | | `base_url` | `str | None` | Base URL for API requests. Only specify if using a proxy or service emulator. Falls back to env var `OPENAI_API_BASE`, then to `OPENAI_BASE_URL` (read by the underlying SDK client). | | `organization` | `str | None` | OpenAI organization ID. If not passed in will be read from env var `OPENAI_ORG_ID`. | See full list of supported init args and their descriptions below. ??? info "Instantiate" Create a model instance with desired params. For example: ```python from langchain_openai import ChatOpenAI model = ChatOpenAI( model="...", temperature=0, max_tokens=None, timeout=None, max_retries=2, # api_key="...", # base_url="...", # organization="...", # other params... ) ``` See all available params below. !!! tip "Preserved params" Any param which is not explicitly supported will be passed directly to [`openai.OpenAI.chat.completions.create(...)`](https://platform.openai.com/docs/api-reference/chat/create) every time to the model is invoked. For example: ```python from langchain_openai import ChatOpenAI import openai ChatOpenAI(..., frequency_penalty=0.2).invoke(...) # Results in underlying API call of: openai.OpenAI(..).chat.completions.create(..., frequency_penalty=0.2) # Which is also equivalent to: ChatOpenAI(...).invoke(..., frequency_penalty=0.2) ``` ??? info "Invoke" Generate a response from the model: ```python messages = [ ( "system", "You are a helpful translator. Translate the user sentence to French.", ), ("human", "I love programming."), ] model.invoke(messages) ``` Results in an `AIMessage` response: ```python AIMessage( content="J'adore la programmation.", response_metadata={ "token_usage": { "completion_tokens": 5, "prompt_tokens": 31, "total_tokens": 36, }, "model_name": "gpt-4.1-mini", "system_fingerprint": "fp_43dfabdef1", "finish_reason": "stop", "logprobs": None, }, id="run-012cffe2-5d3d-424d-83b5-51c6d4a593d1-0", usage_metadata={"input_tokens": 31, "output_tokens": 5, "total_tokens": 36}, ) ``` ??? info "Stream" Stream a response from the model: ```python for chunk in model.stream(messages): print(chunk.text, end="") ``` Results in a sequence of `AIMessageChunk` objects with partial content: ```python AIMessageChunk(content="", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk(content="J", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk(content="'adore", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk(content=" la", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk( content=" programmation", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0" ) AIMessageChunk(content=".", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk( content="", response_metadata={"finish_reason": "stop"}, id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0", ) ``` To collect the full message, you can concatenate the chunks: ```python stream = model.stream(messages) full = next(stream) for chunk in stream: full += chunk ``` ```python full = AIMessageChunk( content="J'adore la programmation.", response_metadata={"finish_reason": "stop"}, id="run-bf917526-7f58-4683-84f7-36a6b671d140", ) ``` ??? info "Async" Asynchronous equivalents of `invoke`, `stream`, and `batch` are also available: ```python # Invoke await model.ainvoke(messages) # Stream async for chunk in (await model.astream(messages)) # Batch await model.abatch([messages]) ``` Results in an `AIMessage` response: ```python AIMessage( content="J'adore la programmation.", response_metadata={ "token_usage": { "completion_tokens": 5, "prompt_tokens": 31, "total_tokens": 36, }, "model_name": "gpt-4.1-mini", "system_fingerprint": "fp_43dfabdef1", "finish_reason": "stop", "logprobs": None, }, id="run-012cffe2-5d3d-424d-83b5-51c6d4a593d1-0", usage_metadata={ "input_tokens": 31, "output_tokens": 5, "total_tokens": 36, }, ) ``` For batched calls, results in a `list[AIMessage]`. ??? info "Tool calling" ```python from pydantic import BaseModel, Field class GetWeather(BaseModel): '''Get the current weather in a given location''' location: str = Field( ..., description="The city and state, e.g. San Francisco, CA" ) class GetPopulation(BaseModel): '''Get the current population in a given location''' location: str = Field( ..., description="The city and state, e.g. San Francisco, CA" ) model_with_tools = model.bind_tools( [GetWeather, GetPopulation] # strict = True # Enforce tool args schema is respected ) ai_msg = model_with_tools.invoke( "Which city is hotter today and which is bigger: LA or NY?" ) ai_msg.tool_calls ``` ```python [ { "name": "GetWeather", "args": {"location": "Los Angeles, CA"}, "id": "call_6XswGD5Pqk8Tt5atYr7tfenU", }, { "name": "GetWeather", "args": {"location": "New York, NY"}, "id": "call_ZVL15vA8Y7kXqOy3dtmQgeCi", }, { "name": "GetPopulation", "args": {"location": "Los Angeles, CA"}, "id": "call_49CFW8zqC9W7mh7hbMLSIrXw", }, { "name": "GetPopulation", "args": {"location": "New York, NY"}, "id": "call_6ghfKxV264jEfe1mRIkS3PE7", }, ] ``` !!! note "Parallel tool calls" [`openai >= 1.32`](https://pypi.org/project/openai/) supports a `parallel_tool_calls` parameter that defaults to `True`. This parameter can be set to `False` to disable parallel tool calls: ```python ai_msg = model_with_tools.invoke( "What is the weather in LA and NY?", parallel_tool_calls=False ) ai_msg.tool_calls ``` ```python [ { "name": "GetWeather", "args": {"location": "Los Angeles, CA"}, "id": "call_4OoY0ZR99iEvC7fevsH8Uhtz", } ] ``` Like other runtime parameters, `parallel_tool_calls` can be bound to a model using `model.bind(parallel_tool_calls=False)` or during instantiation by setting `model_kwargs`. See `bind_tools` for more. ??? info "Built-in (server-side) tools" You can access [built-in tools](https://platform.openai.com/docs/guides/tools?api-mode=responses) supported by the OpenAI Responses API. See [LangChain docs](https://docs.langchain.com/oss/python/integrations/chat/openai#responses-api) for more detail. ```python from langchain_openai import ChatOpenAI model = ChatOpenAI(model="...", output_version="responses/v1") tool = {"type": "web_search"} model_with_tools = model.bind_tools([tool]) response = model_with_tools.invoke("What was a positive news story from today?") response.content ``` ```python [ { "type": "text", "text": "Today, a heartwarming story emerged from ...", "annotations": [ { "end_index": 778, "start_index": 682, "title": "Title of story", "type": "url_citation", "url": "", } ], } ] ``` !!! version-added "Added in `langchain-openai` 0.3.9" !!! version-added "Added in `langchain-openai` 0.3.26: Updated `AIMessage` format" [`langchain-openai >= 0.3.26`](https://pypi.org/project/langchain-openai/#history) allows users to opt-in to an updated `AIMessage` format when using the Responses API. Setting `ChatOpenAI(..., output_version="responses/v1")` will format output from reasoning summaries, built-in tool invocations, and other response items into the message's `content` field, rather than `additional_kwargs`. We recommend this format for new applications. ??? info "Managing conversation state" OpenAI's Responses API supports management of [conversation state](https://platform.openai.com/docs/guides/conversation-state?api-mode=responses). Passing in response IDs from previous messages will continue a conversational thread. ```python from langchain_openai import ChatOpenAI model = ChatOpenAI( model="...", use_responses_api=True, output_version="responses/v1", ) response = model.invoke("Hi, I'm Bob.") response.text ``` ```txt "Hi Bob! How can I assist you today?" ``` ```python second_response = model.invoke( "What is my name?", previous_response_id=response.response_metadata["id"], ) second_response.text ``` ```txt "Your name is Bob. How can I help you today, Bob?" ``` !!! version-added "Added in `langchain-openai` 0.3.9" !!! version-added "Added in `langchain-openai` 0.3.26" You can also initialize `ChatOpenAI` with `use_previous_response_id`. Input messages up to the most recent response will then be dropped from request payloads, and `previous_response_id` will be set using the ID of the most recent response. ```python model = ChatOpenAI(model="...", use_previous_response_id=True) ``` !!! note "OpenAI-compatible endpoints" Some OpenAI-compatible providers/proxies may not support forwarding reasoning blocks in request history. If you see request-format errors while using reasoning + Responses API, prefer `use_previous_response_id=True` (so the server keeps conversation state). ??? info "Reasoning output" OpenAI's Responses API supports [reasoning models](https://platform.openai.com/docs/guides/reasoning?api-mode=responses) that expose a summary of internal reasoning processes. ```python from langchain_openai import ChatOpenAI reasoning = { "effort": "medium", # 'low', 'medium', or 'high' "summary": "auto", # 'detailed', 'auto', or None } model = ChatOpenAI( model="...", reasoning=reasoning, output_version="responses/v1" ) response = model.invoke("What is 3^3?") # Response text print(f"Output: {response.text}") # Reasoning summaries for block in response.content: if block["type"] == "reasoning": for summary in block["summary"]: print(summary["text"]) ``` ```txt Output: 3³ = 27 Reasoning: The user wants to know... ``` !!! version-added "Added in `langchain-openai` 0.3.26: Updated `AIMessage` format" [`langchain-openai >= 0.3.26`](https://pypi.org/project/langchain-openai/#history) allows users to opt-in to an updated `AIMessage` format when using the Responses API. Setting `ChatOpenAI(..., output_version="responses/v1")` will format output from reasoning summaries, built-in tool invocations, and other response items into the message's `content` field, rather than `additional_kwargs`. We recommend this format for new applications. !!! note "Troubleshooting with non-OpenAI backends" When using a non-OpenAI endpoint via `base_url`, request handling for reasoning history can differ. If agent loops fail after tool calls, use: `ChatOpenAI(..., use_responses_api=True, use_previous_response_id=True)`. ??? info "Structured output" ```python from pydantic import BaseModel, Field class Joke(BaseModel): '''Joke to tell user.''' setup: str = Field(description="The setup of the joke") punchline: str = Field(description="The punchline to the joke") rating: int | None = Field( description="How funny the joke is, from 1 to 10" ) structured_model = model.with_structured_output(Joke) structured_model.invoke("Tell me a joke about cats") ``` ```python Joke( setup="Why was the cat sitting on the computer?", punchline="To keep an eye on the mouse!", rating=None, ) ``` See `with_structured_output` for more info. ??? info "JSON mode" ```python json_model = model.bind(response_format={"type": "json_object"}) ai_msg = json_model.invoke( "Return a JSON object with key 'random_ints' and a value of 10 random ints in [0-99]" ) ai_msg.content ``` ```txt '\\n{\\n "random_ints": [23, 87, 45, 12, 78, 34, 56, 90, 11, 67]\\n}' ``` ??? info "Image input" ```python import base64 import httpx from langchain.messages import HumanMessage image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" image_data = base64.b64encode(httpx.get(image_url).content).decode("utf-8") message = HumanMessage( content=[ {"type": "text", "text": "describe the weather in this image"}, { "type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_data}"}, }, ] ) ai_msg = model.invoke([message]) ai_msg.content ``` ```txt "The weather in the image appears to be clear and pleasant. The sky is mostly blue with scattered, light clouds, suggesting a sunny day with minimal cloud cover. There is no indication of rain or strong winds, and the overall scene looks bright and calm. The lush green grass and clear visibility further indicate good weather conditions." ``` ??? info "Token usage" ```python ai_msg = model.invoke(messages) ai_msg.usage_metadata ```txt {"input_tokens": 28, "output_tokens": 5, "total_tokens": 33} ``` When streaming, set the `stream_usage` kwarg: ```python stream = model.stream(messages, stream_usage=True) full = next(stream) for chunk in stream: full += chunk full.usage_metadata ``` ```txt {"input_tokens": 28, "output_tokens": 5, "total_tokens": 33} ``` ??? info "Logprobs" ```python logprobs_model = model.bind(logprobs=True) ai_msg = logprobs_model.invoke(messages) ai_msg.response_metadata["logprobs"] ``` ```txt { "content": [ { "token": "J", "bytes": [74], "logprob": -4.9617593e-06, "top_logprobs": [], }, { "token": "'adore", "bytes": [39, 97, 100, 111, 114, 101], "logprob": -0.25202933, "top_logprobs": [], }, { "token": " la", "bytes": [32, 108, 97], "logprob": -0.20141791, "top_logprobs": [], }, { "token": " programmation", "bytes": [ 32, 112, 114, 111, 103, 114, 97, 109, 109, 97, 116, 105, 111, 110, ], "logprob": -1.9361265e-07, "top_logprobs": [], }, { "token": ".", "bytes": [46], "logprob": -1.2233183e-05, "top_logprobs": [], }, ] } ``` ??? info "Response metadata" ```python ai_msg = model.invoke(messages) ai_msg.response_metadata ``` ```txt { "token_usage": { "completion_tokens": 5, "prompt_tokens": 28, "total_tokens": 33, }, "model_name": "gpt-4.1-mini", "system_fingerprint": "fp_319be4768e", "finish_reason": "stop", "logprobs": None, } ``` ??? info "Flex processing" OpenAI offers a variety of [service tiers](https://platform.openai.com/docs/guides/flex-processing?api-mode=responses). The "flex" tier offers cheaper pricing for requests, with the trade-off that responses may take longer and resources might not always be available. This approach is best suited for non-critical tasks, including model testing, data enhancement, or jobs that can be run asynchronously. To use it, initialize the model with `service_tier="flex"`: ```python from langchain_openai import ChatOpenAI model = ChatOpenAI(model="...", service_tier="flex") ``` Note that this is a beta feature that is only available for a subset of models. See OpenAI [flex processing docs](https://platform.openai.com/docs/guides/flex-processing?api-mode=responses) for more detail. ??? info "OpenAI-compatible APIs" `ChatOpenAI` can be used with OpenAI-compatible APIs like [LM Studio](https://lmstudio.ai/), [vLLM](https://github.com/vllm-project/vllm), [Ollama](https://ollama.com/), and others. To use custom parameters specific to these providers, use the `extra_body` parameter. !!! example "LM Studio example with TTL (auto-eviction)" ```python from langchain_openai import ChatOpenAI model = ChatOpenAI( base_url="http://localhost:1234/v1", api_key="lm-studio", # Can be any string model="mlx-community/QwQ-32B-4bit", temperature=0, extra_body={ "ttl": 300 }, # Auto-evict model after 5 minutes of inactivity ) ``` !!! example "vLLM example with custom parameters" ```python model = ChatOpenAI( base_url="http://localhost:8000/v1", api_key="EMPTY", model="meta-llama/Llama-2-7b-chat-hf", extra_body={"use_beam_search": True, "best_of": 4}, ) ``` !!! warning "Model name can trigger Responses API routing" The choice between the Chat Completions API (`/v1/chat/completions`) and the Responses API (`/v1/responses`) is inferred in part from the model name, independent of `base_url`. `use_responses_api` should generally be set explicitly to avoid ambiguity, especially when using OpenAI-compatible providers: ```python model = ChatOpenAI( base_url="http://localhost:8000/v1", api_key="EMPTY", model="codex-7b-instruct", use_responses_api=False, ) ``` ??? info "`model_kwargs` vs `extra_body`" Use the correct parameter for different types of API arguments: **Use `model_kwargs` for:** - Standard OpenAI API parameters not explicitly defined as class parameters - Parameters that should be flattened into the top-level request payload - Examples: `max_completion_tokens`, `stream_options`, `modalities`, `audio` ```python # Standard OpenAI parameters model = ChatOpenAI( model="...", model_kwargs={ "stream_options": {"include_usage": True}, "max_completion_tokens": 300, "modalities": ["text", "audio"], "audio": {"voice": "alloy", "format": "wav"}, }, ) ``` **Use `extra_body` for:** - Custom parameters specific to OpenAI-compatible providers (vLLM, LM Studio, OpenRouter, etc.) - Parameters that need to be nested under `extra_body` in the request - Any non-standard OpenAI API parameters ```python # Custom provider parameters model = ChatOpenAI( base_url="http://localhost:8000/v1", model="custom-model", extra_body={ "use_beam_search": True, # vLLM parameter "best_of": 4, # vLLM parameter "ttl": 300, # LM Studio parameter }, ) ``` **Key Differences:** - `model_kwargs`: Parameters are **merged into top-level** request payload - `extra_body`: Parameters are **nested under `extra_body`** key in request !!! warning Always use `extra_body` for custom parameters, **not** `model_kwargs`. Using `model_kwargs` for non-OpenAI parameters will cause API errors. ??? info "Prompt caching optimization" OpenAI prompt caching is automatic for eligible prompts. For high-volume applications with repetitive prompts, use `prompt_cache_key` per invocation to improve cache hit rates and reduce costs: ```python model = ChatOpenAI(model="...") response = model.invoke( messages, prompt_cache_key="example-key-a", # Routes to same machine for cache hits ) customer_response = model.invoke(messages, prompt_cache_key="example-key-b") support_response = model.invoke(messages, prompt_cache_key="example-key-c") # Dynamic cache keys based on context cache_key = f"example-key-{dynamic_suffix}" response = model.invoke(messages, prompt_cache_key=cache_key) ``` The default `"implicit"` mode keeps OpenAI's automatic breakpoint and also uses explicit breakpoints. The `"explicit"` mode uses only the breakpoints you provide. For models that support explicit cache breakpoints, pass request-level cache options and mark supported content blocks with `prompt_cache_breakpoint`: ```python model = ChatOpenAI(model="gpt-5.6-sol") response = model.invoke( [ { "role": "system", "content": [ { "type": "text", "text": "Stable instructions and examples...", "prompt_cache_breakpoint": {"mode": "explicit"}, } ], }, {"role": "user", "content": "Current request"}, ], prompt_cache_key="tenant:acme:support-v1", prompt_cache_options={"mode": "explicit", "ttl": "30m"}, ) ``` Set `prompt_cache_options` per invocation, as above, or persist it on the model: ```python model = ChatOpenAI( model="gpt-5.6-sol", prompt_cache_options={"mode": "explicit", "ttl": "30m"}, ) ``` `prompt_cache_options["mode"]` can be `"implicit"` or `"explicit"`. OpenAI limits how many breakpoints can write to the cache in a single request. In `"implicit"` mode, the implicit breakpoint on the latest message uses one write slot, so up to three explicit breakpoints can write. In `"explicit"` mode, up to four explicit breakpoints can write. For reads, OpenAI considers up to the latest 50 breakpoints. For models before the GPT-5.6 family that support legacy prompt cache retention, pass `prompt_cache_retention`. See OpenAI's [prompt caching docs](https://platform.openai.com/docs/guides/prompt-caching) for the current model support list and retention semantics. ```python response = model.invoke(messages, prompt_cache_retention="24h") ``` Cache keys help ensure requests with the same prompt prefix are routed to machines with existing cache, providing cost reduction and latency improvement on cached tokens. Cache reads are available as `response.usage_metadata["input_token_details"]["cache_read"]`; cache writes are available as `"cache_creation"` when the OpenAI response includes `cache_write_tokens`. On the `"priority"` and `"flex"` service tiers these keys are prefixed with the tier name (e.g. `"priority_cache_read"`). NrnrDrXrdc SS0$)z(Mapping of secret environment variables.rLrrrs r} lc_secretsChatOpenAI.lc_secretsOs!"233rc /SQ$)zbGet the namespace of the LangChain object. Returns: `["langchain", "chat_models", "openai"]` ) langchain chat_modelsr!rrs r}get_lc_namespaceChatOpenAI.get_lc_namespaceTs 65rc0nUR(aURUS'UR(aURUS'UR(aURUS'U$)z+Get the attributes of the langchain object.rQrOrS)rQrOrS)r attributess r} lc_attributesChatOpenAI.lc_attributes]s\&(  # #040H0HJ, -   ,0,@,@J( )   )-):):J~ &rcg)z9Return whether this model can be serialized by LangChain.Trrs r}is_lc_serializableChatOpenAI.is_lc_serializablemsrcP>[TU]nSU;aURS5US'U$)rrdrn)rcrr)rrer%s r}rChatOpenAI._default_paramsrs0( 6 !.4jj.FF* + rr=c ">[TU]"U4SU0UD6nSU;aURS5US'UR(aO[R "SUR5(a)UR S/5HnUSS:XdMSUS'M U$) Nrvrdrnz^o\dr rrr)rcrrrrematchr)rrDrvr r rr%s r}rChatOpenAI._get_request_payload{s'.vKDKFK 7 "/6{{UR0UEURE5(a[TU] "U0UD6$[TU]"U0UD6$)+Route to Chat Completions or Responses API.)r0rJrcrr+)rrr r%s r}r+ChatOpenAI._streamsN  " "#Bf#B0A0A#B C C7,d=f= =w///rc># UR0UEURE5(a [TU] "U0UD6ShvN nU7v M[TU]"U0UD6ShvN nU7v MN+ gN g7f)rN)r0rJrcrrX)rrr rr%s r}rXChatOpenAI._astreamsv  " "#Bf#B0A0A#B C C$w94J6J e $w/@@ e  J @sJ5A0A*A(A*A0A.A,A. A0(A**A0,A..A0rFrc 0>[TU]"U4UUUUS.UD6$)a5Model wrapper that returns outputs formatted to match the given schema. Args: schema: The output schema. Can be passed in as: - an OpenAI function/tool schema, - a JSON Schema, - a `TypedDict` class, - or a Pydantic class. If `schema` is a Pydantic class then the model output will be a Pydantic instance of that class, and the model-generated fields will be validated by the Pydantic class. Otherwise the model output will be a dict and will not be validated. See `langchain_core.utils.function_calling.convert_to_openai_tool` for more on how to properly specify types and descriptions of schema fields when specifying a Pydantic or `TypedDict` class. method: The method for steering model generation, one of: - `'json_schema'`: Uses OpenAI's [Structured Output API](https://platform.openai.com/docs/guides/structured-outputs). See the docs for [supported models](https://platform.openai.com/docs/guides/structured-outputs#supported-models). - `'function_calling'`: Uses OpenAI's [tool-calling API](https://platform.openai.com/docs/guides/function-calling) (formerly called function calling). - `'json_mode'`: Uses OpenAI's [JSON mode](https://platform.openai.com/docs/guides/structured-outputs#json-mode). Note that if using JSON mode then you must include instructions for formatting the output into the desired schema into the model call. Learn more about the [differences between methods](https://platform.openai.com/docs/guides/structured-outputs#function-calling-vs-response-format). include_raw: If `False` then only the parsed structured output is returned. If an error occurs during model output parsing it will be raised. If `True` then both the raw model response (a `BaseMessage`) and the parsed model response will be returned. If an error occurs during output parsing it will be caught and returned as well. The final output is always a `dict` with keys `'raw'`, `'parsed'`, and `'parsing_error'`. strict: - `True`: Model output is guaranteed to exactly match the schema. The input schema will also be validated according to the [supported schemas](https://platform.openai.com/docs/guides/structured-outputs#supported-schemas). - `False`: Input schema will not be validated and model output will not be validated. - `None`: `strict` argument will not be passed to the model. If schema is specified via `TypedDict` or JSON schema, `strict` is not enabled by default. Pass `strict=True` to enable it. !!! note `strict` can only be non-null if `method` is `'json_schema'` or `'function_calling'`. tools: A list of tool-like objects to bind to the chat model. Requires that: - `method` is `'json_schema'` (default). - `strict=True` - `include_raw=True` If a model elects to call a tool, the resulting `AIMessage` in `'raw'` will include tool calls. ??? example ```python from langchain.chat_models import init_chat_model from pydantic import BaseModel class ResponseSchema(BaseModel): response: str def get_weather(location: str) -> str: \"\"\"Get weather at a location.\"\"\" pass model = init_chat_model("openai:gpt-5.5") structured_model = model.with_structured_output( ResponseSchema, tools=[get_weather], strict=True, include_raw=True, ) structured_model.invoke("What's the weather in Boston?") ``` ```python { "raw": AIMessage(content="", tool_calls=[...], ...), "parsing_error": None, "parsed": None, } ``` kwargs: Additional keyword args are passed through to the model. Returns: A `Runnable` that takes same inputs as a `langchain_core.language_models.chat.BaseChatModel`. If `include_raw` is `False` and `schema` is a Pydantic class, `Runnable` outputs an instance of `schema` (i.e., a Pydantic object). Otherwise, if `include_raw` is `False` then `Runnable` outputs a `dict`. If `include_raw` is `True`, then `Runnable` outputs a `dict` with keys: - `'raw'`: `BaseMessage` - `'parsed'`: `None` if there was a parsing error, otherwise the type depends on the `schema` as described above. - `'parsing_error'`: `BaseException | None` !!! warning "Behavior changed in `langchain-openai` 0.3.0" `method` default changed from `"function_calling"` to `"json_schema"`. !!! warning "Behavior changed in `langchain-openai` 0.3.12" Support for `tools` added. !!! warning "Behavior changed in `langchain-openai` 0.3.21" Pass `kwargs` through to the model. ??? note "Example: `schema=Pydantic` class, `method='json_schema'`, `include_raw=False`, `strict=True`" Note, OpenAI has a number of restrictions on what types of schemas can be provided if `strict = True`. When using Pydantic, our model cannot specify any Field metadata (like min/max constraints) and fields cannot have default values. See [all constraints](https://platform.openai.com/docs/guides/structured-outputs#supported-schemas). ```python from langchain_openai import ChatOpenAI from pydantic import BaseModel, Field class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str | None = Field( default=..., description="A justification for the answer." ) model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output(AnswerWithJustification) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python AnswerWithJustification( answer="They weigh the same", justification="Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.", ) ``` ??? note "Example: `schema=Pydantic` class, `method='function_calling'`, `include_raw=False`, `strict=False`" ```python from langchain_openai import ChatOpenAI from pydantic import BaseModel, Field class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str | None = Field( default=..., description="A justification for the answer." ) model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output( AnswerWithJustification, method="function_calling" ) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python AnswerWithJustification( answer="They weigh the same", justification="Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.", ) ``` ??? note "Example: `schema=Pydantic` class, `method='json_schema'`, `include_raw=True`" ```python from langchain_openai import ChatOpenAI from pydantic import BaseModel class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output( AnswerWithJustification, include_raw=True ) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python { "raw": AIMessage( content="", additional_kwargs={ "tool_calls": [ { "id": "call_Ao02pnFYXD6GN1yzc0uXPsvF", "function": { "arguments": '{"answer":"They weigh the same.","justification":"Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ."}', "name": "AnswerWithJustification", }, "type": "function", } ] }, ), "parsed": AnswerWithJustification( answer="They weigh the same.", justification="Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.", ), "parsing_error": None, } ``` ??? note "Example: `schema=TypedDict` class, `method='json_schema'`, `include_raw=False`, `strict=False`" ```python from typing_extensions import Annotated, TypedDict from langchain_openai import ChatOpenAI class AnswerWithJustification(TypedDict): '''An answer to the user question along with justification for the answer.''' answer: str justification: Annotated[ str | None, None, "A justification for the answer." ] model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output(AnswerWithJustification) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python { "answer": "They weigh the same", "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume and density of the two substances differ.", } ``` ??? note "Example: `schema=OpenAI` function schema, `method='json_schema'`, `include_raw=False`" ```python from langchain_openai import ChatOpenAI oai_schema = { "name": "AnswerWithJustification", "description": "An answer to the user question along with justification for the answer.", "parameters": { "type": "object", "properties": { "answer": {"type": "string"}, "justification": { "description": "A justification for the answer.", "type": "string", }, }, "required": ["answer"], }, } model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output(oai_schema) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python { "answer": "They weigh the same", "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume and density of the two substances differ.", } ``` ??? note "Example: `schema=Pydantic` class, `method='json_mode'`, `include_raw=True`" ```python from langchain_openai import ChatOpenAI from pydantic import BaseModel class AnswerWithJustification(BaseModel): answer: str justification: str model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output( AnswerWithJustification, method="json_mode", include_raw=True ) structured_model.invoke( "Answer the following question. " "Make sure to return a JSON blob with keys 'answer' and 'justification'.\\n\\n" "What's heavier a pound of bricks or a pound of feathers?" ) ``` ```python { "raw": AIMessage( content='{\\n "answer": "They are both the same weight.",\\n "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight." \\n}' ), "parsed": AnswerWithJustification( answer="They are both the same weight.", justification="Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight.", ), "parsing_error": None, } ``` ??? note "Example: `schema=None`, `method='json_mode'`, `include_raw=True`" ```python structured_model = model.with_structured_output( method="json_mode", include_raw=True ) structured_model.invoke( "Answer the following question. " "Make sure to return a JSON blob with keys 'answer' and 'justification'.\\n\\n" "What's heavier a pound of bricks or a pound of feathers?" ) ``` ```python { "raw": AIMessage( content='{\\n "answer": "They are both the same weight.",\\n "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight." \\n}' ), "parsed": { "answer": "They are both the same weight.", "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight.", }, "parsing_error": None, } ``` r)rcr)rrrrrrar r%s r}r!ChatOpenAI.with_structured_outputs6` w-  #     rr)rzdict[str, str])rz list[str]rrr)rrr rrr)rrr rrrrr)rrrrrr[rdrrrrrrrrrr+rXrrrrs@r}rr sMB H#47NOJ O/ 4466  "& "     (0  $'  + /3W KX!"!W +W H W  W  W W W  7W W rrcF[U[5=(a [U5$r)rrrU)objs r}r1r1:s c4 ?%:3%??rcLSUSUS[R"USSS9S.S.$) NrrrrF) ensure_asciirrrrr)jsondumps)rs r}rr>s6of%If$5EJ  rc&SUSUSUSS.S.$)Nrrrrrrr)invalid_tool_calls r}rrIs.%%f-*62  rctSSKJn [ U5(aSSKnSnSn[5RXS9nUR5 URRS5nU(a&[U5U:a[RSU5 g[UR5U:a[RSU5 gUR[!UR55nUR"upSSS5 WW 4$[+U5(a^UR-S S 5up[.R0"U 5n UR[!U 55nUR"upSSS5 X4$g![a [R S5 gf=f!,(df  N=f!UR$a [RS U5 gUR&a n [RS U 5 Sn A gSn A f[(a n [RS U 5 Sn A gSn A ff=f!,(df  WW 4$=f)Nr)ImagezaUnable to count image tokens. To count image tokens please install `pip install -U pillow httpx`.g@i )rTzcontent-lengthz0Image URL exceeds maximum size limit of %d bytesz,Image URL request timed out after %s secondsz!Image URL returned HTTP error: %sz-Failed to fetch or process image from URL: %s,r)PILr" ImportErrorrinfo_is_urlhttpxr~rraise_for_statusr,rrrr6openr sizeTimeoutExceptionHTTPStatusErrorr_is_b64splitr b64decode) image_sourcer"r(rTmax_sizercontent_lengthimgwidthheightrrencodedrs r}rrVs|# ,.22<2QH  % % '&--112BCN#n"5"@F8##$x/FGH$4$456# # 7&= |!''Q/ ( ZZ &#HHME'} k   -  D76%%  NNI7 S$$  NN> B  NNJA N ' &f}skE.A.F$/F$$F$$F3 F$H&.FF F!F$$&H# H#G66 H#HH#& H7cj[X5up[US- 5n[US- 5nSU-U-S-$)Nir)_resizer )r5r6hws r}rrs=E*ME Vc\A US[A !GaK2 rc[U5n[URUR/5$![a n[ R SU5 SnAgSnAff=f)NzUnable to parse URL: %sF)rrschemenetlocrrdebug)sr6rs r}r'r'sJ!FMM6==122  .2s+. AAAc$URS5$)Nz data:image)r)rAs r}r.r.s << %%rcUS:dUS:aX:a US-U-nSnO US-U-nSnUS:a"US:aX:a US-U-nSnX4$US-U-nSnX4$)Niir)r5r6s r}r:r:s t|v} >tm-FET\f,EF s{v| >S[V+EF =slu,FE =rrc[U[5(a[U5(aU$[U[5(aSU;aUR S5S:XaUnO[U[5(aSU;a SU;aSUS.nOfUcA[U[5(a*[UR S5[ 5(aUSnOSn[ XS9nURS 5US'SUS.nUb[XSR S5LaE[U[5(a0SUR S05;aS USSS US 3n[U5eU$) Nrrrr)rrrFr parametersz0Output schema already has 'strict' value set to z: but 'strict' also passed in to with_structured_output as z@. Please make sure that 'strict' is only specified in one place.) rrrUrrr`rQrr)rrrrrs r}rrsN&$$9&$A$A  64  V # JJv - /  FD ! !f&68v;M#0H >&$''Jvzz(7KT,R,R)-fD%\\,7#0J  -8<.sN +E 5$ ( IIf  / ( w ' (+sAAc3# UH:n[U[5(dMUSS:XdM%SUS;dM0USSv M< g7frHrrrKs r}rrLsR .%& &f / &U7^+ &E'N9 %.sAAAAzdStructured Output response does not have a 'parsed' field nor a 'refusal' field. Received message: r) rrrrOpenAIRefusalErrorrcontent_blocksnextrr)ai_msgrrLrNrs r}rrs**..x88E fd # ##F# #  ##I.. !9!9)!DEE  **    ..  !))  ''-h 0 S/rc\rSrSrSrSrg)rOia5Error raised when OpenAI Structured Outputs API returns a refusal. When using OpenAI's Structured Outputs API with user-generated input, the model may occasionally refuse to fulfill the request for safety reasons. See [more on refusals](https://platform.openai.com/docs/guides/structured-outputs/refusals). rNrrrr}rOrOsrrOcURS5nUbUOSnURS5nUbUOSnURS5nUbUOX5-nUS;aSnU(aUS3OSnURS5=(d 0n S U RS 5US 3U RS 5US 3U RS50n S URS5=(d 0RS 5US3URS5=(d 0RS50n UbFUU RUS 3S5=(d S- X'UU RUS3S5=(d S- X'[UUU[S0U R5V V s0sH upU cM X_M sn n D6[ S0U R5V V s0sH upU cM X_M sn n D6S9$s sn n fs sn n f)N prompt_tokensrcompletion_tokens total_tokens>flexpriorityrrprompt_tokens_detailsr audio_tokens cache_read cached_tokenscache_creationcache_write_tokenscompletion_tokens_detailsrgreasoning_tokens input_tokens output_tokensrWinput_token_detailsoutput_token_detailsrrr9r7rr8)oai_token_usager~_inputrc_outputrd_totalrWservice_tier_prefixrZrerfrrs r}rr s(  1F#/6QL!!"56G&2GM   0F#/6\5QL// 0<\N!,"+//0GHNB&**>:  z*,A,E,Eo,V  ~.0E0I0I 1 ! /%%&ABHbMM    y)    ; < B # ! "-9  # #':&;:$F J Oa- ).; $ $(;'rXrYrrrgoutput_tokens_detailsrainput_tokens_detailsr\r]r^r_rbrrg)rhr~rircrjrdrkrWrlrfrorerrs r} _create_usage_metadata_responsesrp>s  0F#/6QL!!/2G&2GM   0F#/6\5QL// 0<\N!,"  y)    7 8 >B # !" +../EFL"  z*,@,D,D_,U  ~.0D0H0H 1 ! .; $ $(;'F  F /F;Fc*SU;=(a USS:g$)Nrrr)rs r}_is_builtin_toolrrls T> 8d6lj88rcSU;=(a [SUS55n1Skn[U=(d URU55$)Nrac36# UHn[U5v M g7fr)rr)rrs r}r%_use_responses_api..qs4+;4+;s>rr|rgrrzr?)rr` intersection)r uses_builtin_toolsresponses_only_argss r}r0r0psR G+4+27+;41 "O&9&F&Fw&O PPrc [[U5S- SS5HcnXn[U[5(dMURR S5nU(dMBUR S5(dMZXS-SU4s $ US4$)a~Get the last part of the conversation after the last `AIMessage` with an `id`. Will return: 1. Every message after the most-recent `AIMessage` that has a non-empty `response_metadata["id"]` (may be an empty list), 2. That `id`. If the most-recent `AIMessage` does not have an `id` (or there is no `AIMessage` at all) the entire conversation is returned together with `None`. rrrresp_N)rangerrr%rrr)r ir response_ids r}rBrBs3x=1$b" -k c9 % %//33D9K{{55g>>A(+55 . T>rcXSHnX!;dM URU5US'M SU;aSU;aSURS50US'URSS5 URS5=(d SnURS 5(aES U;a?URS5=(d 0RS5S :waURS S5 [XRS 5S9US'URSS5=n(a/nUHnUSS:XaMSU;aGUR 5VVs0sHupxUS;dM Xx_M n nnUR SS0USEU E5 MYUSS:Xa9SU;a Sn [ U 5eURS5(aSU;a 0UESS0EnOUR U5 M XQS'URSS5=n (a5[U [5(aU SS:XaSU ;a SS0U SEUS'OXS'[URS5[5(aUSR5US'URSS5=n (GaURSS5n URS5(d[U 5(aXS'O[U 5(aU R5nSn OU nUSS0:Xa3SU;a#[US[5(a SS0USS 'OqS SS00US'Og[XS!9=n(aV[U[5(aAUSS":Xa8SS"0US"EnSU;a![US[5(a UUSS 'O S U0US'OURS#S5nUb/SU;a"[US[5(a UUSS#'U$S#U0US'U$s snnf)$N)rdrnmax_output_tokensrergrrvrCrrrrrGrrinputrarrrrpartial_imageszPartial image generation is not yet supported via the LangChain ChatOpenAI client. Please drop the 'partial_images' key from the image_generation tool.rrrrrr text_formatTrformatrrrh) rrr_construct_responses_api_inputrrrrrrr1model_json_schemar)r r legacy_token_paramrCra new_toolsrrrextrarrrr schema_dictr format_valuerhs r}rCrCsF  (+2;;7I+JG' (FW$G)C ('++6H*IJ  KK KK &BE !! 5 [[ % + 0 0 :f D M4(5 G,GG GT**u* DF|z)jD.@*.**,X,$!!CW:W,X  &*!RZ8H!RE!RS<#55'4/$ 2#66{{8,,1A1M =$<(8!<  &14%kk-66{6 {D ) )F#z1k)&,j%TK GFO K.I W GFOT!B!B+4GFOK ( N +I6GFO NaYs + N&:N&cURS5S:Xa,SU;a&UR5nURS5US'U$U$)Nr file_citationr file_indexrrr annotationnew_annotations r}_format_annotation_to_lcr sI~~f0W 5J#*'5'9'9''B|$ rcURS5S:Xa,SU;a&UR5nURS5US'U$U$)Nrrrrrrs r}_format_annotation_from_lcrsG~~f0\Z5O#*"0"4"4\"Bw rcUSS:XaSUSS.nSU;aUSUS'U$USS:Xa?SUSSS .nUSRS 5(a USS US 'SU;aUSUS'U$USS :XaSS 0US EnSU;aUSUS'U$U$) z~Convert chat completions content blocks to Responses API format. Only handles text, image, file blocks. Others pass through. rr input_textrrr input_imagerrrr input_file)r)r new_blocks r}-_convert_chat_completions_blocks_to_responsesrs V}*5=A $ -389R3SI/ 0 V} #"{+E2    ! !( + +"' "4X">Ih  $ -389R3SI/ 0 V}\;U6]; $ -389R3SI/ 0 Lrc[U[5(aU$[U[5(a2[SU55(aUVs/sHn[ U5PM sn$[ U5$s snf)Nc3v# UH0n[U[5=(a URS5S;v M2 g7f)r)rrrrrrNrJrKs r}r5_ensure_valid_tool_message_content..CsB -!E 5$ IIf    !s79)rrrrrrL) tool_outputrs r}"_ensure_valid_tool_message_contentr@sv+s##+t$$ -! - * *% $ :% @$   k ""  sA*cSn[UR[5(aURHnURR S5S:Xa<[U[ 5(a'UR S5S:XaUR SUS.n O[U[ 5(dMuUR S5S:XdMUR S05R S5S:XdMUSn O? O 9: rcSnURHn[U[5(a@URS5S:Xa+SURURS5=(d SS.n U$[U[5(dMoURS5S:XdMURS05RS5S:XdMUSn U$ U$)Nrcustom_tool_call_outputrr)rrrrIr)r6rrrr)rcustom_tool_outputrs r}%_make_custom_tool_output_from_messagers eT " "uyy'8upx[U[5(dMUR S 5S :XdM3US USU'M@ SU;aURS5 US S:XaUSn [[[U55n [U5n U (aUR!U 5 GMU (aUR!U 5 GM[#U 5n SU USS.n UR!U 5 GMUS S:XGa [UR S5[ 5(Ga-USGH"n[U[5(dMUR S 5=n (dM5U S;Ga&UR S5nUR S5nU S;aNUR S5nUcMzSUUR S5=(d /Vs/sHn[%U5PM snS.nOU S:XaSUSS.nUHNnUR S5=n(dMUU:XdM%SU;a/US'USR!W5 UbUUS' GM SW/SS.nUSLa&U(aUR'[(5(dUUS'UbUUS'UR!U5 GMbU S :Xa;USLdUR S!5(aUR![+U55 GMGMU S";aUR![+U55 GMU S#:XaVUSLaUR!S#USS$.5 GM[+U5n[-U5S S1- (aUR!U5 GMGM"GM% OA[UR S5[.5(aUR!SSSUS/S./S%.5 URS&S5=n(aqUVs1sH'nUR S 5S';dMS(U;dM"US(iM) nnUH5nUSU;dMS)US*SUS*S+USS,.nUR!U5 M7 GMGMUS S-;a[US[ 5(a/nS.nUSH`nUS S/;aUR![1U55 M(US S0;aUR!U5 MDUS U;aUR!U5 M`Mb UUS'US(aSUS 'UR!U5 GMGMSUS 'UR!U5 GMUR!U5 GM U$s snfs snfs snf)1a)Construct the input for the OpenAI Responses API. Args: messages: Conversation history to serialize into Responses API input items. store: Mirrors the request's `store` flag, controlling stateless-replay behavior. When `False`, the server does not persist response items, so previously returned item IDs cannot be resolved on the next turn. Assistant message IDs (`msg_*`) are therefore omitted and reasoning blocks are dropped unless they carry `encrypted_content` (which can be replayed without server-side storage). When `True` or `None` (the default, matching the server's stored-by-default behavior), item IDs and reasoning blocks are preserved. Returns: A list of Responses API input items derived from `messages`. rrr6c3@# UHn[U[5v M g7frrNrKs r}r1_construct_responses_api_input..s<5CE 5$''^srrrrrrrrrrIrrrfunction_call_outputr)rrrr)r output_textrNphase)rrrNrr)rrrrNrrNr)rr6rFrgencrypted_content) compactionweb_search_callfile_search_callr computer_callcustom_tool_callrmcp_callmcp_list_toolsmcp_approval_requesttool_search_calltool_search_outputapply_patch_callapply_patch_call_outputimage_generation_call)rr)rrr6r)rrrrrr)rrrr)rrr)mcp_approval_responserrconfiguration_update)rrr)rrr)rr%r:rrrrrrn enumeraterrrrr3rrrrrrVrsetrr)r rrDlc_msgrrtcsr|rrrrr block_typemsg_idrrrritemitem_idnew_itemrrcontent_call_idsr new_blocksnon_message_item_typess r}rrs0.F fi ( (1&9F*6{CC#''),d33<58^<99&,%6%6-&7 !, )& 1 )& 1'mmD1  &7-"?s9~s!SI*6{CC#i.$// )#i. 9HA!%..599V3D3V,1'NIq)!: S= GGFO v;& i.K#J[&)$ "Gv!N # 23# 01@M 2)">2($  23 [K '#''),d33 ^E!%..%))FBS4SJ4S%)KK%*YYt_F$)IIg$6E)-DD',yy'8#'<$,,9,0;@))M:R:XVX:X4&:XJ)C:(N:X4&-" ",y!8,5/4Y/?-" )//3xx~$=G$=7fCT'0'<:<Y$(O$:$:9$E','88=W $))/-609{,72" %*$6(.,2,=,=n,M,M 6>$3$-j$9&$A)2:)>{)K'0 )  m4",9"[; ;#i.$// *& !^EV}(EE"))I%Pv*UU"))%0v*@@ e,,",Iy>"+CKMM#&"(F  c" MM# IL M-n4&t$s?%W&W+ W0(W00 W0c&[US5(a UR$URVVs/sHFnURS:XdMURH!nURS:XdMUR PM# MH nnnSR U5$s snnf)zjSafe output text extraction. Context: OpenAI SDK deleted `response.output_text` momentarily in `1.99.2`. rrr)r&rrrr6rjoin)rrr6textss r}_get_output_textrs x''###oo %F ;;) # ~~G <<= (  & %   775> sB B %B c  UR(a[UR5eUcSnURSSSS9R5VVs0sHupEUS;dM XE_M nnnU(aUR U5 SUS 'UR S 5US 'UR (a/[UR R5UR5nOSn/n/n /n 0n URGHn U RS :XGa[U S S5n U RHnURS:XaSUR[UR[ 5(a3URVs/sHn[#UR55PM snO/U R$S.nU bU US 'UR'U5 [)US5(aUR*U S'URS:XdMSUR,U R$S.nU bU US 'UR'U5 GM GM4U RS:XaU RSSS9nSU;aUR/S5US'UR'U5 [0R2"U R4SS9nSnUc/SU R:UU R<S.nU R'U5 GMSU R:UU R<US.nU R'U5 GMU RS:XaZUR'U RSSS95 SU R:SU R>0U R<S.nU R'U5 GMmU RS;dGMUR'U RSSS95 GM [AU5nUbSU ;aU(aUR(aURR5=n(alUR S 05=n(aSUR S!5S":Xa>[0R2"U5nU(a[CU5(a U"S'0UD6nOUnUU S'[EUUR$UUU U U S#9nUS$:Xa [GU5n[I[KUS%9/S&9$s snnfs snf![6a"nU R4n[9U5nSnAGN)SnAff=f![0R6a Nf=f)(z;Construct `ChatResponse` from OpenAI Response API response.Nr;TrF) exclude_nonerr) created_atrincomplete_detailsrobjectstatusrrCr~r!rrCrrrrr)rrrrrLrN)rrNrrrrasync_rrrrr )rrrrrMr__arg1)rgrrrrrrrrrrrrrrrr)r6rrrrrrv0r)r3r)&rMrr$rupdaterrrpr~rrr-r6rrrrrrrr&rLrNrrloadsrr rrrrrr1r%rorErC)rrrrrrrrrPrrrrrr6rr refusal_blockfunction_call_blockrrMrrr text_configformat_ parsed_dictrLrs r}r2r2s~~((( ''FU( %'DA   *  **2&'&7&;&;G&Dl#~~9 NN % % ')>)> NJ // ;;) #FGT2E!>><<=0 & ' &g&9&94@@/6.A.A(.A 5Z5J5J5LM.A(  $ii E().g"))%0w116=nn)(3<<9, )#*??$ii%M (16 g."))-85*6[[O +"("3"3F"3"S ../B/F/Fx/P#G,  ! !"5 6 zz&"2"25A}'"KK  ..  !!),0"KK  .."  #)))4 [[. .  ! !&"3"3F"3"S T# !6<<0nn I   i ( [[   ! !&"3"3F"3"S Tk"L#8,K - -  MM$MM446 6[ 6#"5 5W 5 [[ M 1 **[1K,V44.+.$*0 h ' ;;%++-G,W5 >'#B"C DDWZ(@# ''A ^##   s< RR'"R -!R =R? R<R77R<?SSc[U[5(aSSKJn UR"U5$U$![ aBn[ RSURS5U5 UR"S0UD6sSnA$SnAff=f)NrrrzOpenAI Responses payload failed SDK validation (response id=%s); falling back to non-validating construct. This usually means the OpenAI API has drifted ahead of the installed `openai` package. Details: %srr) rropenai.types.responsesrsmodel_validater]rrrmodel_construct)resprsrs r}_coerce_chunk_responserUsz$3 4**40 0 K 4 NN:  ++3d3 3 4s1 A=7A82A=8A=c ^^^S;SU"URUR5 U RSURTS.5 GOURS:XaU"URUR5 [ UR [5(a UR nOUR RS S S 9nU RS[U5/TS .5 GOURS :Xa?U"URUR5 U RSSURTS.5 GOURS:Xa2[UR5nURnURU S'GOfURS;a[UR5n[[[!UXGS9R"SR$5nUR&R)S5=n(aUU S'UR*n UR,R/5VVs0sHunnUS:wdMUU_M n nnSnGOURS:XaUR0RS:XaiUS:XaUR0RnGO\[3UR0SS5=n(a+U"URS5 U RSSUTS.5 GOGOURS:XGaVUR0RS:XGa;U"UR5 U RSUR0R4UR0R6UR0R8TS.5 SUR0R4UR0R6UR0R8UR0RTS.n[3UR0S S5bUR0R:US '[3UR0S!S5nUc[3UR0S"S5nUbUUS"'U RU5 GOURS#:Xa^UR0RS$;aDU"UR5 UR0RS S S 9nTUS%'U RU5 GO"S'UR0R@05UR0R8TS.5 GOeURS(:XaRU"UR5 U RSURTS).5 U RSURTS*.5 GOURS+:Xa U RS,URBS-.5 GOURS:XarUR0RS.:XaXU"UR5 SmUR0RS S S 9nURES/S5 TUS%'U RU5 GOQURS#:XaUR0RS.:XamUR0RF(aRU"UR5 U RS.UR0R/UR0RFTS0.5 OURS1:XaBU"UR5 U RURHS2SS3./TS.URS4.5 OhURS5:XaOWURS6:XaAU"UR5 U RURHS2URS3./TS.S7.5 OTTTS4$[KU U U U U UUS89nUS:Xa[[J[MUUS995nTTT[OUS:94$s snnf)=NcR>UcTU:waTS- mUmgTU:wdTU:waTS- mUmUmg)a"Advance indexes tracked during streaming. Example: we stream a response item of the form: ```python { "type": "message", # output_index 0 "role": "assistant", "id": "msg_123", "content": [ {"type": "output_text", "text": "foo"}, # sub_index 0 {"type": "output_text", "text": "bar"}, # sub_index 1 ], } ``` This is a single item with a shared `output_index` and two sub-indexes, one for each content block. This will be processed into an `AIMessage` with two text blocks: ```python AIMessage( [ {"type": "text", "text": "foo", "id": "msg_123"}, # index 0 {"type": "text", "text": "bar", "id": "msg_123"}, # index 1 ] ) ``` This function just identifies updates in output or sub-indexes and increments the current index accordingly. Nrr) output_idxsub_idxrrrs r}_advance>_convert_responses_chunk_to_generation_chunk.._advancevsMF ?#z1" *% 28IW8T" ' )rr;r!rzresponse.output_text.deltar)rrrz%response.output_text.annotation.addedTrr)rrrzresponse.output_text.doner)rrrrzresponse.createdr)zresponse.completedzresponse.incomplete)rrrrLlastzresponse.output_item.addedrrr)rrrrrr<)rrrrr)rrrrrr namespacerrzresponse.output_item.done) rrrrrrrrrrrrrrrrz&response.function_call_arguments.delta)rrr)rrrzresponse.refusal.donerNrrgr)rrrrrz%response.reasoning_summary_part.added summary_text)rrr)rrrrz,response.image_generation_call.partial_imagez%response.reasoning_summary_text.delta)rrr)r6rrrrrchunk_position)rrr)rrrrXrr)(r output_index content_indexrrrrrr$rrrrrrr%r2r3rrrrrrrr-rrrrrrrrNrr summary_indexr&rorD)rrrrrrrrrr6rrrrrrrrrrLrrrfunction_call_content async_flagrrgrs ``` r}rrlsh****X(G  B*2&'N-1N B zz11##U%8%89 mTU > >##U%8%89 e&& - -))J))44$V4TJ 8 DE&   2 2##U%8%89mm&    ) ))%..9 [["*++$ D D)%..9 7VQ   **..x8 86 8*0 h '++ 2288: :TQa4iDAqD:    3 3 98T T !Bejj'48 8U 8 U'' + NN""*    22 JJOO .##$)  ,,jj((&   $JJOO--zz))**--" '  5::{D 1 =161E1E !+ .UZZ48   Wd;J  !-7 !' *,- 2 2uzzK8 ##$jj++F+K , G{# 11 JJOO1 1##$jj++F+K , G{#)  Hejj.>.>#?@jj((&    ? ?##$& m T  $5;; W  . . emmDE 3 3 ;8V##$JJ))t&)I   )40* 'y! 11 JJOO{ * JJ ( (##$#jjmm%*ZZ%A%A&    > >##$$11>SUV'#mm   E E > >##$"'!4!4 . % '#  24EtKK)%++ %G  &wm L  G,  U s  aa)rz httpx.Client)rrrrq)rMapping[str, Any]rr')rrIrrIrrI)r6str | list[dict]rr)rN)r6rr(Literal['chat/completions', 'responses']rrNrr)r)rr'rrrr)rrrztype[BaseMessageChunk]rr()r int | dictrrrr)rzopenai.BadRequestErrorrr)rzopenai.APIErrorrr)r.rIr/rrr)rrNrr`)rrrr`)rr2rr)r r/rr)r1rrztuple[int, int] | None)r5rr6rrr)rArrr`)r5rr6rrztuple[int, int])rzdict[str, Any] | typerrVrzdict | TypeBaseModel)rRr%rz type[_BM]rzPydanticBaseModel | Noner)rhrr~rNrr9)rrrr`r)r rrz(tuple[Sequence[BaseMessage], str | None])r rr rrr)rrIrrI)rrIrrI)rrrr)rr3rrf)rr3rr)rrrr)r rrrVrr)rrsrr)NNN) rrsrtype[_BM] | NonerrrrNrrE)rrrr)NNFN)rrrrrrrrrrrrrr`rrNrz0tuple[int, int, int, ChatGenerationChunk | None])r __future__rrrloggingrr sslrrcollections.abcrrrrrr functoolsr ior r mathr operatorrtypingrrrrrr urllib.parsercertifir!rzlangchain_core.callbacksrrlangchain_core.exceptionsrrrrrrrrr langchain_core.language_modelsr!r"*langchain_core.language_models.chat_modelsr#r$langchain_core.messagesr%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6typeslangchain_core.messages.air7r8r90langchain_core.messages.block_translators.openair:r;langchain_core.messages.toolr<langchain_core.output_parsersr=r>*langchain_core.output_parsers.openai_toolsr?r@rArBlangchain_core.outputsrCrDrElangchain_core.runnablesrFrGrHrIlangchain_core.runnables.configrJlangchain_core.toolsrKlangchain_core.tools.baserLlangchain_core.utilsrMlangchain_core.utils._gatewayrNrOrP%langchain_core.utils.function_callingrQrRlangchain_core.utils.pydanticrSrTrUlangchain_core.utils.utilsrVrWrXpydanticrYrZr[r\r]r^r_ pydantic.v1rtyping_extensionsr`langchain_openai._versionra*langchain_openai.chat_models._client_utilsrbrcrdrerfrgrhrirjrkrl$langchain_openai.chat_models._compatrmrnrolangchain_openai.data._profilesrpr(rqrrs getLoggerrrcreate_default_contextwherer|rurr~rrrrrrrrrrrrrrrr"rr#r r r$rr%rr&rr(rr'rrr*r1r4r6r7rrrr9r:r<rr1rrrrr'r.r:rrrrOrrprrr0rBrCrrrrrrrrrr2rrrrr}r.s  #   "    &5 9P SR <)09  UT1"1     6;/   8 $//w}}G$( !(+Y7 6@LF 3A(65GH H 1H H HZ5GO O 1O Od52 52-C5252p#0:8L!7!79MLEFOO5IEM : : J X e9%"&sCx.49"B^#^/:^ ^B& $ !% {E{E {E{E {E  {E|8 $ !%b bbb b  b  bbb6br