hhdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZmZddlmZddlmZddlmZddlmZdd lmZdd lmZmZmZmZmZmZm Z m!Z!m"Z"dd l#m$Z$ddl%Z%ddl&Z&ddl'Z'dd l(m)Z)dd l*m+Z+m,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFddlGmHZHmIZImJZJddlKmLZLddlMmNZNmOZOddlPmQZQmRZRmSZSmTZTddlUmVZVmWZWmXZXddlYmZZZm[Z[m\Z\m]Z]ddl^m_Z_ddl`maZaddlbmcZcddldmeZeddlfmgZgmhZhddlimjZjmkZkmlZlddlmmnZnmoZompZpddlqmrZrmsZsmtZtmuZumvZvddlwmrZxdd lymzZzdd!l{m|Z|m}Z}dd"l~mZmZerdd#lmZejeZej e%j$Zd%ZdPd&ZdQd'ZdRd(Z dSd)Z dTd*ZdUd+ZGd,d-eZe d.er/Ze!eeefeeefZe!eefZGd0d1eZGd2d3e0ZGd4d5eZdVd6ZdWd7Z dXd8ZdYd9ZdZd:Zd[d;Zd[d<Zd\d=Zdd> d]d?Z d^d@ZGdAdBeZd_dCZd_dDZd`dEZdadFZ dbdGZ dcdHZdddIZdedJZdfdKZdgdLZdhdMZ di djdNZ dk dldOZy)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 ,|jd}|jd}|jd}|dk(rt|jdd||S|dk(r|jddxsd}i}|jd x}rt||d <g}g}|jd x} r)| |d <| D]} |jt | d !|jdx} r| |d<t||||||S|dvr+|dk(rd|i}ni}t|jdd|||S|dk(r;t|jddtt|jd|S|dk(rKi}d|vr|d|d<t|jddtt|jd|||St|jdd||S#t $r/} |jt | t| Yd } ~ [d } ~ wwxYw)zConvert 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 _/var/www/html/eduruby.in/venv/lib/python3.12/site-packages/langchain_openai/chat_models/base.py_convert_dict_to_messagersX 99V D 99V D ))D/C v~EIIi$<4PP  ))Ir*0b"$!IIo6 6= 615m1D o . "YY|4 4> 4.< l +!/  %%omt&TU IIg& &5 &). g &/!1    ( ( ; !2D 9  " IIi,/    IIi,4UYYv=N3OTW    U?(-f f %IIi,c599^#<=/   599Y#;$3OOS!&--.}c!fEs7G H$$HHc |r`t|trOg}|D]E}t|tr d|vr|ddvr t|tr&t|r|j t |Vt|tr|j ddk(r|j dx}rt|tr|j ddk(rC|j dx}r0|j dx}r|j dd d |d |id |j dd k(r+|j d x}r|j dd |id 35|j |H|S|}|S) zFormat message content.type)tool_usethinkingreasoning_contentimagesourcebase64 media_typedata image_urlurlzdata:z;base64,rr) isinstancelistrxr0ryr/rw)reformatted_contentblockrrrrs r_format_message_contentrsv:gt," 0E5$'eO&M%RRE4(-B5-I!(()Ee)LM5$'IIf%0$yy22V2vt,::f%1#)::l#;;Z;!'F!333%,,$/*/5 HTF1S)T ZZ'50VZZ=N6Nc6N%,,!,E3<H!((/E" 0L $ c 0dt|ji}|jxs|jj dx}||d<t |t r|j|d<|St |trd|d<|St |trBd|d<|js |jrK|jDcgc] }t|c}|jDcgc] }t|c}z|d<nd|jvrX|jd|d<hd}|dDcgc]+}|jDcic] \}}||vs ||c}}-c}}}|d<n"d |jvr|jd |d <n d |vsd|vr |dxsd|d<d |jvr.|jd }d |vrd |jd d in|} | |d <|St |tr!|jj d d |d<|St |t rd|d<|St |t"rBd|d<|j$|d<hd} |jDcic] \}}|| vs ||}}}|St'd|cc}wcc}wcc}}wcc}}}wcc}}w)zConvert a LangChain message to a dictionary. Args: message: The LangChain message. Returns: The dictionary. rerbNrardrgri>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*:<1"5*"44:"=*L & W66 6)0)B)B<)PL &(B %".l!;**#,//"3V$!Qq J JJ  J#JJ c |jd}tt|jd}tt|jdxsd}i}|jdr!t|d}d|vr |dd|d<||d<g}|jdx}rX||d< |D cgc]G} t | djd| djd | jd| d  I}} |d k(s |t k(r t || S|dk(s |tk(rt||||S|dvs |tk(r|dk(rddi}ni}t|||S|dk(s |tk(rt||d|S|dk(s |tk(rt||d|S|s |tk(rt|||S||| Scc} w#t $rYwxYw)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,' *   Z,,V4Z,,[9wwt}g,     v~*;; S99    ?/-   ( (M=O,O ; !2K @  " !7H    }0DD#G%-CPP =,<<%*?C   "22dsCCW55M    s%#F:'A F53F:5F:: GGc t|tr8t|ts#tdt|dt|||zSt|trqt|ts#tdt|dt||j Dcic]"\}}|t |j|d|$c}}Stjdt||Scc}}w)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!-s37 ?#5.A)B(CE ... It $-t47 ?#5.A)B(CE  ") 1 "#6#:#:1a#@!D D   9$y/9JKL  s'C-cd|jvrd}tj||d|jvrd}tj||)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 rceZdZUded<y) _FunctionCallr{rbN__name__ __module__ __qualname____annotations__rrrrs Irr_BM)boundc,eZdZUded<ded<ded<y)_AllReturnTyper!rawzOptional[_DictOrPydantic]parsedzOptional[BaseException] parsing_errorNrrrrrrs  %%**rrceZdZUeddZded<eddZded<eddZded<eddZded<ed d Z d ed < dZ ded< ee Z ded< ede ddZded<edd Zded< edd Zded< eeddZded<edd Zd!ed"< d#Zd$ed%< dZd&ed'< dZded(< dZded)< dZd&ed*< dZd+ed,< dZd&ed-< dZd.ed/< d#Zd$ed0< dZd&ed1< dZded2< edZd&ed3< dZ ded4< dZ!d5ed6< dZ"ded7< dZ#ded8< dZ$d9ed:<dZ%d;ed<<eddZ&d=ed>< eddZ'd=ed?< edd@ Z(dAedB< dZ)dCedD< d#Z*d$edE< edZ+d5edF< dZ,dGedH< dZ-dedI< dZ.d+edJ< dZ/dedK< d#Z0d$edL< dZ1d+edM< dNZ2dOedP< e3dQZ4e5dRSe6dzdTZ7e5dRSe6dzdUZ8e5dVSd{dWZ9e:d|dXZ;d}dYZ< d~dZZ= d dd[Z> d dd\Z? d dd]Z@ ddd^ dd_ZA d dd`ZBddaZCddb ddcZD d dddZE ddd^ ddeZF d ddfZGe:d|dgZH d dfdh ZI d ddiZJe:ddjZKddkZLdfdl ZM d dfdm ZNeOdndodpq d dfdr ZPdddds dfdtZQ ddud#dddv ddwZRddxZS ddyZTxZUS)BaseChatOpenAINT)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)modec4t|}t||}|S)z>Build extra kwargs from additional params that were passed in.)rErK)clsvaluesall_required_field_namess r build_extrazBaseChatOpenAI.build_extras!$j2j4|_|S#t$$r}t%d|d}~wwxYw#t$$r}t%d|d}~wwxYw)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_environmentz#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=L=L7 L4# L//L47 M M  Mcid|jd|jd|jd|jd|jd|j d|j d|jxsd d |jd |jd |jd |jd|jd|jd|jd|jd|j |j"|j$d}|j&|j(d|j+Dcic] \}}| || c}}|j,}|Scc}}w)2Get the default parameters for calling OpenAI API.rrrrrrrrNrrrrrrrrr)rr)rstream)rrrrrrrrrrrrrrrrrrrrrrr)r,exclude_if_nonerrparamss r_default_paramszBaseChatOpenAI._default_params0s  5 5 !7!7  DII  TZZ    D--   $//  DII%  $//  $//    4++   5 5     t||! " D--# $//ZZ' .__nn !0 5 5 7I11=q!tI    Js ( E 3E c i}d}|D]c}||jd}|7|jD]$\}}| ||vrt|||||< |||<&|S|jd}e||jd}|r||d<|S)N token_usagesystem_fingerprint)r8r)rwrrr) r, llm_outputsrr9outputr8rrcombineds r_combine_llm_outputsz#BaseChatOpenAI._combine_llm_outputsRs$&!! FF~ **]3K&'--/3DAqy //1D/2A2+A.23+A.3")%+ZZ0D%E"! F"$7dooV -?H) *rc|jddk(ry|jd}|jdgxs"|jdijdg}|r t|nd}t|dk(rt|d|| }|S|d}|d yt |d |} |ri|ni} |jd x} rM| | d <|jd x} r| | d <|jdx} r| | d<|jdx}r|| d<|jd}|r|| d<|rt | t r|| _t| | xsd }|S)Nrz content.deltausagechoiceschunkrrf)reusage_metadatargeneration_infodelta finish_reasonrrr9rr)rw_create_usage_metadatalenr<rrr rB)r,rAdefault_chunk_classbase_generation_infor8r@rBgeneration_chunkchoice message_chunkrDrFrr9rrs r"_convert_chunk_to_generation_chunkz1BaseChatOpenAI._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) *2OJ ' jG+9M (.!?3Jd  rc +Kd|d<|j|fd|i|}|jrX|jjjj d i|}|j }dt|ji}n(|jjj d i|}i}|jd} |5} d} d} d} d}d}| D]l}| r|ni}t|| | || |||j\} } }}|s.|r|j|j| d} d |jjvrd}|n dddy#1swYyxYww NTr3rheadersresponse_formatF)schemametadata has_reasoningrrArr)_get_request_payloadrrwith_raw_response responsescreateparserxrQrw,_convert_responses_chunk_to_generation_chunkron_llm_new_tokentextrrlr,messagesr run_managerkwargspayloadraw_context_managercontext_managerrQoriginal_schema_objresponseis_first_chunk current_indexcurrent_output_indexcurrent_sub_indexrVrArUrKs r_stream_responsesz BaseChatOpenAI._stream_responsess x+$++HJ4J6J  ( ("U$"2"2"D"D"N"N"U"U## 2779O $':'B'B"CDG?d..88??J'JOG$jj):;  +!NM#% " !M! +&47" A!(%.%"/#'#6#6  !(%$$"#44,119I5&+N"&6&>&>&P&PP(, **3 +  + + +s%B:E<:E7AE9 EE Ec &Kd|d<|j|fd|i|}|jr`|jjjj d i|d{}|j }dt|ji}n0|jjj d i|d{}i}|jd} |4d{} d} d} d} d}d}| 23d{}| r|ni}t|| | || |||j\} } }}|s4|r%|j|j| d{d} d |jjvrd}|}77777/6dddd{7y#1d{7swYyxYwwrP)rXrrrYrZr[r\rxrQrwr]rr^r_rrlr`s r_astream_responsesz!BaseChatOpenAI._astream_responsess x+$++HJ4J6J  ( (Od,,>>HHOO 2779O $':'B'B"CDG$KD$:$:$D$D$K$K$Vg$VVOG$jj):;" + +h!NM#% " !M' + +e&47" A!(%.%"/#'#6#6  !(%$$")::,119I;&+N"&6&>&>&P&PP(, **UW +  +&' (  + + + + +sAFEAF2E!3FE#F E<!E)%E%&E))+E<"E<7E'8&E<F!F#F%E)'E<)E<* F5E86F<FF F Fc ||jdijd|jjdijd|jg}|D]}t|ts|cS|jS)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)r,rrcstream_usage_sourcesrs r_should_stream_usagez#BaseChatOpenAI._should_stream_usages  JJ' , 0 0 A    ! !"2B 7 ; ;O L      + F&$'     r)rc+Kd|d<|j|fi|}|rd|i|d<|j|fd|i|}t}i}d|vro|jrt j d|j d|jjjjjdi|} | } nx|jrN|jjjdi|} | j} dt!| j"i}n|jjdi|} | } | 5} d} | D]}t%|t s|j'}|j)||| r|ni}|=|j*j,}|j.xsij1d }|r|j3|j4|| d } | dddt= d rJd|vrE| j?}|jA|}|r|j3|j4| |yyy#1swY`xYw#t6j8$r}t;|Yd}~d}~wwxYwwNTr3rrrqrrRLCannot currently include response headers when response_format is specified.rQr)rArFget_final_completionrWr)!rtrXr rrrrrbetar(r)r3rrYr[r\rxrQr model_dumprNr __class__rDrwr^r_r&BadRequestErrorrhasattrrx%_get_generation_chunk_from_completionr,rarrbrrcrdrIrJresponse_streamrf raw_responserhrirArKrrfinal_completions r_streamzBaseChatOpenAI._stream"s x0t00HH (7'FF# $+$++HJ4J6J6D!  ',, ! KK !Kd..3388DDKKVgVO-O,,Ct{{<<CCNgN '--/(14 8L8L3M'N$-4;;--88&O *  +H!%%+E%eT2 % 0 0 2'+'N'N+0>,B($ (/ *:*B*B*L*L' 0 @ @ FBKKJWH"#44,11"2%-5 &+N**'+ +0 83 49Jg9U'<<> #II   ,,$))1A-# ":V 41 + +,%% * &q ) ) *sJD*I%-H:/BH.H:AI%.H73H::I" II%I""I%c |jr!|j|f||d|}t|S|j|fd|i|}d}d|vro|jrt j d|jd |jjjjjdi|}no|j!|r|j#d} | r2t%| r'|jj&jdi|}n|jrX|jj(j&j*di|} | j}dt-| j.i}n&|jj&j*di|}t1|| ||j2S|jrN|j4j(j*di|} | j}dt-| j.i}n|j4j*di|}|j7|S#tj$r} t| Yd} ~ 5d} ~ wwxYw N)rrbrrRrwr3rQ)rTrUrr)rrrrXrrrrrryr(r)r\r&r|r_use_responses_apirw_is_pydantic_classrZrYr[rxrQ'_construct_lc_result_from_responses_apirr_create_chat_result r,rarrbrc stream_iterrdrDrhrrgrs r _generatezBaseChatOpenAI._generatehsC >>&$,,#@FK( 4 4+$++HJ4J6J  ',, ! KK ! .G4++0055AAGGR'R $ $W -"(**->"? "'9:M'N;4++55;;FgF00#V4#3#3#E#E#O#O#V#V$!$L ,113H'0$|7K7K2L&MO@t//99@@K7KH:*(#22    * *?4;;88??J'JL#))+H($|/C/C*DEO)t{{))4G4H''/BB7)) .*1-- .s<:H99I! II!ct|jtr |jS|jdk(ry|jy|j y|j y|jryt|S)Nz responses/v1T) rrrrrrrrr)r,rds rrz!BaseChatOpenAI._use_responses_apism d,,d 3)) )  N 2 \\ % ^^ ' __ (  * *%g. .rrc \|j|j}|||d<i|j|}|j|rC|jr)t |\}}|r|n|}|r||d<t ||}|St ||}|S|D cgc] } t| c} |d<|Scc} w)Nrprevious_response_idra)_convert_input to_messagesr6rr_get_last_messages _construct_responses_api_payloadr) r,input_rrcrard last_messagesrpayload_to_usems rrXz#BaseChatOpenAI._get_request_payloads&&v.::<  !F6N4T))4V4  " "7 +,,6H6R3 32FH'6JG23:>7S ;8WMIQ"Q1#;A#>"QGJ #RsB)cpg}t|tr|n|j}|jdrt |jd |d}| td|jd}|D]}t|d} |r t| trt|| _ |xsi}|jd|jdn|jd|d<d|vr|d|d<t| | } |j| ||jd |j|jd d d } d|vr|d| d<d|vr|d| d<t|tj rt#|ddr}|j$dj&} t)| dr&| j*|dj&j,d<t)| dr&| j.|dj&j,d<t1|| S#t $r"}t d|j |d}~wwxYw)Nerrorr@z Response missing `choices` key: z0Received response with null value for `choices`.r?rrFrrCrr9rf)r8rr9rcrrrrefusal) generations llm_output)rrxrzrwrrkeysrrrrGrBr;ryrr&rNgetattrr@rr}rrlrr=) r,rhrDr response_dictr@rr8resrgenrs rrz"BaseChatOpenAI._create_chat_resultsS  #8T2H8K8K8M    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 1g i7 &&q)11Gw)EL^^ A&&88Bw *FMoo A&&88CkjIIW 2=3E3E3G2HI  sH H5H00H5c ~Kd|d<|j|fi|}|rd|i|d<|j|fd|i|}t}i}d|vro|jrt j d|j d|jjjjjdi|} | } n|jrV|jjjdi|d{} | j} dt!| j"i}n$|jjdi|d{} | } | 4d{} d} | 23d{}t%|t s|j'}|j)||| r|ni}|C|j*j,}|j.xsij1d }|r&|j3|j4|| d{d } |7 77776dddd{7n#1d{7swYnxYwn+#t6j8$r}t;|Yd}~nd}~wwxYwt= d r]d|vrX| j?d{7}|jA|}|r&|j3|j4| d{7|yyywrv)!rtrXr rrrrrryr(r)r3rrYr[r\rxrQrrzrNrr{rDrwr^r_r&r|rr}rxr~rs r_astreamzBaseChatOpenAI._astreams x0t00HH (7'FF# $+$++HJ4J6J6D!  ',, ! KK !Qd4499>>JJQQO.O,,%OT%6%6%H%H%O%O&&  (--/(14 8L8L3M'N$!9!2!2!9!9!DG!DD&O *& + +(!%#+++%%eT2 % 0 0 2'+'N'N+0>,B($ (/ *:*B*B*L*L' 0 @ @ FBKKJWH")::,11"2%-; &+N**=  E ++$, + + + + +,%% * &q ) ) * 83 49Jg9U%-%B%B%DDD #II   !22$))1A3# ":V 4sC'J=)G4*A J=5G76J==H(G9H(H G?G;G?BH'G=( H4J=7J=9H(;G?=H?H H( H H(H$H H$ H('J=(I; I J= I&J=6I978J=/J20 J=cK|jr)|j|f||d|}t|d{S|j|fd|i|}d}d|vrw|jrt j d|jd |jjjjjdi|d{}n|j!|r|j#d} | r:t%| r/|jj&jdi|d{}n|jr`|jj(j&j*di|d{} | j}dt-| j.i}n.|jj&j*di|d{}t1|| ||j2S|jrV|j4j(j*di|d{} | j}dt-| j.i}n$|j4j*di|d{}t7d|j8|d{S7O7#tj$r} t| Yd} ~ Id} ~ wwxYw77N777_7Awr)rrrrXrrrrrryr(r)r\r&r|rrrwrrZrYr[rxrQrrrrBrrs r _ageneratezBaseChatOpenAI._agenerateQs >>'$--#@FK/{;; ;+$++HJ4J6J  ',, ! KK ! .!S!7!7!"? "'9:M'N!G!7!7!A!A!G!G!R'!RR00Wd44FFPPWW%! ,113H'0$|7K7K2L&MO%LT%;%;%E%E%L%L%Ww%WWH:*(#22    * *!K!2!2!D!D!K!K!Vg!VVL#))+H($|/C/C*DEO5T..55@@@H$ $**Ho   W<)) .*1-- . S XWA s1KJAK=JJJAK#J3$AK(J6)AK>J9?AKJ;A KJ=K=J?>KJJ0 J+&K+J00K6K9K;K=K?Kc6d|ji|jS)zGet the identifying parameters.r)rr6r,s r_identifying_paramsz"BaseChatOpenAI._identifying_paramssdooF1E1EFFrc :d|jit| ||j|}|j dx}rUt |t rE|Dcgc]6}t |tr"|j ddk(rd|vri|ddin|n|8c}|d<|Scc}w)z,Get the parameters used to invoke the model.rrtoolsrr^rQz **REDACTED**)rsuper_get_invocation_paramsr6rwrrrx)r,rrcr5rrtr{s rrz%BaseChatOpenAI._get_invocation_paramss T__ g,$,7 ""   ZZ( (E (j.E " dD)dhhv.>%.G9BT8I4D4)^4tF7O s;Bc P|jd d|i|}td|jd|jd|j}|jd|j xs|jd|j x}r||d<|xs|jdd x}r||d <|S) 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)r,rrcr5 ls_paramsrrs r_get_ls_paramszBaseChatOpenAI._get_ls_paramss-,,A$A&A# // !::mT5E5EF  #JJ|T__E  #T__J  = *7Io &6fjj6 67 6#*Ii rcy)zReturn type of chat model.z openai-chatrrs r _llm_typezBaseChatOpenAI._llm_typesrcx|j |j}n |j} tj|}||fS#t$rpd}|jj ds6|jj ds|jj drd}tj |}Y||fSwxYw)N cl100k_basezgpt-4ozgpt-4.1r o200k_base)rrtiktokenencoding_for_modelrr get_encoding)r,rencodingencoders r_get_encoding_modelz"BaseChatOpenAI._get_encoding_models  # # /,,EOOE 62259Hh 6#G**84??--i8??--g6&,,W5Hh 6sAA3B98B9c|j|j|Stjddkrt||S|j \}}|j |S)z9Get the tokens present in the text with tiktoken package.r)custom_get_token_idssys version_infor get_token_idsrencode)r,r__encoding_modelr{s rrzBaseChatOpenAI.get_token_idssg  $ $ 0,,T2 2   A ! #7(. . 446>$$T**rc |tjdtjddkrt||S|j \}}|jdrd}d}nG|jds"|jds|jd rd }d}ntd |d d }|Dcgc] }t|} }| D]} ||z }| jD]n\} } | dk(r|d z }t| tr| D]} t| ts| ddk(r5t| tr| dn| }|t|j!|z }Q| ddk(r=| dj#ddk(r|dz }vt%| dd}|s|t'|z }| ddk(rG|t|j!| ddz }|t|j!| ddz }| ddk(rtjdt)d| n*| s=|t|j!t| z }| dk(sj||z }q|d z }|Scc}w)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-0301rSrgpt-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.rrurr_rdetaillowUrrrrrbfilezEToken counts for file inputs are not supported. Ignoring file inputs.z!Unrecognized content block type )rrrrrget_num_tokens_from_messagesrrNotImplementedErrorrrrrr{rxrHrrw _url_to_size_count_image_tokensr)r,rarrrtokens_per_messagetokens_per_name num_tokensr messages_dictrkeyvaluevalr_ image_sizer{s rrz+BaseChatOpenAI.get_num_tokens_from_messagess.   MMW    A ! #77A A224x   0 1!"  O   _ -((!" O%"G$LL   >FG1!4G G$. 2G , ,J%mmo, 2 U.(!OJeT*$%c3/3v;&3H2U.V*WWJ [F2$MM!8!","EcU K#5:#hooc%j&A"BBJ&=/1JY, 2. 2` a eHs4Iz0.2.1z7langchain_openai.chat_models.base.ChatOpenAI.bind_toolsz1.0.0)since alternativeremovalc f|Dcgc] }t|}}|t|tr|dvrd|in|}t|trt |dk7r t dt|tr&|dd|dk7rt d|d|dddi|d |i}t |d d |i|Scc}w) aBind 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{rxrHrrbind)r,rrhrcfnformatted_functionsr{s rbind_functionszBaseChatOpenAI.bind_functions?sFIRR"9"=RR  $mS1!)99'#  -.37J3Kq3P   =$/'*62mF6KK $]O4--@-CF-K,LAO@??Fw|D&9DVDD-SsB.) tool_choicestrictparallel_tool_callsc |||d<|Dcgc]}t||}}g}|D]7}d|vr|j|ddd|vr|j|d89|rit|tr"||vrdd|id}nH|tvrd|i}n;|dk(rd}n3n2t|t rd}nt|t rntd |||d <t |$d d |i|Scc}w) a`Bind 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) r,rrrrrcrtformatted_tools tool_namesr{s r bind_toolszBaseChatOpenAI.bind_toolszs;X  *,?F( )DI <@ "4 7   # DT!!!$z"26":;4!!$v,/   +s+*, *%+[$9#K!N2#);"7K!E)",KK.( K. !!, /%0F= !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_modezz7BaseChatOpenAI.with_structured_output..r)rrcyrrrs rrz7BaseChatOpenAI.with_structured_output..rr)rr) exception_key)rr)rr issubclass BaseModelV1rrrrrG_filter_disabled_paramsrxrr8r7rr6r5"_convert_to_openai_response_formatr?r_oai_structured_outputs_parserrr with_typesrAassignr with_fallbacksr@)r,rTrrrrrcis_pydantic_schema tool_name bind_kwargsllm output_parserrRt parser_assign parser_noneparser_with_fallbacks rwith_structured_outputz%BaseChatOpenAI.with_structured_outputshV  &K"7N 07 ] "#z&+'F ? ,**73??--h7??g- A$//ARS??, ' '~ %/v6zB6JI6$66  $-,1%176&J&,5    K"$//6(:k:C!*=!($(+ !9&! { "$))  )/(?'/&8&,5   C&%V<%'  } $~ %APVWO $3-3v"F"8"@1   KFK(AB*1V<( G$$))*k*C! .:4fCUV!*dF);*<!1 2 ++1(!5  /66!%(=8M.44NKK#0#?#? _$@$ 3'*>> >& &5(s Kc |js|Si}|jD]9\}}||jvr!|j|||j|vr5|||<;|Sr)rr)r,rcfilteredrrs rr z&BaseChatOpenAI._filter_disabled_paramsst##MLLN DAqD((($$Q'/18L8LQ8O3O   rcD|j|}|jdj}t|tr6|j }d|j vr|j jdnd}td|j |}t||jS)zDGet chunk from completion (e.g., from final completion of a stream).rriNrf)rerlrBrC) rrrrrrBrlrr r<r)r, completion chat_result chat_messagerBrs rr~z4BaseChatOpenAI._get_generation_chunk_from_completions..z: "..q199 lI .)88N|===..22<@!N *<<)  #[-C-C  r)rrreturnr)r#rSr#r)r:zlist[Optional[dict]]r#rx)rArxrIrrJOptional[dict]r#zOptional[ChatGenerationChunk])NN) ralist[BaseMessage]rrrb"Optional[CallbackManagerForLLMRun]rcrr#Iterator[ChatGenerationChunk]) rar&rrrb'Optional[AsyncCallbackManagerForLLMRun]rcrr#"AsyncIterator[ChatGenerationChunk]r)rrrcrr#r) rar&rrrbr'rrrcrr#r() rar&rrrbr'rcrr#r=rdrxr#rrrrrrcrr#rx)rhzUnion[dict, openai.BaseModel]rDr%r#r=) rar&rrrbr)rrrcrr#r*) rar&rrrbr)rcrr#r=)rrrcrr#r)rrrcrr#r)r#r{)r#ztuple[str, tiktoken.Encoding])r_r{r#z list[int])rar&rzCOptional[Sequence[Union[dict[str, Any], type, Callable, BaseTool]]]r#r)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 dLM  4EW4E 4E  4E 34E  4Ex !%.2S=HS= S=S=,S=S= 3S=n26K' !!% $K'.K' K'K'K'K'K' 7K'Z  *  rrc eZdZUdZeddZded< eddZe ddZ edd Z e dd Z edfd Z dd  dfd Zdfd Z dfd Z ddddd dfdZxZS) ChatOpenAIucOpenAI 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 ddiS)Nrrrrs r lc_secretszChatOpenAI.lc_secrets s "233rc gdS)z*Get the namespace of the langchain object.) langchain chat_modelsr&rr s rget_lc_namespacezChatOpenAI.get_lc_namespace s 65rci}|jr|j|d<|jr|j|d<|jr|j|d<|S)Nrrr)rrr)r, attributess r lc_attributeszChatOpenAI.lc_attributes sZ%'  # #040H0HJ, -   ,0,@,@J( )   )-):):J~ &rcy)z9Return whether this model can be serialized by LangChain.Trr=s ris_lc_serializablezChatOpenAI.is_lc_serializable srcLt|}d|vr|jd|d<|S)r2rr)rr6r)r,r5r{s rr6zChatOpenAI._default_params s0( 6 !.4jj.FF* + rrc t||fd|i|}d|vr|jd|d<|jrEt j d|jr%|j dgD]}|ddk(s d|d<|S) Nrrrz^o\drararorp)rrXrrrematchrw)r,rrrcrdrr{s rrXzChatOpenAI._get_request_payload s'.vKDKFK 7 "/6{{Model 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 # } rK)rr)r,rTrrrrcr{s rrz!ChatOpenAI.with_structured_output> s/F w-  !{6 MS  r)r#zdict[str, str])r#z list[str]r$)r#rr,)rrrcrr#r()rrrcrr#r*r) rTr.rr/rrrrrcrr#r0)rrr__doc__rPrrr3r9r2r>rArCr6rXrrrr4r5s@rr7r7s:j X!&d:Q RJ R/ 4466  %) ""     (4  $'  + 26e KX!!% e .e H e  e  e e  7e e rr7c<t|txr t|Sr)rrrJ)objs rrr s c4 ?%:3%??rcPd|d|dtj|ddddS) NrrrcrbrF) ensure_asciirbrrrcrr)jsondumps)rs rrr s6of%If$5EJ  rc&d|d|d|dddS)NrrrcrbrrRrSr)invalid_tool_calls rrr s.%%f-*62  rc. ddlm}t |r[ ddl}|j|}|j|jt|jj\}}||fSt|rU|jdd\}}tj |}|jt|j\}}||fSy#t$rtj dYywxYw#t$rtj dYywxYw)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)PILrYr#loggerinfo_is_urlr"rwraise_for_statusopenr resize_is_b64splitr b64decode) image_sourcerYr"rhwidthheightrencodedrs rrr s |  99\*!!# 78+;+;#<=BB vf}  !''Q/ 7( 74=166 vf}3   -    KK*   s"CC3C0/C03DDcnt||\}}t|dz }t|dz }d|z|zdzS)Nir)_resizer )rfrghws rrr sAE6*ME6 Vc\A US[A !GaK2 rc t|}t|j|jgS#t$r"}t j d|Yd}~yd}~wwxYw)NzUnable to parse URL: F)rallschemenetlocrzr\debug)sresultrs rr^r^ sO!FMM6==122  ,QC01s+. AAAc$|jdS)Nz data:image)r)rss rrbrb s << %%rc|dkDs|dkDr||kDr |dz|z}d}n |dz|z}d}|dkDr"|dkDr||kDr|dz|z}d}||fS|dz|z}d}||fS)Niir)rfrgs rrkrk s t|v} 6>tm-FET\f,EF s{v| 6>S[V+EF &=ckf,FE &=rrct|tr t|r|St|trd|vr|j ddk(r|}n}t|trd|vr d|vrd|d}n_|7t|tr%t|j dt r|d}nd}t ||}|jd |d<d|d}|@||dj dur*t|trd |ddd |d }t||S) NrrrbrT)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)rTrrRrrmsgs rrr s*&$$9&$A  64 V # JJv - /  FD !f&68v;M#0H >&$'Jvzz(7KT,R)-fVD%\\,7#0J  /-8<D"II  '**+BCIrNN  !"%%&ABHbMM  &))*EFL"QQ  " !#!- 3 9 9 ;M1q}q!tM 0 4 : : <N1 q!tN    NOs7 EE& E1Ec|jdd}|jdd}|jd||z}d|jdxsijdi}d|jd xsijd i}t|||td i|jDcic] \}}| || c}}t d i|jDcic] \}}| || c}} Scc}}wcc}}w) Nrrrrroutput_tokens_detailsrrinput_tokens_detailsrrrr)rrrrrrrrs r _create_usage_metadata_responsesrr s"&&~q9L#'';M"&&~|m7STLo))*ABHbMM  " **+ABHbMM  ! !#!- 3 9 9 ;M1q}q!tM 0 4 : : <N1 q!tN    NOs( C23C2 C8"C8cd|vxr|ddk7S)Nrrrr)rts r_is_builtin_toolr s T> 8d6lj88rc|d|vxrtd|dD}hd}t|xs|j|S)Nrc32K|]}t|ywr)r).0rts r z%_use_responses_api.. s4#'4s>r_rrrr)rr intersection)rduses_builtin_toolsresponses_only_argss rrr sR G+4+27+;41 "O&9&F&Fw&O PPrctt|dz ddD]F}||}t|ts|jj d}|r ||dzd|fcS|dfcS|dfS)aI 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``. rrSrcN)rangerHrrresponse_metadatarw)rairy response_ids rrr s}3x=1$b" -&qk c9 %//33D9KA(+55~%& T>rcdD]}||vs|j||d<d|vrd|vrd|jdi|d<|jdd}|jdr|jd dt||d <|jd dx}rwg}|D]k}|d d k(rd |vr|j d d i|d (|d dk(r+d|vr t d|jdr d|vrd|d<n |j |m||d <|jddx}r.t |tr|d d k(rd |vr d d i|d |d<n||d<|jddx}r|jdr|d} td|d| |jdd} |jdst|r||d<nht|r|j} d} n|} | d dik(r dd dii|d<n7t| | x} r't | tr| d dk(rdd di| di|d<n |jdd} | d|vr dd dii|d<| |dd<|S) 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.r3rrrRr_zNCan specify at most one of 'response_format' or 'text', received both: schema=z text=r text_formatTrformatrrr) rrwr_construct_responses_api_inputryrrrxrrmodel_json_schemar)rardlegacy_token_paramrr new_toolsrtrrTr_r schema_dictrRrs rrr sFK  (+2;;7I+JG' (KW$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  s"$rrr;acknowledged_safety_checks)rurrernextrl)rrr;s r'_make_computer_call_output_from_messagers''&"'//4(    (gooF%+"#w'@'@@=D=V=V (> 9: rcd}|jD]M}t|ts|jddk(s)d|j|jdxsdd}|S|S)Nrcustom_tool_call_outputr;rf)rrr;)rerrxrwru)rcustom_tool_outputrs r%_make_custom_tool_output_from_messager3sn eT "uyy'8||d<|Scc}}wcc}}w)zWhen streaming, langchain-core uses the ``index`` key to aggregate text blocks. OpenAI API does not support this key, so we need to remove it. rsummary)rrrry)rrr new_block new_summary sub_block new_sub_blocks r_pop_index_and_sub_indexrAs#(++-@$!Q1<A@I@I*Yy-A4"H "9- .I.7oo.?Pda12($  23 [K '#''),d3 ^4!E!%.%))FBS4SJ4S%)KK%*YYt_F)-DD,9,1&M3899]3K3Qr-" ",y!8,5/4Y/?-" )/"/3xx~$=G$=7fCT'0'<:<Y$(O$:$:9$E$) "!' 094=;0;.4 %&!"( , #MM*B5*IJ'+BB"MM)@d T!i4!jCGGI.4 ) +-:C N$S#T!WW\488z8"($yy(,QQ!U*)$$ $ ",5I .>>$3$-j$9&$A)2:)>{)K'0 )  m45[; ;#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# ]N` Mi$s3#O:ct|dr |jSg}|jD]N}|jdk(s|jD]-}|jdk(s|j |j /Pdj|S)z1OpenAI SDK deleted response.output_text in 1.99.2rrrf)r}rr;rreryr_join)rhtextsr;res r_get_output_textrs{x'###E/// ;;) #!>> /<<=0LL. // 775>rc D|jrt|j|jddjDcic] \}}|dvr||}}}|r|j ||j d|d<|j r$t|j j}nd}g}g} g} i} |jD]*} | jdk(r| jD]} | jd k(rmd | j| jDcgc]}|jc}| jd }|j|t| d r| j | d <| jd k(s|jd | j"| jd| jdk(r|j| jdd t%j&| j(d}d}|.d| j.|| j0d}| j|_d| j.|| j0|d}| j|| jdk(r\|j| jddd| j.d| j2i| j0d}| j|| jdvs |j| jdd-t5|}|d | vr|r|jrw|jjx}r[|j dix}rG|j ddk(r3 t%j&|}|rt7|r |d i|}n|}|| d <t9||j||| | | }|dk(r t;|}n t=t?|gScc}}wcc}w#t*$r"}| j(}t-|}Yd}~ d}~wwxYw#t$j*$rYwxYw)!z9Construct ChatResponse from OpenAI Response API response.TrT exclude_noner ) created_atrcincomplete_detailsrUobjectstatusrdrrrrNrrr_)rr_rrcrr)rrrcrhFrr)rrbrrcrW)rrbrrcrr__arg1) rrrrrrrrrrrr)rercrBrrlrirmrr)rr) rrrzrupdaterwr?rr;rrer_rrcryr}rrrTloadsrr r{rbrrrrrrWr=r;)rhrTrUrrrrrBcontent_blocksrirmrlr;re annotationrrrrrr text_configformat_ parsed_dictrrs rrrs~~((''T'GMMO Aq    1$  *&7&;&;G&Dl#~~9(..:S:S:UVNJ //AU ;;) #!>> <<=0 & ' /6.A.A( *'113(%iiE#))%0w16=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 TCAUd#8,K - -  MM$MM446 6[ 6#"5 5W 5 [[ M 1 **[1K,V4.+.$*0 h ' ;;%++-G,W5 >'#B"C DDcL($# ''A T##   s6OO #O2P  P$PP PPc  d/d0fd }g} g} i} |r|} ni} d} d}|jdk(r>||j|j| jd|jdn|jdk(rx||j|jt |j tr |j }n|j jdd}| j|gd nK|jd k(r | j|jd n|jd k(r1|jj}|jj| d <n|jdk(rttt|j||jdj }|j"j%dx}r|| d<|j&} |j(j+Dcic]\}}|d k7s ||} }}n-|jdk(r8|j,jdk(r|dk(r|j,j}nn|jdk(r|j,jdk(r||j| jd|j,j.|j,j0|j,j2d| jd|j,j.|j,j0|j,j2|j,jdn|jdk(r_|j,jdvrG||j|j,jdd}|d<| j|n|jdk(r|j,jdk(r||j|j,jdd}|d<| j|| jd|j,j.t5j6d|j,j8i|j,j2dn|jdk(rR||j| jd|jd| jd|jd nI|jd!k(r | jd"|j:d#n|jdk(r_|j,jd$k(rF||j|j,jdd}|d<| j|n|jd%k(r7||j| j|j<d&d'd(gd$d)nf|jd*k(rnV|jd+k(rA||j| j|j<d&|jd(gd$d)ndfSt?| | | | | |,}|dk(rtt>tA||-}n tC|.fScc}}w)1NcJ| |k7rdz |y|k7s|k7rdz ||y)a3Advance 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_idxrjrkrls r_advancez>_convert_responses_chunk_to_generation_chunk.._advancesMH ?#z1" *% 28IW8T" ' )rzresponse.output_text.deltar_)rr_rz%response.output_text.annotation.addedTrTr)rrzresponse.output_text.done)rcrzresponse.createdrczresponse.completed)rTrrrzresponse.output_item.addedrrrhr4)rrbrrcr)rrbrrrcrzresponse.output_item.done)rrrrrrrrrrrz&response.function_call_arguments.delta)rrr)rrrzresponse.refusal.donerrrz%response.reasoning_summary_part.added summary_textrf)rrr_)rrrz,response.image_generation_call.partial_imagez%response.reasoning_summary_text.delta)rerrBrrlrc)rVrr)rrrrr#None)"r output_index content_indexryrErrrxrzrrhrcrrrrrrlrwrBrrrrbrrrTrUrr summary_indexr rWr<)rArjrkrlrTrUrVrrrerrlrrBrcrryrrrrrrs ``` rr]r]s+*+*ZG $N B zz11##U%8%89 mTU > >##U%8%89 e&& -))J))44$V4TJ |mLM 2 2emmmDE ) ) ^^  "'.."3"3$ + + 7NN6.Q   **..x8 86 8*0 h '++ 2288: Qa4iAqD   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 8 ZZ)r|Mapping[str, Any]r#r!)rerr#r)rr!r#rx)r|rrztype[BaseMessageChunk]r#r")rUnion[int, dict]rrr#r)rzopenai.BadRequestErrorr#r)rOrr#r)rr,r#rx)rWr)r#rx)rer{r#zOptional[tuple[int, int]])rfrrgrr#r)rsr{r#r)rfrrgrr#ztuple[int, int])rTzUnion[dict[str, Any], type]rrr#zUnion[dict, TypeBaseModel])r|rrTz type[_BM]r#zOptional[PydanticBaseModel])rrxr#r3)rtrxr#rr+)raSequence[BaseMessage]r#z+tuple[Sequence[BaseMessage], Optional[str]])rarrdrxr#rx)rr-r#rx)rr-r#r%)rrxr#rx)rarr#r)rhrXr#r{)NNr) rhrXrTOptional[type[_BM]]rUr%rrr#r=)NNFr)rArrjrrkrrlrrTrrUr%rVrrrr#z3tuple[int, int, int, Optional[ChatGenerationChunk]])rM __future__rrrTloggingrrFsslrrcollections.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 getLoggerrr\create_default_contextwherer%rrrrrrrrrrxr{r_DictOrPydanticClass_DictOrPydanticrrr7rrrrrr^rbrkrrrzr{rGrrrrrrrrrrrr]rrrr#s"  FF    " 6> ( 9P SR <)09 VUMM0" /   8 $0S//}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