g ,UddlmZddlZddlZddlZddlmZmZm Z m Z ddl m Z m Z mZddlmZddlmZddlmZmZmZmZmZmZmZddlZddlmZmZmZd d l m!Z!m"Z"m#Z#m$Z$m%Z&m'Z'm(Z(m)Z*d d l(m+Z+d d l,m-Z-m.Z.d d l/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8dZ9ejtdZ; ddlm?Z?e=jjxjeCe?eDjjfz c_BeHdZIedZJ edZK eejdGddee0e+fZMejGddZNedZOdePd<ed dZQejGddee+ZRy#eG$rYwxYw)!) annotationsN) AsyncIterator AwaitableIteratorSequence)AbstractAsyncContextManagerasynccontextmanagercontextmanager) ContextVar) FrameType)AnyCallableGenericLiteralcastfinaloverload)TypeVar assert_never deprecated)_result_system_prompt_utils exceptionsmessagesmodelsresultusage) ResultData) ModelSettingsmerge_model_settings) AgentDeps RunContextToolToolDefinitionToolFuncContextToolFuncEither ToolFuncPlain ToolParamsToolPrepareFunc)Agentcapture_run_messages EndStrategyz pydantic-ai) otel_scope)Path)early exhaustive RunResultDataF)initc eZdZUdZded< ded< ded< ded < ej d Zd ed <ej d Zded<ej d Z ded<ej d Z ded<ej d Z ded<ej d Z ded<ej d Z ded<ej d Zded<ej d Zded<ej d Zded<ej d Zded<ej d d !Zd"ed#<ej d d !Zd$ed%< dded&ed d d'd(d d d&d d)d* ded+Zed d d d d d d d,d- dfd.Zed d d d d d d,d/ dgd0Zd d d d d d d d,d1 dhd2Zed d d d d d d,d/ did3Zed d d d d d d,d/ djd4Zd d d d d d d d,d- dkd5Zed d d d d d d d,d- dld6Zed d d d d d d,d/ dmd7Zed d d d d d d d,d- dnd8Zeej<ej<d9 dod:Ze dpd;Z e dqd<Z edrd=Z edsd>Z ed d? dtd@Z ddd d? dudAZ e dvdBZ!e dwdCZ!edxdDZ!e dydEZ! dzdFZ!ed{dGZ"ed d dH d|dIZ" ddd d dH d}dJZ"ed~dKZ#ed d dH ddLZ# ddd d dH ddMZ# ddNZ$ddOZ%ddPZ& ddQZ' ddRZ( ddSZ) ddTZ* ddUZ+ ddVZ, ddWZ- ddXZ. ddYZ/ ddZZ0dd[Z1dd\Z2 dd]Z3dd^Z4dd_Z5e6dd`Z7e8e9dad bddcZ:y )r,aYClass for defining "agents" - a way to have a specific type of "conversation" with an LLM. Agents are generic in the dependency type they take [`AgentDeps`][pydantic_ai.tools.AgentDeps] and the result data type they return, [`ResultData`][pydantic_ai.result.ResultData]. By default, if neither generic parameter is customised, agents have type `Agent[None, str]`. Minimal usage example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-4o') result = agent.run_sync('What is the capital of France?') print(result.data) #> Paris ``` +models.Model | models.KnownModelName | Nonemodel str | Nonenamer. end_strategyModelSettings | Nonemodel_settingsF)reprstr_result_tool_name_result_tool_descriptionz'_result.ResultSchema[ResultData] | None_result_schemaz4list[_result.ResultValidator[AgentDeps, ResultData]]_result_validatorsztuple[str, ...]_system_promptszdict[str, Tool[AgentDeps]]_function_toolsint_default_retriesz2list[_system_prompt.SystemPromptRunner[AgentDeps]]_system_prompt_functionsz7dict[str, _system_prompt.SystemPromptRunner[AgentDeps]] _system_prompt_dynamic_functionstype[AgentDeps] _deps_type_max_result_retriesN)defaultr=z_utils.Option[AgentDeps]_override_depsz_utils.Option[models.Model]_override_modelr final_resultr1) result_type system_prompt deps_typer9r<retriesresult_tool_nameresult_tool_descriptionresult_retriestoolsdefer_model_checkr:c || r||_ntj||_| |_||_||_||_| |_tj|j||| |_ t|tr|fn t||_i|_||_| D]>}t|t$r|j'|%|j't%|@||_g|_i|_| | n||_g|_y)a? Create an agent. Args: model: The default model to use for this agent, if not provide, you must provide the model when calling it. result_type: The type of the result data, used to validate the result data, defaults to `str`. system_prompt: Static system prompts to use for this agent, you can also register system prompts via a function with [`system_prompt`][pydantic_ai.Agent.system_prompt]. deps_type: The type used for dependency injection, this parameter exists solely to allow you to fully parameterize the agent, and therefore get the best out of static type checking. If you're not using deps, but want type checking to pass, you can set `deps=None` to satisfy Pyright or add a type hint `: Agent[None, ]`. name: The name of the agent, used for logging. If `None`, we try to infer the agent name from the call frame when the agent is first run. model_settings: Optional model request settings to use for this agent's runs, by default. retries: The default number of retries to allow before raising an error. result_tool_name: The name of the tool to use for the final result. result_tool_description: The description of the final result tool. result_retries: The maximum number of retries to allow for result validation, defaults to `retries`. tools: Tools to register with the agent, you can also register tools via the decorators [`@agent.tool`][pydantic_ai.Agent.tool] and [`@agent.tool_plain`][pydantic_ai.Agent.tool_plain]. defer_model_check: by default, if you provide a [named][pydantic_ai.models.KnownModelName] model, it's evaluated to create a [`Model`][pydantic_ai.models.Model] instance immediately, which checks for the necessary environment variables. Set this to `false` to defer the evaluation until the first run. Useful if you want to [override the model][pydantic_ai.Agent.override] for testing. end_strategy: Strategy for handling tool calls that are requested alongside a final result. See [`EndStrategy`][pydantic_ai.agent.EndStrategy] for more information. N)r7r infer_modelr:r9r<r?r@r ResultSchemabuildrA isinstancer>tuplerCrDrFr%_register_toolrJrGrHrKrB)selfr7rQrRrSr9r<rTrUrVrWrXrYr:tools F/var/www/openai/venv/lib/python3.12/site-packages/pydantic_ai/agent.py__init__zAgent.__init__xs\ =-DJ++E2DJ( ,!1(?%%22;?EE )+B 4>mS3Q /W\]jWk! 'D$%##D)##DJ/  $(*%02-5C5O>U\ "$TrQmessage_historyr7depsr< usage_limitsr infer_namec KywNrO ra user_promptrQrgr7rhr<rirrjs rcrunz Agent.runs (+)rgr7rhr<rirrjc KywrlrOrms rcroz Agent.runs +.rp)rgr7rhr<rirrQrjc K| r/|j#|jtj|j |d{} |j |}|r t |nd} |j|} tjd||| j|jxsd5} t|| |xstj|}|j|||d{}||_|jj!D] }d|_ t%|j&|}|xstj(} |j+|j,|xj.dz c_tjd|j.5|j1|| d{}dddtjd |j.5}j3||d{\}}|j5d ||j5d |ddd|j7|j,j9d |j;|j,tjd |j.5}|j=||| d{\}}|r$|j7t?j@|||jB}|jD}| j5d|| j5d |j,|j5d|d|_#tIjJ|| |||j,cdddcdddS|j5d|djMd|D}d||_# dddc7k77#1swYxYw7#1swYxYw7)#1swY4xYw#1swYyxYww)aRun the agent with a user prompt in async mode. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-4o') result_sync = agent.run_sync('What is the capital of Italy?') print(result_sync.data) #> Rome ``` Args: result_type: Custom result type to use for this run, `result_type` may only be used if the agent has no result validators since result validators would expect an argument that matches the agent's result type. user_prompt: User input to start/continue the conversation. message_history: History of the conversation so far. model: Optional model to use for this run, required if `model` was not set when creating the agent. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request. usage_limits: Optional limits on model request count or token usage. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. infer_name: Whether to try to infer the agent name from the call frame if it's not set. Returns: The result of the run. Nrz{agent_name} run {prompt=}agentpromptrs model_name agent_namer%preparing model and tools {run_step=}run_stepz model requestresponser)requestshandle model response all_messagesr%handle model response -> final resulttool_responses c34K|]}|jywrl part_kind.0rs rc zAgent.run..Is5Z>aakk>handle model response -> )'r9 _infer_nameinspect currentframe _get_model _get_depslen_prepare_result_schema_logfirespanr$_usageUsage_prepare_messagesrrDvalues current_retryr"r< UsageLimitscheck_before_requestrrz_prepare_modelrequest set_attributeappendincr check_tokens_handle_model_response _messages ModelRequestdata tool_namemessager RunResultjoin)rarnrgr7rhr<rirrQrj model_usednew_message_index result_schemarun_span run_contextrrb agent_modelmodel_req_spanmodel_response request_usage handle_spanrPr result_datarUtool_responses_strs rcroz Agent.runsR $))+   W113 4??511 ~~d#4CC033K@ ]] (!(yy+G  $T:u7N P[\K!33KR]^^H#+K ,,335%&"62$2E2E~VN'?6+=+=+?L11+2C2CD$$)$]]#JU`UiUi]j(,(;(;K(W"WKk]]?[=Q=Q]RVd:E:M:MhXf:g4g1NM"00^L"00-HS /!!&&}q&A))+*;*;<]]#:[EYEY]Z^i9=9T9T& ]:40L.&  (>(>~(NO$/&2&7&7 +7+A+A( ..~xH ..w 8I8IJ#11(KH.U +%//$&7FVXcXiXi #[ZC  n$112BNS-0XX5Z>5Z-Z*0IJ\I].^ +1[!/2_#Xkj5hSR4[ZC  sAO4N3 A+O44;O(/N60B1O(!N<7N98N<<)O(%O ;O <+O 'A2O(O0O1B0O! O(* O444O) O(3O46O(9N<<O O( O  O O(OO% !O((O1-O4cyrlrO) rarnrgr7rhr<rirrjs rcrun_synczAgent.run_syncLs(+recyrlrOrms rcrzAgent.run_syncZs+.rec | r/|j#|jtjt j j |j||||||||d S)aRun the agent with a user prompt synchronously. This is a convenience method that wraps [`self.run`][pydantic_ai.Agent.run] with `loop.run_until_complete(...)`. You therefore can't use this method inside async code or if there's an active event loop. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-4o') async def main(): result = await agent.run('What is the capital of France?') print(result.data) #> Paris ``` Args: result_type: Custom result type to use for this run, `result_type` may only be used if the agent has no result validators since result validators would expect an argument that matches the agent's result type. user_prompt: User input to start/continue the conversation. message_history: History of the conversation so far. model: Optional model to use for this run, required if `model` was not set when creating the agent. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request. usage_limits: Optional limits on model request count or token usage. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. infer_name: Whether to try to infer the agent name from the call frame if it's not set. Returns: The result of the run. Frf)r9rrrasyncioget_event_looprun_until_completerorms rcrzAgent.run_syncispZ $))+   W113 4%%':: HH' /-)     recyrlrOrms rc run_streamzAgent.run_streams X[recyrlrOrms rcrzAgent.run_streams [^recK| r=j1tjx} rj| jj |d{} j |}|r t|nd} j|tjd|| jjxsd5t|| |xstj|j||d{_j j#D] } d| _ t'j(|}|xstj*} xj,dz c_|j/j0tjdj,5j3d{}dddtjd j,5}j5|4d{}j0xj6dz c_|j9d |j:j<|j?dddtjd 5}jA|d{}tC|tDr}|jF}|jHd |_%fd }tMjN| ||jP|  ddddddd{ddddddy|\}}jS||r$jStUjV||j9d|djYd|D}d||_%|j1}j0j[||j]j0 ddddddd{ddd777?#1swY?xYw7 77 #1swYBxYw79#1d{7swYIxYw#1swYMxYw#1swYyxYww)ajRun the agent with a user prompt in async mode, returning a streamed response. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-4o') async def main(): async with agent.run_stream('What is the capital of the UK?') as response: print(await response.get_data()) #> London ``` Args: result_type: Custom result type to use for this run, `result_type` may only be used if the agent has no result validators since result validators would expect an argument that matches the agent's result type. user_prompt: User input to start/continue the conversation. message_history: History of the conversation so far. model: Optional model to use for this run, required if `model` was not set when creating the agent. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request. usage_limits: Optional limits on model request count or token usage. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. infer_name: Whether to try to infer the agent name from the call frame if it's not set. Returns: The result of the run. Nrz!{agent_name} run stream {prompt=}rsrtrrxryzmodel request {run_step=} response_typer}rcnKd}t|tjsJ|jDcgc]}t|tjs|!}} j |d{}|r$j tj|jdycc}w7Bw)zCalled when the stream has completed. The model response will have been added to messages by now by `StreamedRunResult._marked_completed`. Nr~) r^r ModelResponseparts ToolCallPart_process_function_toolsrrr) last_messagepart tool_callsrrrrUrrras rc on_completez%Agent.run_stream..on_complete$s 48$T2&-&s#0B5B.B.B50B31AB5rrc34K|]}|jywrlrrs rcrz#Agent.run_stream..Ls=bSaaakkSarr)/r9rrrf_backrrrrrrr$rrrrrDrrr"r<rrzrrrrequest_streamr|r __class____name____exit___handle_streamed_model_responser^_MarkFinalResultrrrrStreamedRunResultrBrrrrrr)rarnrQrgr7rhr<rirrjframerrrbrrrrmaybe_final_result result_streamrmodel_response_msgrrmodel_response_usagerrrUrrs` @@@@@rcrzAgent.run_streamsV $))+,,..u.  .??511 ~~d#4CC033K@ ]] /!(yy+G  $T:u7N P[\K!33KR]^^H#+K ,,335%&"62$2E2E~VN'?6+=+=+?L$$)$11+2C2CD]]#JU`UiUi]j(,(;(;K(W"WKk]]#>I]I]]^bp*99(NSSWe#))22a72&44_nF^F^FgFgh'//dDA%]]+BC{7;7[7[ . ]82. **<>NO0B0G0G 3E3O3O 06] 3!U!U$'-&>&>$,$5$0$1$1$/$($;$;$4$/ '" !"!'QD TS_1  VFX B 2N (0B C#1$,OOI4J4J>4Z$[ + 9 9:JN [58XX=bSa=b5b 28QRdQe6f 37E7K7K7M 4 + 1 1 6 67K L , 9 9+:K:K LqD TS_/2_#Xkj T2 TDC TSSS_^1  s%AQPA+Q;QPB1Q5P  P  P )Q9QP QA.P1P# P A(P# P1 QP QQ" Q+B6P# "P1* Q5P/6Q: QQQ P  P QQP# Q#P, (P1/Q1Q 7P:8Q ?QQ QQQ)rhr7c#ZKtj|r'|j}tj||_ntj}tj|r:|j }tjt j||_ntj} dtj|r||_tj|r||_yy#tj|r||_tj|r||_wwxYww)aContext manager to temporarily override agent dependencies and model. This is particularly useful when testing. You can find an example of this [here](../testing-evals.md#overriding-model-via-pytest-fixtures). Args: deps: The dependencies to use instead of the dependencies passed to the agent run. model: The model to use instead of the model passed to the agent run. N)ris_setrMSomeUNSETrNrr[)rarhr7override_deps_beforeoverride_model_befores rcoverridezAgent.overrideSs == #'#6#6 "(++d"3D #)<<  == $($8$8 !#);;v/A/A%/H#ID $*LL ! = }}12&:#}}23'<$4}}12&:#}}23'<$4sB,D+/C-3:D+-;D((D+cyrlrOrafuncs rcrRzAgent.system_promptys25recyrlrOrs rcrRzAgent.system_prompt~s=@recyrlrOrs rcrRzAgent.system_promptsNQrecyrlrOrs rcrRzAgent.system_promptsdgredynamiccyrlrO)rars rcrRzAgent.system_prompts nqrec| dfd }|SrJdjjtj||S)aDecorator to register a system prompt function. Optionally takes [`RunContext`][pydantic_ai.tools.RunContext] as its only argument. Can decorate a sync or async functions. The decorator can be used either bare (`agent.system_prompt`) or as a function call (`agent.system_prompt(...)`), see the examples below. Overloads for every possible signature of `system_prompt` are included so the decorator doesn't obscure the type of the function, see `tests/typed_agent.py` for tests. Args: func: The function to decorate dynamic: If True, the system prompt will be reevaluated even when `messages_history` is provided, see [`SystemPromptPart.dynamic_ref`][pydantic_ai.messages.SystemPromptPart.dynamic_ref] Example: ```python from pydantic_ai import Agent, RunContext agent = Agent('test', deps_type=str) @agent.system_prompt def simple_system_prompt() -> str: return 'foobar' @agent.system_prompt(dynamic=True) async def async_system_prompt(ctx: RunContext[str]) -> str: return f'{ctx.deps} is the best' ``` ctj|}jj|r|j|j <|S)Nr)rSystemPromptRunnerrGrrH __qualname__)func_runnerrras rc decoratorz&Agent.system_prompt..decoratorsI(::5'R--44V<PVD99%:L:LM rez"dynamic can't be True in this caser)r*_system_prompt.SystemPromptFunc[AgentDeps]returnr)rGrrr)rarrrs` ` rcrRzAgent.system_prompts^R < A ;   D D D;  ) ) 0 01R1RSWah1i jKrecyrlrOrs rcresult_validatorzAgent.result_validators EHrecyrlrOrs rcrzAgent.result_validators PSrecyrlrOrs rcrzAgent.result_validatorssvrecyrlrOrs rcrzAgent.result_validators9 str: if 'wrong' in data: raise ModelRetry('wrong response') return data @agent.result_validator async def result_validator_deps(ctx: RunContext[str], data: str) -> str: if ctx.deps in data: raise ModelRetry('wrong response') return data result = agent.run_sync('foobar', deps='spam') print(result.data) #> success (no tool calls) ``` )rBrrResultValidatorr#r rs rcrzAgent.result_validators2D &&w'>'>y#~'Nt'TU recyrlrOrs rcrbz Agent.toolsorre)rTpreparecyrlrOrarTrs rcrbz Agent.tools firecT| dfd }|Sj|d|S)aDecorator to register a tool function which takes [`RunContext`][pydantic_ai.tools.RunContext] as its first argument. Can decorate a sync or async functions. The docstring is inspected to extract both the tool description and description of each parameter, [learn more](../tools.md#function-tools-and-schema). We can't add overloads for every possible signature of tool, since the return type is a recursive union so the signature of functions decorated with `@agent.tool` is obscured. Example: ```python from pydantic_ai import Agent, RunContext agent = Agent('test', deps_type=int) @agent.tool def foobar(ctx: RunContext[int], x: int) -> int: return ctx.deps + x @agent.tool(retries=2) async def spam(ctx: RunContext[str], y: float) -> float: return ctx.deps + y result = agent.run_sync('foobar', deps=1) print(result.data) #> {"foobar":1,"spam":1.0} ``` Args: func: The tool function to register. retries: The number of retries to allow for this tool, defaults to the agent's default retries, which defaults to 1. prepare: custom method to prepare the tool definition for each step, return `None` to omit this tool from a given step. This is useful if you want to customise a tool at call time, or omit it completely from a step. See [`ToolPrepareFunc`][pydantic_ai.tools.ToolPrepareFunc]. c0j|d|SNT_register_functionrrrTras rctool_decoratorz"Agent.tool..tool_decorator:s''tWgF reT)r&ToolFuncContext[AgentDeps, ToolParams]rrrrarrTrrs` `` rcrbz Agent.tool sCZ < = 7 " !  # #D$ AKrecyrlrOrs rc tool_plainzAgent.tool_plainGs[^recyrlrOrs rcrzAgent.tool_plainJs LOrecL| dfd }|Sj|d|S)aDecorator to register a tool function which DOES NOT take `RunContext` as an argument. Can decorate a sync or async functions. The docstring is inspected to extract both the tool description and description of each parameter, [learn more](../tools.md#function-tools-and-schema). We can't add overloads for every possible signature of tool, since the return type is a recursive union so the signature of functions decorated with `@agent.tool` is obscured. Example: ```python from pydantic_ai import Agent, RunContext agent = Agent('test') @agent.tool def foobar(ctx: RunContext[int]) -> int: return 123 @agent.tool(retries=2) async def spam(ctx: RunContext[str]) -> float: return 3.14 result = agent.run_sync('foobar', deps=1) print(result.data) #> {"foobar":123,"spam":3.14} ``` Args: func: The tool function to register. retries: The number of retries to allow for this tool, defaults to the agent's default retries, which defaults to 1. prepare: custom method to prepare the tool definition for each step, return `None` to omit this tool from a given step. This is useful if you want to customise a tool at call time, or omit it completely from a step. See [`ToolPrepareFunc`][pydantic_ai.tools.ToolPrepareFunc]. c0j|d|S)NFrrs rcrz(Agent.tool_plain..tool_decorators''ugwG reF)rToolFuncPlain[ToolParams]rr rrs` `` rcrzAgent.tool_plainSs1Z <  " !  # #D%' BKrecd||n |j}t||||}|j|y)z1Private utility to register a function as a tool.N) takes_ctx max_retriesr)rFr%r`)rarr rTrretries_rbs rcrzAgent._register_functions4&17t7L7LDI8WU D!rec|j!tj||j}|j|j vr"t jd|j|jrD|j|jjvr"t jd|j||j |j<y)z,Private utility to register a tool instance.N)rz(Tool name conflicts with existing tool: z-Tool name conflicts with result schema name: ) r dataclassesreplacerFr9rDr UserErrorrArX)rarbs rcr`zAgent._register_tools    #&&t9N9NOD 99,, ,&&)QRVR[R[Q^'_` `   4990C0C0I0I#I&&)VW[W`W`Vc'de e*.TYY'recLK|jx}r1|!|jtjd|j}|S|t j |}|S|j(t j |jx}|_|Stjdw)zCreate a model configured for this agent. Args: model: model to use for this run, required if `model` was not set when creating the agent. Returns: The model used z`model` must be set either when creating the agent or when calling it. (Even when `override(model=...)` is customizing the model that will actually be called)zF`model` must be set either when creating the agent or when calling it.)rNr7rrvaluerr[)rar7 some_modelmodel_s rcrzAgent._get_models-- -: -}!3 **n %%F  ''.F ZZ #"("4"4TZZ"@ @FTZ &&'op psB"B$c.Kgdfd }tjt||jj d{j j |j|||jngd{S7K7w)z&Build tools and create an agent model.cKj|j|j}|j|d{x}rj |yy7w)N)retryr) replace_withrr9prepare_tool_defr)rbctxtool_deffunction_toolsrs rcadd_toolz&Agent._prepare_model..add_toolsU**1C1Ctyy*YC!%!6!6s!;;;x;%%h/<;s ? OOI2259 :) 857H 8 J7sHDDA D#D$AD6D7AD DDDDDcKg}g}|jD]V}t|tjr)|js*|j |jF|j |X|r|j |||d{S|r,dj|}|j|||d{Stjd7G7w)zProcess a non-streamed response from the model. Returns: A tuple of `(final_result, request parts)`. If `final_result` is not `None`, the conversation should end. Nz zReceived empty model response) rr^rTextPartcontentr_handle_structured_responser_handle_text_responserUnexpectedModelBehavior)rarrrtextsrrtexts rcrzAgent._handle_model_response s35 "((D$ 2 23<<LL.!!$' ) 99*kS`aa a ;;u%D33D+}UU U445TU U bVs):CACC -C2C3CCc|K|j|r:tt|} |j||dd{}t |dgfS|j|tjd}d|gfS7>#t j $r*}|j|d|jgfcYd}~Sd}~wwxYww)zHHandle a plain text response from the model for non-streaming responses.NQPlain text responses are not permitted, please call one of the functions instead.r>) r'rr3_validate_resultrrToolRetryError_incr_result_retry tool_retryrRetryPromptPart)rarCrrresult_data_inputrer{s rcr@zAgent._handle_text_response.s  " "= 1 $]D 9  ?$($9$9:K[Z^$__ ( T:B>>  # #K 0 00kH(# #`)) ,'' 4all^++ ,sD"B<A<A:A<:B<:A<<B9B4.B9/B<4B99B<cK|sJdd}g}|x}r[|j|x}rH|\}} |j|} |j| ||d{} t| |j}||j||xr |j||d{z }||fS7K#t j $r6} |j||j| jYd} ~ wd} ~ wwxYw7Xw)z^Handle a structured response containing tool calls from the model for non-streaming responses.zExpected at least one tool callN) find_toolvalidaterGrrrrHrIrrJr) rarrrrPrmatchcall result_toolrrMs rcr?z!Agent._handle_structured_responseBs<<d}|jt j | jd| j S|jj| jx} r|r<|jt j | jd| j |jtj| j| || j|Y| j|jvrA||jt j | jd | j T|j|j| j|||ritjd |D cgc]} | j!c} 5tj"|d{} |j%| ddd|S|Scc} w7&#1swY|SxYww) zProcess function (non-result) tool calls in parallel. Also add stub return parts for any other tools that need it. r1FTzFinal result processed.)rr> tool_call_idz9Tool not executed - a final result was already processed.r9Nz>[`KaEa  \*X u :WEaX sCD:H+>BH+H H+H5H6H H+HH(#H+c Kt|tjrP|j|r t |dS|j |t jd}|23d{} t|tjr||j}|js6 |jd{|j}|js6|j!|jx}r|\} }t || j"S|23d{} tA|y76dj|jd}t jt j|g|gfS7#t$rYwxYw7r6|j} | jst%j&dg} g} | jD]} t| t j(s| } |j*j| j"x}rA| j-t/j0|j3| || j"| j-|j5| j"||t6j9d | Dcgc]}|j;ncc}wc} 5t/j<| d{7}| j?|ddd| | fS#1swY| | fSxYww) zProcess a streamed response from the model. Returns: Either a final result or a tuple of the model response and the tool responses for the next request. If a final result is returned, the conversation should end. NrErFT)rz Received empty tool call messagerVrWrX)!r^rStreamTextResponser'rrIrrKrr.rr=StreamStructuredResponser __anext__StopAsyncIterationrOrrrArrDrrr[ror\rrr]r%r8r)rarrrr{_rCstructured_msgrQrRrr^ritemrbrarbs rcrz%Agent._handle_streamed_model_responses nf&?&? @&&}5'=='' 4$44o .!(G(G H("0!3!3!5(..,66888&4%7%7%9N )..*33N4H4HII5I#GD!+NDNNKK* a*  (Y~ww~111=> .. 0B0B40H/IJXJVV9- >!/!3!3!5 %++ 889[\\EGE68E*00dI$:$:;D#3377GGtG W%8%8$ 9T[_[i[i%jk T%7%7 Ub%cd 11PU9VPU1!**,PU9VWKR>>[`KaEaEa  \*X&u, ,X&u, ,sA!L#D-'D+(D-+:L&E=9E;:E=>L:LFF FL+D--AL;E== F LF  L FAL.B,LJ2 1L?K8KK8, L8L= LcK|jrLtt|}|jD]}|j|||d{}tt|S|S7wrl)rBrr rPr3)rarr tool_callagent_result_data validators rcrGzAgent._validate_resultsc  " " $Z = !44 *3*<*<=NPY[f*g$g!5 '89 9 %hsAAAAc|xjdz c_|j|jkDr#tjd|jdy)NrzExceeded maximum retries (z) for result validation)rrKrrA)rars rcrIzAgent._incr_result_retrysSQ   t77 744,T-E-E,FF]^  8recK|jDcgc]}tj|}}|jD]}|j |d{}|j r;|j tj||jjc|j tj||Scc}w7xw)z0Build the initial messages for the conversation.Nr*) rCrr-rGrorrfunctionr)rarprsys_prompt_runnerrus rcr:zAgent._sys_partss]a]q]q5r]qXYi6P6PQR6S]q5r!%!>!> ,00==F (( : :6O`OiOiOvOv wx : :6 BC "? 6s=sC C%C C A9C c|j|t|jj}|r|j |j |rddj |}nd}tjd|d|S)NzAvailable tools: z, zNo tools available.zUnknown tool name: z. rF) rIlistrDkeysr8 tool_namesrrrK)rarrrnamesr/s rcr\zAgent._unknown_tools  ,T))..01  LL113 4 %dii&6%78C'C((3FymSUVYUZ1[\\rec:|jx}r |jS|S)zGet deps for a run. If we've overridden deps via `_override_deps`, use that, otherwise use the deps passed to the call. We could do runtime type checking of deps against `self._deps_type`, but that's a slippery slope. )rMr)rarh some_depss rcrzAgent._get_depss$++ +9 +?? "Krec>|jJd||jx}ry|jjD]\}}||us ||_y|j|jk7r0|jjD]\}}||us ||_yyyyy)zwInfer the agent name from the call frame. Usage should be `self._infer_name(inspect.currentframe())`. NzName already set)r9rf_localsitems f_globals)rafunction_frame parent_framer9rks rcrzAgent._infer_name!s yy 4"44  %-444|4"."7"7"="="?JD$t|$( #@ ((L,B,BB&2&<&<&B&B&D d4<(,DI"'EC 5 &rec&|duxs |jSrl)r!)rs rcr'zAgent._allow_text_result4s$G (G(GGreWThe `last_run_messages` attribute has been removed, use `capture_run_messages` instead.)categoryctd)Nr)AttributeError)ras rclast_run_messageszAgent.last_run_messages8s vwwrerl)r7r6rQztype[ResultData]rRzstr | Sequence[str]rSrIr9r8r<r;rTrErUr>rVr8rW int | NonerXz:Sequence[Tool[AgentDeps] | ToolFuncEither[AgentDeps, ...]]rYrYr:r.)rnr>rQr$rg#list[_messages.ModelMessage] | Noner7r6rhr#r<r;ri_usage.UsageLimits | Noner_usage.Usage | NonerjrYrresult.RunResult[ResultData])rnr>rQtype[RunResultData]rgrr7r6rhr#r<r;rirrrrjrYrresult.RunResult[RunResultData])rnr>rgrr7r6rhr#r<r;rirrrrQtype[RunResultData] | NonerjrYrresult.RunResult[Any])rnr>rgrr7r6rhr#r<r;rirrrrjrYrr)rnr>rQrrgrr7r6rhr#r<r;rirrrrjrYrr)rnr>rQrrgrr7r6rhr#r<r;rirrrrjrYrr)rnr>rQr$rgrr7r6rhr#r<r;rirrrrjrYrzLAbstractAsyncContextManager[result.StreamedRunResult[AgentDeps, ResultData]])rnr>rQrrgrr7r6rhr#r<r;rirrrrjrYrzOAbstractAsyncContextManager[result.StreamedRunResult[AgentDeps, RunResultData]])rnr>rQrrgrr7r6rhr#r<r;rirrrrjrYrz7AsyncIterator[result.StreamedRunResult[AgentDeps, Any]])rhzAgentDeps | _utils.Unsetr7z3models.Model | models.KnownModelName | _utils.UnsetrzIterator[None])r&Callable[[RunContext[AgentDeps]], str]rr)r1Callable[[RunContext[AgentDeps]], Awaitable[str]]rr)rCallable[[], str]rr)rCallable[[], Awaitable[str]]rr)rrYrzbCallable[[_system_prompt.SystemPromptFunc[AgentDeps]], _system_prompt.SystemPromptFunc[AgentDeps]])rz1_system_prompt.SystemPromptFunc[AgentDeps] | NonerrYrzCallable[[_system_prompt.SystemPromptFunc[AgentDeps]], _system_prompt.SystemPromptFunc[AgentDeps]] | _system_prompt.SystemPromptFunc[AgentDeps])r9Callable[[RunContext[AgentDeps], ResultData], ResultData]rr)rDCallable[[RunContext[AgentDeps], ResultData], Awaitable[ResultData]]rr)r"Callable[[ResultData], ResultData]rr)r-Callable[[ResultData], Awaitable[ResultData]]rr)r2_result.ResultValidatorFunc[AgentDeps, ResultData]rr)rrrr)rTrr!ToolPrepareFunc[AgentDeps] | NonerzZCallable[[ToolFuncContext[AgentDeps, ToolParams]], ToolFuncContext[AgentDeps, ToolParams]])rz-ToolFuncContext[AgentDeps, ToolParams] | NonerTrrrrr )rr rr )rTrrrrz@Callable[[ToolFuncPlain[ToolParams]], ToolFuncPlain[ToolParams]])rz ToolFuncPlain[ToolParams] | NonerTrrrrr ) rz%ToolFuncEither[AgentDeps, ToolParams]r rYrTrrrrr$r#)r7r6rz models.Model)rRunContext[AgentDeps]r*_result.ResultSchema[RunResultData] | Nonerzmodels.AgentModel)rlist[_messages.ModelMessage]rrrr$)rQrrr)rnr>rgrrrrr)rz_messages.ModelResponserrrrrOtuple[_MarkFinalResult[RunResultData] | None, list[_messages.ModelRequestPart]])rCr>rrrrrr)rlist[_messages.ToolCallPart]rrrrrr) rrrUr8rrrrr list[_messages.ModelRequestPart])rzmodels.EitherStreamedResponserrrrrzr_MarkFinalResult[models.EitherStreamedResponse] | tuple[_messages.ModelResponse, list[_messages.ModelRequestPart]])rr3rrrmz_messages.ToolCallPart | Nonerr3)rrrr$)rrrr)rr>rrrrrz_messages.RetryPromptPart)rhr#rr#)rzFrameType | Nonerr$)rrrrY)rr);r __module__r__doc____annotations__rfieldr?r@rArBrCrDrFrGrHrJrKrMrNr>NoneTyperdrrorrr r rrrrRrrbrrr`rrr2rrrr@r?rrrGrIr:r\rr staticmethodr'propertyrrrOrercr,r,@s ( 766 H(( /[..E:s:+<;+<+<%+HjH>Ok>O>OUZ>[N;[O`{O`O`fkOlLl'8{'8'8e'DO_D2C+2C2C2OO/O-K--59c9SdS^SdSdjoSpPp`q`k`q`q a$&]#4+"3"3"?J?0{00e<BH%),-/%-/3 ..2%)LN"'$+H%:H%& H% + H% # H%H%-H%H%H%",H%#H%JH% H%"H%T !?C=A/326%) + + + = + ; + +- +0 +# + + & + + @D=A/326%) . .) . = . ; . .- .0 .# . . ) . .$@D=A/326%)26j_j_= j_ ; j_  j_-j_0j_#j_0j_j_ j_X @D=A/326%) + += + ; +  +- +0 +# + + & + + @D=A/326%) . .0 . = . ; . .- .0 .# . . ) . .$37?C=A/326%); ; 0 ; = ; ; ; ; -; 0; #; ;  ; z !?C=A/326%) [ [ [ = [ ; [ [- [0 [# [ [ V [ [ @D=A/326%) ^ ^) ^ = ^ ; ^ ^- ^0 ^# ^ ^ Y ^ ^ 37?C=A/326%)LMLM0 LM = LM ; LMLM-LM0LM#LMLM ALMLM\*0EK\\ #='#=C #=  #=#=J5:5 /55@E@ :@@QQ gg $)q!q kqq CG8  8?8  8 58tHMH BHHSXS MSSvv <A< 6<<#F# ;#Jrr #59 i i 3 i d ii?C: #59 :;:  : 3 : :x^^ #59 O O 3 O J OO267 #59 7.7  7 3 7 7r "3 " " " 3 "  " /8 0 Ak  &"4"CX" "" '5 ' 3 '1Tcx %6V/V+VB V Y VB$$&;$Lv$ X$(#0#+#B # Y #@:0:%:+ : B : * :xE)5E)+E)B E)  K E)N " + 1    ]]+]B ] # ] #&HHalpxxrer,c&eZdZUded<dZded<y) _RunMessagesrrFrYr6N)rrrrr6rOrercrr@s**D$rervarzContextVar[_RunMessages]r5c#K tjjy#t$rWg}tj t |} |tj |Yy#tj |wxYwwxYww)a*Context manager to access the messages used in a [`run`][pydantic_ai.Agent.run], [`run_sync`][pydantic_ai.Agent.run_sync], or [`run_stream`][pydantic_ai.Agent.run_stream] call. Useful when a run may raise an exception, see [model errors](../agents.md#model-errors) for more information. Examples: ```python from pydantic_ai import Agent, capture_run_messages agent = Agent('test') with capture_run_messages() as messages: try: result = agent.run_sync('foobar') except Exception: print(messages) raise ``` !!! note If you call `run`, `run_sync`, or `run_stream` more than once within a single `capture_run_messages` context, `messages` will represent the messages exchanged during the first call only. N)r5r.rr7setrreset)rtokens rcr-r-Isp0+##%... +13!%%l8&<= +N  # #E *  # #E * +s7B %B)BA*B(B*BBBc(eZdZUdZded< ded<y)raMarker class to indicate that the result is the final result. This allows us to use `isinstance`, which wouldn't be possible if we were returning `ResultData` directly. It also avoids problems in the case where the result type is itself `None`, but is set. r rr8rN)rrrrrrOrercrrls  Hrer)rz&Iterator[list[_messages.ModelMessage]])S __future__r _annotationsrrrcollections.abcrrrr contextlibrr r contextvarsr typesr typingr rrrrrr logfire_apityping_extensionsrrrrdrrrrrrrrrrr settingsr!r"rXr#r$r%r&r'r(r)r*r+__all__Logfirerlogfire._internal.stack_infologfirepathlibr0 _internal stack_infoNON_USER_CODE_PREFIXESr>__file__parentabsolute ImportErrortyperr.r3 dataclassr,rr5rr-rrOrercrs2HHWW"III??   9    9 ;  - 8d'   77CX@U@U@^@^@`