"j;SrSSKJr SSKrSSKJrJr SSKJ r SSKJ r J r SSK J r SSK Jr SS KJr S S KJrJrJrJr S S KJr S S KJr S SKJrJr SrSSjrSSSS.SSjjr SSSS.SSjjr!SSSS.SSjjr"SSSS.SSjjr#SSjr$\ "SS55r%g)aRMethods for making imperative requests to language models with minimal abstraction. These methods allow you to make requests to LLMs where the only abstraction is input and output schema translation so you can use all models with the same API. These methods are thin wrappers around [`Model`][pydantic_ai.models.Model] implementations. ) annotationsN)IteratorSequence)AbstractAsyncContextManager) dataclassfield)datetime) TracebackType) RequestUsage)agentmessagesmodelssettings)SyncStreamBridge)run_until_complete)StreamedResponse instrumented) model_requestmodel_request_syncmodel_request_streammodel_request_stream_syncStreamedResponseSyncc URbU$[U5Hen[U[R5(dM$UR cM3[ R"U[R"UR S9/S9s $ U$)a.Populate instruction_parts from message history if not already set. When using the direct API, users set `instructions` on `ModelRequest` but may not set `instruction_parts` on `ModelRequestParameters`. This bridges the gap so models that read `instruction_parts` directly still see the instructions. )content)instruction_parts) rreversed isinstancer ModelRequest instructions dataclassesreplaceInstructionPart)msgsmodel_request_parametersmessages O/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/direct.py_ensure_instruction_partsr("sw 11=''D> gx44 5 5':N:N:Z&&(#+#;#;GDXDX#Y"Z " $#model_settingsr% instrumentc# [X5n[X=(d [R"55nUR [ U5UU5IShvN $N7f)aMake a non-streamed request to a model. ```py title="model_request_example.py" from pydantic_ai import ModelRequest from pydantic_ai.direct import model_request async def main(): model_response = await model_request( 'anthropic:claude-haiku-4-5', [ModelRequest.user_text_prompt('What is the capital of France?')] # (1)! ) print(model_response) ''' ModelResponse( parts=[TextPart(content='The capital of France is Paris.')], usage=RequestUsage(input_tokens=56, output_tokens=7), model_name='claude-haiku-4-5', timestamp=datetime.datetime(...), ) ''' ``` 1. See [`ModelRequest.user_text_prompt`][pydantic_ai.messages.ModelRequest.user_text_prompt] for details. Args: model: The model to make a request to. We allow `str` here since the actual list of allowed models changes frequently. messages: Messages to send to the model model_settings: optional model settings model_request_parameters: optional model request parameters instrument: Whether to instrument the request with OpenTelemetry/Logfire, if `None` the value from [`logfire.instrument_pydantic_ai`][logfire.Logfire.instrument_pydantic_ai] is used. Returns: The model response and token usage associated with the request. N)_prepare_modelr(rModelRequestParametersrequestlistmodelrr+r%r,model_instancemrps r'rr7sTX$E6N #H.i&JgJgJi jC'' X   sAAAAc @[[U[U5UUUS95$)aMake a Synchronous, non-streamed request to a model. This is a convenience method that wraps [`model_request`][pydantic_ai.direct.model_request] with `loop.run_until_complete(...)`. You therefore can't use this method inside async code or if there's an active event loop. ```py title="model_request_sync_example.py" from pydantic_ai import ModelRequest from pydantic_ai.direct import model_request_sync model_response = model_request_sync( 'anthropic:claude-haiku-4-5', [ModelRequest.user_text_prompt('What is the capital of France?')] # (1)! ) print(model_response) ''' ModelResponse( parts=[TextPart(content='The capital of France is Paris.')], usage=RequestUsage(input_tokens=56, output_tokens=7), model_name='claude-haiku-4-5', timestamp=datetime.datetime(...), ) ''' ``` 1. See [`ModelRequest.user_text_prompt`][pydantic_ai.messages.ModelRequest.user_text_prompt] for details. Args: model: The model to make a request to. We allow `str` here since the actual list of allowed models changes frequently. messages: Messages to send to the model model_settings: optional model settings model_request_parameters: optional model request parameters instrument: Whether to instrument the request with OpenTelemetry/Logfire, if `None` the value from [`logfire.instrument_pydantic_ai`][logfire.Logfire.instrument_pydantic_ai] is used. Returns: The model response and token usage associated with the request. r*)_run_until_completerr1r3rr+r%r,s r'rrls-Z   N)%=!   r)c[X5n[X=(d [R"55nUR [ U5UU5$)aMake a streamed async request to a model. ```py {title="model_request_stream_example.py"} from pydantic_ai import ModelRequest from pydantic_ai.direct import model_request_stream async def main(): messages = [ModelRequest.user_text_prompt('Who was Albert Einstein?')] # (1)! async with model_request_stream('openai:gpt-5-mini', messages) as stream: chunks = [] async for chunk in stream: chunks.append(chunk) print(chunks) ''' [ PartStartEvent(index=0, part=TextPart(content='Albert Einstein was ')), FinalResultEvent(tool_name=None, tool_call_id=None), PartDeltaEvent( index=0, delta=TextPartDelta(content_delta='a German-born theoretical ') ), PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='physicist.')), PartEndEvent( index=0, part=TextPart( content='Albert Einstein was a German-born theoretical physicist.' ), ), ] ''' ``` 1. See [`ModelRequest.user_text_prompt`][pydantic_ai.messages.ModelRequest.user_text_prompt] for details. Args: model: The model to make a request to. We allow `str` here since the actual list of allowed models changes frequently. messages: Messages to send to the model model_settings: optional model settings model_request_parameters: optional model request parameters instrument: Whether to instrument the request with OpenTelemetry/Logfire, if `None` the value from [`logfire.instrument_pydantic_ai`][logfire.Logfire.instrument_pydantic_ai] is used. Returns: A [stream response][pydantic_ai.models.StreamedResponse] async context manager. )r.r(rr/request_streamr1r2s r'rrsGl$E6N #H.i&JgJgJi jC  ( ( X  r)rcD[U[U5UUUS9n[U5$)aXMake a streamed synchronous request to a model. This is the synchronous version of [`model_request_stream`][pydantic_ai.direct.model_request_stream]. It drives the asynchronous stream on the caller's event loop while providing a synchronous iterator interface. The returned context manager must be used and closed on the thread where the synchronous stream is created. ```py {title="model_request_stream_sync_example.py"} from pydantic_ai import ModelRequest from pydantic_ai.direct import model_request_stream_sync messages = [ModelRequest.user_text_prompt('Who was Albert Einstein?')] with model_request_stream_sync('openai:gpt-5-mini', messages) as stream: chunks = [] for chunk in stream: chunks.append(chunk) print(chunks) ''' [ PartStartEvent(index=0, part=TextPart(content='Albert Einstein was ')), FinalResultEvent(tool_name=None, tool_call_id=None), PartDeltaEvent( index=0, delta=TextPartDelta(content_delta='a German-born theoretical ') ), PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='physicist.')), PartEndEvent( index=0, part=TextPart( content='Albert Einstein was a German-born theoretical physicist.' ), ), ] ''' ``` Args: model: The model to make a request to. We allow `str` here since the actual list of allowed models changes frequently. messages: Messages to send to the model model_settings: optional model settings model_request_parameters: optional model request parameters instrument: Whether to instrument the request with OpenTelemetry/Logfire, if `None` the value from [`logfire.instrument_pydantic_ai`][logfire.Logfire.instrument_pydantic_ai] is used. Returns: A [sync stream response][pydantic_ai.direct.StreamedResponseSync] context manager. r8)rr1r)r3rr+r%r,async_stream_cms r'rrs/l+h%!9 O  00r)c[R"U5nUc[RRn[ R "X!5$N)r infer_modelr Agent_instrument_defaultinstrumented_modelsinstrument_model)r3r,r4s r'r.r.$s:''.N[[44  / / KKr)c\rSrSr%SrS\S'\"SSS9rS\S '\"SSS9rS \S 'SS jr SS jr SSjr SSjr \ r SSjr\SSj5r\SSj5r\SSj5r\SSj5rSrg)ri0a$Synchronous wrapper for an async streaming response, running the whole stream on the caller's event loop. The stream uses the internal `SyncStreamBridge` to keep context-manager and iterator lifecycles in stable tasks. Exiting the `with` block cancels the underlying request promptly and closes the connection instead of waiting for the whole response to arrive. This class must be used as a context manager with the `with` statement. The synchronous stream is created when the `with` block is entered and must be used and closed on that thread. z-AbstractAsyncContextManager[StreamedResponse]_async_stream_cmNF)defaultinitz)SyncStreamBridge[StreamedResponse] | None_bridgebool_context_enteredcFSUl[URSS9UlU$)NTz`model_request_stream`)async_alternative)rJrrErHselfs r' __enter__StreamedResponseSync.__enter__@s$ $'(=(=Qij  r)cfURcS5eURRXU45 g)Nz=`__exit__` is only reachable after `__enter__` sets `_bridge`)rHshutdown)rNexc_typeexc_valexc_tbs r'__exit__StreamedResponseSync.__exit__Es1 ||'h)hh' x&9:r)cf^UR5nURmURU4Sj5$)zsStream the response as an iterable of [`ModelResponseStreamEvent`][pydantic_ai.messages.ModelResponseStreamEvent]s.c>[T5$r>)aiter)streamsr'/StreamedResponseSync.__iter__..Ts %-r))_ensure_bridger[ stream_sync)rNbridger[s @r'__iter__StreamedResponseSync.__iter__Ns.$$&!!"788r)cURb[URR5$URRSUR S3$)Nz(context_entered=))rHreprr[ __class____name__rJrMs r'__repr__StreamedResponseSync.__repr__VsH << # ++, ,nn--..?@U@U?VVWX Xr)cJURc [S5eUR$)NzmStreamedResponseSync must be used as a context manager. Use: `with model_request_stream_sync(...) as stream:`)rH RuntimeErrorrMs r'r^#StreamedResponseSync._ensure_bridge^s+ << H ||r)clUR5nURURR5$)z&Get the current state of the response.)r^callr[getrNr`s r'responseStreamedResponseSync.responsefs+$$&{{6==,,--r)cN^UR5mTRU4Sj5$)z%Get the usage of the response so far.c0>TRR$r>)r[usager`sr'r\,StreamedResponseSync.usage..ps6==#6#6r)r^rnrps @r'ruStreamedResponseSync.usagels#$$&{{677r)cN^UR5mTRU4Sj5$)z#Get the model name of the response.c0>TRR$r>)r[ model_namervsr'r\1StreamedResponseSync.model_name..vs6==#;#;r)rxrps @r'r|StreamedResponseSync.model_namers#$$&{{;<TRR$r>)r[ timestamprvsr'r\0StreamedResponseSync.timestamp..|s6==#:#:r)rxrps @r'rStreamedResponseSync.timestampxs#$$&{{:;;r))rHrJ)returnr)rSztype[BaseException] | NonerTzBaseException | NonerUzTracebackType | NonerNone)rz+Iterator[messages.ModelResponseStreamEvent])rstr)rz"SyncStreamBridge[StreamedResponse])rmessages.ModelResponse)rr )rr )rg __module__ __qualname____firstlineno____doc____annotations__rrHrJrOrVrarh__str__r^propertyrqrur|r__static_attributes__r)r'rr0sDC9>tRW9XG 6X"5u=d= ;,;&;% ;  ;9Y G.. 88 == <rs3.2(*//*=I $ )$;$#$259EILP 2 52-22 2 C 2 J 22r59EILP 5 55-52 5 C 5 J 55x59EILP < 5<-<2 < C < J <:<F59EILP >1 5>1->12 >1 C >1 J >1>1B L 5 LI L L K<K< K