3fiUdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZmZmZmZddlmZddlmZddlmZddlmZdd lmZdd lmZmZmZmZm Z m!Z!dd l"m#Z#ddl$Z$ddl%Z%ddl&Z&dd l'm(Z(m)Z)dd l*m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAddl0mBZCddlDmEZEmFZFmGZGddlHmIZImJZJddlKmLZLddlMmNZNmOZOddlPmQZQmRZRmSZSmTZTddlUmVZVmWZWmXZXddlYmZZZm[Z[m\Z\m]Z]ddl^m_Z_ddl`maZaddlbmcZcddldmeZeddlfmgZgmhZhddlimjZjmkZkmlZlddlmmnZnmoZompZpddlqmrZrmsZsmtZtmuZumvZvdd lwmrZxdd!lymzZzdd"l{m|Z|m}Z}m~Z~dd#lmZmZmZdd$lmZer dd%l*mZdd&lmZejeZeje$j'Ze!e,eZdXd(Zd)ZdYd*Z dZ d[d+Z d\ d]d,Z d^d-Z d_d.Zd`d/Zdad0Ze d1er2ZeeefeezezZd3ed4<eezZd3ed5<Gd6d7e.ZGd8d9eZdbd:Zdcd;Z ddd<Zded=Zdfd>Zdgd?Zdgd@ZdhdAZddB didCZ djdDZGdEdFeZ dk dldGZ dk dldHZdmdIZdndJZ dodKZ dpdLZdqdMZdqdNZ drdOZdsdPZ dtdQZdudRZdvdSZdwdTZdxdUZ dy dzdVZ d{ d|dWZy)}zOpenAI chat wrapper.) annotationsN) AsyncIterator AwaitableCallableIteratorMappingSequence)partial)BytesIO)JSONDecodeError)ceil) itemgetter) TYPE_CHECKINGAnyLiteral TypeAliasTypeVarcast)urlparse)AsyncCallbackManagerForLLMRunCallbackManagerForLLMRun)LanguageModelInputModelProfileRegistry) BaseChatModelLangSmithParams) AIMessageAIMessageChunk BaseMessageBaseMessageChunk ChatMessageChatMessageChunkFunctionMessageFunctionMessageChunk HumanMessageHumanMessageChunkInvalidToolCall SystemMessageSystemMessageChunkToolCall ToolMessageToolMessageChunkis_data_content_block)content)InputTokenDetailsOutputTokenDetails UsageMetadata)_convert_from_v03_ai_messageconvert_to_openai_data_block)tool_call_chunk)JsonOutputParserPydanticOutputParser)JsonOutputKeyToolsParserPydanticToolsParsermake_invalid_tool_callparse_tool_call)ChatGenerationChatGenerationChunk ChatResult)RunnableRunnableLambda RunnableMapRunnablePassthrough)run_in_executor)BaseTool) _stringify)get_pydantic_field_names)convert_to_openai_functionconvert_to_openai_tool)PydanticBaseModel TypeBaseModelis_basemodel_subclass)_build_model_kwargsfrom_envsecret_from_env) BaseModel ConfigDictField SecretStrmodel_validator)rM)Self)_get_default_async_httpx_client_get_default_httpx_client _resolve_sync_and_async_api_keys)$_convert_from_v1_to_chat_completions_convert_from_v1_to_responses_convert_to_v03_ai_message) _PROFILES) ModelProfile)Response)cafilecTtj|xsi}|jSN)_MODEL_PROFILESgetcopy) model_namedefaults _/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_openai/chat_models/base.py_get_default_model_profileres#!!*-3G <<>) file_searchweb_search_preview web_searchcomputer_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]} |jt | d !|jdx} r| |d<t||||||S|dvr*|dk(rd|ini}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 } ~ Zd } ~ wwxYw)zConvert a dictionary to a LangChain message. Args: _dict: The dictionary. Returns: The LangChain message. rolenameiduserr-)r-rqrp assistant function_call tool_callsT) return_idNaudio)r-additional_kwargsrprqrvinvalid_tool_callssystem developerr}__openai_role__)r-rprqryfunctionr-rprqtool tool_call_id)r-rryrprqr-rorq)r`r$dictappendr9 Exceptionr8strrr'r"rr*r ) _dictrorpid_r-ryrurvrzraw_tool_calls raw_tool_callerxs rd_convert_dict_to_messagersJ 99V D 99V D ))D/C v~EIIi$<4PP {))Ir*0b"$!IIo6 6= 615m1D o . "YY|4 4> 4!/  %%omt&TU IIg& &5 &). g &/!1    &&9=9L.5RTIIi,/    zIIi,4UYYv=N3OTW   v~ U?(-f f %IIi,c599^#<=/    uyyB7ds KKK!&--.}c!fEs2G H $HH c H|rt|trg}|D]}t|trd|vr|ddvs |ddvr|dk(r,t|trUt|rJ|dk(r(t |j j ds|jt||t|tr|jddk(r|jd x}rt|tr|jdd k(rD|jd x}r1|jd x}r|jd dd|d|id0|jddk(r+|jdx}r|jd d|idoq|j||S|}|S)zFormat message content.type)tool_usethinkingreasoning_content)rucode_interpreter_callchat/completions responsesaiapiimagesourcebase64 media_typedata image_urlurlzdata:z;base64,rr) isinstancelistrr,rlower startswithrr2r`) r-rroformatted_contentblockrrrrs rd_format_message_contentrs :gt,. 0E5$'eO&M%RRf )SS#555$')%0 +D 0A0L0LT0R!(()EeQT)UV5$'IIf%0$yy22V2vt,::f%1#)::l#;;Z;!'F!333%,,$/*/5 HTF1S)T ZZ'50VZZ=N6Nc6N%,,!,E3<H!((/]. 0d $ rfc dt|j||ji}|jxs|jj dx}||d<t |tr|j|d<|St |trd|d<|St |trd|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} |jD]F} t | t s| j d d k(s)| j d x} s=|dk7sCd | i} H| s7d |jvr)|jd } d | vrd |jd d in| } | r| |d <|St |t"r!|jj dd|d<|St |t$rd|d<|St |t&rBd|d<|j(|d<hd} |jDcic] \}}|| vs ||}}}|Sd|}t+|cc}wcc}wcc}}wcc}}}wcc}}w)zDConvert a LangChain message to dictionary format expected by OpenAI.r-)rrorpNrorrrtrv>rqrrrurrxrqrr~r|rrr>ror-rzGot unknown type )rr-rrpryr`rr ror$rrvrz!_lc_tool_call_to_openai_tool_call)_lc_invalid_tool_call_to_openai_tool_callitemsrr'r"r*r TypeError)messager message_dictrptctool_call_supported_props tool_callkvrxrr raw_audiosupported_propsmsgs rd_convert_message_to_dictr sr *7??',,W$L E 9 9 = =f EER# V';'&|| V@  G\ *% V| { GY '* V   !;!;@G@R@R*:<1"5*"44:"=*L & W66 6)0)B)B<)PL &(B %".l!;**#,//"3V$!Qq K< K</K5c |jd}tt|jd}tt|jdxsd}i}|jdr!t|d}d|vr |dd|d<||d<g}|jdx}rS |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)z%Convert to a LangChain message chunk.rqror-rsrurprvr argumentsindex)rpargsrqrrr)r-rqrt)r-ryrqtool_call_chunksr{r}r~)r-rqryrrr)r-rrqr) r`rrrr3KeyErrorr%rr(r#r+r!) r default_classrror-ryrurrrtcs rd_convert_delta_to_message_chunkrps ))D/C UYYv& 'D3 ),23G  yy!U?34 ] "}V'<'D$&M& !-:/*<00~0 *   Z,,V4Z,,[9wwt}g,     v~*;; S99 {m~=/-    &&-;M*M ; !2K @  " !7H   z].BB#G%-CPP v~*::%*?C   } 00dsCC S 11K    s%F5"A F0.F50F55 GGc t|tr:t|ts%dt|dt|}t|||zSt|trst|ts%dt|dt|}t||j Dcic]"\}}|t |j|d|$c}}Stjdt||Scc}}w)Nz%Got different types for token usage: z and rz!Unexpected type for token usage: ) rintr ValueErrorrr_update_token_usager`warningswarn)overall_token_usage new_usagerrrs rdrrs )S!-s37 ?#5.A)B(CE S/ !...)T"-t47 ?#5.A)B(CE S/ !") 1 "#6#:#:1a#@!D D   MM5d9o5FGH   s#'C1cd|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 rd_handle_openai_bad_requestrs[R  3   g+qyy8 [   g rfc|syd|vS)NFz gpt-5.2-pro)rbs rd_model_prefers_responses_apirs  J &&rf_BM)boundr_DictOrPydanticClass_DictOrPydanticceZdZUdZeddZded<eddZded<eddZded<eddZ ded <ed d Z d ed< dZ ded< ee Z ded< ededdZded< edd Zded< edd Zded< eeddZded <edd! Zd"ed#< dZd$ed%< dZd&ed'< dZded(< dZded)< dZd&ed*< dZd$ed+< dZd&ed,< dZd-ed.< d/Zd0ed1< dZd&ed2< dZded3< edZ d&ed4< dZ!ded5< dZ"d6ed7< dZ#ded8< dZ$ded9< dZ%d:ed;<dZ&ded?< eddZ(d>ed@< eddA Z)dBedC< dZ*dDedE< d/Z+d0edF< edZ,d6edG< dZ-dHedI< dZ.dedJ< dZ/d$edK< dZ0dedL< d/Z1d0edM< dZ2d$edN< eedOdZ3dedP< e4dQZ5e6dRSe7dwdTZ8e6dRSe7dwdUZ9e6dVSdxdWZ:e6dVSdxdXZ;e d{d[Z?d|d\Z@ d} d~d]ZA d} dd^ZB d dd_ZC d}dd` ddaZD d} ddbZEddcZFddd ddeZG d ddfZH d}dd` ddgZI d} ddhZJeBuild extra kwargs from additional params that were passed in.)rDrJ)clsvaluesall_required_field_namess rd build_extrazBaseChatOpenAI.build_extraGs$z6BaseChatOpenAI.validate_environment..s'c4(D0s) rrrrrrrrrrOPENAI_BASE_URLT)rrrrrrzwCannot 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`.)proxyverify)rrr)#rrrrosgetenvrallenvironrrrUrrrrrrrrrhttpx ImportErrorClientglobal_ssl_contextrTopenaiOpenAIr completionsr AsyncClientrS AsyncOpenAIr) r.rsync_api_key_valueasync_api_key_value client_paramsrrrr7r sync_specificasync_specifics ` rdvalidate_environmentz#BaseChatOpenAI.validate_environmentns 66 $&&1*)CS/ ! 66 $&&1*/CS/ !  $ $ 0yy) 0yy./  $33SryyAR7S   "3 $D >BIM    *7W##7 3  3 !44,,++#33!//      '+/+;+;M- (   $"2"2d6L6L,,L**K $ 6 6 !/K>1F4E3GI  S/ !{{!)# #' $$T-=-=6$(-||"//8J(4(D$$(#3#3$0,,d.B.B 2 ! $*==#R=#RM#R "..33??     )?)?2 */):):++4F*;*& $55 2(($*>*>/ N&,%7%7&& &D "!% 6 6 ; ; G GD  W'6J*#.A5 6,#2F&c*1 2s0M"N" M>+M99M> N NNcR|jt|j|_|S)z$Set model profile if not overridden.)profilererbr.s rd_set_model_profilez!BaseChatOpenAI._set_model_profiles# << 5dooFDL rfcid|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.rrrrrrrrNrrrrrrrr r )rr )rstream)rrrrrrrrrrrrrrrr r rr rbrrr)r.exclude_if_nonerrs rd_default_paramszBaseChatOpenAI._default_paramss  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)rPrb)r`rrrb) r. llm_outputsrrQoutputrPrrcombineds rd_combine_llm_outputsz#BaseChatOpenAI._combine_llm_outputss$&!! FF~ **]3K&'--/3DAqy //1D/2A2+A.23+A.3")%+ZZ0D%E"! F"$7dooV -?H) *rfcZ|jddk(ry|jd}|jdgxs"|jdijdg}|rt||jdnd}t|dk(rPt|d| | }|jd k(r*g|j _d |j jd <|S|d}|d yt|d |} |ri|ni} |jdx} rM| | d<|jdx} r| | d<|jdx} r| | d<|jdx}r|| d<|jd}|r|| d<|rt| tr|| _ d| jd<t| | xsd S)Nrz content.deltausagechoiceschunkr rrs)r-usage_metadatargeneration_infov1rdelta finish_reasonrrbrQrr;model_provider) r`_create_usage_metadatalenr;rrr-response_metadatarrrrZ)r.rYdefault_chunk_classbase_generation_inforPrXrZgeneration_chunkchoice message_chunkr\r_rbrQr rs rd"_convert_chunk_to_generation_chunkz1BaseChatOpenAI._convert_chunk_to_generation_chunk+s 99V  /ii( IIi $ 9yy"%)))R8  #; .0I J  w<1 2+B~V 4  ""d*35 ((0OS ((::;KL# # '? "7 7O0 7K212PR"JJ7 7= 7//::j) *2OJ ' jG+9M (&>&P&PP(, **3 +  + + +s%C E :EAE EEEc &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{7swYyxYwwrm)rurrrvrrwrxrrnr`ryrrzr{rryr|s rd_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|jxsdS)zDetermine whether to include usage metadata in streaming output. For backwards compatibility, we check for `stream_options` passed explicitly to kwargs or in the `model_kwargs` and override `self.stream_usage`. stream_options include_usageF)r`rrrr)r.rrstream_usage_sourcesrs rd_should_stream_usagez#BaseChatOpenAI._should_stream_usages  JJ' , 0 0 A    ! !"2B 7 ; ;O L      + F&$'    )E)rf)rc+K|jd|d<|j|fi|}|rd|i|d<|j|fd|i|}t}i}d|vro|jrt j d|jd|jjjjjdi|} | } nx|jrN|jjjdi|} | j!} dt#| j$i}n|jjdi|} | } | 5} d} | D]}t'|t"s|j)}|j+||| r|ni}|=|j,j.}|j0xsij3d }|r|j5|j6|| d } | dddt? d rJd|vrE| jA}|jC|}|r|j5|j6| |yyy#1swY`xYw#t8j:$r}t=|Yd}~d}~wwxYwwNTrLrrrrozLCannot currently include response headers when response_format is specified.rnr)rYrFget_final_completionrtr)"rkrrurrrrr"rbetarr=rLrrvrwrxrrnr model_dumprir __class__r\r`rzr{r;BadRequestErrorrhasattrr%_get_generation_chunk_from_completionr.r}rr~rrrrdreresponse_streamr raw_responserrrYrfrrfinal_completions rd_streamzBaseChatOpenAI._streams **,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:I5=I ?BH>I 'AI5>II I2 I-(I5-I22I5c ~|j|j|fd|i|}d}d} d|vr^|jd |jjj j jdi|}|j}n|j|r|jd} | rQ+R#U4#3#3#=#=#O#O#U#U$!$L$W4#3#3#=#=#O#O#V#V$!$L(--/00'0$|7K7K2L&MO>.,#'#6#6  Dt{{<<CCNgN '--/  ) )( i0($|/C/C*DEO''/BBE--2.q1120 'GL/,R)77 G sIH A G" CH )6H "H 5 HH H  H H<!H77H<ct|jtr |jS|jdk(sE|j9|j -|j !|jst|jryt|S)N responses/v1T) rrrrr rrrrrbr)r.rs rdrz!BaseChatOpenAI._use_responses_apissm d,,d 3)) )   > 1||'~~)*,,+DOO<!'**rfrc |j|j}|||d<i|j|}|j|rC|jr)t |\}}|r|n|}|r||d<t ||}|St ||}|S|D cgc]1} t| trtt| n t| 3c} |d<|Scc} w)Nrprevious_response_idr}) _convert_input to_messagesrNrr_get_last_messages _construct_responses_api_payloadrrrrV) r.input_rrr}r last_messagesrpayload_to_usems rdruz#BaseChatOpenAI._get_request_payloads&&v.::<  !F6N4T))4V4  " "7 +,,6H6R3 32FH'6JG23:>7S;8WM" #a+))Ma)PQ-a01#GJ   #s6C cg}t|tr|n|j}|jdrt |jd |d}| d}t||jd}|jd} |D]} t| d} |r!t| trt|| | _ |xsi}| jd| jdn|jd|d<d | vr| d |d <t| | } |j| |d |jd |j|jd dd} d|vr|d| d<| r| | d<t|tj rt#|ddr}|j$dj&} t)| dr&| j*|dj&j,d<t)| dr&| j.|dj&j,d<t1|| S#t $r$}d|j }t ||d}~wwxYw)NerrorrXz Response missing `choices` key: z0Received response with null value for `choices`.rWr rr_rr[r;rrQrs)rPr`rbrQrqrparsedrefusal) generations llm_output)rrrr`rrkeysrrrrarZr:rrbr;rMr+rXrrrryrr<)r.rr\r response_dictrXrrrPr resrgenrs rdrz"BaseChatOpenAI._create_chat_resultsd  #8T2H8K8K8M    W %]..w78 8 '#I.G ?DCC. #''0 $((8  $C.s9~>Gz'9=)?*&.3O77?+7($((9 O , S .1*o + /RC   s # $"'&'++GT__E"/"3"34H""M  = ,T2Jt  )5J~ & h 0 0 1g i7 &&q)11Gw)EL^^ A&&88Bw *FMoo A&&88CkjII_ '4]5G5G5I4JKC3-Q & 'sH I#IIc ~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|yyywr)!rrurrrrr"rrrr=rLrrvrwrxrrnrrrirrr\r`rzr{r;rrrrrrs rd_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|j|fd|i|}d}d} d|vrf|jd |jjjj j di|d{}|j }n*|j|r|jd} | rDt| r9|jjj j di|d{}n8|jjj jdi|d{}|j }|jrdt!|j"i}t%|| ||j&S|j(j jdi|d{}|j }|jr%|#t-|drdt!|j"i}t3d|j4|d{S7#tj$r} t| Yd} ~ wd} ~ wwxYw7G77#t*$r&} |t-|dr|j.| _| d} ~ wwxYw7lwr)rur"rrr=rvrxr;rrrr`rrrwrrrnrrrrrrrrArrs rd _ageneratezBaseChatOpenAI._agenerate/sx,$++HJ4J6J )  G+ H%2)h)?)?)D)D)P)P)b)b)h)h*!*$L ,113H((1&,jj1B&C#&+=>Q+RVd44>>PPVV%!Xd44>>PPWW%! (--/00'0$|7K7K2L&MO>.,#'#6#6 &PT%6%6%H%H%O%O&&  (--/  ) )( i0($|/C/C*DEO$ $**Ho   Y$--2.q112    'GL/,R)77 G  sI,H8=H0H1HA$H8)H0*8H8"H3#AH82I,3)H8H6H81A I,=I*>I,HH- H(#H8(H--H83H86H88 I'!I""I''I,c6d|ji|jS)zGet the identifying parameters.rb)rbrNrHs rd_identifying_paramsz"BaseChatOpenAI._identifying_paramsmsdooF1E1EFFrfc :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.rrtoolsrrlrnz **REDACTED**)rbsuper_get_invocation_paramsrNr`rrr)r.rrparamsrrrs rdrz%BaseChatOpenAI._get_invocation_paramsrs T__ g,$,7 ""   ZZ( (E (j.E " dD)dhhv.>%.G9BT8I4D4)^4tF7O s;Bc p|jd d|i|}td|jd|jd|jd|j}|jd|j xs|jd|j x}r||d <|xs|jdd x}r||d <|S) z Get standard params for tracing.rr;rrr) ls_provider ls_model_name ls_model_typels_temperaturermax_completion_tokens ls_max_tokensNls_stopr)rrr`rbrr)r.rrr ls_paramsrrs rd_get_ls_paramszBaseChatOpenAI._get_ls_paramss-,,A$A&A#  **Wdoo> !::mT5E5EF  #JJ|T__E  #T__J  = *7Io &6fjj6 67 6#*Ii rfcy)zvReturn type of chat model. Will always return `'openai-chat'` regardless of the specific model name. z openai-chatrrHs rd _llm_typezBaseChatOpenAI._llm_types rfc|j |j}n |j} tj|}||fS#t$r@|j }d}|j drd}tj|}Y||fSwxYw)N cl100k_base)zgpt-4ozgpt-4.1r o200k_base)rrbtiktokenencoding_for_modelrrr get_encoding)r.rencodingr#encoders rd_get_encoding_modelz"BaseChatOpenAI._get_encoding_models  # # /,,EOOE 62259Hh  6++-K#G%%&DE&,,W5Hh  6sAAB B c|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_modelrs rdrzBaseChatOpenAI.get_token_idssg  $ $ 0,,T2 2   A ! #7(. . 446>$$T**rfc |tjdtjddkrt||S|j \}}|jdrd}d}n'|jdrd}d}nd |d }t|d }|D cgc] } t| } } | D]} ||z }| jD]p\} } | d k(r|dz }t| tr| D]}t|ts|d dk(r5t|tr|dn|}|t|j!|z }Q|d dk(r=|dj#ddk(r|dz }vt%|dd}|s|t'|z }|d dk(rG|t|j!|ddz }|t|j!|ddz }|d dk(rtjdd|}t)|n*| s?|t|j!t| z }| dk(sl||z }s|dz }|Scc} w)aCalculate num tokens for `gpt-3.5-turbo` and `gpt-4` with `tiktoken` package. !!! warning You must have the `pillow` installed if you want to count image tokens if you are specifying the image as a base64 string, and you must have both `pillow` and `httpx` installed if you are specifying the image as a URL. If these aren't installed image inputs will be ignored in token counting. [OpenAI reference](https://github.com/openai/openai-cookbook/blob/main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb). Args: messages: The message inputs to tokenize. tools: If provided, sequence of `dict`, `BaseModel`, function, or `BaseTool` to be converted to tool schemas. zECounting tokens in tool schemas is not yet supported. Ignoring tools.rrzgpt-3.5-turbo-0301rp)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.rrrr{rdetaillowUrrrrpfilezEToken counts for file inputs are not supported. Ignoring file inputs.z!Unrecognized content block type )rrrrrget_num_tokens_from_messagesrrNotImplementedErrorrrrrrrrbrr` _url_to_size_count_image_tokensr)r.r}rrrtokens_per_messagetokens_per_namer num_tokensr messages_dictrr-valuevalr{ image_sizers rdrz+BaseChatOpenAI.get_num_tokens_from_messagess*   MMW    A ! #77A A224x   0 1!"  O   A B!" O"G$LL  &c* * >FG1!4G G$, 2G , ,J%mmo* 2 U.(!OJeT*$2%c3/3v;&3H2U.V*WWJ [F2$MM!8 %Hu"MC",S/1526#hooc%j&A"BBJ&=/1JU* 2, 2\ a aHsI) tool_choicestrictparallel_tool_callsroc |||d<|Dcgc]}t||}}g} |D]7}d|vr| j|ddd|vr| j|d89|rkt|tr"|| vrdd|id}nJ|tvrd|i}n=|dk(rd }n5n4t|t rd }n!t|t rnd |} t| ||d <|rst|t rS|jdd k(r?d |jd ivr+|d jdd}tt |d d }t|||d<t |0dd|i|Scc}w)aBind tool-like objects to this chat model. Assumes model is compatible with OpenAI tool-calling API. Args: tools: A list of tool definitions to bind to this chat model. Supports any tool definition handled by [`convert_to_openai_tool`][langchain_core.utils.function_calling.convert_to_openai_tool]. tool_choice: Which tool to require the model to call. Options are: - `str` of the form `'<>'`: calls `<>` tool. - `'auto'`: automatically selects a tool (including no tool). - `'none'`: does not call a tool. - `'any'` or `'required'` or `True`: force at least one tool to be called. - `dict` of the form `{"type": "function", "function": {"name": <>}}`: calls `<>` tool. - `False` or `None`: no effect, default OpenAI behavior. strict: If `True`, model output is guaranteed to exactly match the JSON Schema provided in the tool definition. The input schema will also be validated according to the [supported schemas](https://platform.openai.com/docs/guides/structured-outputs/supported-schemas?api-mode=responses#supported-schemas). If `False`, input schema will not be validated and model output will not be validated. If `None`, `strict` argument will not be passed to the model. parallel_tool_calls: Set to `False` to disable parallel tool use. Defaults to `None` (no specification, which allows parallel tool use). response_format: Optional schema to format model response. If provided and the model does not call a tool, the model will generate a [structured response](https://platform.openai.com/docs/guides/structured-outputs). kwargs: Any additional parameters are passed directly to `bind`. Nrrrrp)rrranyrequiredzEUnrecognized tool_choice type. Expected str, bool or dict. Received: r json_schemarqrrorr) rFrrrWellKnownToolsrrrr`r"_convert_to_openai_response_formatrbind) r.rrrrrorrformatted_tools tool_namesrrs rd bind_toolszBaseChatOpenAI.bind_toolssL  *,?F( )DI <@ "4 7   # DT!!!$z"26":;4!!$v,/   +s+*, *%+[$9#K!N2#);"7K!E)",KK.( K.!!, /!o%$/F= ! ?D1#''/=@ 3 3M2 FF)7;;HdK"&t_]-KH-U"V(J)F$ %w| str: """Get weather at a location.""" pass model = init_chat_model("openai:gpt-4o-mini") structured_model = model.with_structured_output( ResponseSchema, tools=[get_weather], strict=True, include_raw=True, ) structured_model.invoke("What's the weather in Boston?") ``` ```python { "raw": AIMessage(content="", tool_calls=[...], ...), "parsing_error": None, "parsed": None, } ``` kwargs: Additional keyword args are passed through to the model. Returns: A `Runnable` that takes same inputs as a `langchain_core.language_models.chat.BaseChatModel`. If `include_raw` is `False` and `schema` is a Pydantic class, `Runnable` outputs an instance of `schema` (i.e., a Pydantic object). Otherwise, if `include_raw` is `False` then `Runnable` outputs a `dict`. If `include_raw` is `True`, then `Runnable` outputs a `dict` with keys: - `'raw'`: `BaseMessage` - `'parsed'`: `None` if there was a parsing error, otherwise the type depends on the `schema` as described above. - `'parsing_error'`: `BaseException | None` !!! warning "Behavior changed in `langchain-openai` 0.3.12" Support for `tools` added. !!! warning "Behavior changed in `langchain-openai` 0.3.21" Pass `kwargs` through to the model. json_modezz7BaseChatOpenAI.with_structured_output..xrf)r parsing_errorcyr^rrs rdrz7BaseChatOpenAI.with_structured_output..zrrf)rr) exception_key)rr)rr issubclass BaseModelV1rrrbrrF_filter_disabled_paramsrr7r6rr5r4rrr>r _oai_structured_outputs_parserrr with_typesr@assignrwith_fallbacksr?)r.rqr r rrrris_pydantic_schema tool_name bind_kwargsllm output_parserrot parser_assign parser_noneparser_with_fallbacks rdwith_structured_outputz%BaseChatOpenAI.with_structured_outputysPR  &K"7PCS/ !/7 ] "#z&+'F ? ,**73??--h7??g- A$//ARS??, ' '~%!o%.v6zB6JI6$66 #,+0$-3v"F"(4   K"$//6(:k:C!*=!($(+ !9&! { "$)) (. '>#+V"4"(4   C&%V<%'  } $~%!o%@PVWO $3-3v"F"8"@1   KFK(AB*1V<( G$$))*k*C! .:4fCUV!*dF);*<!1 2 ++1(!5 S/ ! /66!%(=8M.44NKK#0#?#? _$@$ 3'*>> >]""5(s?J5c |js|Si}|jD]9\}}||jvr!|j|||j|vr5|||<;|Sr^)r r)r.rfilteredrrs rdr z&BaseChatOpenAI._filter_disabled_paramssr##MLLN DAqD((($$Q'/18L8LQ8O3OHQK rfcD|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).rrvNrs)r-ryrZr[) rrrrrrZryr"rr;r)r. completion chat_result chat_messagerZrs rdrz4BaseChatOpenAI._get_generation_chunk_from_completions..z: "..q199 lI .)88N|===..22<@!N *<<)  #[-C-C  rf)rrreturnr)r5rRr5r)rRzlist[dict | None]r5r)rYrrdrre dict | Noner5zChatGenerationChunk | None)r5None)NN) r}list[BaseMessage]rr r~CallbackManagerForLLMRun | Nonerrr5Iterator[ChatGenerationChunk]) r}r9rr r~$AsyncCallbackManagerForLLMRun | Nonerrr5"AsyncIterator[ChatGenerationChunk]r^)rrrrr5r) r}r9rr r~r:rrrrr5r;) r}r9rr r~r:rrr5r<rrr5rrrrr rrr5r)rzdict | openai.BaseModelr\r7r5r<) r}r9rr r~r<rrrrr5r=) r}r9rr r~r<rrr5r<)rr rrr5r)rr rrr5r)r5r)r5ztuple[str, tiktoken.Encoding])r{rr5z list[int])r}Sequence[BaseMessage]rzs>O7CJC $K$+#(#>L.>V 9ISW)X K -^#(J"GOZG_&+D&OON % > L*AFIAO=!%L+$ #K"<%)l)$&*|*;D* Hk %#L*# )-J%,PIt/AzAE<D"40J 0/#'j'(,I$+ !Iz '+* 15O-415M.5$D$?K? %*$$EzE $)=M#ND N!+/J(/&&+d*X-24-@O*@ !%G $  $L*#E;"J !&+d*<&*{)"' !4dC"NJ"t4L(#E$E (#$<'"z#zx'"#   >2< < "< * < $ < |""&7; 4+#4+4+5 4+  4+ ' 4+r"&<@ 5+#5+5+: 5+  5+ , 5+p+/*'*:=* *,"&7; E# %) E##E#E#5 E# " E#E# 'E#T"&7; 7C#7C7C5 7C  7C  7Cr +$"& "     D(,CJ)CJ%CJ  CJP"&<@ H# %) H##H#H#: H# " H#H# ,H#Z"&<@ < #< < : <  <  < |GG (,$7: ,(,$7: & +OS]']L] ]F15"+/7;\=D\=. \=  \= ) \=5\=\= 1\=@/3F# !"!F#+F# F#F#F#F#F# 7F#P  *  rfrceZdZUdZeddZded< eddZe ddZ edd Z e dd Z edfd Z dd  dfd Zdfd Z dfd Z dddddd dfdZxZS) ChatOpenAIucInterface to OpenAI chat model APIs. ???+ info "Setup" Install `langchain-openai` and set environment variable `OPENAI_API_KEY`. ```bash pip install -U langchain-openai # or using uv uv add langchain-openai ``` ```bash export OPENAI_API_KEY="your-api-key" ``` ??? info "Key init args — completion params" | Param | Type | Description | | ------------------- | ------------- | ----------------------------------------------------------------------------------------------------------- | | `model` | `str` | Name of OpenAI model to use. | | `temperature` | `float` | Sampling temperature. | | `max_tokens` | `int | None` | Max number of tokens to generate. | | `logprobs` | `bool | None` | Whether to return logprobs. | | `stream_options` | `dict` | Configure streaming outputs, like whether to return token usage when streaming (`{"include_usage": True}`). | | `use_responses_api` | `bool | None` | Whether to use the responses API. | See full list of supported init args and their descriptions below. ??? info "Key init args — client params" | Param | Type | Description | | -------------- | ------------------------------------------ | ----------------------------------------------------------------------------------- | | `timeout` | `float | Tuple[float, float] | Any | None` | Timeout for requests. | | `max_retries` | `int | None` | Max number of retries. | | `api_key` | `str | None` | OpenAI API key. If not passed in will be read from env var `OPENAI_API_KEY`. | | `base_url` | `str | None` | Base URL for API requests. Only specify if using a proxy or service emulator. | | `organization` | `str | None` | OpenAI organization ID. If not passed in will be read from env var `OPENAI_ORG_ID`. | See full list of supported init args and their descriptions below. ??? info "Instantiate" Create a model instance with desired params. For example: ```python from langchain_openai import ChatOpenAI model = ChatOpenAI( model="...", temperature=0, max_tokens=None, timeout=None, max_retries=2, # api_key="...", # base_url="...", # organization="...", # other params... ) ``` See all available params below. !!! tip "Preserved params" Any param which is not explicitly supported will be passed directly to [`openai.OpenAI.chat.completions.create(...)`](https://platform.openai.com/docs/api-reference/chat/create) every time to the model is invoked. For example: ```python from langchain_openai import ChatOpenAI import openai ChatOpenAI(..., frequency_penalty=0.2).invoke(...) # Results in underlying API call of: openai.OpenAI(..).chat.completions.create(..., frequency_penalty=0.2) # Which is also equivalent to: ChatOpenAI(...).invoke(..., frequency_penalty=0.2) ``` ??? info "Invoke" Generate a response from the model: ```python messages = [ ( "system", "You are a helpful translator. Translate the user sentence to French.", ), ("human", "I love programming."), ] model.invoke(messages) ``` Results in an `AIMessage` response: ```python AIMessage( content="J'adore la programmation.", response_metadata={ "token_usage": { "completion_tokens": 5, "prompt_tokens": 31, "total_tokens": 36, }, "model_name": "gpt-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}, ) ``` ??? info "Stream" Stream a response from the model: ```python for chunk in model.stream(messages): print(chunk.text, end="") ``` Results in a sequence of `AIMessageChunk` objects with partial content: ```python AIMessageChunk(content="", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk(content="J", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk(content="'adore", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk(content=" la", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk( content=" programmation", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0" ) AIMessageChunk(content=".", id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0") AIMessageChunk( content="", response_metadata={"finish_reason": "stop"}, id="run-9e1517e3-12bf-48f2-bb1b-2e824f7cd7b0", ) ``` To collect the full message, you can concatenate the chunks: ```python stream = model.stream(messages) full = next(stream) for chunk in stream: full += chunk ``` ```python full = AIMessageChunk( content="J'adore la programmation.", response_metadata={"finish_reason": "stop"}, id="run-bf917526-7f58-4683-84f7-36a6b671d140", ) ``` ??? info "Async" Asynchronous equivalents of `invoke`, `stream`, and `batch` are also available: ```python # Invoke await model.ainvoke(messages) # Stream async for chunk in (await model.astream(messages)) # Batch await model.abatch([messages]) ``` Results in an `AIMessage` response: ```python AIMessage( content="J'adore la programmation.", response_metadata={ "token_usage": { "completion_tokens": 5, "prompt_tokens": 31, "total_tokens": 36, }, "model_name": "gpt-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, }, ) ``` For batched calls, results in a `list[AIMessage]`. ??? info "Tool calling" ```python from pydantic import BaseModel, Field class GetWeather(BaseModel): '''Get the current weather in a given location''' location: str = Field( ..., description="The city and state, e.g. San Francisco, CA" ) class GetPopulation(BaseModel): '''Get the current population in a given location''' location: str = Field( ..., description="The city and state, e.g. San Francisco, CA" ) model_with_tools = model.bind_tools( [GetWeather, GetPopulation] # strict = True # Enforce tool args schema is respected ) ai_msg = model_with_tools.invoke( "Which city is hotter today and which is bigger: LA or NY?" ) ai_msg.tool_calls ``` ```python [ { "name": "GetWeather", "args": {"location": "Los Angeles, CA"}, "id": "call_6XswGD5Pqk8Tt5atYr7tfenU", }, { "name": "GetWeather", "args": {"location": "New York, NY"}, "id": "call_ZVL15vA8Y7kXqOy3dtmQgeCi", }, { "name": "GetPopulation", "args": {"location": "Los Angeles, CA"}, "id": "call_49CFW8zqC9W7mh7hbMLSIrXw", }, { "name": "GetPopulation", "args": {"location": "New York, NY"}, "id": "call_6ghfKxV264jEfe1mRIkS3PE7", }, ] ``` !!! note "Parallel tool calls" [`openai >= 1.32`](https://pypi.org/project/openai/) supports a `parallel_tool_calls` parameter that defaults to `True`. This parameter can be set to `False` to disable parallel tool calls: ```python ai_msg = model_with_tools.invoke( "What is the weather in LA and NY?", parallel_tool_calls=False ) ai_msg.tool_calls ``` ```python [ { "name": "GetWeather", "args": {"location": "Los Angeles, CA"}, "id": "call_4OoY0ZR99iEvC7fevsH8Uhtz", } ] ``` Like other runtime parameters, `parallel_tool_calls` can be bound to a model using `model.bind(parallel_tool_calls=False)` or during instantiation by setting `model_kwargs`. See `bind_tools` for more. ??? info "Built-in (server-side) tools" You can access [built-in tools](https://platform.openai.com/docs/guides/tools?api-mode=responses) supported by the OpenAI Responses API. See [LangChain docs](https://docs.langchain.com/oss/python/integrations/chat/openai#responses-api) for more detail. ```python from langchain_openai import ChatOpenAI model = ChatOpenAI(model="...", output_version="responses/v1") tool = {"type": "web_search"} model_with_tools = model.bind_tools([tool]) response = model_with_tools.invoke("What was a positive news story from today?") response.content ``` ```python [ { "type": "text", "text": "Today, a heartwarming story emerged from ...", "annotations": [ { "end_index": 778, "start_index": 682, "title": "Title of story", "type": "url_citation", "url": "", } ], } ] ``` !!! version-added "Added in `langchain-openai` 0.3.9" !!! version-added "Added in `langchain-openai` 0.3.26: Updated `AIMessage` format" [`langchain-openai >= 0.3.26`](https://pypi.org/project/langchain-openai/#history) allows users to opt-in to an updated `AIMessage` format when using the Responses API. Setting `ChatOpenAI(..., output_version="responses/v1")` will format output from reasoning summaries, built-in tool invocations, and other response items into the message's `content` field, rather than `additional_kwargs`. We recommend this format for new applications. ??? info "Managing conversation state" OpenAI's Responses API supports management of [conversation state](https://platform.openai.com/docs/guides/conversation-state?api-mode=responses). Passing in response IDs from previous messages will continue a conversational thread. ```python from langchain_openai import ChatOpenAI model = ChatOpenAI( model="...", use_responses_api=True, output_version="responses/v1", ) response = model.invoke("Hi, I'm Bob.") response.text ``` ```txt "Hi Bob! How can I assist you today?" ``` ```python second_response = model.invoke( "What is my name?", previous_response_id=response.response_metadata["id"], ) second_response.text ``` ```txt "Your name is Bob. How can I help you today, Bob?" ``` !!! version-added "Added in `langchain-openai` 0.3.9" !!! version-added "Added in `langchain-openai` 0.3.26" You can also initialize `ChatOpenAI` with `use_previous_response_id`. Input messages up to the most recent response will then be dropped from request payloads, and `previous_response_id` will be set using the ID of the most recent response. ```python model = ChatOpenAI(model="...", use_previous_response_id=True) ``` ??? info "Reasoning output" OpenAI's Responses API supports [reasoning models](https://platform.openai.com/docs/guides/reasoning?api-mode=responses) that expose a summary of internal reasoning processes. ```python from langchain_openai import ChatOpenAI reasoning = { "effort": "medium", # 'low', 'medium', or 'high' "summary": "auto", # 'detailed', 'auto', or None } model = ChatOpenAI( model="...", reasoning=reasoning, output_version="responses/v1" ) response = model.invoke("What is 3^3?") # Response text print(f"Output: {response.text}") # Reasoning summaries for block in response.content: if block["type"] == "reasoning": for summary in block["summary"]: print(summary["text"]) ``` ```txt Output: 3³ = 27 Reasoning: The user wants to know... ``` !!! version-added "Added in `langchain-openai` 0.3.26: Updated `AIMessage` format" [`langchain-openai >= 0.3.26`](https://pypi.org/project/langchain-openai/#history) allows users to opt-in to an updated `AIMessage` format when using the Responses API. Setting `ChatOpenAI(..., output_version="responses/v1")` will format output from reasoning summaries, built-in tool invocations, and other response items into the message's `content` field, rather than `additional_kwargs`. We recommend this format for new applications. ??? info "Structured output" ```python from pydantic import BaseModel, Field class Joke(BaseModel): '''Joke to tell user.''' setup: str = Field(description="The setup of the joke") punchline: str = Field(description="The punchline to the joke") rating: int | None = Field( description="How funny the joke is, from 1 to 10" ) structured_model = model.with_structured_output(Joke) structured_model.invoke("Tell me a joke about cats") ``` ```python Joke( setup="Why was the cat sitting on the computer?", punchline="To keep an eye on the mouse!", rating=None, ) ``` See `with_structured_output` for more info. ??? info "JSON mode" ```python json_model = model.bind(response_format={"type": "json_object"}) ai_msg = json_model.invoke( "Return a JSON object with key 'random_ints' and a value of 10 random ints in [0-99]" ) ai_msg.content ``` ```txt '\\n{\\n "random_ints": [23, 87, 45, 12, 78, 34, 56, 90, 11, 67]\\n}' ``` ??? info "Image input" ```python import base64 import httpx from langchain.messages import HumanMessage image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" image_data = base64.b64encode(httpx.get(image_url).content).decode("utf-8") message = HumanMessage( content=[ {"type": "text", "text": "describe the weather in this image"}, { "type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_data}"}, }, ] ) ai_msg = model.invoke([message]) ai_msg.content ``` ```txt "The weather in the image appears to be clear and pleasant. The sky is mostly blue with scattered, light clouds, suggesting a sunny day with minimal cloud cover. There is no indication of rain or strong winds, and the overall scene looks bright and calm. The lush green grass and clear visibility further indicate good weather conditions." ``` ??? info "Token usage" ```python ai_msg = model.invoke(messages) ai_msg.usage_metadata ```txt {"input_tokens": 28, "output_tokens": 5, "total_tokens": 33} ``` When streaming, set the `stream_usage` kwarg: ```python stream = model.stream(messages, stream_usage=True) full = next(stream) for chunk in stream: full += chunk full.usage_metadata ``` ```txt {"input_tokens": 28, "output_tokens": 5, "total_tokens": 33} ``` ??? info "Logprobs" ```python logprobs_model = model.bind(logprobs=True) ai_msg = logprobs_model.invoke(messages) ai_msg.response_metadata["logprobs"] ``` ```txt { "content": [ { "token": "J", "bytes": [74], "logprob": -4.9617593e-06, "top_logprobs": [], }, { "token": "'adore", "bytes": [39, 97, 100, 111, 114, 101], "logprob": -0.25202933, "top_logprobs": [], }, { "token": " la", "bytes": [32, 108, 97], "logprob": -0.20141791, "top_logprobs": [], }, { "token": " programmation", "bytes": [ 32, 112, 114, 111, 103, 114, 97, 109, 109, 97, 116, 105, 111, 110, ], "logprob": -1.9361265e-07, "top_logprobs": [], }, { "token": ".", "bytes": [46], "logprob": -1.2233183e-05, "top_logprobs": [], }, ] } ``` ??? info "Response metadata" ```python ai_msg = model.invoke(messages) ai_msg.response_metadata ``` ```txt { "token_usage": { "completion_tokens": 5, "prompt_tokens": 28, "total_tokens": 33, }, "model_name": "gpt-4o", "system_fingerprint": "fp_319be4768e", "finish_reason": "stop", "logprobs": None, } ``` ??? info "Flex processing" OpenAI offers a variety of [service tiers](https://platform.openai.com/docs/guides/flex-processing?api-mode=responses). The "flex" tier offers cheaper pricing for requests, with the trade-off that responses may take longer and resources might not always be available. This approach is best suited for non-critical tasks, including model testing, data enhancement, or jobs that can be run asynchronously. To use it, initialize the model with `service_tier="flex"`: ```python from langchain_openai import ChatOpenAI model = ChatOpenAI(model="...", service_tier="flex") ``` Note that this is a beta feature that is only available for a subset of models. See OpenAI [flex processing docs](https://platform.openai.com/docs/guides/flex-processing?api-mode=responses) for more detail. ??? info "OpenAI-compatible APIs" `ChatOpenAI` can be used with OpenAI-compatible APIs like [LM Studio](https://lmstudio.ai/), [vLLM](https://github.com/vllm-project/vllm), [Ollama](https://ollama.com/), and others. To use custom parameters specific to these providers, use the `extra_body` parameter. !!! example "LM Studio example with TTL (auto-eviction)" ```python from langchain_openai import ChatOpenAI model = ChatOpenAI( base_url="http://localhost:1234/v1", api_key="lm-studio", # Can be any string model="mlx-community/QwQ-32B-4bit", temperature=0, extra_body={ "ttl": 300 }, # Auto-evict model after 5 minutes of inactivity ) ``` !!! example "vLLM example with custom parameters" ```python model = ChatOpenAI( base_url="http://localhost:8000/v1", api_key="EMPTY", model="meta-llama/Llama-2-7b-chat-hf", extra_body={"use_beam_search": True, "best_of": 4}, ) ``` ??? info "`model_kwargs` vs `extra_body`" Use the correct parameter for different types of API arguments: **Use `model_kwargs` for:** - Standard OpenAI API parameters not explicitly defined as class parameters - Parameters that should be flattened into the top-level request payload - Examples: `max_completion_tokens`, `stream_options`, `modalities`, `audio` ```python # Standard OpenAI parameters model = ChatOpenAI( model="...", model_kwargs={ "stream_options": {"include_usage": True}, "max_completion_tokens": 300, "modalities": ["text", "audio"], "audio": {"voice": "alloy", "format": "wav"}, }, ) ``` **Use `extra_body` for:** - Custom parameters specific to OpenAI-compatible providers (vLLM, LM Studio, OpenRouter, etc.) - Parameters that need to be nested under `extra_body` in the request - Any non-standard OpenAI API parameters ```python # Custom provider parameters model = ChatOpenAI( base_url="http://localhost:8000/v1", model="custom-model", extra_body={ "use_beam_search": True, # vLLM parameter "best_of": 4, # vLLM parameter "ttl": 300, # LM Studio parameter }, ) ``` **Key Differences:** - `model_kwargs`: Parameters are **merged into top-level** request payload - `extra_body`: Parameters are **nested under `extra_body`** key in request !!! warning Always use `extra_body` for custom parameters, **not** `model_kwargs`. Using `model_kwargs` for non-OpenAI parameters will cause API errors. ??? info "Prompt caching optimization" For high-volume applications with repetitive prompts, use `prompt_cache_key` per-invocation to improve cache hit rates and reduce costs: ```python model = ChatOpenAI(model="...") response = model.invoke( messages, prompt_cache_key="example-key-a", # Routes to same machine for cache hits ) customer_response = model.invoke(messages, prompt_cache_key="example-key-b") support_response = model.invoke(messages, prompt_cache_key="example-key-c") # Dynamic cache keys based on context cache_key = f"example-key-{dynamic_suffix}" response = model.invoke(messages, prompt_cache_key=cache_key) ``` 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)z(Mapping of secret environment variables.rrrrHs rd lc_secretszChatOpenAI.lc_secrets s!"233rfc gdS)zzGet the namespace of the LangChain object. Returns: `["langchain", "chat_models", "openai"]` ) langchain chat_modelsr;rrs rdget_lc_namespacezChatOpenAI.get_lc_namespace s 65rfci}|jr|j|d<|jr|j|d<|jr|j|d<|S)z+Get the attributes of the langchain object.rrr)rrr)r. attributess rd lc_attributeszChatOpenAI.lc_attributes s\&(  # #040H0HJ, -   ,0,@,@J( )   )-):):J~ &rfcy)z9Return whether this model can be serialized by LangChain.TrrTs rdis_lc_serializablezChatOpenAI.is_lc_serializable srfcLt|}d|vr|jd|d<|S)rKrr)rrNr")r.rrs rdrNzChatOpenAI._default_params s0( 6 !.4jj.FF* + rfrc t||fd|i|}d|vr|jd|d<|jrEt j d|jr%|j dgD]}|ddk(s d|d<|S) Nrrrz^o\dr}ror|r})rrur"rbrematchr`)r.rrrrrrs rdruzChatOpenAI._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: - an OpenAI function/tool schema, - a JSON Schema, - a `TypedDict` class, - or a Pydantic class. If `schema` is a Pydantic class then the model output will be a Pydantic instance of that class, and the model-generated fields will be validated by the Pydantic class. Otherwise the model output will be a dict and will not be validated. See `langchain_core.utils.function_calling.convert_to_openai_tool` for more on how to properly specify types and descriptions of schema fields when specifying a Pydantic or `TypedDict` class. method: The method for steering model generation, one of: - `'json_schema'`: Uses OpenAI's [Structured Output API](https://platform.openai.com/docs/guides/structured-outputs). See the docs for [supported models](https://platform.openai.com/docs/guides/structured-outputs#supported-models). - `'function_calling'`: Uses OpenAI's [tool-calling API](https://platform.openai.com/docs/guides/function-calling) (formerly called function calling). - `'json_mode'`: Uses OpenAI's [JSON mode](https://platform.openai.com/docs/guides/structured-outputs#json-mode). Note that if using JSON mode then you must include instructions for formatting the output into the desired schema into the model call. Learn more about the [differences between methods](https://platform.openai.com/docs/guides/structured-outputs#function-calling-vs-response-format). include_raw: If `False` then only the parsed structured output is returned. If an error occurs during model output parsing it will be raised. If `True` then both the raw model response (a `BaseMessage`) and the parsed model response will be returned. If an error occurs during output parsing it will be caught and returned as well. The final output is always a `dict` with keys `'raw'`, `'parsed'`, and `'parsing_error'`. strict: - `True`: Model output is guaranteed to exactly match the schema. The input schema will also be validated according to the [supported schemas](https://platform.openai.com/docs/guides/structured-outputs#supported-schemas). - `False`: Input schema will not be validated and model output will not be validated. - `None`: `strict` argument will not be passed to the model. If schema is specified via `TypedDict` or JSON schema, `strict` is not enabled by default. Pass `strict=True` to enable it. !!! note `strict` can only be non-null if `method` is `'json_schema'` or `'function_calling'`. tools: A list of tool-like objects to bind to the chat model. Requires that: - `method` is `'json_schema'` (default). - `strict=True` - `include_raw=True` If a model elects to call a tool, the resulting `AIMessage` in `'raw'` will include tool calls. ??? example ```python from langchain.chat_models import init_chat_model from pydantic import BaseModel class ResponseSchema(BaseModel): response: str def get_weather(location: str) -> str: \"\"\"Get weather at a location.\"\"\" pass model = init_chat_model("openai:gpt-4o-mini") structured_model = model.with_structured_output( ResponseSchema, tools=[get_weather], strict=True, include_raw=True, ) structured_model.invoke("What's the weather in Boston?") ``` ```python { "raw": AIMessage(content="", tool_calls=[...], ...), "parsing_error": None, "parsed": None, } ``` kwargs: Additional keyword args are passed through to the model. Returns: A `Runnable` that takes same inputs as a `langchain_core.language_models.chat.BaseChatModel`. If `include_raw` is `False` and `schema` is a Pydantic class, `Runnable` outputs an instance of `schema` (i.e., a Pydantic object). Otherwise, if `include_raw` is `False` then `Runnable` outputs a `dict`. If `include_raw` is `True`, then `Runnable` outputs a `dict` with keys: - `'raw'`: `BaseMessage` - `'parsed'`: `None` if there was a parsing error, otherwise the type depends on the `schema` as described above. - `'parsing_error'`: `BaseException | None` !!! warning "Behavior changed in `langchain-openai` 0.3.0" `method` default changed from `"function_calling"` to `"json_schema"`. !!! warning "Behavior changed in `langchain-openai` 0.3.12" Support for `tools` added. !!! warning "Behavior changed in `langchain-openai` 0.3.21" Pass `kwargs` through to the model. ??? note "Example: `schema=Pydantic` class, `method='json_schema'`, `include_raw=False`, `strict=True`" Note, OpenAI has a number of restrictions on what types of schemas can be provided if `strict = True`. When using Pydantic, our model cannot specify any Field metadata (like min/max constraints) and fields cannot have default values. See [all constraints](https://platform.openai.com/docs/guides/structured-outputs#supported-schemas). ```python from langchain_openai import ChatOpenAI from pydantic import BaseModel, Field class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str | None = Field( default=..., description="A justification for the answer." ) model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output(AnswerWithJustification) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python AnswerWithJustification( answer="They weigh the same", justification="Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.", ) ``` ??? note "Example: `schema=Pydantic` class, `method='function_calling'`, `include_raw=False`, `strict=False`" ```python from langchain_openai import ChatOpenAI from pydantic import BaseModel, Field class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str | None = Field( default=..., description="A justification for the answer." ) model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output( AnswerWithJustification, method="function_calling" ) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python AnswerWithJustification( answer="They weigh the same", justification="Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.", ) ``` ??? note "Example: `schema=Pydantic` class, `method='json_schema'`, `include_raw=True`" ```python from langchain_openai import ChatOpenAI from pydantic import BaseModel class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output( AnswerWithJustification, include_raw=True ) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python { "raw": AIMessage( content="", additional_kwargs={ "tool_calls": [ { "id": "call_Ao02pnFYXD6GN1yzc0uXPsvF", "function": { "arguments": '{"answer":"They weigh the same.","justification":"Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ."}', "name": "AnswerWithJustification", }, "type": "function", } ] }, ), "parsed": AnswerWithJustification( answer="They weigh the same.", justification="Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.", ), "parsing_error": None, } ``` ??? note "Example: `schema=TypedDict` class, `method='json_schema'`, `include_raw=False`, `strict=False`" ```python from typing_extensions import Annotated, TypedDict from langchain_openai import ChatOpenAI class AnswerWithJustification(TypedDict): '''An answer to the user question along with justification for the answer.''' answer: str justification: Annotated[ str | None, None, "A justification for the answer." ] model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output(AnswerWithJustification) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python { "answer": "They weigh the same", "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume and density of the two substances differ.", } ``` ??? note "Example: `schema=OpenAI` function schema, `method='json_schema'`, `include_raw=False`" ```python from langchain_openai import ChatOpenAI oai_schema = { "name": "AnswerWithJustification", "description": "An answer to the user question along with justification for the answer.", "parameters": { "type": "object", "properties": { "answer": {"type": "string"}, "justification": { "description": "A justification for the answer.", "type": "string", }, }, "required": ["answer"], }, } model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output(oai_schema) structured_model.invoke( "What weighs more a pound of bricks or a pound of feathers" ) ``` ```python { "answer": "They weigh the same", "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume and density of the two substances differ.", } ``` ??? note "Example: `schema=Pydantic` class, `method='json_mode'`, `include_raw=True`" ```python from langchain_openai import ChatOpenAI from pydantic import BaseModel class AnswerWithJustification(BaseModel): answer: str justification: str model = ChatOpenAI(model="...", temperature=0) structured_model = model.with_structured_output( AnswerWithJustification, method="json_mode", include_raw=True ) structured_model.invoke( "Answer the following question. " "Make sure to return a JSON blob with keys 'answer' and 'justification'.\\n\\n" "What's heavier a pound of bricks or a pound of feathers?" ) ``` ```python { "raw": AIMessage( content='{\\n "answer": "They are both the same weight.",\\n "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight." \\n}' ), "parsed": AnswerWithJustification( answer="They are both the same weight.", justification="Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight.", ), "parsing_error": None, } ``` ??? note "Example: `schema=None`, `method='json_mode'`, `include_raw=True`" ```python structured_model = model.with_structured_output( method="json_mode", include_raw=True ) structured_model.invoke( "Answer the following question. " "Make sure to return a JSON blob with keys 'answer' and 'justification'.\\n\\n" "What's heavier a pound of bricks or a pound of feathers?" ) ``` ```python { "raw": AIMessage( content='{\\n "answer": "They are both the same weight.",\\n "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight." \\n}' ), "parsed": { "answer": "They are both the same weight.", "justification": "Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight.", }, "parsing_error": None, } ``` r )rr.)r.rqr r rrrrs rdr.z!ChatOpenAI.with_structured_output s6` w-  #     rf)r5zdict[str, str])r5z list[str]r6)r5rr?)rrrrr5r;)rrrrr5r=r^rB)rCrDrErFrOrrGrJrPrIrUrXrZrNrurrr.rKrLs@rdrNrNsH[ z#47NOJ O/ 4466  "& "     (0  $'  + /3W KX!"!W +W H W  W  W W W  7W W rfrNc<t|txr t|Sr^)rrrI)objs rdrrr s c4 ?%:3%??rfcPd|d|dtj|ddddS) NrrqrprF) ensure_asciirprrrqr)jsondumps)rs rdrrv s6of%If$5EJ  rfc&d|d|d|dddS)Nrrqrprrgrhr)invalid_tool_calls rdrr s.%%f-*62  rfc. 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)PILrnr8loggerinfo_is_urlr7r`raise_for_statusopenr r-size_is_b64splitr b64decode) image_sourcernr7rwidthheightrencodedrs rdrr s |  99\*!!# 78+;+;#<=BB vf}|!''Q/ 7( 74=166 vf} 1   -    KK*   s"CC3C0/C03DDcnt||\}}t|dz }t|dz }d|z|zdzS)Nir)_resizer )r{r|hws rdrr sAE6*ME6 Vc\A US[A !GaK2 rfc t|}t|j|jgS#t$r }t j d|Yd}~yd}~wwxYw)NzUnable to parse URL: %sF)rr5schemenetlocrrqdebug)sresultrs rdrsrs sJ!FMM6==122  .2s+. AAAc$|jdS)Nz data:image)r)rs rdrwrw s << %%rfc|dkDs|dkDr||kDr |dz|z}d}n |dz|z}d}|dkDr"|dkDr||kDr|dz|z}d}||fS|dz|z}d}||fS)Niir)r{r|s rdrr s t|v} 6>tm-FET\f,EF s{v| 6>S[V+EF &=slu,FE &=rfrc<t|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}|T||dj dur>t|tr.d|j divrd |ddd |d }t||S) Nrrrprq)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.) rrrIrr`rrEr"r)rqrrorrs rdrr s=&$$9&$A  64 V # JJv - /  FD !f&68v;M#0H >&$'Jvzz(7KT,R)-fVD%\\,7#0J  /-8<D"II    z*    7 8 >B #o  ! /%%&ABHbMM    y)    ; < B # ! "-9;N;R;R"#: .< - L).;=Q=U=U"#9 -q> . \* !#!- 3 9 9 ;M1q}q!tM 0 4 : : <N1 q!tN    NOs FF5 FFc|jdd}|jdd}|jd||z}|dvrd}|r|dnd}|d|jd xsijd i}|d |jd xsijd i}|6||j|ddz ||<||j|d dz ||<t|||tdi|jD cic] \}} |  ||  c} }t di|jD cic] \}} |  ||  c} }Scc} }wcc} }w)Nrrrr>rrrrsroutput_tokens_detailsrrinput_tokens_detailsrrrr) rr rrrrrrrrs rd _create_usage_metadata_responsesrVs#&&~q9L#'';M"&&~|m7STL// 0<\N!,"  y)    7 8 >B # !"  z*    6 7 =2 #o ! .;=Q=U=U"#9 -q> . \*-9;N;R;R"#: .< - L) !#!- 3 9 9 ;M1q}q!tM 0 4 : : <N1 q!tN    NOs5 D?D?$ E/Ecd|vxr|ddk7S)Nrrr)rs rd_is_builtin_toolrs T> 8d6lj88rfc|d|vxrtd|dD}hd}t|xs|j|S)Nrc32K|]}t|ywr^)r)r,rs rdr/z%_use_responses_api..s4#'4s>r{r rrr)rr intersection)ruses_builtin_toolsresponses_only_argss rdrrsR G+4+27+;41 "O&9&F&Fw&O PPrfctt|dz ddD]S}||}t|ts|jj d}|s7|j dsI||dzd|fcS|dfS)aGet the last part of the conversation after the last `AIMessage` with an `id`. Will return: 1. Every message after the most-recent `AIMessage` that has a non-empty `response_metadata["id"]` (may be an empty list), 2. That `id`. If the most-recent `AIMessage` does not have an `id` (or there is no `AIMessage` at all) the entire conversation is returned together with `None`. rrprqresp_N)rangerbrrrcr`r)r}ir response_ids rdrrs3x=1$b" -6qk c9 %//33D9K{55g>A(+55 6 T>rfchdD]}||vs|j||d<d|vrd|vrd|jdi|d<|jdxsd}|jdr=d |vr9|jdxsijdd k7r|jd dt||d <|jd dx}r|g}|D]p}|ddk(rd|vr|j ddi|d(|ddk(r0d|vr d}t ||jdr d|vr i|ddi}n |j |r||d <|jddx}r.t |tr|ddk(rd|vr ddi|d|d<n||d<|jddx} r|jdd} |jdst| r| |d<nt| r| j} d} n| } | ddik(r,d|vrt |dtr ddi|dd<ncdddii|d<nYt| | x} rIt | tr9| ddk(r1ddi| d} d|vrt |dtr | |dd<n d| i|d<n |jdd}|(d|vrt |dtr ||dd<|Sd|i|d<|S) N)rrmax_output_tokensrrr!rrsrrr rinputrrrrmpartial_imageszPartial image generation is not yet supported via the LangChain ChatOpenAI client. Please drop the 'partial_images' key from the image_generation tool.rLrrror text_formatTrr{formatrrr) r"r`r_construct_responses_api_inputrrrrrmodel_json_schemar)r}rlegacy_token_paramrr new_toolsrrrrqr schema_dictro format_valuers rdrrsqFK  (+2;;7I+JG' (KW$G)C ('++6H*IJ  KK &BE ! 5 [[ % + 0 0 :f D M4(5h?GG GT**u*  'DF|z)jD.@  &*!IZ8H!IJ<#55'4/$ 2#66{{8,1A1M =$<(8!<  &/ '2%kk-66{6 {D )F#z1k)&,j%TK GFO K.I W GFOT!B+4GFOK ( N +I6GFO Nrfc|jddk(r*d|vr&|j}|jd|d<|S|S)Nr file_citationr file_indexr`rar" annotationnew_annotations rd_format_annotation_to_lcrsI~~f0W 5J#*'5'9'9''B|$ rfc|jddk(r*d|vr&|j}|jd|d<|S|S)Nrrrrrrs rd_format_annotation_from_lcrsG~~f0\Z5O#*"0"4"4\"Bw rfc|ddk(rd|ddS|ddk(r,d|ddd}|djd r |dd |d <|S|dd k(r dd i|d S|S) zConvert chat completions content blocks to Responses API format. Only handles text, image, file blocks. Others pass through. rr{ input_text)rr{r input_imagerrrr input_file)r`)r new_blocks rd-_convert_chat_completions_blocks_to_responsesr's V}%eFm<< V} #"{+E2    ! !( +"' "4X">Ih  V} 6f 66 Lrfct|tr|St|tr+td|Dr|Dcgc] }t |c}St |Scc}w)Nc3fK|])}t|txr|jddv+yw)r)rrrr{rrNrrs rdr/z5_ensure_valid_tool_message_content..DsA -  5$ IIf     -s/1)rrrr5rrC) tool_outputrs rd"_ensure_valid_tool_message_contentrAsf+s#+t$ -! - *%  :% @   k ""  sAcfd}t|jtr|jD]}|jj ddk(r6t|t r&|j ddk(r|j d|d}nt|t sh|j ddk(s}|j dij ddk(s|d}n=n;|jj ddk(r|j dd|jdd}| d|jvr|jd|d<|S) Nrcomputer_call_outputr)call_idrrSrrracknowledged_safety_checks)rr-rryr`rr)rrrs rd'_make_computer_call_output_from_messagerXs;37'//4(__ E))--f59OOud+IIf%6 '332#($ 5$'IIf%7IIgr*..v6:PP',W~$' (  " " & &v .2H H++*,7??K  ( (G,E,E E=D=V=V (> 9: rfcdd}|jD]}t|tr:|jddk(r&d|j|jdxsdd}|St|ts^|jddk(ss|jdijddk(s|d}|S|S)Nrcustom_tool_call_outputrSrs)rrrSrr)r-rrr`r)rcustom_tool_outputrs rd%_make_custom_tool_output_from_messagers eT "uyy'8||d<|Scc}}wcc}}w)zWhen streaming, `langchain-core` uses `index` to aggregate text blocks. OpenAI API does not support this key, so we need to remove it. rsummary)rrrr)rrrr new_summary sub_block new_sub_blocks rd_pop_index_and_sub_indexrs #(++-@$!Q1<A@I@I*Yy-A4"H "9- .I.7oo.?Pda1|d |vr|j!|WX||d<|ds:|j!|M|j!|`|j!|s|Scc}wcc}wcc}w)-z1Construct the input for the OpenAI Responses API.rrr-c3<K|]}t|tywr^rrs rdr/z1_construct_responses_api_input..s<,1 5$'<srrprrqrrprrqrrrrorfunction_call_outputr)rrSrrt)r{ output_textr)r{rr{Nrr)rr{rrrrr)rr-rorq) rweb_search_callfile_search_callru computer_callcustom_tool_callrmcp_callmcp_list_toolsmcp_approval_requestimage_generation_call)rrq)rror-rv)rurrrurr)rrprr)rrr|r})mcp_approval_response)r{rr)rrr)rrr1rr`rr5rvrW enumeraterr"rrr*rrrrrrr)r}rlc_msgrrtcsrrrrrr block_typemsg_idr{rritemitem_idrvcontent_call_idsru new_blocksnon_message_item_typess rdrrs1 Fb fi (1&9F*6{CC#''),d3<58^<9&,%6%6-" !, )& 1 )& 1'mmD1 --"?s9~s!SI*6{CC#i.$/ )#i. 9;HAu!%.599V3D3V,1'NIq); S= GGFO v;& i.K#J[&)$ "Gv!N # 23# 01@M 2)">2($  23 [K '#''),d3 ^<!E!%.%))FBS4SJ4S%)KK%*YYt_F)-DD',yy'8#'<$,,9,0;@))M:R:XVX4&,6)C:(N4&-" ",y!8,5/4Y/?-" )/"/3xx~$=G$=7fCT'0'<:<Y$(O$:$:9$E$) "!' 094=;0;.4 %&!"( , #MM*B5*IJ'+BB"MM)@d T!y<!zCGGI.4 ) +)6(+I/1$  !WW\488z8"($yy(,QQ!U*)$$ $ ",5I .>>$3$-j$9&$A)2:)>{)K'0 )  m45[; ;#i.$/ )C& ^ EV}(EE"))I%Pv*UU"))%0v*@@ e, ",Iy>MM#& c" MM# EbH M{-l4&@$s3#Q;R #Rct|dr |jS|jDcgc]=}|jdk(r,|jD]}|jdk(r |j ?}}}dj |Scc}}w)zrSafe output text extraction. Context: OpenAI SDK deleted `response.output_text` momentarily in `1.99.2`. rrrs)rrrSrr-r{join)rrSr-textss rd_get_output_textr Ps x'###oo   ;;) #~~    <<= (    E  775> sAA>c |jrt|j|d}|jddjDcic] \}}|dvr||}}}|r|j |d|d<|j d |d <|j r/t|j j|j}nd}g}g} g} i} |jD]O} | jd k(r| jD]} | jd k(rd | jt| jtr1| jDcgc]}t!|jc}ng| j"d}|j%|t'| dr| j(| d<| jdk(s|j%d| j*| j"d| jdk(r|j%| jdd t-j.| j0d}d}|.d| j6|| j8d}| j%|d| j6|| j8|d}| j%|| jdk(r\|j%| jddd| j6d| j:i| j8d}| j%|| jdvs.|j%| jddRt=|}|d| vr|r|jrw|jjx}r[|j dix}rG|j ddk(r3 t-j.|}|rt?|r |d#i|}n|}|| d<tA||j"||| | | }|d k(r tC|}tEtG|!g"Scc}}wcc}w#t2$r"}| j0}t5|}Yd}~ d}~wwxYw#t,j2$rYwxYw)$z;Construct `ChatResponse` from OpenAI Response API response.NrTri exclude_noner) created_atrqincomplete_detailsrrobjectstatusrrrr r;r`rrbrrr{)rr{rrqrr)rrrqruFrrrrl)rrprrqrr__arg1) rrrrrrrrrrrr)r-rqrZrcryrvrzv0r)rr)$rrrrupdater`rWrr rSrr-r{rrrrrqrrrrriloadsrr rrprrr rrrXr<r:)rrqrrrrrrcrZrrvrzryrSr-rrrrrrr text_configformat_ parsed_dictrrs rdrrasY~~(((''T'GMMO Aq    1$  **2&'&7&;&;G&Dl#~~9 NN % % ')>)> NJ //CU ;;) #!>> <<=0 & ' &g&9&94@/6.A.A( *5Z5J5J5LM(  $ii E#))%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 TGCUh#8,K - -  MM$MM446 6[ 6#"5 5W 5 [[ M 1 **[1K,V4.+.$*0 h ' ;;%++-G,W5 >'#B"C DDmR((# ''A T##   s6 P P #P2Q P=P88P=QQc  d4d5fd }|d}g} g} i} |xsi} d| d<d} d}d}|jdk(r>||j|j| jd|jdn |jdk(r||j|jt |j tr |j }n|j jd d }| jdt|gd nx|jd k(r?||j|j| jdd|jdn*|jdk(r1|jj}|jj| d<n|jdvrttt|j||j dj"}|j$j'dx}r|| d<|j(} |j*j-Dcic]\}}|dk7s ||} }}d}n:|jdk(r8|j.jdk(r|dk(r|j.j}nn|jdk(r|j.jdk(r||j| jd|j.j0|j.j2|j.j4d| jd|j.j0|j.j2|j.j4|j.jdn|jdk(r_|j.jdvrG||j|j.jd d }|d <| j|n|jdk(r|j.jd!k(r||j|j.jd d }|d <| j|| jd|j.j0t7j8d"|j.j:i|j.j4dn|jd#k(rR||j| jd|jd$| jd|jd%nV|jd&k(r | jd'|j<d(n'|jdk(ra|j.jd)k(rH||jd|j.jd d }|d <| j|n|jd*k(rB||j| j|j>d+dd,gd)|jd-nf|jd.k(rnV|jd/k(rA||j| j|j>d+|jd,gd)d0ndfStA| | | | | ||1}|dk(rtt@tC||2}tE|3fScc}}w)6NcJ| |k7rdz |y|k7s|k7rdz ||y)aAdvance indexes tracked during streaming. Example: we stream a response item of the form: ```python { "type": "message", # output_index 0 "role": "assistant", "id": "msg_123", "content": [ {"type": "output_text", "text": "foo"}, # sub_index 0 {"type": "output_text", "text": "bar"}, # sub_index 1 ], } ``` This is a single item with a shared `output_index` and two sub-indexes, one for each content block. This will be processed into an `AIMessage` with two text blocks: ```python AIMessage( [ {"type": "text", "text": "foo", "id": "msg_123"}, # index 0 {"type": "text", "text": "bar", "id": "msg_123"}, # index 1 ] ) ``` This function just identifies updates in output or sub-indexes and increments the current index accordingly. Nrr) output_idxsub_idxrrrs rd_advancez>_convert_responses_chunk_to_generation_chunk.._advancesMF ?#z1" *% 28IW8T" ' )rfrr;r`zresponse.output_text.deltar{)rr{rz%response.output_text.annotation.addedTrir )rrrzresponse.output_text.doners)rr{rqrzresponse.createdrq)zresponse.completedzresponse.incomplete)rqrrrlastzresponse.output_item.addedrrrur3)rrprrqr)rrprrrqrzresponse.output_item.done)rrrrrrrrrrrz&response.function_call_arguments.delta)rrr)rrrzresponse.refusal.donerrrz%response.reasoning_summary_part.added summary_text)rrr{)rrrrqz,response.image_generation_call.partial_imagez%response.reasoning_summary_text.delta)rrr)r-rrZrcryrqchunk_position)rsrr^)rrrrr5r8)#r output_index content_indexrr^rrrrrrrrqrrrrrryr`rZrcrrrprrrirjrr summary_indexrrXr;)rYrrrrqrrrsrrr-rryrcrZr rqrrrrrrrrs ``` rdryry s,****X(G  B*2&'N-1N B zz11##U%8%89 mTU > >##U%8%89 e&& -))J))44$V4TJ 8 DE&   2 2##U%8%89mm&    ) ) ^^  "'.."3"3$ D D 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'#mm   E E > >##$"'!4!4 . % '#  24EtKK)%++ %G  &wm L  G,  C s * [8[)rbrr5rZ)rMapping[str, Any]r5r)rN)r-rr(Literal['chat/completions', 'responses']rorr5r)r)rrrr%r5r)rr$rztype[BaseMessageChunk]r5r)r int | dictrr&r5r&)rzopenai.BadRequestErrorr5r8)rbrr5r)rdrr5r)rr)r5r)rlr&r5r)rzrr5ztuple[int, int] | None)r{rr|rr5r)rrr5r)r{rr|rr5ztuple[int, int])rqzdict[str, Any] | typerrr5zdict | TypeBaseModel)rrrqz type[_BM]r5zPydanticBaseModel | Noner^)rrr rr5r0)rrr5rr>)r}r@r5z(tuple[Sequence[BaseMessage], str | None])r}r@rrr5r)rrr5r)rrr5r)rrr5zstr | list[dict])rr*r5r)rr*r5r7)rrr5r)r}r@r5r)rr[r5r)NNN) rr[rqtype[_BM] | Nonerrr7rrr5r<)NNFN)rYrrrrrrrrqr'rrr7rsrrrr5z0tuple[int, int, int, ChatGenerationChunk | None])rF __future__rrriloggingr3r]sslrrcollections.abcrrrrrr functoolsr ior r mathr operatorrtypingrrrrrr urllib.parsercertifir;rlangchain_core.callbacksrrlangchain_core.language_modelsrr*langchain_core.language_models.chat_modelsrrlangchain_core.messagesrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-typeslangchain_core.messages.air.r/r00langchain_core.messages.block_translators.openair1r2langchain_core.messages.toolr3langchain_core.output_parsersr4r5*langchain_core.output_parsers.openai_toolsr6r7r8r9langchain_core.outputsr:r;r<langchain_core.runnablesr=r>r?r@langchain_core.runnables.configrAlangchain_core.toolsrBlangchain_core.tools.baserClangchain_core.utilsrD%langchain_core.utils.function_callingrErFlangchain_core.utils.pydanticrGrHrIlangchain_core.utils.utilsrJrKrLpydanticrMrNrOrPrQ pydantic.v1rtyping_extensionsrR*langchain_openai.chat_models._client_utilsrSrTrU$langchain_openai.chat_models._compatrVrWrXlangchain_openai.data._profilesrYrZopenai.types.responsesr[ getLoggerrCrqcreate_default_contextwherer:r_rerrrrrrrrrrrrrrGrrrNrrrrrrsrwrrr!rrrarrrrrrrrrrrrrr rryrrfrdrPs{"   " &5 9P SR <)09 VU1"  6;/   8 $0S//}w}}G+Y7 @LJ5G: : 1: : :~5GM M 1M M`52 52-C5252p#0:8 2' e9%"&sCx.49"