o ia @sUddlmZddlZddlmZmZddlmZmZm Z m Z ddl m Z m Z ddlmZmZmZmZmZmZmZddlmZddlmZd d lmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-d d l.m/Z/d d l0m1Z1m2Z2d d l3m4Z4erddl5m6Z6dZ7 edZ8 edZ9 ee2eBZ:de;d< e e1egdfe e1egedfBe e1egee8fBZIs zUIEventStream.)default_factoryr6 message_id%Literal['request', 'response'] | None_turnz"AgentRunResult[OutputDataT] | None_resultzFinalResultEvent | None_final_result_eventreturncCstt|_|jS)z$Generate and store a new message ID.)r6rr;selfr7r7r8new_message_idQs zUIEventStream.new_message_idMapping[str, str] | NonecCsdS)z+Response headers to return to the frontend.Nr7rAr7r7r8response_headersVzUIEventStream.response_headerscCstS)axGet the content type for the event stream, compatible with the `Accept` header value. By default, this returns the Server-Sent Events content type (`text/event-stream`). If a subclass supports other types as well, it should consider `self.accept` in [`encode_event()`][pydantic_ai.ui.UIEventStream.encode_event] and return the resulting content type. )SSE_CONTENT_TYPErAr7r7r8 content_type[szUIEventStream.content_typeeventr.cCst)z-Encode a protocol-specific event as a string.)NotImplementedErrorrBrIr7r7r8 encode_eventdrFzUIEventStream.encode_eventstreamAsyncIterator[EventT]AsyncIterator[str]cCs&|2z 3dHW}||Vq6dS)z^Encode a stream of protocol-specific events as strings according to the `Accept` header value.N)rL)rBrMrIr7r7r8 encode_streamiszUIEventStream.encode_streamr-c CsLzddlm}Wnty}ztd|d}~ww||||j|jdS)zHGenerate a streaming response from a stream of protocol-specific events.rr,uPlease install the `starlette` package to use the `streaming_response()` method, you can use the `ui` optional group — `pip install "pydantic-ai-slim[ui]"`N)headers media_type)starlette.responsesr- ImportErrorrPrErH)rBrMr-er7r7r8streaming_responsensz UIEventStream.streaming_responseAsyncIterator[NativeEvent] on_completeOnCompleteFunc[EventT] | Nonec Cs|2z 3dHW}|Vq6z-z|2z3dHW}t|tr1|d2z 3dHW}|Vq%6nt|trG|d2z 3dHW}|Vq;6nt|tr|jr|jj}r|jj}r|d2z 3dHW}|Vq`6d|_t t ||ddd}| |2z 3dHW}|Vq}6t t t|j}||_|d2z 3dHW}|Vq6|durt|r||2z 3dHW}|Vq6nt|r||IdHnt||IdHnt|tr||_t|ttBrq||2z 3dHW}|Vq6q6Wn$ty}z||2z 3dHW}|Vq6WYd}~nd}~wwW|d2z 3dHW}|Vq!6|2z 3dHW}|Vq16dS|d2z 3dHW}|VqD6|2z 3dHW}|VqT6w)a`Transform a stream of Pydantic AI events into protocol-specific events. This method dispatches to specific hooks and `handle_*` methods that subclasses can override: - [`before_stream()`][pydantic_ai.ui.UIEventStream.before_stream] - [`after_stream()`][pydantic_ai.ui.UIEventStream.after_stream] - [`on_error()`][pydantic_ai.ui.UIEventStream.on_error] - [`before_request()`][pydantic_ai.ui.UIEventStream.before_request] - [`after_request()`][pydantic_ai.ui.UIEventStream.after_request] - [`before_response()`][pydantic_ai.ui.UIEventStream.before_response] - [`after_response()`][pydantic_ai.ui.UIEventStream.after_response] - [`handle_event()`][pydantic_ai.ui.UIEventStream.handle_event] Args: stream: The stream of Pydantic AI events to transform. on_complete: Optional callback function called when the agent run completes successfully. The callback receives the completed [`AgentRunResult`][pydantic_ai.agent.AgentRunResult] and can optionally yield additional protocol-specific events. NresponserequestzFinal result processed.) tool_call_id tool_namecontent)result) before_stream isinstancer _turn_torr*r?r\r]rr'handle_function_tool_resultrr)r(r_r>inspectisasyncgenfunctionris_async_callablerun_in_executorrrr handle_event Exceptionon_error after_stream) rBrMrXrUrIr\r]output_tool_result_eventr_r7r7r8transform_stream~s        3     zUIEventStream.transform_streamto_turncCs||jkrdS|jdkr|2z 3dHW}|Vq6n|jdkr1|2z 3dHW}|Vq&6||_|dkrI|2z 3dHW}|Vq<6dS|dkr^|2z 3dHW}|VqQ6dSdS)z?Fire hooks when turning from request to response or vice versa.Nr[rZ)r= after_requestafter_responsebefore_requestbefore_response)rBrnrUr7r7r8rbs*   zUIEventStream._turn_tor0cCst|tdr||2z 3dHW}|Vq6dStdr5||2z 3dHW}|Vq(6dStdrO||2z 3dHW}|VqB6dStdri||2z 3dHW}|Vq\6dStdr| |2z 3dHW}|Vqv6dSt dr| |2z 3dHW}|Vq6dSt dr| |2z 3dHW}|Vq6dS dS)aBTransform a Pydantic AI event into one or more protocol-specific events. This method dispatches to specific `handle_*` methods based on event type: - [`PartStartEvent`][pydantic_ai.messages.PartStartEvent] -> [`handle_part_start()`][pydantic_ai.ui.UIEventStream.handle_part_start] - [`PartDeltaEvent`][pydantic_ai.messages.PartDeltaEvent] -> `handle_part_delta` - [`PartEndEvent`][pydantic_ai.messages.PartEndEvent] -> `handle_part_end` - [`FinalResultEvent`][pydantic_ai.messages.FinalResultEvent] -> `handle_final_result` - [`FunctionToolCallEvent`][pydantic_ai.messages.FunctionToolCallEvent] -> `handle_function_tool_call` - [`FunctionToolResultEvent`][pydantic_ai.messages.FunctionToolResultEvent] -> `handle_function_tool_result` - [`AgentRunResultEvent`][pydantic_ai.run.AgentRunResultEvent] -> `handle_run_result` Subclasses are encouraged to override the individual `handle_*` methods rather than this one. If you need specific behavior for all events, make sure you call the super method. r7N)r handle_part_startrhandle_part_deltarhandle_part_endrhandle_final_resultrhandle_function_tool_callrrcr*handle_run_result)rBrIrUr7r7r8rhsN zUIEventStream.handle_eventr cCsX|j}|j}|tdr%|j||dkd2z 3dHW}|Vq6dStdrC|j||dkd2z 3dHW}|Vq66dStdr]||2z 3dHW}|VqP6dStdrw| |2z 3dHW}|Vqj6dSt dr| |2z 3dHW}|Vq6dSt dr| |2z 3dHW}|Vq6dSdS)aHandle a `PartStartEvent`. This method dispatches to specific `handle_*` methods based on part type: - [`TextPart`][pydantic_ai.messages.TextPart] -> [`handle_text_start()`][pydantic_ai.ui.UIEventStream.handle_text_start] - [`ThinkingPart`][pydantic_ai.messages.ThinkingPart] -> [`handle_thinking_start()`][pydantic_ai.ui.UIEventStream.handle_thinking_start] - [`ToolCallPart`][pydantic_ai.messages.ToolCallPart] -> [`handle_tool_call_start()`][pydantic_ai.ui.UIEventStream.handle_tool_call_start] - [`BuiltinToolCallPart`][pydantic_ai.messages.BuiltinToolCallPart] -> [`handle_builtin_tool_call_start()`][pydantic_ai.ui.UIEventStream.handle_builtin_tool_call_start] - [`BuiltinToolReturnPart`][pydantic_ai.messages.BuiltinToolReturnPart] -> [`handle_builtin_tool_return()`][pydantic_ai.ui.UIEventStream.handle_builtin_tool_return] - [`FilePart`][pydantic_ai.messages.FilePart] -> [`handle_file()`][pydantic_ai.ui.UIEventStream.handle_file] Subclasses are encouraged to override the individual `handle_*` methods rather than this one. If you need specific behavior for all part start events, make sure you call the super method. Args: event: The part start event. r7text) follows_textNthinking)follows_thinking)partprevious_part_kindr!handle_text_startr#handle_thinking_startr%handle_tool_call_startrhandle_builtin_tool_call_startrhandle_builtin_tool_returnr handle_file)rBrIr}r~rUr7r7r8rssD zUIEventStream.handle_part_startrcCs|j}|tdr||2z 3dHW}|Vq6dStdr8||2z 3dHW}|Vq+6dStdrP||2z 3dHW}|VqC6dSdS)aMHandle a PartDeltaEvent. This method dispatches to specific `handle_*_delta` methods based on part delta type: - [`TextPartDelta`][pydantic_ai.messages.TextPartDelta] -> [`handle_text_delta()`][pydantic_ai.ui.UIEventStream.handle_text_delta] - [`ThinkingPartDelta`][pydantic_ai.messages.ThinkingPartDelta] -> [`handle_thinking_delta()`][pydantic_ai.ui.UIEventStream.handle_thinking_delta] - [`ToolCallPartDelta`][pydantic_ai.messages.ToolCallPartDelta] -> [`handle_tool_call_delta()`][pydantic_ai.ui.UIEventStream.handle_tool_call_delta] Subclasses are encouraged to override the individual `handle_*_delta` methods rather than this one. If you need specific behavior for all part delta events, make sure you call the super method. Args: event: The PartDeltaEvent. r7N)deltar"handle_text_deltar$handle_thinking_deltar&handle_tool_call_delta)rBrIrrUr7r7r8rt9s$ zUIEventStream.handle_part_deltarcCs|j}|j}|tdr%|j||dkd2z 3dHW}|Vq6dStdrC|j||dkd2z 3dHW}|Vq66dStdr]||2z 3dHW}|VqP6dStdrw| |2z 3dHW}|Vqj6dSt drdSt drdSdS)aHandle a `PartEndEvent`. This method dispatches to specific `handle_*_end` methods based on part type: - [`TextPart`][pydantic_ai.messages.TextPart] -> [`handle_text_end()`][pydantic_ai.ui.UIEventStream.handle_text_end] - [`ThinkingPart`][pydantic_ai.messages.ThinkingPart] -> [`handle_thinking_end()`][pydantic_ai.ui.UIEventStream.handle_thinking_end] - [`ToolCallPart`][pydantic_ai.messages.ToolCallPart] -> [`handle_tool_call_end()`][pydantic_ai.ui.UIEventStream.handle_tool_call_end] - [`BuiltinToolCallPart`][pydantic_ai.messages.BuiltinToolCallPart] -> [`handle_builtin_tool_call_end()`][pydantic_ai.ui.UIEventStream.handle_builtin_tool_call_end] Subclasses are encouraged to override the individual `handle_*_end` methods rather than this one. If you need specific behavior for all part end events, make sure you call the super method. Args: event: The part end event. r7ry)followed_by_textNr{)followed_by_thinking) r}next_part_kindr!handle_text_endr#handle_thinking_endr%handle_tool_call_endrhandle_builtin_tool_call_endrr)rBrIr}rrUr7r7r8ruTs:zUIEventStream.handle_part_endcCdS)zYield events before agent streaming starts. This hook is called before any agent events are processed. Override this to inject custom events at the start of the stream. Nr7rAr7r7r8r`wzUIEventStream.before_streamcCr)zYield events after agent streaming completes. This hook is called after all agent events have been processed. Override this to inject custom events at the end of the stream. Nr7rAr7r7r8rkrzUIEventStream.after_streamerrorricCr)zHandle errors that occur during streaming. Args: error: The error that occurred during streaming. Nr7)rBrr7r7r8rjrzUIEventStream.on_errorcCr)zYield events before a model request is processed. Override this to inject custom events at the start of the request. Nr7rAr7r7r8rqzUIEventStream.before_requestcCr)zYield events after a model request is processed. Override this to inject custom events at the end of the request. Nr7rAr7r7r8rorzUIEventStream.after_requestcCr)zYield events before a model response is processed. Override this to inject custom events at the start of the response. Nr7rAr7r7r8rrrzUIEventStream.before_responsecCr)zYield events after a model response is processed. Override this to inject custom events at the end of the response. Nr7rAr7r7r8rprzUIEventStream.after_responseFr}r!rzboolcCr)a Handle the start of a `TextPart`. Args: part: The text part. follows_text: Whether the part is directly preceded by another text part. In this case, you may want to yield a "text-delta" event instead of a "text-start" event. Nr7)rBr}rzr7r7r8rzUIEventStream.handle_text_startrr"cCr)zYHandle a `TextPartDelta`. Args: delta: The text part delta. Nr7rBrr7r7r8rrzUIEventStream.handle_text_deltarcCr)zHandle the end of a `TextPart`. Args: part: The text part. followed_by_text: Whether the part is directly followed by another text part. In this case, you may not want to yield a "text-end" event yet. Nr7)rBr}rr7r7r8rrzUIEventStream.handle_text_endr#r|cCr)a"Handle the start of a `ThinkingPart`. Args: part: The thinking part. follows_thinking: Whether the part is directly preceded by another thinking part. In this case, you may want to yield a "thinking-delta" event instead of a "thinking-start" event. Nr7)rBr}r|r7r7r8rrz#UIEventStream.handle_thinking_startr$cCr)zaHandle a `ThinkingPartDelta`. Args: delta: The thinking part delta. Nr7rr7r7r8rrz#UIEventStream.handle_thinking_deltarcCr)aHandle the end of a `ThinkingPart`. Args: part: The thinking part. followed_by_thinking: Whether the part is directly followed by another thinking part. In this case, you may not want to yield a "thinking-end" event yet. Nr7)rBr}rr7r7r8rs z!UIEventStream.handle_thinking_endr%cCr)zcHandle the start of a `ToolCallPart`. Args: part: The tool call part. Nr7rBr}r7r7r8rrz$UIEventStream.handle_tool_call_startr&cCr)zbHandle a `ToolCallPartDelta`. Args: delta: The tool call part delta. Nr7rr7r7r8rrz$UIEventStream.handle_tool_call_deltacCr)zaHandle the end of a `ToolCallPart`. Args: part: The tool call part. Nr7rr7r7r8rrz"UIEventStream.handle_tool_call_endrcCr)znHandle a `BuiltinToolCallPart` at start. Args: part: The builtin tool call part. Nr7rr7r7r8r rz,UIEventStream.handle_builtin_tool_call_startcCr)zpHandle the end of a `BuiltinToolCallPart`. Args: part: The builtin tool call part. Nr7rr7r7r8rrz*UIEventStream.handle_builtin_tool_call_endrcCr)ziHandle a `BuiltinToolReturnPart`. Args: part: The builtin tool return part. Nr7rr7r7r8rrz(UIEventStream.handle_builtin_tool_returnrcCr)zMHandle a `FilePart`. Args: part: The file part. Nr7rr7r7r8r$rzUIEventStream.handle_filercCr)z_Handle a `FinalResultEvent`. Args: event: The final result event. Nr7rKr7r7r8rv-rz!UIEventStream.handle_final_resultrcCr)zjHandle a `FunctionToolCallEvent`. Args: event: The function tool call event. Nr7rKr7r7r8rw6rz'UIEventStream.handle_function_tool_callrcCr)znHandle a `FunctionToolResultEvent`. Args: event: The function tool result event. Nr7rKr7r7r8rc?rz)UIEventStream.handle_function_tool_resultr*cCr)zgHandle an `AgentRunResultEvent`. Args: event: The agent run result event. Nr7rKr7r7r8rxHrzUIEventStream.handle_run_result)r@r6)r@rD)rIr.r@r6)rMrNr@rO)rMrNr@r-r5)rMrWrXrYr@rN)rnr<r@rN)rIr0r@rN)rIr r@rN)rIrr@rN)rIrr@rN)r@rN)rrir@rN)F)r}r!rzrr@rN)rr"r@rN)r}r!rrr@rN)r}r#r|rr@rN)rr$r@rN)r}r#rrr@rN)r}r%r@rN)rr&r@rN)r}rr@rN)r}rr@rN)r}rr@rN)rIrr@rN)rIrr@rN)rIrr@rN)rIr*r@rN)1__name__ __module__ __qualname____doc____annotations__r4r r;r=r>r?rCpropertyrErHrrLrPrVrmrbrhrsrtrur`rkrjrqrorrrprrrrrrrrrrrrrrvrwrcrxr7r7r7r8r2=sf            U  ) (  #       r2)> __future__rrdabcrrcollections.abcrrrr dataclassesr r typingr r r rrrruuidr pydantic_airmessagesrrrrrrrrrrrr r!r"r#r$r%r&r'outputr(runr)r*toolsr+rSr-rGr.r/r0rr1r2r7r7r7r8s>$  T    $