Struct AutoFunctionResult 

#[non_exhaustive]
pub struct AutoFunctionResult {
    pub response: InteractionResponse,
    pub executions: Vec<FunctionExecutionResult>,
    pub reached_max_loops: bool,
}

Result from create_with_auto_functions() containing the final response and a history of all function executions.

This type provides visibility into which functions were called during automatic function execution, useful for debugging, logging, and evaluation.

Memory Considerations

The executions vector accumulates all FunctionExecutionResult records from each iteration of the auto-function loop. For typical use cases (1-5 iterations with 1-3 functions each), this is negligible.

For edge cases with many function calls or large result payloads, consider:

• Limit iterations: Use crate::InteractionBuilder::with_max_function_call_loops() to cap the maximum number of iterations (default: 5)
• Extract and drop: Extract only the data you need, then drop the result
• Manual control: For fine-grained memory management, implement function calling manually using crate::InteractionBuilder::add_functions() and crate::InteractionBuilder::create() instead of the auto-function helpers

Each FunctionExecutionResult contains the function name, call ID, result value (as serde_json::Value), and execution duration. Memory usage scales primarily with the size of function result payloads.

Example

let result = client
    .interaction()
    .with_model("gemini-3-flash-preview")
    .with_text("What's the weather in London?")
    .create_with_auto_functions()
    .await?;

// Access the final response
if let Some(text) = result.response.as_text() {
    println!("Answer: {}", text);
}

// Access execution history
for exec in &result.executions {
    println!("Called {} -> {}", exec.name, exec.result);
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

response: InteractionResponse

The final response from the model (after all function calls completed)

executions: Vec<FunctionExecutionResult>

All functions that were executed during the auto-function loop

reached_max_loops: bool

Whether the auto-function loop was terminated due to reaching the maximum number of iterations (set via with_max_function_call_loops()).

When true, the response contains the last response from the model before hitting the limit, which likely still contains pending function calls. The executions vector contains all functions that were successfully executed before the limit was reached.

This allows debugging why the model is stuck in a loop and preserves partial results that may still be useful.

Implementations

impl AutoFunctionResult

pub fn all_executions_succeeded(&self) -> bool

Returns true if all function executions succeeded (no errors).

This is useful for detecting missing function implementations or function execution failures that would otherwise be silently sent to the model as error results.

Example

let result = client.interaction()
    .with_text("What's the weather?")
    .add_functions(vec![get_weather_function()])
    .create_with_auto_functions()
    .await?;

assert!(result.all_executions_succeeded(),
    "Function executions failed: {:?}",
    result.failed_executions());

pub fn failed_executions(&self) -> Vec<&FunctionExecutionResult>

Returns all executions that failed (had errors).

Trait Implementations

impl Clone for AutoFunctionResult

fn clone(&self) -> AutoFunctionResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AutoFunctionResult

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AutoFunctionResult

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AutoFunctionResult

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.