Struct ToolCallBuffer 

pub struct ToolCallBuffer { /* private fields */ }

Streaming buffer that accumulates tokens and detects tool call boundaries.

Use this in streaming response handlers to buffer tokens when a tool call prefix is detected, then parse and emit Part::FunctionCall when the closing tag arrives.

Example

let mut buffer = ToolCallBuffer::new();

for chunk in stream {
    match buffer.push(&chunk.text) {
        BufferAction::Emit(parts) => {
            for part in parts { yield part; }
        }
        BufferAction::Buffering => { /* still accumulating */ }
    }
}
// Flush any remaining content at end of stream
for part in buffer.flush() { yield part; }

Implementations

impl ToolCallBuffer

pub fn new() -> Self

Create a new empty buffer that accepts a parsed call to any tool name.

pub fn for_declared_tools(declared_tools: HashSet<String>) -> Self

Create a buffer that emits a parsed call only when every call names one of declared_tools, as parse_declared_tool_calls does.

With no declared tools the buffer never holds text back: every chunk is emitted as text immediately.

Example

use std::collections::HashSet;

use adk_core::Part;
use adk_model::tool_call_parser::{BufferAction, ToolCallBuffer};

let mut buffer = ToolCallBuffer::for_declared_tools(HashSet::new());
let BufferAction::Emit(parts) = buffer.push("<tool_call>{\"name\":\"x\"}</tool_call>") else {
    panic!("nothing is buffered without declared tools");
};
assert!(matches!(&parts[0], Part::Text { .. }));

pub fn push(&mut self, text: &str) -> BufferAction

Push a text chunk into the buffer.

Returns BufferAction::Emit with parts to yield, or BufferAction::Buffering if we’re accumulating a potential tool call.

pub fn flush(&mut self) -> Vec<Part>

Flush any remaining buffered content as parts. Call this when the stream ends.

Trait Implementations

impl Default for ToolCallBuffer

fn default() -> Self

Returns the “default value” for a type.