$hSrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK J r J r JrJr SSKJr SSKJr SSKJr SSKJr SS KJr SS KJrJrJrJrJrJrJ r J!r!J"r" SS K#J$r$ SSK%r%SSK&r&SSK'r'SS K(J)r) SS K*J+r+J,r, SSK-J.r. SSK/J0r0J1r1J2r2J3r3 SSK4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrF SSKGJHrHJIrIJJrJ SSKKJLrL SSKMJNrNJOrO SSKPJQrQJRrRJSrSJTrT SSKUJVrVJWrWJXrX SSKYJZrZJ[r[J\r\J]r] SSK^J_r_ SSK`Jara SSKbJcrc SSKdJere SSKfJgrgJhrh SSKiJjrjJkrkJlrl SSKmJnrnJoroJprp SSKqJrrrJsrsJtrtJuruJvrv SSKwJrrx SS KyJzrz SS!K{J|r|J}r} SS"K~JrJr \(aSS#KJr \GR"\5r\GR "\%GR"5S$9rS%rSPS&jrSQS'jrSRS(jrSSS)jrSTS*jrSUS+jr"S,S-\5r\ "S.\rS/9r\!\\\4\\\4r\!\\4r"S0S1\5r"S2S3\05r"S4S5\5rSVS6jrSWS7jrSXS8jrSYS9jrSZS:jrS[S;jrS[S<jrS\S=jrSS>.S]S?jjrS^S@jr"SASB\5rS_SCjrS_SDjrS`SEjrSaSFjrSbSGjrScSHjrSdSIjrSeSJjrSfSKjrSgSLjrShSMjrSiSjSNjjrSkSlSOjjrg)mzOpenAI chat wrapper.) annotationsN) AsyncIteratorIteratorMappingSequence)partial)BytesIO)JSONDecodeError)ceil) itemgetter) TYPE_CHECKINGAnyCallableLiteralOptional TypedDictTypeVarUnioncast)urlparse) deprecated)AsyncCallbackManagerForLLMRunCallbackManagerForLLMRun)LanguageModelInput) BaseChatModelLangSmithParamsagenerate_from_streamgenerate_from_stream) AIMessageAIMessageChunk BaseMessageBaseMessageChunk ChatMessageChatMessageChunkFunctionMessageFunctionMessageChunk HumanMessageHumanMessageChunkInvalidToolCall SystemMessageSystemMessageChunkToolCall ToolMessageToolMessageChunkconvert_to_openai_data_blockis_data_content_block)InputTokenDetailsOutputTokenDetails UsageMetadata)tool_call_chunk)JsonOutputParserPydanticOutputParser)JsonOutputKeyToolsParserPydanticToolsParsermake_invalid_tool_callparse_tool_call)ChatGenerationChatGenerationChunk ChatResult)RunnableRunnableLambda RunnableMapRunnablePassthrough)run_in_executor)BaseTool) _stringify)get_pydantic_field_names)convert_to_openai_functionconvert_to_openai_tool)PydanticBaseModel TypeBaseModelis_basemodel_subclass)_build_model_kwargsfrom_envsecret_from_env) BaseModel ConfigDictField SecretStrmodel_validator)rN)Self)_get_default_async_httpx_client_get_default_httpx_client)_convert_from_v03_ai_message_convert_to_v03_ai_message)Response)cafile) file_searchweb_search_previewcomputer_use_previewcode_interpretermcpimage_generationc <URS5nURS5nURS5nUS:Xa[URSS5X2S9$US:XaURSS5=(d Sn0nURS 5=n(a[U5US '/n/nURS 5=n (a'XS 'U Hn UR[ U S S 95 M URS5=n (aXS'[UUUUUUS9$US;a)US:XaSU0nO0n[URSS5UUUS9$US:Xa8[URSS5[[URS55US9$US:XaJ0nSU;aUSUS'[URSS5[[URS55UUUS9$[URSS5XS9$![ a0n UR[ U [U 555 S n A GMWS n A ff=f)ztConvert a dictionary to a LangChain message. Args: _dict: The dictionary. Returns: The LangChain message. rolenameidusercontent)rercrb assistant function_call tool_callsT) return_idNaudio)readditional_kwargsrbrcriinvalid_tool_callssystem developerrp__openai_role__)rerbrcrlfunctionrerbrctool tool_call_id)rerurlrbrcrerarc)getr'dictappendr: Exceptionr9strrr*r%rr-r#) _dictrarbid_rerlrhrirmraw_tool_calls raw_tool_callerks Y/var/www/html/shao/venv/lib/python3.13/site-packages/langchain_openai/chat_models/base.py_convert_dict_to_messagersI 99V D 99V D ))D/C v~EIIi$<PP  ))Ir*0b"$!IIo6 6= 615m1D o . "YY|4 4> 4.rcrrrrhrkrcrqrorrrtru>rareruzGot unknown type )rrerbrlrwrr#rar'rrirm!_lc_tool_call_to_openai_tool_call)_lc_invalid_tool_call_to_openai_tool_callitemsr*r%r-ru TypeError) message message_dictrbtctool_call_supported_props tool_callkv raw_audiorksupported_propss r_convert_message_to_dictrs%./Fw/W#XL E 9 9 = =f EER#V';''&|| Vj i G\ * *% Vf e 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 # g// / 11':I9$w009$?@  %* !  G] + +&88<< x V  G_ - -) V  G[ ) )% V'.';'; ^$=)5););)=V)=AU)= V +G9566]*W*FWs6K>K K" K 0K 6K K)K Kc URS5n[[URS55n[[URS5=(d S5n0nURS5(a#[US5nSU;a UScSUS'XeS'/nURS5=n(aVXS'UV 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)Nrcrarerfrhrbrirr argumentsindex)rbargsrcrrd)rercrg)rerlrctool_call_chunksrnrprq)rercrlrsrtru)rerurcrv) rwrr{rxr4KeyErrorr(r r+r&r.r$) r| default_classr}rarerlrhrr~rtcs r_convert_delta_to_message_chunkrAs ))D/C UYYv& 'D3 ),23G  yy!!U?34 ] "}V'<'D$&M& !-:/*<00~0*8,' * *C  Z,,V4Z,,[9wwt}g,  *   v~*;; 99    ?/-   ( (M=O,O ; !2K @  " !7H    }0DD#G-CPP =,<<*?C   "22sCCW55M    s%3G7A F;G;G G  G c [U[5(a<[U[5(d#[S[U5S[U535eX-$[U[5(aw[U[5(d#[S[U5S[U535eUR 5VVs0sH"up#U[ URUS5U5_M$ snn$[R"S[U535 U$s snnf)Nz%Got different types for token usage: z and rz!Unexpected type for token usage: ) rint ValueErrorrrxr_update_token_usagerwwarningswarn)overall_token_usage new_usagerrs rrrzs  )S!!-s337 ?#5.A)B(CE .. It $ $-t447 ?#5.A)B(CE  ") ) "#6#:#:1a#@!D D)   9$y/9JKL  s2(DcSUR;aSn[R"U5 UeSUR;aSn[R"U5 Uee)NzH'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)rrr)rrs r_handle_openai_bad_requestrs[R  3   g - : [   g rc \rSrSr%S\S'Srg) _FunctionCallir{rbN__name__ __module__ __qualname____firstlineno____annotations____static_attributes__rrrrrs Irr_BM)boundc4\rSrSr%S\S'S\S'S\S'Srg ) _AllReturnTypeir!rawzOptional[_DictOrPydantic]parsedzOptional[BaseException] parsing_errorrNrrrrrrs  %%**rrc^\rSrSr%\"SSS9rS\S'\"SSS9rS\S'\"SSS9rS\S'\"SSS9r S\S '\"S S S 9r S \S'Sr S\S'\"\ S9r S\S'\"S\"SSS9S9rS\S'\"SSS 9rS\S'\"SSS 9rS\S'\"\"SSS9S9rS\S '\"SS!S 9rS"\S#'S$rS%\S&'SrS'\S('SrS\S)'SrS\S*'SrS'\S+'SrS,\S-'SrS'\S.'SrS/\S0'S$rS%\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@'\"SSAS 9r)SB\SC'Sr*SD\SE'S$r+S%\SF'\"SS9r,S6\SG'Sr-SH\SI'Sr.S\SJ'Sr/S,\SK'Sr0S\SL'S$r1S%\SM'Sr2S,\SN'SOr3SP\SQ'\4"SSR9r5\6"SSST9\7S|SUj55r8\6"SSST9\7S|SVj55r9\6"SWST9S}SXj5r:\;S~SYj5rSSS\jjr?SSS]jjr@SSS^jjrASSS_.SS`jjjrBSSSajjrCSSbjrDSSc.SSdjjrESSSejjrFSSS_.SSfjjjrGSSSgjjrH\;S~Shj5rISSU4SijjjrJSSSjjjrK\;SSkj5rLSSljrMSU4SmjjrNSSU4SnjjjrO\P"SoSpSqSr9SSU4Ssjjj5rQSSSSt.SU4SujjjrRSSvS$SSSw.SSxjjjrSSSyjrTSSzjrUS{rVU=rW$)BaseChatOpenAIiNT)defaultexcluderclient async_client root_clientroot_async_client gpt-3.5-turbomodelraliasr{ model_namezOptional[float] temperature)default_factorydict[str, Any] model_kwargsapi_keyOPENAI_API_KEY)r)rrzOptional[SecretStr]openai_api_keybase_urlz Optional[str]openai_api_base organizationopenai_organization OPENAI_PROXY openai_proxytimeoutz,Union[float, tuple[float, float], Any, None]request_timeoutFbool stream_usage Optional[int] max_retriespresence_penaltyfrequency_penaltyseedOptional[bool]logprobs top_logprobszOptional[dict[int, int]] logit_bias streamingntop_p max_tokensreasoning_effortzOptional[dict[str, Any]] reasoning verbositytiktoken_model_namezUnion[Mapping[str, str], None]default_headersz!Union[Mapping[str, object], None] default_queryzUnion[Any, None] http_clienthttp_async_clientstop_sequenceszOptional[Union[list[str], str]]stopzOptional[Mapping[str, Any]] extra_bodyinclude_response_headersdisabled_paramsOptional[list[str]]include service_tierstore truncationuse_previous_response_iduse_responses_apiv0Literal['v0', 'responses/v1']output_version)populate_by_namebefore)modec2[U5n[X5nU$)z>Build extra kwargs from additional params that were passed in.)rErK)clsvaluesall_required_field_namess r build_extraBaseChatOpenAI.build_extras$R2R4UlU$![$an[%S5UeSnAff=f![$an[%S5UeSnAff=f)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_ORGANIZATIONOPENAI_API_BASE)rrrrrrrzwCannot specify 'openai_proxy' if one of 'http_client'/'http_async_client' is already specified. Received: openai_proxy=z http_client=z http_async_client=rzRCould not import httpx python package. Please install it with `pip install httpx`.)proxyverifyrr) rrrrosgetenvrrget_secret_valuerrrrrrrrhttpx ImportErrorClientglobal_ssl_contextrUopenaiOpenAIrchat completionsr AsyncClientrT AsyncOpenAIr) self client_paramsrrrr&r sync_specificasync_specifics rvalidate_environment#BaseChatOpenAI.validate_environments5 66 $&&1*45 5 VV DFFQJ4>>:; ;  $ $ 0yy) 0yy./  $33SryyAR7S;?:M:M##446SW 44,,++#33!//      '+/+;+;M- (   $"2"2d6L6L,,L**K $ 6 6 !/K>1F4E3GI  {{  )9)9 $)<<++4F$0$ t// Y,T-A-A4CWCWXM &}}N}N ND **//;;DK    )?)? */):):++4F*;*&t55 2(($*>*>N &,%7%7&& &D "!% 6 6 ; ; G GD  K#%F$#%Fs0?M1N1 N ; NN  N* N%%N*c0SUR_SUR_SUR_SUR_SUR_SUR _SUR _SUR=(d S _S UR_S UR_S UR_S UR_SUR_SUR_SUR_SUR_SUR _UR"UR$S.EnUR&UR(S.UR+5VVs0sH up#UcM X#_M snnEUR,EnU$s snnf)2Get the default parameters for calling OpenAI API.rrrrrrrrNrrrrrrrrr)rr)rstream)rrrrrrrrrrrrrrrrrrrrrrr)r0exclude_if_nonerrparamss r_default_paramsBaseChatOpenAI._default_params0s  5 5 !7!7  DII  TZZ    D--   $//  DII%  $//  $//    4++   5 5     t||! " D--# $//ZZ' .__nn !0 5 5 7I 71tqt 7I    Js -E9Ec"0nSnUHknUcMURS5nUb9UR5H%upgUcM Xb;a[X&U5X&'M!XrU'M' UbMZURS5nMm X RS.nU(aX8S'U$)N token_usagesystem_fingerprint)r>r)rwrrr) r0 llm_outputsrr?outputr>rrcombineds r_combine_llm_outputs#BaseChatOpenAI._combine_llm_outputsRs$&!!F~ **]3K&'--/DAy /1D/2A2+.23A.0")%+ZZ0D%E"!""$7ooV -?) *rcURS5S:XagURS5nURS/5=(d" URS05RS/5nU(a [U5OSn[U5S:Xa[U"SUS9US 9nU$USnUS cg[ US U5n U(a0UEO0n URS 5=n (aXXS 'URS 5=n (aXS 'URS5=n (aXS'URS5=n(aXS'URS5nU(aXS'U(a[ U [ 5(aXil[X=(d SS 9nU$)Nrz content.deltausagechoiceschunkrrf)reusage_metadatargeneration_infodelta finish_reasonrrr?rr)rw_create_usage_metadatalenr<rrr rI)r0rHdefault_chunk_classbase_generation_infor>rGrIgeneration_chunkchoice message_chunkrKrMrr?rrs r"_convert_chunk_to_generation_chunk1BaseChatOpenAI._convert_chunk_to_generation_chunkks 99V  /ii( IIi $ 9yy"%)))R8 4? "; /D  w<1 2+B~V 4  $ # '? "7 7O0 7K212PR"JJ7 7= 7//::j) *2J ' jGG+9 (.!3Jd  rc +# SUS'UR"U4SU0UD6nUR(aXURRRR "S 0UD6nUR 5nS[UR50nO(URRR "S 0UD6n0nURS5n Un Sn Sn Sn SnSnU HynU (aUO0n[UU U UU UUURS9un n nnU(dM6U(aURURUS 9 Sn S URR;aSnUv M{ SSS5 g!,(df  g=f7f NTr8rheadersresponse_formatF)schemametadata has_reasoningr rHrr)_get_request_payloadrrwith_raw_response responsescreateparserxrYrw,_convert_responses_chunk_to_generation_chunkr on_llm_new_tokentextrrlr0messagesr run_managerkwargspayloadraw_context_managercontext_managerrYoriginal_schema_objresponseis_first_chunk current_indexcurrent_output_indexcurrent_sub_indexr^rHr]rRs r_stream_responses BaseChatOpenAI._stream_responsess x++HJ4J6J  ( ("&"2"2"D"D"N"N"U"U## 2779O $':'B'B"CDG"..88??J'JOG$jj):; !NM#% " !M!&47" A!(%.%"/#'#6#6  !(%$$#"#44,119I5&+N"&6&>&>&P&PP(, **3" __s%B?E%?EAE E% E"E%c T# SUS'UR"U4SU0UD6nUR(a`URRRR "S 0UD6IShvN nUR 5nS[UR50nO0URRR "S 0UD6IShvN n0nURS5n UIShvN n Sn Sn Sn SnSnU ShvN nU (aUO0n[UU U UU UUURS9un n nnU(dM<U(a"URURUS 9IShvN Sn S URR;aSnU7v MGNNNNN2 SSS5IShvN g!,IShvN (df  g=f7frX)r`rrrarbrcrdrxrYrwrer rfrgrrlrhs r_astream_responses!BaseChatOpenAI._astream_responsess x++HJ4J6J  ( (,,>>HHOO 2779O $':'B'B"CDG$($:$:$D$D$K$K$Vg$VVOG$jj):;"?h!NM#% " !M' +e&47" A!(%.%"/#'#6#6  !(%$$#")::,119I;&+N"&6&>&>&P&PP(, **UW#  +&' ( #?????sAF(!E0"AF(7E38F(E5F( F&E;*E7+E;.0F"$FE9)F0F(3F(5F(7E;9F;F< F(F F(F%F  F%!F(c UURS05RS5URRS05RS5UR/nUHn[U[5(dMUs $ UR$)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_usage)rwrrrr)r0rrkstream_usage_sourcesrs r_should_stream_usage#BaseChatOpenAI._should_stream_usages  JJ' , 0 0 A    ! !"2B 7 ; ;O L      +F&$'' +   r)rc+8# SUS'UR"U40UD6nU(aSU0US'UR"U4SU0UD6n[n0nSU;auUR(a[R "S5 UR S5 URRRRR"S0UD6n U n O}UR(aNURRR"S0UD6n U R5n S[!U R"50nOURR"S0UD6n U n U n Sn U Hn[%U[ 5(dUR'5nUR)UUU (aUO05nUcMIUR*R,nUR.=(d 0R1S 5nU(aUR3UR4UUS 9 S n Uv M SSS5 [=W S 5(aNSU;aGU R?5nURAU5nU(aUR3UR4US 9 Uv ggg!,(df  Nn=f![6R8an[;U5 SnANSnAff=f7fNTr8r|r{rrZLCannot currently include response headers when response_format is specified.rYr)rHrFget_final_completionr_r)!r~r`r rrrrrbetar,r-r8rrarcrdrxrYr model_dumprUr __class__rKrwrfrgr*BadRequestErrorrhasattrr%_get_generation_chunk_from_completionr0rirrjrrkrlrPrQresponse_streamrn raw_responserprqrHrRrrfinal_completions r_streamBaseChatOpenAI._stream"s x00HH (7'FF# $++HJ4J6J6D!  ',, ! KK !"..3388DDKKVgVO-O,,#{{<<CCNgN '--/(14 8L8L3M'N$;;--88&O * H!%%E%eT22 % 0 0 2'+'N'N+0>,B($ (/ *:*B*B*L*L' 0 @ @ FBKKJWH"#44,11"2%-5 &+N**'&!0 83 4 49Jg9U'<<> #II   ,,$))1A-# ":V 41!,%% * &q ) ) *sVD>,,#@FK( 4 4++HJ4J6J  ',, ! KK ! .++0055AAGGR'R $ $W - -"(**->"? "'9:M'N'N++55;;FgF00#'#3#3#E#E#O#O#V#V$!$L ,113H'0$|7K7K2L&MO#//99@@K7KH:*(#22    * *;;88??J'JL#))+H($|/C/C*DEO{{))4G4H''/BB7)) .*1-- .s:IJ/ I??Jc[UR[5(a UR$URS:XagURbgUR bgUR bgUR(ag[U5$)Nz responses/v1T) rrrr rrrrr)r0rls rr!BaseChatOpenAI._use_responses_apisp d,,d 3 3)) )  N 2 \\ % ^^ ' __ (  * *%g. .rrc URU5R5nUbX#S'0UREUEnURU5(aOUR(a0[ U5upgU(aUOUnU(aXuS'[ X5nU$[ XE5nU$UV s/sHn [U 5PM sn US'U$s sn f)Nrprevious_response_idri)_convert_input to_messagesr;rr_get_last_messages _construct_responses_api_payloadr) r0input_rrkrirl last_messagesrpayload_to_usems rr`#BaseChatOpenAI._get_request_payloads&&v.::<  !6N4T))4V4  " "7 + +,,6H6R3 2FH'6J23:>S ;8MIQ"Q1#;A#>"QGJ #Rs B<c/n[U[5(aUOUR5nURS5(a[ URS55eUSnUc [S5eURS5nUHn[US5n U(a%[U [5(a[U5U l U=(d 0nURS5bURS5OURS5US'SU;aUSUS'[XS 9n URU 5 M UURS UR5URS S 5S .n SU;aUSU S'SU;aUSU S'[U[R 5(a[#USS5(aUR$SR&n [)U S5(a&U R*USR&R,S'[)U S5(a&U R.USR&R,S'[1X;S9$![ a"n[ SUR 535UeSnAff=f)NerrorrGz Response missing `choices` key: z0Received response with null value for `choices`.rFrrMrrJrr?rf)r>rr?rcrrrrefusal) generations llm_output)rrxrrwrrkeysrrrrNrIr;ryrr*rNgetattrrGrrrrlrr=) r0rprKr response_dictrGrr>resrgenrs rr"BaseChatOpenAI._create_chat_resultsa  #8T22H8K8K8M    W % %]..w78 8 #I.G ?NO O#''0 C.s9~>Gz'9==)? )L&-3O77?+7($((9 O , S .1*o + RC   s #''++GT__E"/"3"34H""M = ,T2Jt  ] *)6~)FJ~ & h 0 0 1 1g i7 7 &&q)11Gw))EL^^ A&&88Bw **FMoo A&&88CkIIW 2=3E3E3G2HI  sH99 I%I  I%c # SUS'UR"U40UD6nU(aSU0US'UR"U4SU0UD6n[n0nSU;auUR(a[R "S5 UR S5 URRRRR"S0UD6n U n OUR(aVURRR"S0UD6IShvN n U R5n S[!U R"50nO$URR"S0UD6IShvN n U n U IShvN n Sn U ShvN n[%U[ 5(dUR'5nUR)UUU (aUO05nUcMOUR*R,nUR.=(d 0R1S 5nU(a#UR3UR4UUS 9IShvN S n U7v MGNNNNN SSS5IShvN OF!,IShvN (df  O/=f![6R8an[;U5 SnAOSnAff=f[=W S 5(aaSU;aZU R?5IShvN nURAU5nU(a#UR3UR4US 9IShvN U7v ggg7fr)!r~r`r rrrrrrr,r-r8rrarcrdrxrYrrrUrrrKrwrfrgr*rrrrrrs r_astreamBaseChatOpenAI._astreams x00HH (7'FF# $++HJ4J6J6D!  ',, ! KK !"4499>>JJQQO.O,,%)%6%6%H%H%O%O&&  (--/(14 8L8L3M'N$!%!2!2!9!9!DG!DD&O *&(!%#++%%eT22 % 0 0 2'+'N'N+0>,B($ (/ *:*B*B*L*L' 0 @ @ FBKKJWH")::,11"2%-; &+N**=  E'+$,',%% * &q ) ) * 83 4 49Jg9U%-%B%B%DDD #II   !22$))1A3# ":V 4sC9K1;HI ? I IK1II;& I61K16I;;-K1(J+):K1#K&$ K1c# UR(a(UR"U4X#S.UD6n[U5IShvN $UR"U4SU0UD6nSnSU;a}UR(a[ R "S5 URS5 URRRRR"S0UD6IShvN nGOUR!U5(Ga UR#S5n U (a?[%U 5(a/URR&R"S0UD6IShvN nOUR(a`URR(R&R*"S0UD6IShvN n U R5nS[-U R.50nO.URR&R*"S0UD6IShvN n[1UU UUR2S9$UR(aVUR4R(R*"S0UD6IShvN n U R5nS[-U R.50nO$UR4R*"S0UD6IShvN n[7SUR8WU5IShvN $GNmGN![Ran [U 5 Sn A NJSn A ff=fGNGNQNNN`NB7fr)rrrr`rrrrrrr,r-rdr*rrrrwrrbrarcrxrYrr rrBrrs r _agenerateBaseChatOpenAI._agenerateQs >>--#@FK/{;; ;++HJ4J6J  ',, ! KK ! .!%!7!7!"? "'9:M'N'N!%!7!7!A!A!G!G!R'!RR00"44FFPPWW%! ,113H'0$|7K7K2L&MO%)%;%;%E%E%L%L%Ww%WWH:*(#22    * *!%!2!2!D!D!K!K!Vg!VVL#))+H($|/C/C*DEO!..55@@@H$ $**Ho   W<)) .*1-- . S XWA s5K$J$AK$=J*J'J*A*K$>K?A K$K AK$KAK$3K4A K$?K K$K" K$'J**K> K K$KK$K$K$K$ K$"K$c6SUR0URE$)zGet the identifying parameters.r)rr;r0s r_identifying_params"BaseChatOpenAI._identifying_paramssdooF1E1EFFrc \>SUR0[TU] US9EUREUEnUR S5=n(ad[ U[ 5(aOUVs/sH?n[ U[5(a%UR S5S:XaSU;a0UESS0EOUOUPMA snUS'U$s snf)z,Get the parameters used to invoke the model.rrtoolsrr^rYz **REDACTED**)rsuper_get_invocation_paramsr;rwrrrx)r0rrkr:rrtrs rr%BaseChatOpenAI._get_invocation_paramss T__ g,$,7 ""   ZZ( (E (j.E.E " "DdD))dhhv.>%.G9BT8I4D4)^4t" F7O sAB)c nUR"S SU0UD6n[SURSURSUR5S9nURSUR 5=(d URSUR 5=n(aXTS'U=(d URSS 5=n(aXdS 'U$) z Get standard params for tracing.rr*r,r) ls_provider ls_model_name ls_model_typels_temperaturermax_completion_tokens ls_max_tokensNls_stopr)rrrrwrr)r0rrkr: ls_paramsrrs r_get_ls_paramsBaseChatOpenAI._get_ls_paramss,,A$A&A# // !::mT5E5EF  #JJ|T__E  #T__J  = *7o &6fjj6 67 6#*i rcg)zReturn type of chat model.z openai-chatrrs r _llm_typeBaseChatOpenAI._llm_typesrcURb URnO URn[R"U5nX4$![a SnURR S5(d@URR S5(d URR S5(aSn[R "U5nX4$f=f)N cl100k_basezgpt-4ozgpt-4.1r o200k_base)rrtiktokenencoding_for_modelrr get_encoding)r0rencodingencoders r_get_encoding_model"BaseChatOpenAI._get_encoding_models  # # /,,EOOE 62259H 6#G**844??--i88??--g66&,,W5H 6sABC  C c>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_infor get_token_idsrencode)r0rg_encoding_modelrs rrBaseChatOpenAI.get_token_idsse  $ $ 0,,T2 2   A ! #7(. . 446$$T**rc P>Ub[R"S5 [RSS::a[TU]U5$UR 5up4URS5(aSnSnOVURS5(d,URS5(dURS 5(aS nSnO[S US 35eS nUVs/sHn[U5PM n nU GHn Xu- nU R5GHupU S:XaUS - nM[U [5(Ga2U GH*n [U [5(d U SS:Xa;[U [5(aU SOU nU[UR!U55- nM]U SS:XaFU SR#S5S:XaUS- nM[%U SS5nU(dMU['U6- nMU SS:XaHU[UR!U SS55- nU[UR!U SS55- nMU SS:Xa[R"S5 GM[)SU 35e O0U (dGMeU[UR![U 555- nU S:XdGMXv- nGM GM US - nU$s snf)aCalculate num tokens for ``gpt-3.5-turbo`` and ``gpt-4`` with ``tiktoken`` package. **Requirements**: 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 `__ Args: messages: The message inputs to tokenize. tools: If provided, sequence of dict, BaseModel, function, or BaseTools to be converted to tool schemas. zECounting tokens in tool schemas is not yet supported. Ignoring tools.rrzgpt-3.5-turbo-0301r[rgpt-4rzFget_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.rrurrgrdetaillowUrrrrrbfilezEToken counts for file inputs are not supported. Ignoring file inputs.z!Unrecognized content block type )rrrrrget_num_tokens_from_messagesrrNotImplementedErrorrrrrr{rxrOrrw _url_to_size_count_image_tokensr)r0rirrrtokens_per_messagetokens_per_name num_tokensr messages_dictrkeyvaluevalrg image_sizers rr+BaseChatOpenAI.get_num_tokens_from_messagess.   MMW    A ! #77A A224   0 1 1!"  O   _ - -((((!" O%"G$LL   >FGh1!4h G$G  ,J%mmo .(!OJeT**$%c3//3v;&3H2U.V*WWJ [F2$MM!8!","EcU K#5 %:#hooc%j&A"BBJ&=1JY.%` a eHs J#z0.2.1z7langchain_openai.chat_models.base.ChatOpenAI.bind_toolsz1.0.0)since alternativeremovalc >UVs/sHn[U5PM nnUb[U[5(a US;aSU0OUn[U[5(a[ U5S:wa [ S5e[U[5(a'USSUS:wa[ SUSUSSS35e0UES U0En[ TU]"S S U0UD6$s snf) asBind functions (and other objects) to this chat model. Assumes model is compatible with OpenAI function-calling API. .. note:: Using ``bind_tools()`` is recommended instead, as the ``functions`` and ``function_call`` request parameters are officially marked as deprecated by OpenAI. Args: functions: A list of function definitions to bind to this chat model. Can be a dictionary, pydantic model, or callable. Pydantic models and callables will be automatically converted to their schema dictionary representation. function_call: Which function to require the model to call. Must be the name of the single provided function or ``'auto'`` to automatically determine which function to call (if any). **kwargs: Any additional parameters to pass to the :class:`~langchain.runnable.Runnable` constructor. )autononerbrzGWhen specifying `function_call`, you must provide exactly one function.rzFunction call z3 was specified, but the only provided function was .rh functionsr)rFrr{rxrOrrbind)r0rrhrkfnformatted_functionsrs rbind_functionsBaseChatOpenAI.bind_functions?s FIRR "9"= R  $mS11!)99'#  -..37J3Kq3P   =$//'*62mF6KK $]O4--@-CF-K,LAO@??Fw|D&9DVDD-SsC) tool_choicestrictparallel_tool_callsc >UbXES'UVs/sH n[XcS9PM nn/nUH>nSU;aURUSS5 M"SU;aURUS5 M>M@ U(a{[U[5(a&X(;aSSU0S.nOUU[;aSU0nOFUS:XaSnO=O<[U[ 5(aSnO$[U[ 5(aO[S U35eX%S '[T U]$"S S U0UD6$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 :meth:`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 `__. 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). kwargs: Any additional parameters are passed directly to :meth:`~langchain_openai.chat_models.base.ChatOpenAI.bind`. .. versionchanged:: 0.1.21 Support for ``strict`` argument added. rrrrrb)rrrranyrequiredzEUnrecognized tool_choice type. Expected str, bool or dict. Received: rrr) rGryrr{WellKnownToolsrrxrrr) r0rrrrrkrtformatted_tools tool_namesrs r bind_toolsBaseChatOpenAI.bind_toolszs9X  *,?( )DI DID "4 7E   #DT!!!$z"26":;4!!$v,/ $ +s++, *%+[$9#K!N2#);"7K!E)",KK..( K.. !!, /%0= !w|`__ - ``'json_schema'``: Uses OpenAI's Structured Output `API `__ Supported for ``'gpt-4o-mini'``, ``'gpt-4o-2024-08-06'``, ``'o1'``, and later models. - ``'json_mode'``: Uses OpenAI's `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 the methods and which models support which methods `here `__. 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 `__. - False: Input schema will not be validated and model output will not be validated. - None: ``strict`` argument will not be passed to the model. 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. .. dropdown:: Example .. code-block:: 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 llm = init_chat_model("openai:gpt-4o-mini") structured_llm = llm.with_structured_output( ResponseSchema, tools=[get_weather], strict=True, include_raw=True, ) structured_llm.invoke("What's the weather in Boston?") .. code-block:: 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 :class:`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'``: Optional[BaseException] .. versionchanged:: 0.1.20 Added support for TypedDict class ``schema``. .. versionchanged:: 0.1.21 Support for ``strict`` argument added. Support for ``method="json_schema"`` added. .. versionchanged:: 0.3.12 Support for ``tools`` added. .. versionchanged:: 0.3.21 Pass ``kwargs`` through to the model. json_modez7BaseChatOpenAI.with_structured_output..sRVr)rrcgr rr!s rr"r#sdr)rr) exception_key)rr)rr issubclass BaseModelV1rrrrrG_filter_disabled_paramsrxrr8r7rr6r5"_convert_to_openai_response_formatr?r_oai_structured_outputs_parserrr with_typesrAassignr with_fallbacksr@)r0r\rrrrrkis_pydantic_schema tool_name bind_kwargsllm output_parserrZt parser_assign parser_noneparser_with_fallbacks rwith_structured_output%BaseChatOpenAI.with_structured_outputsbV  &K"7N 07 ] "#z&+'F'F ? ,**733??--h77??g- A$//ARS??, ' '~ %/v6zB6JI66  $-,1%17&J&,5    K//6(:k:C!*=!($(+ !9&! { "))  )/(?'/&8&,5   C&%V<%'  } $~ %AWO $3-3"F"8"@1   KFK(FK*1> >& &5(s+Kc UR(dU$0nUR5H<up4X0R;a$URUbX@RU;aM8XBU'M> U$r )rr)r0rkfilteredrrs rr(&BaseChatOpenAI._filter_disabled_paramssg##MLLNDA((($$Q'/18L8LQ8O3O  #rcDURU5nURSRn[U[5(a8UR nSUR ;aUR RS5 OSn[SUR US9n[XRRS9$)zDGet chunk from completion (e.g., from final completion of a stream).rriNrf)rerlrIrJ) rrrrrrIrlrr r<r)r0 completion chat_result chat_messagerIrs rr4BaseChatOpenAI._get_generation_chunk_from_completions..z: "..q199 lI . .)88N|===..22<@!N *<<)  #-C-C  r)rrrrrrrr)rrreturnr)rArSrAr)r@zlist[Optional[dict]]rArx)rHrxrPrrQOptional[dict]rAzOptional[ChatGenerationChunk])NN) rilist[BaseMessage]rrrj"Optional[CallbackManagerForLLMRun]rkrrAIterator[ChatGenerationChunk]) rirDrrrj'Optional[AsyncCallbackManagerForLLMRun]rkrrA"AsyncIterator[ChatGenerationChunk]r )rrrkrrAr) rirDrrrjrErrrkrrArF) rirDrrrjrErkrrAr=rlrxrArrrrrrkrrArx)rpzUnion[dict, openai.BaseModel]rKrCrAr=) rirDrrrjrGrrrkrrArH) rirDrrrjrGrkrrAr=)rrrkrrAr)rrrkrrAr)rAr{)rAztuple[str, tiktoken.Encoding])rgr{rAz list[int])rirDrzCOptional[Sequence[Union[dict[str, Any], type, Callable, BaseTool]]]rAr)rzDSequence[Union[dict[str, Any], type[BaseModel], Callable, BaseTool]]rhzs>O7CJC#'K'+#(#>L.>V*/9ISW)X+N'&+4z%JO]J_).t>)RRP"' >#L-EJIEOAL$ "&K%<(,o,$)--;D-#Hn#%"&L-&#,0J(/PIt/A}A!E?!D %d 3J 3/&*m* +/I'. $I}# *.-J7;O3:7;M4;%*$$EK!E+0d*K'KW,1$FV,WD )W!.2J+2&&+d*Z05d0CO-C"$(G ' #'L-&!E>  !%J $&+d*!F)-~,59N18$t4L(#$ (#$*'"M#M^B26 6 "6 - 6 ' 6 v%):> 3+#3+"3+8 3+  3+ ' 3+p%)?C 5+#5+"5+= 5+  5+ , 5+p.2!*!=@! !,%):> D# (, D##D#"D#8 D# % D#D# 'D#R%):> 2C#2C"2C8 2C  2C  2Ch/(%) ""     :+/?J/?J(?J  ?JH%)?C H# (, H##H#"H#= H# % H#H# ,H#Z%)?C 8 #8 "8 = 8  8  8 tGG +/':= ,+/':= &$+  d#d d ddLM  4EW4E 4E  4E 34E  4Ex !%.2S=HS= S=S=,S=S= 3S=S=n26K' !!% $K'.K' K'K'K'K'K' 7K'Z  *   rrc0^\rSrSr%Sr\"SSS9rS\S'\SSj5r \ SS j5r \SS j5r \ SS j5r \SU4S jj5rSS .SU4SjjjrSU4SjjrSU4SjjrSSSSS.SU4SjjjjrSrU=r$) ChatOpenAIiuZOpenAI chat model integration. .. dropdown:: Setup :open: Install ``langchain-openai`` and set environment variable ``OPENAI_API_KEY``. .. code-block:: bash pip install -U langchain-openai export OPENAI_API_KEY="your-api-key" .. dropdown:: Key init args — completion params model: str Name of OpenAI model to use. temperature: float Sampling temperature. max_tokens: Optional[int] Max number of tokens to generate. logprobs: Optional[bool] Whether to return logprobs. stream_options: Dict Configure streaming outputs, like whether to return token usage when streaming (``{"include_usage": True}``). use_responses_api: Optional[bool] Whether to use the responses API. See full list of supported init args and their descriptions in the params section. .. dropdown:: Key init args — client params timeout: Union[float, Tuple[float, float], Any, None] Timeout for requests. max_retries: Optional[int] Max number of retries. api_key: Optional[str] OpenAI API key. If not passed in will be read from env var ``OPENAI_API_KEY``. base_url: Optional[str] Base URL for API requests. Only specify if using a proxy or service emulator. organization: Optional[str] 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 in the params section. .. dropdown:: Instantiate .. code-block:: python from langchain_openai import ChatOpenAI llm = ChatOpenAI( model="gpt-4o", temperature=0, max_tokens=None, timeout=None, max_retries=2, # api_key="...", # base_url="...", # organization="...", # other params... ) .. note:: Any param which is not explicitly supported will be passed directly to the ``openai.OpenAI.chat.completions.create(...)`` API every time to the model is invoked. For example: .. code-block:: 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) .. dropdown:: Invoke .. code-block:: python messages = [ ( "system", "You are a helpful translator. Translate the user sentence to French.", ), ("human", "I love programming."), ] llm.invoke(messages) .. code-block:: pycon AIMessage( content="J'adore la programmation.", response_metadata={ "token_usage": { "completion_tokens": 5, "prompt_tokens": 31, "total_tokens": 36, }, "model_name": "gpt-4o", "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}, ) .. dropdown:: Stream .. code-block:: python for chunk in llm.stream(messages): print(chunk.text(), end="") .. code-block:: 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", ) .. code-block:: python stream = llm.stream(messages) full = next(stream) for chunk in stream: full += chunk full .. code-block:: python AIMessageChunk( content="J'adore la programmation.", response_metadata={"finish_reason": "stop"}, id="run-bf917526-7f58-4683-84f7-36a6b671d140", ) .. dropdown:: Async .. code-block:: python await llm.ainvoke(messages) # stream: # async for chunk in (await llm.astream(messages)) # batch: # await llm.abatch([messages]) .. code-block:: python AIMessage( content="J'adore la programmation.", response_metadata={ "token_usage": { "completion_tokens": 5, "prompt_tokens": 31, "total_tokens": 36, }, "model_name": "gpt-4o", "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, }, ) .. dropdown:: Tool calling .. code-block:: 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" ) llm_with_tools = llm.bind_tools( [GetWeather, GetPopulation] # strict = True # enforce tool args schema is respected ) ai_msg = llm_with_tools.invoke( "Which city is hotter today and which is bigger: LA or NY?" ) ai_msg.tool_calls .. code-block:: 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:: ``openai >= 1.32`` supports a ``parallel_tool_calls`` parameter that defaults to ``True``. This parameter can be set to ``False`` to disable parallel tool calls: .. code-block:: python ai_msg = llm_with_tools.invoke( "What is the weather in LA and NY?", parallel_tool_calls=False ) ai_msg.tool_calls .. code-block:: 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 ``llm.bind(parallel_tool_calls=False)`` or during instantiation by setting ``model_kwargs``. See ``ChatOpenAI.bind_tools()`` method for more. .. dropdown:: Built-in tools .. versionadded:: 0.3.9 You can access `built-in tools `_ supported by the OpenAI Responses API. See LangChain `docs `__ for more detail. .. note:: ``langchain-openai >= 0.3.26`` allows users to opt-in to an updated AIMessage format when using the Responses API. Setting .. code-block:: python llm = ChatOpenAI(model="...", 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. .. code-block:: python from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-4.1-mini", output_version="responses/v1") tool = {"type": "web_search_preview"} llm_with_tools = llm.bind_tools([tool]) response = llm_with_tools.invoke( "What was a positive news story from today?" ) response.content .. code-block:: 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": "", } ], } ] .. dropdown:: Managing conversation state .. versionadded:: 0.3.9 OpenAI's Responses API supports management of `conversation state `_. Passing in response IDs from previous messages will continue a conversational thread. See LangChain `conversation docs `__ for more detail. .. code-block:: python from langchain_openai import ChatOpenAI llm = ChatOpenAI( model="gpt-4.1-mini", use_responses_api=True, output_version="responses/v1", ) response = llm.invoke("Hi, I'm Bob.") response.text() .. code-block:: python "Hi Bob! How can I assist you today?" .. code-block:: python second_response = llm.invoke( "What is my name?", previous_response_id=response.response_metadata["id"], ) second_response.text() .. code-block:: python "Your name is Bob. How can I help you today, Bob?" .. versionadded:: 0.3.26 You can also initialize ChatOpenAI with :attr:`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. .. code-block:: python llm = ChatOpenAI(model="gpt-4.1-mini", use_previous_response_id=True) .. dropdown:: Reasoning output OpenAI's Responses API supports `reasoning models `_ that expose a summary of internal reasoning processes. .. note:: ``langchain-openai >= 0.3.26`` allows users to opt-in to an updated AIMessage format when using the Responses API. Setting .. code-block:: python llm = ChatOpenAI(model="...", 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. .. code-block:: python from langchain_openai import ChatOpenAI reasoning = { "effort": "medium", # 'low', 'medium', or 'high' "summary": "auto", # 'detailed', 'auto', or None } llm = ChatOpenAI( model="o4-mini", reasoning=reasoning, output_version="responses/v1" ) response = llm.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"]) .. code-block:: none Output: 3³ = 27 Reasoning: The user wants to know... .. dropdown:: Structured output .. code-block:: python from typing import Optional 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: Optional[int] = Field( description="How funny the joke is, from 1 to 10" ) structured_llm = llm.with_structured_output(Joke) structured_llm.invoke("Tell me a joke about cats") .. code-block:: python Joke( setup="Why was the cat sitting on the computer?", punchline="To keep an eye on the mouse!", rating=None, ) See ``ChatOpenAI.with_structured_output()`` for more. .. dropdown:: JSON mode .. code-block:: python json_llm = llm.bind(response_format={"type": "json_object"}) ai_msg = json_llm.invoke( "Return a JSON object with key 'random_ints' and a value of 10 random ints in [0-99]" ) ai_msg.content .. code-block:: python '\n{\n "random_ints": [23, 87, 45, 12, 78, 34, 56, 90, 11, 67]\n}' .. dropdown:: Image input .. code-block:: python import base64 import httpx from langchain_core.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 = llm.invoke([message]) ai_msg.content .. code-block:: python "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." .. dropdown:: Token usage .. code-block:: python ai_msg = llm.invoke(messages) ai_msg.usage_metadata .. code-block:: python {"input_tokens": 28, "output_tokens": 5, "total_tokens": 33} When streaming, set the ``stream_usage`` kwarg: .. code-block:: python stream = llm.stream(messages, stream_usage=True) full = next(stream) for chunk in stream: full += chunk full.usage_metadata .. code-block:: python {"input_tokens": 28, "output_tokens": 5, "total_tokens": 33} Alternatively, setting ``stream_usage`` when instantiating the model can be useful when incorporating ``ChatOpenAI`` into LCEL chains-- or when using methods like ``.with_structured_output``, which generate chains under the hood. .. code-block:: python llm = ChatOpenAI(model="gpt-4o", stream_usage=True) structured_llm = llm.with_structured_output(...) .. dropdown:: Logprobs .. code-block:: python logprobs_llm = llm.bind(logprobs=True) ai_msg = logprobs_llm.invoke(messages) ai_msg.response_metadata["logprobs"] .. code-block:: python { "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": [], }, ] } .. dropdown:: Response metadata .. code-block:: python ai_msg = llm.invoke(messages) ai_msg.response_metadata .. code-block:: python { "token_usage": { "completion_tokens": 5, "prompt_tokens": 28, "total_tokens": 33, }, "model_name": "gpt-4o", "system_fingerprint": "fp_319be4768e", "finish_reason": "stop", "logprobs": None, } .. dropdown:: Flex processing OpenAI offers a variety of `service tiers `_. 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"``: .. code-block:: python from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="o4-mini", service_tier="flex") Note that this is a beta feature that is only available for a subset of models. See OpenAI `flex processing docs `__ for more detail. .. dropdown:: OpenAI-compatible APIs ``ChatOpenAI`` can be used with OpenAI-compatible APIs like `LM Studio `__, `vLLM `__, `Ollama `__, and others. To use custom parameters specific to these providers, use the ``extra_body`` parameter. **LM Studio example** with TTL (auto-eviction): .. code-block:: python from langchain_openai import ChatOpenAI llm = 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 ) **vLLM example** with custom parameters: .. code-block:: python llm = 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}, ) .. dropdown:: 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`` .. code-block:: python # Standard OpenAI parameters llm = ChatOpenAI( model="gpt-4o", 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, etc.) - Parameters that need to be nested under ``extra_body`` in the request - Any non-standard OpenAI API parameters .. code-block:: python # Custom provider parameters llm = 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 .. important:: Always use ``extra_body`` for custom parameters, **not** ``model_kwargs``. Using ``model_kwargs`` for non-OpenAI parameters will cause API errors. .. dropdown:: Prompt caching optimization For high-volume applications with repetitive prompts, use ``prompt_cache_key`` per-invocation to improve cache hit rates and reduce costs: .. code-block:: python llm = ChatOpenAI(model="gpt-4o-mini") response = llm.invoke( messages, prompt_cache_key="example-key-a", # Routes to same machine for cache hits ) customer_response = llm.invoke(messages, prompt_cache_key="example-key-b") support_response = llm.invoke(messages, prompt_cache_key="example-key-c") # Dynamic cache keys based on context cache_key = f"example-key-{dynamic_suffix}" response = llm.invoke(messages, prompt_cache_key=cache_key) 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. Nrrrrc SS0$)Nrrrrs r lc_secretsChatOpenAI.lc_secrets s "233rc /SQ$)z*Get the namespace of the langchain object.) langchain chat_modelsr*rrs rget_lc_namespaceChatOpenAI.get_lc_namespace s 65rc0nUR(aURUS'UR(aURUS'UR(aURUS'U$)Nrrr)rrr)r0 attributess r lc_attributesChatOpenAI.lc_attributes sZ%'  # #040H0HJ, -   ,0,@,@J( )   )-):):J~ &rcg)z9Return whether this model can be serialized by LangChain.Trr\s ris_lc_serializableChatOpenAI.is_lc_serializable srcP>[TU]nSU;aURS5US'U$)r7rr)rr;r)r0r:rs rr;ChatOpenAI._default_params s0( 6 !.4jj.FF* + rrc ">[TU]"U4SU0UD6nSU;aURS5US'UR(aO[R "SUR5(a)UR S/5HnUSS:XdMSUS'M U$) Nrrrz^o\drirarorp)rr`rrrematchrw)r0rrrkrlrrs rr`ChatOpenAI._get_request_payload s'.vKDKFK 7 "/6{{UR0UEURE5(a[TU] "U0UD6$[TU]"U0UD6$)+Route to Chat Completions or Responses API.)rrrrur)r0rrkrs rrChatOpenAI._stream, sN  " "#Bf#B0A0A#B C C7,d=f= =7?D3F3 3rc># UR0UEURE5(a [TU] "U0UD6ShvN nU7v M[TU]"U0UD6ShvN nU7v MN+ gN g7f)rmN)rrrrxr)r0rrkrHrs rrChatOpenAI._astream3 sv  " "#Bf#B0A0A#B C C$w94J6J e $w/@@ e  J @sJ5A0A*A(A*A0A.A,A. A0(A**A0,A..A0rFrrrc ,>[TU]"U4X#US.UD6$)a7Model wrapper that returns outputs formatted to match the given schema. Args: schema: The output schema. Can be passed in as: - a JSON Schema, - a TypedDict class, - or a Pydantic class, - an OpenAI function/tool schema. 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 :meth:`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 `__. Supported for ``'gpt-4o-mini'``, ``'gpt-4o-2024-08-06'``, ``'o1'``, and later models. - ``'function_calling'``: Uses OpenAI's tool-calling (formerly called function calling) `API `__ - ``'json_mode'``: Uses OpenAI's `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 the methods and which models support which methods `here `__. 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 `__. - 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. .. dropdown:: Example .. code-block:: 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 llm = init_chat_model("openai:gpt-4o-mini") structured_llm = llm.with_structured_output( ResponseSchema, tools=[get_weather], strict=True, include_raw=True, ) structured_llm.invoke("What's the weather in Boston?") .. code-block:: 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 :class:`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'``: Optional[BaseException] .. versionchanged:: 0.1.20 Added support for TypedDict class ``schema``. .. versionchanged:: 0.1.21 Support for ``strict`` argument added. Support for ``method="json_schema"`` added. .. versionchanged:: 0.3.0 ``method`` default changed from "function_calling" to "json_schema". .. versionchanged:: 0.3.12 Support for ``tools`` added. .. versionchanged:: 0.3.21 Pass ``kwargs`` through to the model. .. dropdown:: 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 `here `__. .. code-block:: python from typing import Optional 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: Optional[str] = Field( default=..., description="A justification for the answer." ) llm = ChatOpenAI(model="gpt-4o", temperature=0) structured_llm = llm.with_structured_output(AnswerWithJustification) structured_llm.invoke( "What weighs more a pound of bricks or a pound of feathers" ) # -> 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.' # ) .. dropdown:: Example: schema=Pydantic class, method="function_calling", include_raw=False, strict=False .. code-block:: python from typing import Optional 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: Optional[str] = Field( default=..., description="A justification for the answer." ) llm = ChatOpenAI(model="gpt-4o", temperature=0) structured_llm = llm.with_structured_output( AnswerWithJustification, method="function_calling" ) structured_llm.invoke( "What weighs more a pound of bricks or a pound of feathers" ) # -> 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.' # ) .. dropdown:: Example: schema=Pydantic class, method="json_schema", include_raw=True .. code-block:: 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 llm = ChatOpenAI(model="gpt-4o", temperature=0) structured_llm = llm.with_structured_output( AnswerWithJustification, include_raw=True ) structured_llm.invoke( "What weighs more a pound of bricks or a pound of feathers" ) # -> { # '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 # } .. dropdown:: Example: schema=TypedDict class, method="json_schema", include_raw=False, strict=False .. code-block:: python # IMPORTANT: If you are using Python <=3.8, you need to import Annotated # from typing_extensions, not from typing. 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[ Optional[str], None, "A justification for the answer." ] llm = ChatOpenAI(model="gpt-4o", temperature=0) structured_llm = llm.with_structured_output(AnswerWithJustification) structured_llm.invoke( "What weighs more a pound of bricks or a pound of feathers" ) # -> { # '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.' # } .. dropdown:: Example: schema=OpenAI function schema, method="json_schema", include_raw=False .. code-block:: 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'] } } llm = ChatOpenAI(model="gpt-4o", temperature=0) structured_llm = llm.with_structured_output(oai_schema) structured_llm.invoke( "What weighs more a pound of bricks or a pound of feathers" ) # -> { # '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.' # } .. dropdown:: Example: schema=Pydantic class, method="json_mode", include_raw=True .. code-block:: from langchain_openai import ChatOpenAI from pydantic import BaseModel class AnswerWithJustification(BaseModel): answer: str justification: str llm = ChatOpenAI(model="gpt-4o", temperature=0) structured_llm = llm.with_structured_output( AnswerWithJustification, method="json_mode", include_raw=True ) structured_llm.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?" ) # -> { # '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 # } .. dropdown:: Example: schema=None, method="json_mode", include_raw=True .. code-block:: structured_llm = llm.with_structured_output(method="json_mode", include_raw=True) structured_llm.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?" ) # -> { # '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 # } rq)rr7)r0r\rrrrkrs rr7!ChatOpenAI.with_structured_output> s-F w-  !6 MS  rr)rAzdict[str, str])rAz list[str]rB)rArrJ)rrrkrrArF)rrrkrrArHr ) r\rLrrMrrrrrkrrArN)rrrr__doc__rPrrrQrWrPr]rardr;r`rrr7rrRrSs@rrUrUs?j X!&d:Q RJ R/ 4466  %) ""     (4  $'  + 26e KX!!% e .e H e  e  e e  7e e rrUcF[U[5=(a [U5$r )rrrJ)objs rrr s c4 ?%:3%??rcLSUSUS[R"USSS9S.S.$) NrrrcrbrF) ensure_asciirbrrrcrr)jsondumps)rs rrr s6of%If$5EJ  rc&SUSUSUSS.S.$)Nrrrcrbrryrzr)invalid_tool_calls rrr s.%%f-*62  rc>SSKJn [ U5(aYSSKnURU5nUR5 UR[UR55RupEXE4$[U5(aSURSS5upg[R "U5nUR[U55RupEXE4$g![a [R S5 gf=f![a [R S5 gf=f)Nr)ImagezaUnable to count image tokens. To count image tokens please install `pip install -U pillow httpx`.zZUnable to count image tokens. To count image tokens please install `pip install -U httpx`.,r)PILrr'loggerinfo_is_urlr&rwraise_for_statusopenr resize_is_b64splitr b64decode) image_sourcerr&rpwidthheightrencodedrs rrr s|  99\*!!# 78+;+;#<=BB }   !''Q/ ( 74=166 }3   -    KK*   s"CC:C76C7:DDcj[X5up[US- 5n[US- 5nSU-U-S-$)Nir)_resizer )rrhws rrr s=E*ME Vc\A US[A !GaK2 rc[U5n[URUR/5$![a"n[ R SU35 SnAgSnAff=f)NzUnable to parse URL: F)rallschemenetlocrzrdebug)sresultrs rrr sO!FMM6==122  ,QC01s+. AAAc$URS5$)Nz data:image)r)rs rrr s << %%rcUS:dUS:aX:a US-U-nSnO US-U-nSnUS:a"US:aX:a US-U-nSnX4$US-U-nSnX4$)Niir)rrs rrr s t|v} >tm-FET\f,EF s{v| >S[V+EF =ckf,FE =rr cd[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.nUbEXSR S5La/[U[5(aS USSS US 3n[U5eU$) Nrrrbr\)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.) rrrJrxrwrrFrr)r\rrZrrmsgs rr)r) s;&$$9&$A$A  64  V # JJv - /  FD ! !f&68v;M#0H >&$''Jvzz(7KT,R,R)-fD%\\,7#0J  -8<D"II  '**+BCIrNN  !"%%&ABHbMM  &))*EFL"QQ  " !#!- 3 9 9 ;M ;qtqt ;M 0 4 : : <N <tqt <N    NOsE$%E$ E*E*cURSS5nURSS5nURSX-5nSURS5=(d 0RS50nSURS 5=(d 0RS 50n[UUU[S 0UR5VVs0sH upgUcM Xg_M snnD6[ S 0UR5VVs0sH upgUcM Xg_M snnD6S 9$s snnfs snnf) Nrrrrroutput_tokens_detailsrrinput_tokens_detailsrrrr)rrrrrrrrs r _create_usage_metadata_responsesrr s"&&~q9L#'';M"&&~|7STLo))*ABHbMM  " **+ABHbMM  ! !#!- 3 9 9 ;M ;qtqt ;M 0 4 : : <N <tqt <N    NOs1C<=C<"D.Dc*SU;=(a USS:g$)Nrrrr)rts r_is_builtin_toolr s T> 8d6lj88rcSU;=(a [SUS55n1Skn[U=(d URU55$)Nrc36# UHn[U5v M g7fr )r).0rts r %_use_responses_api.. s4+;4+;s>rgrrrr)r r intersection)rluses_builtin_toolsresponses_only_argss rrr sR G+4+27+;41 "O&9&F&Fw&O PPrc[[U5S- SS5HOnXn[U[5(dMURR S5nU(a XS-SU4s $US4s $ US4$)a- 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``. rr[rcN)rangerOrrresponse_metadatarw)riir response_ids rrr sw3x=1$b" -k c9 % %//33D9KA(+55~%. T>rcDSHnX!;dM URU5US'M SU;aSU;aSURS50US'URSS5nURS5(aURS S5 [U5US 'URS S5=n(a/nUHznUS S :Xa S U;aUR S S 0US E5 M,US S:Xa4SU;a [ S5eURS5(a SU;aSUS'OUR U5 M| XQS 'URSS5=n(a5[ U[5(aUS S :XaS U;a S S 0US EUS'OXqS'URSS5=n(aURS5(aUSn [SU<SU <35eURSS5n URS5(d[U5(aXS'Ou[U5(aUR5n Sn OUn U S S0:Xa SS S00US'O>[XS9=n (a-[ U [5(aU S S:XaSS S0U SE0US'OURSS5n U bSU;a SS S00US'XSS'U$) N)rrmax_output_tokensrreffortrrfrrinputrrrrr_partial_imageszPartial image generation is not yet supported via the LangChain ChatOpenAI client. Please drop the 'partial_images' key from the image_generation tool.r8rrrZrgzNCan specify at most one of 'response_format' or 'text', received both: schema=z text=r text_formatTrformatr rr) rrwr_construct_responses_api_inputryrrrxrrmodel_json_schemar))rirllegacy_token_paramrr new_toolsrtrr\rgr schema_dictrZrs rrr sF  (+2;;7I+JG' (FW$G)C ('++6H*IJ  KK $E    M4(5h?GG GT**u* DF|z)jD.@  &*!IZ8H!IJ<#55'4/1$ !X..3C43O23-.  &-0%kk-66{6 {D ) )F#z1k)&,j%TK .#s- (D% (M9 E(s) )rrrAacknowledged_safety_checks)rurrernextrl)rrrAs r'_make_computer_call_output_from_messagers''&"'//4((    (gooF%+"#w'@'@@=D=V=V (> 9: rcSnURHZn[U[5(dMURS5S:XdM1SURURS5=(d SS.n U$ U$)Nrcustom_tool_call_outputrArf)rrrA)rerrxrwru)rcustom_tool_outputrs r%_make_custom_tool_output_from_messager3sl eT " "uyy'82($  23 [K '#''),d33 ^E!%..%))FBS4SJ4S%)KK%*YYt_F)-DD,9,1&M3899]3K3Qr-" ",y!8,5/4Y/?-" )//3xx~$=G$=7CT'0'<:<Y$(O$:$:9$E$) )/!' 094=;0;.4 %&!"( , #MM*B5*IJ'+BB"MM)@d T!i,jCGGI.44 ) +-:C N$S#T!WW\488z8"($!'yy(,QQ%"U*%E)$!'!$ ",I .>>$3$-j$9&$A)2:)>{)K'0 )  m4",9"[; ;#i.$// )C& ^EV}."))<v*WXv+5$1).{);E)B% !-11(;;27 2DX2NIh/")))4v&0%+\$KU6]$K ")))4v*UU"))%0v*@@ e,/,0",Iy>MM#&" c" MM# ]` Mi$sR!R) Rc,[US5(a UR$/nURHUnURS:XdMURH0nURS:XdMUR UR 5 M2 MW SRU5$)z1OpenAI SDK deleted response.output_text in 1.99.2rrrf)rrrArreryrgjoin)rptextsrAres r_get_output_textrstx''###E// ;;) #!>><<=0LL.*" 775>rc UR(a[UR5eURSSS9R5VVs0sHupEUS;dM XE_M nnnU(aUR U5 UR S5US'UR (a$[UR R55nOSn/n/n /n 0n URGH7n U RS:XaU RHn U RS :XatS U RU RVs/sHnUR5PM snU RS .nURU5 [U S 5(aU R U S 'U RS :XdMURS U R"U RS.5 M MU RS:XaURU RSSS95 [$R&"U R(SS9nSnUc/SU R.UU R0S.nU RU5 GMkSU R.UU R0US.nU RU5 GMU RS:XaZURU RSSS95 SU R.SU R20U R0S.nU RU5 GMU RS;dGMURU RSSS95 GM: [5U5nUbS U ;aU(aUR(aURR5=n(alUR S05=n(aSUR S5S:Xa>[$R&"U5nU(a[7U5(a U"S 0UD6nOUnUU S '[9UURUUU U U S9nUS:Xa [;U5nO[=[?US9/S9$s snnfs snf![*a"nU R(n[-U5nSnAGN+SnAff=f![$R*a Nf=f)!z9Construct ChatResponse from OpenAI Response API response.Tr{ exclude_noner ) created_atrcincomplete_detailsr]objectstatusrdrrrrNrrrg)rrgrrcrr)rrrcrhFr r)rrbrrcr~)rrbrrcrr__arg1) rrrrrrrrrrrr)rercrIrrlrirmrr)rr) rrrrupdaterwrFrrArrergrrcryrrrr{loadsrr r{rbrrrrrrWr=r;)rpr\r]r rrrrIcontent_blocksrirmrlrAre annotationrrrrrr text_configformat_ parsed_dictrrs rrrs~~((''T'GMMOODA    O$  *&7&;&;G&Dl#~~9(..:S:S:UVNJ // ;;) #!>><<=0 & ' /6.A.A(.A '113.A(%iiE#))%0w116=nn)(3<<9,"))!*wfiiX*$[[O +  ! !&"3"3F"3"S T zz&"2"25A}'"KK  ..  !!),0"KK  .."  #)))4 [[. .  ! !&"3"3F"3"S T# !6<<0nn I   i ( [[     ! !&"3"3F"3"S TC"d#8,K - -  MM$MM446 6[ 6#"5 5W 5 [[ M 1 **[1K,V44.+.$*0 h ' ;;%++-G,W5 >'#B"C DDcL($# ''A T##   s< P P $P /!P=Q QP;;QQQc 6 ^^^S/S0UUU4Sjjjn/n /n 0n U(aUn O0n Sn SnURS:Xa>U"URUR5 U RSURTS.5 GOURS:XazU"URUR5 [ UR [5(a UR nOUR RSSS9nU RU/TS .5 GO\URS :Xa U RURTS .5 GO,URS :Xa1URRnURRU S 'GOURS:Xa[[[URXGS9RSR 5nUR"R%S5=n(aUU S'UR&n UR(R+5VVs0sHunnUS :wdMUU_M n nnGO6URS:Xa:UR,RS:Xa US:XaUR,RnGOGOURS:XaUR,RS:XaU"UR5 U RSUR,R.UR,R0UR,R2TS.5 U RSUR,R.UR,R0UR,R2UR,RTS.5 GOURS:Xa^UR,RS;aDU"UR5 UR,RSSS9nTUS'U RU5 GOURS:XaUR,RS:XaU"UR5 UR,RSSS9nTUS'U RU5 U RSUR,R.[4R6"SUR,R805UR,R2TS.5 GOURS:XaRU"UR5 U RSURTS.5 U RSURTS .5 GOLURS!:Xa U RS"UR:S#.5 GOURS:Xa]UR,RS$:XaCU"UR5 UR,RSSS9nTUS'U RU5 OURS%:Xa7U"UR5 U RUR<S&S'S(./TS$S).5 OhURS*:XaOWURS+:XaAU"UR5 U RUR<S&URS(./TS$S).5 OTTTS4$[?U U U U U US,9nUS:Xa[[>[AUUS-95nOTTT[CUS.94$s snnf)1NcR>UcTU:waTS- mUmgTU:wdTU:waTS- mUmUmg)asAdvance indexes tracked during streaming. Example: we stream a response item of the form: .. code-block:: 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: .. code-block:: 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_idxrrrsrts r_advance>_convert_responses_chunk_to_generation_chunk.._advancesMH ?#z1" *% 28IW8T" ' )rzresponse.output_text.deltarg)rrgrz%response.output_text.annotation.addedTr{r)rrzresponse.output_text.done)rcrzresponse.createdrczresponse.completed)r\r rrzresponse.output_item.addedrrrhr4)rrbrrcr)rrbrrrcrzresponse.output_item.done)rrrrrrrrrrr z&response.function_call_arguments.delta)rrr)rrrzresponse.refusal.donerrrz%response.reasoning_summary_part.added summary_textrf)rrrg)rrrz,response.image_generation_call.partial_imagez%response.reasoning_summary_text.delta)rerrIrrlrc)r^rr )rrrrrANone)"r output_index content_indexryrLrrrxrrrprcrrrrrrlrwrIrrrrbrrr{r|rr summary_indexr rWr<)rHrrrsrtr\r]r^r rrerrlrrIrcrrrrrrrrs ``` rreres+*+*ZG $N B zz11##U%8%89 mTU > >##U%8%89 e&& - -))J))44$V4TJ |mLM 2 2emmmDE ) ) ^^  "'.."3"3$ + + 7NN6Q   **..x8 86 8*0 h '++ 2288: :TQa4iDAqD:   3 3 98T T !B  22 JJOO .##$)  ,,jj((&    ' "ZZ11 ::--jjmm&    2 2uzz K 8 ##$jj++F+K , G{# 11 JJOO1 1##$jj++F+K , G{#)  Hejj.>.>#?@jj((&    ? ?##$& m T  $5;; W  . . emmDE 3 3 ;8V##$JJ))t&)I * 'y! > >##$$11>SUV'#    E E > >##$"'!4!4 . % '#  24EtKK)%++ G  &wm L  G,  } s  ZZ)r|Mapping[str, Any]rAr!)rerrAr)rr!rArx)r|r!rztype[BaseMessageChunk]rAr")rUnion[int, dict]rr"rAr")rzopenai.BadRequestErrorrAr)rvrrAr)rr,rArx)r~r)rArx)rr{rAzOptional[tuple[int, int]])rrrrrAr)rr{rAr)rrrrrAztuple[int, int])r\zUnion[dict[str, Any], type]rrrAzUnion[dict, TypeBaseModel])rrr\z type[_BM]rAzOptional[PydanticBaseModel])rrxrAr3)rtrxrArrI)riSequence[BaseMessage]rAz+tuple[Sequence[BaseMessage], Optional[str]])rir#rlrxrArx)rr-rArx)rr-rArC)rrxrArx)rir#rAr)rprXrAr{)NNr) rprXr\Optional[type[_BM]]r]rCr r rAr=)NNFr)rHrrrrrsrrtrr\r$r]rCr^rr r rAz3tuple[int, int, int, Optional[ChatGenerationChunk]])rt __future__rrr{loggingr#risslrrcollections.abcrrrr functoolsrior r mathr operatorr typingr rrrrrrrr urllib.parsercertifir*rlangchain_core._api.deprecationrlangchain_core.callbacksrrlangchain_core.language_modelsr*langchain_core.language_models.chat_modelsrrrrlangchain_core.messagesrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0langchain_core.messages.air1r2r3langchain_core.messages.toolr4langchain_core.output_parsersr5r6*langchain_core.output_parsers.openai_toolsr7r8r9r:langchain_core.outputsr;r<r=langchain_core.runnablesr>r?r@rAlangchain_core.runnables.configrBlangchain_core.toolsrClangchain_core.tools.baserDlangchain_core.utilsrE%langchain_core.utils.function_callingrFrGlangchain_core.utils.pydanticrHrIrJlangchain_core.utils.utilsrKrLrMpydanticrNrOrPrQrR pydantic.v1r'typing_extensionsrS*langchain_openai.chat_models._client_utilsrTrU$langchain_openai.chat_models._compatrVrWopenai.types.responsesrX getLoggerrrcreate_default_contextwherer)r rrrrrrrrrxr{r_DictOrPydanticClass_DictOrPydanticrrrUrrrrrrrrr)r*rzrrNrrrrrrrrrrrrerrrrMs"  FF    " 6> ( 9P SR <)09 VUMM0" /   8 $//w}}GEPP*ZDN66 66-C6666r)6F64Ie9%T#s(^T#Y<=c "+Y+ A ]A H2a a H%@ &   >&*FJ$ '$4B$$N  (   &  B69 Q#00b#b.2b bJ .  Sl  #'#48 [E[E [E[E2 [E  [EF#'#48a aaa a a  aa2a9ar