Struct Agent 

pub struct Agent {

    pub id: String,
    pub provider: Provider,
    pub system_instruction: Vec<MessageNum>,
    pub tools: Arc<RwLock<ToolRegistry>>,
    pub max_iterations: u32,
    pub run_config: Option<AgentRunConfig>,
    pub model_override: Option<String>,
    pub criteria: Vec<Box<dyn CompletionCriteria>>,
    pub callbacks: Vec<Arc<dyn AgentCallback>>,
    pub memory: Option<Arc<Mutex<Box<dyn Memory>>>>,
    pub app_name: Option<String>,
    pub user_id: Option<String>,
    pub session_id: Option<String>,
    pub session_store: Option<Arc<dyn SessionStore>>,
    pub user_state_store: Option<Arc<dyn UserStateStore>>,
    pub app_state_store: Option<Arc<dyn AppStateStore>>,
    /* private fields */
}

Fields

id: String

provider: Provider

system_instruction: Vec<MessageNum>

tools: Arc<RwLock<ToolRegistry>>

max_iterations: u32

run_config: Option<AgentRunConfig>

model_override: Option<String>

If set, overrides the model in any Prompt built by AgentBuilder::run().

criteria: Vec<Box<dyn CompletionCriteria>>

callbacks: Vec<Arc<dyn AgentCallback>>

memory: Option<Arc<Mutex<Box<dyn Memory>>>>

app_name: Option<String>

Application name used for store scoping.

user_id: Option<String>

User identifier used for store scoping.

session_id: Option<String>

Session identifier used to key store lookups.

session_store: Option<Arc<dyn SessionStore>>

Optional durable session state store.

user_state_store: Option<Arc<dyn UserStateStore>>

Optional per-user state store.

app_state_store: Option<Arc<dyn AppStateStore>>

Optional app-level state store.

Implementations

impl Agent

Rust method implementation of the Agent

pub async fn rebuild_client(&self) -> Result<Agent, AgentError>

Helper method to rebuild the client, useful for deserialization

pub async fn new( provider: Provider, system_instruction: Option<Vec<MessageNum>>, ) -> Result<Agent, AgentError>

pub fn register_tool(&self, tool: Box<dyn Tool + Sync + Send>)

pub async fn execute_task( &self, task: &Task, ) -> Result<AgentResponse, AgentError>

pub async fn execute_prompt( &self, prompt: &Prompt, ) -> Result<AgentResponse, AgentError>

pub async fn execute_task_with_context( &self, task: &Arc<RwLock<Task>>, context: &Value, ) -> Result<AgentResponse, AgentError>

Execute task with context without mutating the original task This method is used by the workflow executor to run individual tasks with context

pub async fn execute_task_with_context_message( &self, task: &Arc<RwLock<Task>>, context_messages: HashMap<String, Vec<MessageNum>>, parameter_context: Value, global_context: Option<Arc<Value>>, ) -> Result<AgentResponse, AgentError>

pub fn client_provider(&self) -> &Provider

Trait Implementations

impl AgentRunner for Agent

fn id(&self) -> &str

fn run<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, input: &'life1 str, session: &'life2 mut SessionState, ) -> Pin<Box<dyn Future<Output = Result<AgentRunOutcome, AgentError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Agent: 'async_trait,

fn resume<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_answer: &'life1 str, ctx: ResumeContext, session: &'life2 mut SessionState, ) -> Pin<Box<dyn Future<Output = Result<AgentRunOutcome, AgentError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Agent: 'async_trait,

Resume a previously paused run with the user’s answer.

impl Clone for Agent

Manual Clone: clones the provider-level fields; criteria/callbacks/memory are NOT cloned. This preserves backward compatibility with the workflow layer which stores Arc<Agent>.

fn clone(&self) -> Agent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Agent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Agent

Allows for deserialization of the Agent, re-initializing the client.

fn deserialize<D>( deserializer: D, ) -> Result<Agent, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Agent

fn eq(&self, other: &Agent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Agent

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.