pub struct AgentBuilder { /* private fields */ }Expand description
Builder for Agent.
Implementations§
Source§impl AgentBuilder
impl AgentBuilder
Sourcepub fn require_per_service_call_history_persistence(
self,
enabled: bool,
) -> AgentBuilder
pub fn require_per_service_call_history_persistence( self, enabled: bool, ) -> AgentBuilder
Persist history after every model call instead of once per run
(upstream’s require_per_service_call_history_persistence, which
create_harness_agent turns on).
With a local history provider (the service does not store the conversation), each model call of the tool loop records what it added: the run’s input with the first reply, then each batch of tool results with the reply that followed. A long tool run that fails midway keeps the turns it completed. Runs without a tool loop record once, at the end, as before. When the service stores the conversation this has no effect: history providers are not used then.
pub fn id(self, id: impl Into<String>) -> AgentBuilder
pub fn name(self, name: impl Into<String>) -> AgentBuilder
pub fn description(self, description: impl Into<String>) -> AgentBuilder
pub fn instructions(self, instructions: impl Into<String>) -> AgentBuilder
pub fn model(self, model: impl Into<String>) -> AgentBuilder
pub fn temperature(self, temperature: f32) -> AgentBuilder
pub fn max_tokens(self, max_tokens: u32) -> AgentBuilder
Sourcepub fn response_format(self, format: ResponseFormat) -> AgentBuilder
pub fn response_format(self, format: ResponseFormat) -> AgentBuilder
Request a structured-output response format (e.g. a JSON schema).
Sourcepub fn tool(self, tool: ToolDefinition) -> AgentBuilder
pub fn tool(self, tool: ToolDefinition) -> AgentBuilder
Add a tool available to the agent.
Sourcepub fn tools(
self,
tools: impl IntoIterator<Item = ToolDefinition>,
) -> AgentBuilder
pub fn tools( self, tools: impl IntoIterator<Item = ToolDefinition>, ) -> AgentBuilder
Add multiple tools.
Sourcepub fn tool_source(self, source: Arc<dyn ToolSource>) -> AgentBuilder
pub fn tool_source(self, source: Arc<dyn ToolSource>) -> AgentBuilder
Register a dynamic tool source (e.g. an MCP server wrapper), resolved
fresh on every run and appended after the agent’s static/context/
per-run tools (dedup by name against those and any earlier-registered
source; first registrant wins). Call repeatedly to register more than
one source. See ToolSource, resolved internally by every
Agent run.
Sourcepub fn context_provider(
self,
provider: Arc<dyn ContextProvider>,
) -> AgentBuilder
pub fn context_provider( self, provider: Arc<dyn ContextProvider>, ) -> AgentBuilder
Add a single context provider (repeatable; providers run in registration order, agent providers after any thread-level ones).
Sourcepub fn context_providers(
self,
providers: Vec<Arc<dyn ContextProvider>>,
) -> AgentBuilder
pub fn context_providers( self, providers: Vec<Arc<dyn ContextProvider>>, ) -> AgentBuilder
Set the context provider list, replacing any previously registered.
Sourcepub fn with_compaction(
self,
strategy: impl CompactionStrategy + 'static,
) -> AgentBuilder
pub fn with_compaction( self, strategy: impl CompactionStrategy + 'static, ) -> AgentBuilder
Attach conversation-history compaction, via a
CompactionProvider wrapping
strategy (with the default ApproxTokenizer; use
AgentBuilder::context_provider with
CompactionProvider::with_tokenizer
for a custom tokenizer).
Registered as one of the agent’s own context providers, which
Agent::providers_for always runs after the session’s —
including the auto-attached (or explicitly attached)
HistoryProvider, which lives on
the session — so compaction sees, and can shrink, the full
history-prepended message list for the run. Not calling this leaves
the default behavior unchanged: the full history is sent every run.
Sourcepub fn with_async_compaction(
self,
strategy: impl AsyncCompactionStrategy + 'static,
) -> AgentBuilder
pub fn with_async_compaction( self, strategy: impl AsyncCompactionStrategy + 'static, ) -> AgentBuilder
Compact with an AsyncCompactionStrategy
— LLM summarization, a pipeline, or a triggered strategy.
Sourcepub fn middleware(self, mw: Arc<dyn Middleware<AgentContext>>) -> AgentBuilder
pub fn middleware(self, mw: Arc<dyn Middleware<AgentContext>>) -> AgentBuilder
Add an agent middleware.
Sourcepub fn chat_middleware(
self,
mw: Arc<dyn Middleware<ChatContext>>,
) -> AgentBuilder
pub fn chat_middleware( self, mw: Arc<dyn Middleware<ChatContext>>, ) -> AgentBuilder
Add a chat middleware, run around the underlying chat-client call on
every request (repeatable, like AgentBuilder::middleware).
See the chat-client call pipeline for exactly what it can observe
and mutate.
Sourcepub fn function_middleware(
self,
mw: Arc<dyn Middleware<FunctionInvocationContext>>,
) -> AgentBuilder
pub fn function_middleware( self, mw: Arc<dyn Middleware<FunctionInvocationContext>>, ) -> AgentBuilder
Add a function-invocation middleware, run around every local tool call
(repeatable). Plumbed down into the FunctionInvokingChatClient
this builder wraps the underlying client with.
Sourcepub fn observability_config(self, config: ObservabilityConfig) -> AgentBuilder
pub fn observability_config(self, config: ObservabilityConfig) -> AgentBuilder
Set the ObservabilityConfig
for the execute_tool spans this agent’s tool loop emits — content
capture and the GenAI semantic-convention version.
The builder wraps the caller’s client in a
FunctionInvokingChatClient itself, so this is the only way to reach
that wrapper’s own config. Pass the same value given to an
ObservableChatClient
around the same client, so one trace reports one convention version
across its chat and tool spans. Left unset, the tool loop reads the
environment, as it always has.
Sourcepub fn function_invocation_config(
self,
config: FunctionInvocationConfig,
) -> AgentBuilder
pub fn function_invocation_config( self, config: FunctionInvocationConfig, ) -> AgentBuilder
Set the FunctionInvocationConfig
for this agent’s tool loop: iteration cap, the per-request call and
wall-clock budgets, the consecutive-error limit, and how unknown calls
and tool errors are reported.
Like observability_config, this is the
only way to reach that config: the builder wraps the caller’s client in
a FunctionInvokingChatClient itself, so configuring one before
handing it over would just be wrapped again.
let config = FunctionInvocationConfig {
// Bound an unattended run three ways.
max_iterations: 10,
max_function_calls: Some(25),
max_duration_seconds: Some(120.0),
..Default::default()
};
let agent = Agent::builder(client).function_invocation_config(config).build();Sourcepub fn chat_options(self, options: ChatOptions) -> AgentBuilder
pub fn chat_options(self, options: ChatOptions) -> AgentBuilder
Override the whole chat options object (advanced).