asepharyana
2efd40ca88
- Added module-level documentation for memory tools (`remember`, `recall`, `forget`) to clarify their purpose. - Improved documentation in `recall.rs` and `remember.rs` to describe the functionality and flow of memory entry operations. - Updated `mod.rs` to include descriptions for the tool trait and execution context. - Enhanced `plan.rs` with detailed comments on plan-mode signaling tools. - Documented text search tools in `search.rs` to explain their functionality. - Improved sequential-thinking tool documentation in `seqthink.rs`. - Added safety filter documentation in `shell_filter` for credential and git operations. - Enhanced utility tools documentation, including `cd`, `dir_cache_update`, and `todowrite`. - Improved rendering documentation in view modules (`chat`, `markdown`, `status`, `workflow`) to clarify rendering flows and purposes.
102 lines
3.3 KiB
Rust
102 lines
3.3 KiB
Rust
//! Standalone accumulator for streamed tool-call deltas.
|
|
//!
|
|
//! Flow: `ToolCallAccumulator::add_delta` is fed incremental `(index, id,
|
|
//! name, arguments_delta)` chunks as they arrive over SSE → grows its
|
|
//! internal `Vec<ParsedToolCall>` as needed → `is_complete` reports once
|
|
//! every accumulated call has both a name and arguments.
|
|
//!
|
|
//! Why: mirrors the accumulation logic built into `StreamedTurn::apply_event`
|
|
//! but as an independent, reusable type for callers that want to track
|
|
//! tool-call deltas without a full `StreamedTurn` (e.g. a lighter-weight
|
|
//! preview). Currently unused (`#[allow(dead_code)]`), kept for that future
|
|
//! use case.
|
|
|
|
use super::turn::ParsedToolCall;
|
|
use serde_json::{json, Value};
|
|
|
|
/// Standalone tool-call delta accumulator, functionally equivalent to the accumulation
|
|
/// logic built into `StreamedTurn::apply_event`. Reserved for callers that want to track
|
|
/// tool-call deltas independently of a full `StreamedTurn` (e.g. a lighter-weight preview).
|
|
#[allow(dead_code)]
|
|
pub struct ToolCallAccumulator {
|
|
calls: Vec<ParsedToolCall>,
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
impl ToolCallAccumulator {
|
|
/// Construct an empty accumulator with no tool calls tracked yet.
|
|
///
|
|
/// Return: a fresh `ToolCallAccumulator`.
|
|
pub fn new() -> Self {
|
|
ToolCallAccumulator { calls: Vec::new() }
|
|
}
|
|
|
|
/// Append a delta to the tool call at the given index, growing the
|
|
/// calls vector if needed.
|
|
pub fn add_delta(
|
|
&mut self,
|
|
index: usize,
|
|
id: Option<&str>,
|
|
name: Option<&str>,
|
|
arguments_delta: &str,
|
|
) {
|
|
while self.calls.len() <= index {
|
|
self.calls.push(ParsedToolCall {
|
|
id: String::new(),
|
|
name: String::new(),
|
|
arguments: String::new(),
|
|
is_complete: false,
|
|
});
|
|
}
|
|
let tc = &mut self.calls[index];
|
|
if let Some(new_id) = id {
|
|
if !new_id.is_empty() {
|
|
tc.id = new_id.to_string();
|
|
}
|
|
}
|
|
if let Some(new_name) = name {
|
|
if !new_name.is_empty() {
|
|
tc.name = new_name.to_string();
|
|
}
|
|
}
|
|
tc.arguments.push_str(arguments_delta);
|
|
}
|
|
|
|
/// Borrow the accumulated tool calls.
|
|
pub fn calls(&self) -> &[ParsedToolCall] {
|
|
&self.calls
|
|
}
|
|
|
|
/// Return true once all tool calls have both a name and arguments.
|
|
pub fn is_complete(&self) -> bool {
|
|
!self.calls.is_empty() && self.calls.iter().all(|tc| !tc.name.is_empty() && !tc.arguments.is_empty())
|
|
}
|
|
|
|
/// Clear all accumulated calls (starting a fresh turn).
|
|
pub fn reset(&mut self) {
|
|
self.calls.clear();
|
|
}
|
|
|
|
/// Build a JSON-serialisable `Vec<Value>` of pending (non-empty-name)
|
|
/// tool calls, suitable for downstream inspection or replay.
|
|
pub fn pending_args(&self) -> Vec<Value> {
|
|
self.calls
|
|
.iter()
|
|
.filter(|tc| !tc.name.is_empty())
|
|
.map(|tc| {
|
|
json!({
|
|
"tool_call_id": tc.id,
|
|
"name": tc.name,
|
|
"arguments": tc.arguments,
|
|
})
|
|
})
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
impl Default for ToolCallAccumulator {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|