Struct LlmWorker 

pub struct LlmWorker<T> { /* private fields */ }

Worker for executing LLM calls with tool support and typed responses.

LlmWorker<T> manages the full lifecycle of LLM interactions including:

• Sending messages to the LLM
• Executing tool calls requested by the LLM
• Managing multi-turn tool execution loops
• Combining multiple toolsets
• Deserializing responses into typed values

Type Parameters

• T - The type to deserialize the LLM response into. Must implement DeserializeOwned. Use Thread if you want the raw conversation thread back without deserialization.

Examples

use serde::Deserialize;

#[derive(Deserialize, JsonSchema)]
struct MyResponse {
    answer: String,
    confidence: f64,
}

let worker = LlmWorker::<MyResponse>::builder(my_llm)
    .with_tool(tool1)
    .build();

let response: MyResponse = worker.run(thread).await?;

Use [LlmWorker::builder(model)] to construct instances with the desired configuration.

Implementations

impl<T> LlmWorker<T>

where T: LLMOutputTrait + JsonSchema + MaybeSend + MaybeSync + 'static,

pub fn builder(model: impl BaseLlm + 'static) -> LlmWorkerBuilder<T>

Creates a new builder for constructing an LlmWorker<T>.

The model is required and must be provided upfront.

Type Parameters

• T - The response type to deserialize into

Arguments

• model - The LLM model to use for this worker

Examples

use serde::Deserialize;

#[derive(Deserialize)]
struct Response { answer: String }

let worker = LlmWorker::<Response>::builder(my_llm)
    .with_tool(tool1)
    .build();

pub fn builder_shared(model: Arc<dyn BaseLlm>) -> LlmWorkerBuilder<T>

Creates a new builder from an already-Arc-wrapped LLM.

Use this when you have a shared Arc<dyn BaseLlm> from the runtime and want to avoid re-wrapping it.

pub async fn run<IT>(&self, input: IT) -> AgentResult<T>

where IT: Into<Thread>,

Runs the worker on the given input thread.

This method executes the LLM with the provided thread, handling any tool calls requested by the LLM. The worker will continue executing tools in a loop until the LLM produces a final response, which is then deserialized into type T.

Arguments

• input - Thread or any type that can be converted into a Thread

Returns

Returns the deserialized response of type T.

Errors

Returns an error if:

• The LLM call fails
• Tool execution fails
• Response deserialization fails

Examples

use radkit::models::Thread;
use serde::Deserialize;

#[derive(Deserialize)]
struct WeatherInfo {
    temp: f64,
    condition: String,
}

let thread = Thread::new().with_user("What's the weather?");
let response: WeatherInfo = worker.run(thread).await?;
println!("Temperature: {}°F", response.temp);

pub async fn run_and_continue<IT>(&self, input: IT) -> AgentResult<(T, Thread)>

where IT: Into<Thread>,

Runs the worker and returns both the deserialized result and the thread for follow-up work.

This method executes the LLM with the provided thread, handling tool calls and executing them in a loop. After completion, it returns both the deserialized response and the updated thread, allowing for multi-turn conversations.

Arguments

• input - Thread or any type that can be converted into a Thread

Returns

Returns a tuple of:

• The deserialized response of type T
• The updated Thread with all tool calls and responses included

Errors

Returns an error if:

• The LLM call fails
• Tool execution fails
• Response deserialization fails

Examples

use radkit::models::Thread;
use serde::Deserialize;

#[derive(Deserialize)]
struct Response { answer: String }

let thread = Thread::new().with_user("What's the weather?");
let (response, continued_thread) = worker.run_and_continue(thread).await?;
println!("Answer: {}", response.answer);

// Continue the conversation with the same thread
let continued_thread = continued_thread
    .with_user("What about tomorrow?");
let (next_response, _) = worker.run_and_continue(continued_thread).await?;

pub fn has_tools(&self) -> bool

Checks if this worker has any toolsets configured.

Examples

if worker.has_tools() {
    println!("Worker can execute tools");
}

pub fn toolset(&self) -> Option<&Arc<dyn BaseToolset>>

Returns a reference to the configured toolset, if any.

Examples

if let Some(toolset) = worker.toolset() {
    let tools = toolset.get_tools().await;
    println!("Worker has {} tools", tools.len());
}