Struct BaseAgent 

pub struct BaseAgent<T: AgentDeriveT + AgentExecutor + AgentHooks + Send + Sync, A: AgentType> {
    pub id: ActorID,
    /* private fields */
}

Base agent type that wraps an AgentDeriveT implementation with additional runtime components

Fields

id: ActorID

Agent ID

Implementations

impl<T: AgentDeriveT + AgentExecutor + AgentHooks, A: AgentType> BaseAgent<T, A>

pub async fn new( inner: T, llm: Arc<dyn LLMProvider>, memory: Option<Box<dyn MemoryProvider>>, tx: Sender<Event>, stream: bool, ) -> Result<Self, RunnableAgentError>

Create a new BaseAgent wrapping an AgentDeriveT implementation

pub fn inner(&self) -> Arc<T>

pub fn name(&self) -> &str

Get the agent’s name

pub fn description(&self) -> &str

Get the agent’s description

pub fn tools(&self) -> Vec<Box<dyn ToolT>>

Get the tools as Arc-wrapped references

pub fn serialized_tools(&self) -> Option<Arc<Vec<Tool>>>

pub fn stream(&self) -> bool

pub fn agent_config(&self) -> AgentConfig

pub fn llm(&self) -> Arc<dyn LLMProvider>

Get the LLM provider

pub fn memory(&self) -> Option<Arc<Mutex<Box<dyn MemoryProvider>>>>

Get the memory provider if available

impl<T: AgentDeriveT + AgentExecutor + AgentHooks> BaseAgent<T, ActorAgent>

pub fn tx(&self) -> Result<Sender<Event>, RunnableAgentError>

pub async fn run( self: Arc<Self>, task: Task, ) -> Result<<T as AgentDeriveT>::Output, RunnableAgentError>

where Value: From<<T as AgentExecutor>::Output>, <T as AgentDeriveT>::Output: From<<T as AgentExecutor>::Output>, <T as AgentExecutor>::Error: Into<RunnableAgentError>,

pub async fn run_stream( self: Arc<Self>, task: Task, ) -> Result<BoxRuntimeStream<Result<<T as AgentDeriveT>::Output, RunnableAgentError>>, RunnableAgentError>

where <T as AgentDeriveT>::Output: From<<T as AgentExecutor>::Output>, <T as AgentExecutor>::Error: Into<RunnableAgentError>,

Return a live executor output stream without the full task lifecycle.

Event channel: Does not emit terminal protocol events (TaskComplete, TaskError) on the agent event channel. In-stream failures appear only as Err items on the returned stream. Lifecycle hooks (on_run_start, on_run_complete) are also skipped.

Use Self::run_stream_to_completion when dispatching through a runtime, waiting on TaskComplete / TaskError, or matching the pub/sub actor path (which calls run_stream_to_completion internally).

Mid-run events (StreamChunk, tool-call events, etc.) may still be emitted by the executor while the returned stream is polled.

pub async fn run_stream_to_completion( self: Arc<Self>, task: Task, ) -> Result<<T as AgentDeriveT>::Output, RunnableAgentError>

where Value: From<<T as AgentExecutor>::Output>, <T as AgentDeriveT>::Output: From<<T as AgentExecutor>::Output>, <T as AgentExecutor>::Error: Into<RunnableAgentError>,

Execute a streaming task to completion inside the actor, draining the stream and running lifecycle hooks before returning.

This is the event-aware streaming entry point: emits TaskError on hook abort, stream setup failure, in-stream item errors, and empty streams; emits TaskComplete on success. Pub/sub AgentActor dispatch uses this method when stream() is enabled.

When the executor stream yields multiple successful outputs, only the last item is used for TaskComplete and the returned agent output. Intermediate items are not emitted as terminal events.

For incremental output without terminal events, see Self::run_stream.

impl<T: AgentDeriveT + AgentExecutor + AgentHooks> BaseAgent<T, DirectAgent>

pub async fn run( &self, task: Task, ) -> Result<<T as AgentDeriveT>::Output, RunnableAgentError>

where Value: From<<T as AgentExecutor>::Output>, <T as AgentDeriveT>::Output: From<<T as AgentExecutor>::Output>, <T as AgentExecutor>::Output: Clone, <T as AgentExecutor>::Error: Into<RunnableAgentError>,

Execute the agent for a single task and return the final agent output.

pub async fn run_stream( &self, task: Task, ) -> Result<BoxRuntimeStream<Result<<T as AgentDeriveT>::Output, Error>>, RunnableAgentError>

where Value: From<<T as AgentExecutor>::Output>, <T as AgentDeriveT>::Output: From<<T as AgentExecutor>::Output>, <T as AgentExecutor>::Output: Clone, <T as AgentExecutor>::Error: Into<RunnableAgentError>,

Execute the agent with streaming enabled and receive a stream of partial outputs which culminate in a final chunk with done=true.

Trait Implementations

impl<T: Clone + AgentDeriveT + AgentExecutor + AgentHooks + Send + Sync, A: Clone + AgentType> Clone for BaseAgent<T, A>

fn clone(&self) -> BaseAgent<T, A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: AgentDeriveT + AgentExecutor + AgentHooks, A: AgentType> Debug for BaseAgent<T, A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.