Function parse_anthropic_non_stream_response

src-tauri/src/agents/runner.rs:1644–1683

Parse a non-streaming Anthropic Messages API response into an `LLMTurn`. Used as a fallback when the gateway returns an empty stream (some proxies don't support streaming for certain models).

(
    body: &Value,
    agent_run_id: &str,
    token_sink: &S,
    app_handle: &tauri::AppHandle,
)

/// Used as a fallback when the gateway returns an empty stream (some proxies
/// don't support streaming for certain models).
fn parse_anthropic_non_stream_response<S: TokenSink + Sync>(
    body: &Value,
    agent_run_id: &str,
    token_sink: &S,
    app_handle: &tauri::AppHandle,
) -> AppResult<LLMTurn> {
    let mut text = String::new();
    let mut tool_calls = Vec::new();

    if let Some(content) = body.get("content").and_then(Value::as_array) {
        for block in content {
            let block_type = block.get("type").and_then(Value::as_str).unwrap_or("");
            match block_type {
                "text" => {
                    if let Some(t) = block.get("text").and_then(Value::as_str) {
                        text.push_str(t);
                        // Send tokens to UI so the user sees the response
                        token_sink.send(t);
                        let _ = app_handle.emit(
                            "agent-token",
                            AgentTokenEvent {
                                agent_run_id: agent_run_id.to_string(),
                                token: t.to_string(),
                            },
                        );
                    }
                }
                "tool_use" => {
                    let id = block.get("id").and_then(Value::as_str).unwrap_or("").to_string();
                    let name = block.get("name").and_then(Value::as_str).unwrap_or("").to_string();
                    let input = block.get("input").cloned().unwrap_or(Value::Object(Default::default()));
                    tool_calls.push(ParsedToolCall { id, name, input });
                }
                _ => {}
            }
        }
    }

    Ok(LLMTurn { text, tool_calls })
}

#[derive(Debug, Clone)]
struct ToolExecutionOutcome {