Move off auto_functions for finer-grained ctrl-c cancellation

[evansenter]

Problem

Currently using create_stream_with_auto_functions() which handles tool execution internally. This means we can only check for ctrl-c cancellation between tool batches, not during individual tool execution.

If Gemini requests multiple tools at once, pressing ctrl-c won't take effect until the entire batch completes.

Proposed Solution

Switch to manual function calling:

1. Get function call requests from the stream
2. Check cancellation before each individual tool call
3. Execute tools ourselves with cancellation checks
4. Send results back and continue

This would allow:

• Cancellation between individual tool calls (not just batches)
• Potentially aborting long-running tools mid-execution
• More control over tool execution flow

Current State

Basic ctrl-c handling is implemented using ctrlc crate + AtomicBool. It works for cancelling between batches, which is acceptable for now.

[evansenter]

Implementation Guide

Based on genai-rs docs (MULTI_TURN_FUNCTION_CALLING.md, STREAMING_API.md), here's the pattern:

Current Code (auto_functions)

let mut stream = client.interaction()
    .with_text(prompt)
    .with_tool_service(tool_service)
    .create_stream_with_auto_functions();  // Handles everything internally

while let Some(event) = stream.next().await {
    match &event.chunk {
        AutoFunctionStreamChunk::Delta(content) => { /* stream text */ }
        AutoFunctionStreamChunk::ExecutingFunctions(resp) => { /* can't get calls here! */ }
        AutoFunctionStreamChunk::FunctionResults(results) => { /* results after execution */ }
        AutoFunctionStreamChunk::Complete(resp) => { /* done */ }
    }
}

New Code (manual function calling)

let functions = tool_service.tools().iter()
    .map(|t| t.declaration())
    .collect::<Vec<_>>();

let mut response = client.interaction()
    .with_model(model)
    .with_text(prompt)
    .with_system_instruction(system_prompt)
    .add_functions(functions.clone())
    .with_store_enabled()
    .create_stream();  // Basic streaming, no auto-execution

// Stream the response
let mut accumulated_response = stream_to_completion(&mut response).await?;

// Manual function calling loop
const MAX_ITERATIONS: usize = 10;
for _ in 0..MAX_ITERATIONS {
    let calls = accumulated_response.function_calls();
    if calls.is_empty() { break; }

    let mut results = Vec::new();
    for call in &calls {
        // ✅ CHECK CANCELLATION HERE - between each tool
        if cancelled.load(Ordering::SeqCst) {
            return Err(anyhow!("Cancelled"));
        }

        // ✅ LOG BEFORE EXECUTION
        log_event(&format!("CALL {} {}", call.name, call.args));

        let start = Instant::now();
        let result = tool_service.execute(&call.name, call.args.clone()).await?;
        let duration = start.elapsed();

        // ✅ LOG AFTER EXECUTION  
        log_event(&format!("[{}] {:?}", call.name, duration));

        results.push(Content::function_result(
            call.name.clone(),
            call.id.clone().unwrap(),  // Required for multi-turn
            result,
        ));
    }

    // Send results back - no need to resend tools on function result turns
    let mut next_stream = client.interaction()
        .with_model(model)
        .with_previous_interaction(accumulated_response.id.as_ref().unwrap())
        .with_content(results)
        .create_stream();

    accumulated_response = stream_to_completion(&mut next_stream).await?;
}

Key Details from Docs

1. call.id is required for multi-turn function results
2. Tools don't need to be resent on function result turns (only on new user message turns)
3. System instruction is NOT inherited via previous_interaction_id - must set on each turn if needed (but function result turns seem to work without it)
4. Content::function_result(name, call_id, result) to create result content

Helper Function

async fn stream_to_completion(stream: &mut impl Stream<Item = Result<StreamEvent>>) -> Result<InteractionResponse> {
    let mut response = None;
    while let Some(event) = stream.next().await {
        let event = event?;
        match &event.chunk {
            StreamChunk::Delta(content) => {
                if let Some(text) = content.as_text() {
                    print!("{}", text);
                }
            }
            StreamChunk::Complete(resp) => {
                response = Some(resp.clone());
            }
            _ => {}
        }
    }
    response.ok_or_else(|| anyhow!("Stream ended without Complete"))
}

Benefits

• ✅ Cancellation between individual tool calls (not just batches)
• ✅ Two-phase logging: tool name/args BEFORE execution, timing AFTER
• ✅ Full control over execution flow
• ✅ Solves Logging: Show tool calls before execution, timing after #49 as a side effect

[evansenter]

Fixed in 0286640 - Manual function calling now enables individual tool cancellation and two-phase logging.