o i @srUddlmZddlZddlZddlmZmZddlm Z m Z m Z m Z m Z mZmZddlmZmZmZddlmZddlmZmZmZmZmZmZddlZddlmZm Z m!Z!dd l"m#Z#d d l$m%Z%m&Z&m'Z'm(Z(m)Z*m+Z+m,Z,m-Z.d d l/m0Z0d d l1m2Z2d dl3m4Z4m5Z5d dl,m6Z6m7Z7m8Z8d dl9m:Z:m;Z;mZ>d dl?m@Z@mAZAmBZBmCZCmDZDd dlEmFZFd dl-mGZGmHZHerddlImJZJddlKmLZLddlMmNZNmOZOddlPmQZQddlRmSZSddlTmUZUmVZVddlWmXZXmYZYddlZm[Z[e!dZ\e!dZ]e^dZ_e!dZ` e eBe@e e*jage dfZbd ecd!< ede&jee@Beede&jee@BBdBZfGd"d#d#ee@e4feZgdS)$) annotationsN)ABCabstractmethod) AsyncIterable AsyncIterator AwaitableCallableIteratorMappingSequence)AbstractAsyncContextManagerasynccontextmanagercontextmanager) FrameType) TYPE_CHECKINGAnyGeneric TypeAliascastoverload)SelfTypeIsTypeVar)End) _agent_graph_system_prompt_utils exceptionsmessagesmodelsresultusage) ToolManager)AbstractBuiltinTool) OutputDataT OutputSpec) AgentStream FinalResultStreamedRunResult)AgentRunAgentRunResultAgentRunResultEvent) ModelSettings) AgentDepsTDeferredToolResults RunContextToolToolFuncEither)AbstractToolset)RunUsage UsageLimits)FastA2A)Broker) AgentProviderSkill)Storage) Middleware) BaseRouteRoute)ExceptionHandlerLifespanAGUIAppTSRunOutputDataTrEventStreamHandlerc@seZdZdZeedddZeedddZejedd dZeedd dZ eedddZ eedddZ eedddZ e ddddddddddddddd dd5d6Ze dddddddddddddd7 dd:d6Z ddddddddddddddd dd=d6Ze ddddddddddddddd dd>d?Ze dddddddddddddd7 dd@d?Z ddddddddddddddd ddAd?Ze ddddddddddddddd ddCdDZe dddddddddddddd7 ddFdDZe ddddddddddddddd ddHdDZe ddddddddddddddI ddKdLZe dddddddddddddM ddOdLZ ddddddddddddddI ddQdLZe ddddddddddddddR ddTdUZe dddddddddddddV ddXdUZ ddddddddddddddR ddZdUZ ddddddddddddd[ dd\d]Ze ddddddddddddddR dd_d`Ze dddddddddddddV ddbd`Zee ddddddddddddddR dddd`ZeeejejejejejejdeddodpZddsdtZeeddudvZeddzd{Zedd}d~ZedddZedddZ edddZ!edddZ"dddddddddddddddddddddZ#dddddddddddddd dddZ$  ddddZ%  ddddZ&dS) AbstractAgentzAbstract superclass for [`Agent`][pydantic_ai.agent.Agent], [`WrapperAgent`][pydantic_ai.agent.WrapperAgent], and your own custom agent implementations.return1models.Model | models.KnownModelName | str | NonecCt)z,The default model configured for this agent.NotImplementedErrorselfrN`/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/pydantic_ai/agent/abstract.pymodelMzAbstractAgent.model str | NonecCrI)zThe 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. rJrLrNrNrOnameSzAbstractAgent.namevalueNonecCrI)z,Set the name of the agent, used for logging.rJ)rMrUrNrNrOrS\rQtypecCrI)z+The type of dependencies used by the agent.rJrLrNrNrO deps_typebrQzAbstractAgent.deps_typeOutputSpec[OutputDataT]cCrI)zjThe type of data output by agent runs, used to validate the data returned by the model, defaults to `str`.rJrLrNrNrO output_typehrQzAbstractAgent.output_type%EventStreamHandler[AgentDepsT] | NonecCrI)zcOptional handler for events from the model's streaming response and the agent's execution of tools.rJrLrNrNrOevent_stream_handlernrQz"AbstractAgent.event_stream_handler%Sequence[AbstractToolset[AgentDepsT]]cCrI)zVAll toolsets registered on the agent. Output tools are not included. rJrLrNrNrOtoolsetstrTzAbstractAgent.toolsetsNT rZmessage_historydeferred_tool_resultsrP instructionsdepsmodel_settings usage_limitsr" infer_namer^ builtin_toolsr\ user_prompt,str | Sequence[_messages.UserContent] | NonerZr`'Sequence[_messages.ModelMessage] | NoneraDeferredToolResults | NonerPrbInstructions[AgentDepsT]rcr.rdModelSettings | Nonere_usage.UsageLimits | Noner"_usage.RunUsage | Nonerfboolr^,Sequence[AbstractToolset[AgentDepsT]] | Nonerg$Sequence[AbstractBuiltinTool] | Noner\AgentRunResult[OutputDataT]c dSNrNrMrhrZr`rarPrbrcrdrer"rfr^rgr\rNrNrOrun}zAbstractAgent.run) r`rarPrbrcrdrer"rfr^rgr\OutputSpec[RunOutputDataT]AgentRunResult[RunOutputDataT]c rtrurNrvrNrNrOrwrx!OutputSpec[RunOutputDataT] | NoneAgentRunResult[Any]c s| r|jdur|t|p|j}|j||||||||| | | | d 4IdHO}|2z@3dHW}|durl||s@||rl||j 4IdH}|t |j |IdHWdIdHn 1IdHsgwYq,6WdIdHn 1IdHs~wY|j dusJd|j S)aRun the agent with a user prompt in async mode. This method builds an internal agent graph (using system prompts, tools and output schemas) and then runs the graph to completion. The result of the run is returned. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-4o') async def main(): agent_run = await agent.run('What is the capital of France?') print(agent_run.output) #> The capital of France is Paris. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. 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. toolsets: Optional additional toolsets for this run. event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run. builtin_tools: Optional additional builtin tools for this run. Returns: The result of the run. N) rhrZr`rarPrbrcrdrer"r^rgz%The graph run did not finish properly) rS _infer_nameinspect currentframer\iteris_model_request_nodeis_call_tools_nodestreamctxrbuild_run_contextr!)rMrhrZr`rarPrbrcrdrer"rfr^rgr\ agent_runnoderrNrNrOrwsB7  ((c CdSrurNrvrNrNrOrun_synczAbstractAgent.run_syncc CrrurNrvrNrNrOr rc CsL| r|jdur|tt|j||||||||| | d| | |dS)aSynchronously run the agent with a user prompt. This is a convenience method that wraps [`self.run`][pydantic_ai.agent.AbstractAgent.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') result_sync = agent.run_sync('What is the capital of Italy?') print(result_sync.output) #> The capital of Italy is Rome. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. 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. toolsets: Optional additional toolsets for this run. event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run. builtin_tools: Optional additional builtin tools for this run. Returns: The result of the run. NFr_)rSr}r~rrget_event_looprun_until_completerwrvrNrNrOr!s(6NAbstractAsyncContextManager[result.StreamedRunResult[AgentDepsT, OutputDataT]]c CrrurNrvrNrNrO run_streammrzAbstractAgent.run_streamQAbstractAsyncContextManager[result.StreamedRunResult[AgentDepsT, RunOutputDataT]]c CrrurNrvrNrNrOrr8AsyncIterator[result.StreamedRunResult[AgentDepsT, Any]]c s| r|jdurt}r||j|p|j}d}|j||||||||| | d| | d 4IdHj}t|t j s>J|} j | |r| 4IdHmddfd d }|durn|t |IdHn |2z3dHW}qr6durtdjj|rtd d}jjdfd d }tjj|V WdIdHnWdIdHn 1IdHswYn7||r|dur| j 4IdH|t j IdHWdIdHn 1IdHswY|IdH}t|tr&jdur&tjjjjjdVd}nt|t js2tdtt jt t f|}qAWdIdHn 1IdHsNwY|s[tddS)a Run the agent with a user prompt in async streaming mode. This method builds an internal agent graph (using system prompts, tools and output schemas) and then runs the graph until the model produces output matching the `output_type`, for example text or structured data. At this point, a streaming run result object is yielded from which you can stream the output as it comes in, and -- once this output has completed streaming -- get the complete output, message history, and usage. As this method will consider the first output matching the `output_type` to be the final output, it will stop running the agent graph and will not execute any tool calls made by the model after this "final" output. If you want to always run the agent graph to completion and stream events and output at the same time, use [`agent.run()`][pydantic_ai.agent.AbstractAgent.run] with an `event_stream_handler` or [`agent.iter()`][pydantic_ai.agent.AbstractAgent.iter] instead. 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_output()) #> The capital of the UK is London. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. 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. toolsets: Optional additional toolsets for this run. builtin_tools: Optional additional builtin tools for this run. event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run. It will receive all the events up until the final result is found, which you can then read or stream from inside the context manager. Note that it does _not_ receive any events after the final result is found. Returns: The result of the run. NF) rZr`rarPrcrbrdrer"rfr^rgTrr'rG1AsyncIterator[_messages.ModelResponseStreamEvent]cs6|2z3dHW}|Vt|tjr|dSq6dSru) isinstance _messagesFinalResultEvent)revent)final_result_eventrNrOstream_to_finals z1AbstractAgent.run_stream..stream_to_finalz Agent run produced final resultsrVcstIdHjjg}tjjjjj d|d2z3dHW}q6|r5 t j |j jdtIdHdS)zCalled when the stream has completed. The model response will have been added to messages by now by `StreamedRunResult._marked_completed`. N) tool_manager tool_callstool_call_results final_resultr output_parts)run_id)r( get_output tool_name tool_call_idrprocess_tool_callsrcrresponserappendr ModelRequeststaternextSetFinalResult)parts_event)rr graph_ctxrrrNrO on_completes$  z-AbstractAgent.run_stream..on_complete) run_resultz The capital of the UK is London. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. 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. toolsets: Optional additional toolsets for this run. builtin_tools: Optional additional builtin tools for this run. event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run. It will receive all the events up until the final result is found, which you can then read or stream from inside the context manager. Note that it does _not_ receive any events after the final result is found. Returns: The result of the run. Ncsf j   d 4IdH}|VWdIdHdS1IdHs,wYdS)Nr)r) stream_resultrgrarcr\rfr`rPrdrZrMr^r"rerhrNrO_consume_streams&.z6AbstractAgent.run_stream_sync.._consume_stream) rSr}r~rrrranextr!StreamedRunResultSync)rMrhrZr`rarPrcrdrer"rfr^rgr\r async_resultrNrrOr|s A& ) rZr`rarPrbrcrdrer"rfr^rgLAsyncIterator[_messages.AgentStreamEvent | AgentRunResultEvent[OutputDataT]]c CrrurNrMrhrZr`rarPrbrcrdrer"rfr^rgrNrNrOrun_stream_eventsrzAbstractAgent.run_stream_events) r`rarPrbrcrdrer"rfr^rgOAsyncIterator[_messages.AgentStreamEvent | AgentRunResultEvent[RunOutputDataT]]c CrrurNrrNrNrOrrDAsyncIterator[_messages.AgentStreamEvent | AgentRunResultEvent[Any]]c Cs>| r|jdur|t|j||||||||| | | | d S)a Run the agent with a user prompt in async mode and stream events from the run. This is a convenience method that wraps [`self.run`][pydantic_ai.agent.AbstractAgent.run] and uses the `event_stream_handler` kwarg to get a stream of events from the run. Example: ```python from pydantic_ai import Agent, AgentRunResultEvent, AgentStreamEvent agent = Agent('openai:gpt-4o') async def main(): events: list[AgentStreamEvent | AgentRunResultEvent] = [] async for event in agent.run_stream_events('What is the capital of France?'): events.append(event) print(events) ''' [ PartStartEvent(index=0, part=TextPart(content='The capital of ')), FinalResultEvent(tool_name=None, tool_call_id=None), PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='France is Paris. ')), PartEndEvent( index=0, part=TextPart(content='The capital of France is Paris. ') ), AgentRunResultEvent( result=AgentRunResult(output='The capital of France is Paris. ') ), ] ''' ``` Arguments are the same as for [`self.run`][pydantic_ai.agent.AbstractAgent.run], except that `event_stream_handler` is now allowed. Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. 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. toolsets: Optional additional toolsets for this run. builtin_tools: Optional additional builtin tools for this run. Returns: An async iterable of stream events `AgentStreamEvent` and finally a `AgentRunResultEvent` with the final run result. N rZr`rarPrbrcrdrer"r^rg)rSr}r~r_run_stream_eventsrrNrNrOrs Grc stjtjttB\ } d fdd d  fd d }t|}| 4IdH| 2z 3dHW}|Vq96WdIdHn 1IdHsTwY|IdH}t|VdS)NrRunContext[AgentDepsT]events)AsyncIterable[_messages.AgentStreamEvent]rGrVcs*|2z3dHW}|IdHq6dSru)send)rrr) send_streamrNrOr\ksz>AbstractAgent._run_stream_events..event_stream_handlerr|csj 4IdH! j d dIdHWdIdHS1IdHs.wYdS)NFr_)rwrNrgrarcr\rbr`rPrdrZrMrr^r"rerhrNrO run_agentqs& 0z3AbstractAgent._run_stream_events..run_agent)rrrrrGrV)rGr|)anyiocreate_memory_object_streamrAgentStreamEventr,rasyncio create_task)rMrhrZr`rarPrbrcrdrer"r^rgreceive_streamrtaskmessager!rNrrOrWs  * ( z AbstractAgent._run_stream_events>AbstractAsyncContextManager[AgentRun[AgentDepsT, OutputDataT]]c CrrurNrrNrNrOrrzAbstractAgent.iterAAbstractAsyncContextManager[AgentRun[AgentDepsT, RunOutputDataT]]c CrrurNrrNrNrOrr(AsyncIterator[AgentRun[AgentDepsT, Any]]c Cst)aA contextmanager which can be used to iterate over the agent graph's nodes as they are executed. This method builds an internal agent graph (using system prompts, tools and output schemas) and then returns an `AgentRun` object. The `AgentRun` can be used to async-iterate over the nodes of the graph as they are executed. This is the API to use if you want to consume the outputs coming from each LLM model response, or the stream of events coming from the execution of tools. The `AgentRun` also provides methods to access the full message history, new messages, and usage statistics, and the final result of the run once it has completed. For more details, see the documentation of `AgentRun`. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-4o') async def main(): nodes = [] async with agent.iter('What is the capital of France?') as agent_run: async for node in agent_run: nodes.append(node) print(nodes) ''' [ UserPromptNode( user_prompt='What is the capital of France?', instructions_functions=[], system_prompts=(), system_prompt_functions=[], system_prompt_dynamic_functions={}, ), ModelRequestNode( request=ModelRequest( parts=[ UserPromptPart( content='What is the capital of France?', timestamp=datetime.datetime(...), ) ], run_id='...', ) ), CallToolsNode( model_response=ModelResponse( parts=[TextPart(content='The capital of France is Paris.')], usage=RequestUsage(input_tokens=56, output_tokens=7), model_name='gpt-4o', timestamp=datetime.datetime(...), run_id='...', ) ), End(data=FinalResult(output='The capital of France is Paris.')), ] ''' print(agent_run.result.output) #> The capital of France is Paris. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. 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. toolsets: Optional additional toolsets for this run. builtin_tools: Optional additional builtin tools for this run. Returns: The result of the run. rJrrNrNrOrsb)rSrcrPr^toolsrbrSstr | _utils.UnsetAgentDepsT | _utils.Unset9models.Model | models.KnownModelName | str | _utils.Unset4Sequence[AbstractToolset[AgentDepsT]] | _utils.UnsetrKSequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] | _utils.Unset'Instructions[AgentDepsT] | _utils.UnsetIterator[None]ccst)a]Context manager to temporarily override agent name, dependencies, model, toolsets, tools, or instructions. This is particularly useful when testing. You can find an example of this [here](../testing.md#overriding-model-via-pytest-fixtures). Args: name: The name to use instead of the name passed to the agent constructor and agent run. 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. toolsets: The toolsets to use instead of the toolsets passed to the agent constructor and agent run. tools: The tools to use instead of the tools registered with the agent. instructions: The instructions to use instead of the instructions registered with the agent. rJ)rMrSrcrPr^rrbrNrNrOoverrideszAbstractAgent.overridefunction_frameFrameType | NonecCs|jdus Jd|dur@|j}rB|jD]\}}||ur%||_dSq|j|jkrD|jD]\}}||ur?||_dSq1dSdSdSdS)zzInfer the agent name from the call frame. RunUsage should be `self._infer_name(inspect.currentframe())`. NzName already set)rSrf_localsitems f_globals)rMr parent_framerSitemrNrNrOr}4s$  zAbstractAgent._infer_nameccs6t dVWddS1swYdS)z/Run tool calls sequentially during the context.N)r#sequential_tool_callsrNrNrNrOrGs "z#AbstractAgent.sequential_tool_callsr9_agent_graph.AgentNode[T, S] | End[result.FinalResult[S]]+TypeIs[_agent_graph.ModelRequestNode[T, S]]cC t|tjS)zCheck if the node is a `ModelRequestNode`, narrowing the type if it is. This method preserves the generic parameters while narrowing the type, unlike a direct call to `isinstance`. )rrModelRequestNoderrNrNrOrN z#AbstractAgent.is_model_request_node(TypeIs[_agent_graph.CallToolsNode[T, S]]cCr)zCheck if the node is a `CallToolsNode`, narrowing the type if it is. This method preserves the generic parameters while narrowing the type, unlike a direct call to `isinstance`. )rr CallToolsNoderrNrNrOrXrz AbstractAgent.is_call_tools_node)TypeIs[_agent_graph.UserPromptNode[T, S]]cCr)zCheck if the node is a `UserPromptNode`, narrowing the type if it is. This method preserves the generic parameters while narrowing the type, unlike a direct call to `isinstance`. )rrrrrNrNrOis_user_prompt_nodebrz!AbstractAgent.is_user_prompt_node"TypeIs[End[result.FinalResult[S]]]cCs t|tS)zCheck if the node is a `End`, narrowing the type if it is. This method preserves the generic parameters while narrowing the type, unlike a direct call to `isinstance`. )rrrrNrNrO is_end_nodels zAbstractAgent.is_end_node&AbstractAgent[AgentDepsT, OutputDataT]ctrurJrLrNrNrO __aenter__vzAbstractAgent.__aenter__argsr bool | NonecrrurJ)rMrrNrNrO __aexit__zrzAbstractAgent.__aexit__F)rZr`rarPrcrdrer"rfr^debugroutes middlewareexception_handlers on_startup on_shutdownlifespanOutputSpec[OutputDataT] | NoneUsageLimits | NoneRunUsage | NonerrSequence[BaseRoute] | NonerSequence[Middleware] | Noner%Mapping[Any, ExceptionHandler] | Noner"Sequence[Callable[[], Any]] | Nonerr1Lifespan[AGUIApp[AgentDepsT, OutputDataT]] | None AGUIApp[AgentDepsT, OutputDataT]cCsddlm}|did|d|d|d|d|d|d |d |d |d | d | d| d| d| d|d|d|d|S)aReturns an ASGI application that handles every AG-UI request by running the agent. Note that the `deps` will be the same for each request, with the exception of the AG-UI state that's injected into the `state` field of a `deps` object that implements the [`StateHandler`][pydantic_ai.ag_ui.StateHandler] protocol. To provide different `deps` for each request (e.g. based on the authenticated user), use [`pydantic_ai.ag_ui.run_ag_ui`][pydantic_ai.ag_ui.run_ag_ui] or [`pydantic_ai.ag_ui.handle_ag_ui_request`][pydantic_ai.ag_ui.handle_ag_ui_request] instead. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-4o') app = agent.to_ag_ui() ``` The `app` is an ASGI application that can be used with any ASGI server. To run the application, you can use the following command: ```bash uvicorn app:app --host 0.0.0.0 --port 8000 ``` See [AG-UI docs](../ui/ag-ui.md) for more information. Args: output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. 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. toolsets: Optional additional toolsets for this run. debug: Boolean indicating if debug tracebacks should be returned on errors. routes: A list of routes to serve incoming HTTP and WebSocket requests. middleware: A list of middleware to run for every request. A starlette application will always automatically include two middleware classes. `ServerErrorMiddleware` is added as the very outermost middleware, to handle any uncaught errors occurring anywhere in the entire stack. `ExceptionMiddleware` is added as the very innermost middleware, to deal with handled exception cases occurring in the routing or endpoints. exception_handlers: A mapping of either integer status codes, or exception class types onto callables which handle the exceptions. Exception handler callables should be of the form `handler(request, exc) -> response` and may be either standard functions, or async functions. on_startup: A list of callables to run on application startup. Startup handler callables do not take any arguments, and may be either standard functions, or async functions. on_shutdown: A list of callables to run on application shutdown. Shutdown handler callables do not take any arguments, and may be either standard functions, or async functions. lifespan: A lifespan context function, which can be used to perform startup and shutdown tasks. This is a newer style that replaces the `on_startup` and `on_shutdown` handlers. Use one or the other, not both. Returns: An ASGI application for running Pydantic AI agents with AG-UI protocol support. rr@agentrZr`rarPrcrdrer"rfr^rrrrrrrNrN)pydantic_ai.ui.ag_ui.apprA)rMrZr`rarPrcrdrer"rfr^rrrrrrrrArNrNrOto_ag_uisL T    zAbstractAgent.to_ag_uizhttp://localhost:8000z1.0.0 storagebrokerrSurlversion descriptionproviderskillsrrrrrrStorage | Noner Broker | NonerstrrrrAgentProvider | Nonerlist[Skill] | NoneSequence[Route] | None"dict[Any, ExceptionHandler] | NoneLifespan[FastA2A] | Noner6c Cs0ddlm}||||||||||| | | | | dS)aConvert the agent to a FastA2A application. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-4o') app = agent.to_a2a() ``` The `app` is an ASGI application that can be used with any ASGI server. To run the application, you can use the following command: ```bash uvicorn app:app --host 0.0.0.0 --port 8000 ``` r) agent_to_a2ar)_a2ar%)rMrrrSrrrrrrrrrrr%rNrNrOto_a2as" %zAbstractAgent.to_a2a pydantic-airMr prog_namec s<ddlm}ddlm}|d|||d||dIdHdS)a%Run the agent in a CLI chat interface. Args: deps: The dependencies to pass to the agent. prog_name: The name of the program to use for the CLI. Defaults to 'pydantic-ai'. message_history: History of the conversation so far. Example: ```python {title="agent_to_cli.py" test="skip"} from pydantic_ai import Agent agent = Agent('openai:gpt-4o', instructions='You always respond in Italian.') async def main(): await agent.to_cli() ``` r)Console)run_chatTmonokai)rrrcconsole code_themer)r`N) rich.consoler*pydantic_ai._clir+)rMrcr)r`r*r+rNrNrOto_cli$s  zAbstractAgent.to_clicCst|j|||dS)aGRun the agent in a CLI chat interface with the non-async interface. Args: deps: The dependencies to pass to the agent. prog_name: The name of the program to use for the CLI. Defaults to 'pydantic-ai'. message_history: History of the conversation so far. ```python {title="agent_to_cli_sync.py" test="skip"} from pydantic_ai import Agent agent = Agent('openai:gpt-4o', instructions='You always respond in Italian.') agent.to_cli_sync() agent.to_cli_sync(prog_name='assistant') ``` )rcr)r`)rrrr1)rMrcr)r`rNrNrO to_cli_syncIszAbstractAgent.to_cli_sync)rGrH)rGrR)rUrRrGrV)rGrW)rGrY)rGr[)rGr]ru)rhrirZrVr`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGrs)rhrirZryr`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGrz)rhrirZr{r`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGr|)rhrirZrVr`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGr)rhrirZryr`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGr)rhrirZr{r`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGr)rhrirZrVr`rjrarkrPrHrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGr)rhrirZryr`rjrarkrPrHrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGr)rhrirZr{r`rjrarkrPrHrcr.rdrmrernr"rorfrpr^rqrgrrr\r[rGr)rhrirZrVr`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrrGr)rhrirZryr`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrrGr)rhrirZr{r`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrrGr)rhrirZr{r`rjrarkrPrHrbrlrcr.rdrmrernr"ror^rqrgrrrGr)rhrirZrVr`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrrGr)rhrirZryr`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrrGr)rhrirZr{r`rjrarkrPrHrbrlrcr.rdrmrernr"rorfrpr^rqrgrrrGr)rSrrcrrPrr^rrrrbrrGr)rrrGrV)rGr)rrrGr)rrrGr)rrrGr)rrrGr)rGr)rrrGr)$rZr r`rjrarkrPrHrcr.rdrmrer r"r rfrpr^rqrrprr rr rrrrrrrrrGr)rrrrrSrRrrrrrrRrr rr!rrprr"rr rr#rr$rGr6)Nr(N) rMrrcr.r)rr`rjrGrV)'__name__ __module__ __qualname____doc__propertyrrPrSsetterrXrZr\r^rrwrrr rrrrrrUNSETrr} staticmethodrrrrrrrrr'r1r2rNrNrNrOrFJsTLAY^6c       p: 'rF)h __future__r _annotationsrr~abcrrcollections.abcrrrrr r r contextlibr r rtypesrtypingrrrrrrrtyping_extensionsrrrpydantic_graphrrrrrrrr r!r"_usage _tool_managerr#rgr$outputr%r&r'r(r)rwr*r+r,settingsr-rr.r/r0r1r2r^r3r4r5fasta2a.applicationsr6fasta2a.brokerr7fasta2a.schemar8r9fasta2a.storager:starlette.middlewarer;starlette.routingr<r=starlette.typesr>r?rrArBrCrWNoneTyperDrrE__annotations__rSystemPromptFunc InstructionsrFrNrNrNrOs`$   (