diff --git a/Cargo.lock b/Cargo.lock index 319239b83..368230eae 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5337,6 +5337,8 @@ dependencies = [ "futures", "goose-provider-types", "rmcp 3.1.4", + "schemars 1.2.2", + "serde", "serde_json", "tokio", "tokio-util", diff --git a/crates/goose-agent/Cargo.toml b/crates/goose-agent/Cargo.toml index 9df8025f5..4c8582867 100644 --- a/crates/goose-agent/Cargo.toml +++ b/crates/goose-agent/Cargo.toml @@ -17,9 +17,13 @@ tokio = { workspace = true, features = ["rt-multi-thread", "macros", "sync", "ti tokio-util = { workspace = true, features = ["compat"] } async-trait = { workspace = true } goose-provider-types = { version = "0.1.0-alpha.7", path = "../goose-provider-types", default-features = false } -rmcp = { workspace = true } +rmcp = { workspace = true, features = ["server"] } uuid = { workspace = true } serde_json = { workspace = true } futures = { workspace = true } tracing = { workspace = true } tracing-futures = { workspace = true } + +[dev-dependencies] +schemars.workspace = true +serde = { workspace = true, features = ["derive"] } diff --git a/crates/goose-agent/README.md b/crates/goose-agent/README.md index 0a65d743f..02864986e 100644 --- a/crates/goose-agent/README.md +++ b/crates/goose-agent/README.md @@ -18,6 +18,13 @@ is a function of the persisted conversation, not of in-memory loop state. - **`Inference`** — the step that reaches the provider. Before calling it, the machine collects tools and prompt parts from *every* operation in the list into an `InferenceInput`. +- **`ToolOperation`** — adapts caller-defined `rmcp` tools into one operation. + Register `SyncTool` and `AsyncTool` implementations with the typed builder + methods, or implement `ToolProvider` for tools discovered dynamically per + session. Dynamic providers are queried before inference and again before + execution, so their tool names and handlers must remain stable between those + boundaries. Their schemas are sent to inference and matching calls are + dispatched against the current session. - **`StateMachine<'a, S, E>`** — holds `Vec>` and a `CancellationToken`. `step()` runs one pass, `apply()` writes effects back, `run()` loops until a step yields to the client or no step applies. diff --git a/crates/goose-agent/src/lib.rs b/crates/goose-agent/src/lib.rs index b1f818333..8b44d40bd 100644 --- a/crates/goose-agent/src/lib.rs +++ b/crates/goose-agent/src/lib.rs @@ -2,3 +2,4 @@ pub mod events; pub mod inference; pub mod machine; pub mod operation; +pub mod tool; diff --git a/crates/goose-agent/src/machine.rs b/crates/goose-agent/src/machine.rs index b4dfbe0e9..32708a404 100644 --- a/crates/goose-agent/src/machine.rs +++ b/crates/goose-agent/src/machine.rs @@ -1,4 +1,4 @@ -use std::sync::Arc; +use std::{collections::HashSet, sync::Arc}; use anyhow::{anyhow, Result}; use async_trait::async_trait; @@ -50,6 +50,20 @@ pub struct StateMachine<'a, S, E = ConversationEffect> { cancel: CancellationToken, } +fn add_tools_to_inference_input( + input: &mut InferenceInput, + tool_names: &mut HashSet, + tools: Vec, +) -> Result<()> { + for tool in tools { + if !tool_names.insert(tool.name.to_string()) { + anyhow::bail!("multiple operations registered tool '{}'", tool.name); + } + input.tools.push(tool); + } + Ok(()) +} + impl<'a, S, E> StateMachine<'a, S, E> where S: MachineSession, @@ -72,11 +86,18 @@ where let step_fut: OperationFuture<'_, Result>> = match step { Step::Operation(operation) => operation.run(session, conversation, emit), Step::Inference(inference) => { + if !inference.applies(conversation) { + continue; + } let mut input = InferenceInput::default(); + let mut tool_names = HashSet::new(); for operation in self.steps.iter().map(|step| step.operation()) { - input - .tools - .extend(operation.inference_tools(session).await?); + let tools = tokio::select! { + biased; + _ = self.cancel.cancelled() => return Ok(None), + tools = operation.inference_tools(session) => tools?, + }; + add_tools_to_inference_input(&mut input, &mut tool_names, tools)?; input .prompt_parts .extend(operation.prompt_parts(session, conversation).await?); @@ -151,3 +172,33 @@ where runtime.load(session_id).await } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_duplicate_tools_across_operations() { + let schema = Arc::new(serde_json::Map::new()); + let mut input = InferenceInput::default(); + let mut names = HashSet::new(); + + add_tools_to_inference_input( + &mut input, + &mut names, + vec![rmcp::model::Tool::new("duplicate", "first", schema.clone())], + ) + .unwrap(); + let error = add_tools_to_inference_input( + &mut input, + &mut names, + vec![rmcp::model::Tool::new("duplicate", "second", schema)], + ) + .unwrap_err(); + + assert_eq!( + error.to_string(), + "multiple operations registered tool 'duplicate'" + ); + } +} diff --git a/crates/goose-agent/src/tool.rs b/crates/goose-agent/src/tool.rs new file mode 100644 index 000000000..956302310 --- /dev/null +++ b/crates/goose-agent/src/tool.rs @@ -0,0 +1,371 @@ +use std::{collections::HashSet, sync::Arc}; + +use anyhow::Result; +use async_trait::async_trait; +use goose_provider_types::conversation::{ + message::{Message, MessageContent, ToolRequest}, + Conversation, +}; +use rmcp::{ + handler::server::router::tool::{AsyncTool, SyncTool, ToolBase}, + model::{CallToolRequestParams, CallToolResult, ErrorData, JsonObject, Tool}, +}; +use serde_json::{json, Value}; + +use crate::operation::{ + applied, messages_since_kickoff, not_applicable, Emitter, Operation, OperationFuture, + OperationResult, +}; + +fn empty_input_schema() -> Arc { + Arc::new( + serde_json::from_value(json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + })) + .expect("empty tool input schema is an object"), + ) +} + +fn definition() -> Tool { + let mut tool = Tool::new_with_raw( + T::name(), + T::description(), + T::input_schema().unwrap_or_else(empty_input_schema), + ); + if let Some(title) = T::title() { + tool = tool.with_title(title); + } + if let Some(output_schema) = T::output_schema() { + tool = tool.with_raw_output_schema(output_schema); + } + if let Some(annotations) = T::annotations() { + tool = tool.with_annotations(annotations); + } + if let Some(icons) = T::icons() { + tool = tool.with_icons(icons); + } + if let Some(meta) = T::meta() { + tool = tool.with_meta(meta); + } + tool +} + +fn pending_requests(requests: Vec, tool_names: &HashSet<&str>) -> Vec { + requests + .into_iter() + .filter(|request| { + request + .tool_call + .as_ref() + .map_or(true, |call| tool_names.contains(call.name.as_ref())) + }) + .collect() +} + +fn interrupted_result() -> Result { + Ok(CallToolResult::error(vec![ + rmcp::model::ContentBlock::text("Tool call was interrupted before completing"), + ])) +} + +fn parameters(arguments: Option) -> Result { + if T::input_schema().is_none() { + return Ok(T::Parameter::default()); + } + + serde_json::from_value(Value::Object(arguments.unwrap_or_default())).map_err(|error| { + ErrorData::invalid_params(format!("failed to deserialize parameters: {error}"), None) + }) +} + +fn result(output: Result) -> Result { + let output = output.map_err(Into::into)?; + let value = serde_json::to_value(output).map_err(|error| { + ErrorData::internal_error(format!("failed to serialize tool output: {error}"), None) + })?; + Ok(CallToolResult::structured(value)) +} + +/// Supplies tools whose definitions and implementations may vary by session. +/// +/// A provider's tool names and their handlers must remain stable from an inference +/// advertisement until every tool call produced by that inference has been handled. +#[async_trait] +pub trait ToolProvider: Send + Sync { + async fn tools(&self, session: &S) -> Result>; + + async fn call( + &self, + session: &S, + request_id: &str, + call: CallToolRequestParams, + emit: &Emitter, + ) -> Result; +} + +type ToolHandler = dyn for<'a> Fn(&'a S, Option) -> OperationFuture<'a, Result> + + Send + + Sync; + +struct RegisteredTool { + definition: Tool, + handler: Arc>, +} + +struct RegisteredToolProvider { + tools: Vec>, +} + +#[async_trait] +impl ToolProvider for RegisteredToolProvider +where + S: Send + Sync + 'static, +{ + async fn tools(&self, _session: &S) -> Result> { + Ok(self + .tools + .iter() + .map(|tool| tool.definition.clone()) + .collect()) + } + + async fn call( + &self, + session: &S, + _request_id: &str, + call: CallToolRequestParams, + _emit: &Emitter, + ) -> Result { + let tool = self + .tools + .iter() + .find(|tool| tool.definition.name == call.name) + .ok_or_else(|| { + ErrorData::invalid_params(format!("unknown tool {}", call.name), None) + })?; + (tool.handler)(session, call.arguments).await + } +} + +/// An agent operation that advertises and dispatches tools. +/// +/// Tools can be registered from rmcp's typed tool traits, or supplied at runtime +/// by a [`ToolProvider`] whose definitions may vary by session. +pub struct ToolOperation { + registered: RegisteredToolProvider, + providers: Vec>>, +} + +impl ToolOperation +where + S: Send + Sync + 'static, +{ + pub fn new() -> Self { + Self { + registered: RegisteredToolProvider { tools: Vec::new() }, + providers: Vec::new(), + } + } + + fn register(&mut self, tool: RegisteredTool) { + if let Some(existing) = self + .registered + .tools + .iter_mut() + .find(|existing| existing.definition.name == tool.definition.name) + { + *existing = tool; + } else { + self.registered.tools.push(tool); + } + } + + pub fn with_provider(mut self, provider: Arc>) -> Self { + self.providers.push(provider); + self + } + + pub fn with_sync_tool(mut self) -> Self + where + S: Clone, + T: SyncTool + Send + Sync + 'static, + { + self.register(RegisteredTool { + definition: definition::(), + handler: Arc::new(|session, arguments| { + let session = session.clone(); + Box::pin(async move { + let parameters = parameters::(arguments)?; + tokio::task::spawn_blocking(move || { + result::(T::invoke(&session, parameters)) + }) + .await + .map_err(|error| { + ErrorData::internal_error( + format!("synchronous tool task failed: {error}"), + None, + ) + })? + }) + }), + }); + self + } + + pub fn with_async_tool(mut self) -> Self + where + T: AsyncTool + Send + Sync + 'static, + { + self.register(RegisteredTool { + definition: definition::(), + handler: Arc::new(|session, arguments| { + Box::pin(async move { + let parameters = parameters::(arguments)?; + result::(T::invoke(session, parameters).await) + }) + }), + }); + self + } + + async fn available_tools(&self, session: &S) -> Result)>> { + let mut available = self + .registered + .tools(session) + .await? + .into_iter() + .map(|tool| (tool, &self.registered as &dyn ToolProvider)) + .collect::>(); + for provider in &self.providers { + for tool in provider.tools(session).await? { + if available + .iter() + .any(|(available, _)| available.name == tool.name) + { + anyhow::bail!("multiple tool providers registered '{}'", tool.name); + } + available.push((tool, provider.as_ref())); + } + } + Ok(available) + } +} + +impl Default for ToolOperation +where + S: Send + Sync + 'static, +{ + fn default() -> Self { + Self::new() + } +} + +#[async_trait] +impl Operation for ToolOperation +where + S: Send + Sync + 'static, + E: From + Send + 'static, +{ + fn name(&self) -> &'static str { + "tools" + } + + async fn inference_tools(&self, session: &S) -> Result> { + Ok(self + .available_tools(session) + .await? + .into_iter() + .map(|(tool, _)| tool) + .collect()) + } + + async fn run( + &self, + session: &S, + conversation: &Conversation, + emit: &Emitter, + ) -> Result> { + let turn = messages_since_kickoff(conversation)?; + let answered: HashSet<&str> = turn + .iter() + .flat_map(Message::get_tool_response_ids) + .collect(); + let pending = turn + .iter() + .flat_map(|message| message.content.iter()) + .filter_map(MessageContent::as_tool_request) + .filter(|request| { + !request.was_executed_externally() && !answered.contains(request.id.as_str()) + }) + .cloned() + .collect::>(); + if pending.is_empty() { + return not_applicable(); + } + + let available = tokio::select! { + biased; + _ = emit.cancelled() => { + let mut message = Message::user(); + for request in pending { + message.add_tool_response_with_metadata( + request.id, + interrupted_result(), + request.metadata.as_ref(), + ); + } + let message = emit.message(message).await; + return applied([E::from(message)]); + }, + available = self.available_tools(session) => available?, + }; + let available_names = available + .iter() + .map(|(tool, _)| tool.name.as_ref()) + .collect(); + let pending = pending_requests(pending, &available_names); + if pending.is_empty() { + return not_applicable(); + } + + let mut message = Message::user(); + let mut cancelled = false; + for request in pending { + let provider = match request.tool_call.as_ref() { + Ok(call) => available + .iter() + .find(|(tool, _)| tool.name == call.name) + .map(|(_, provider)| *provider) + .expect("pending requests were filtered by available tools"), + Err(_) => &self.registered as &dyn ToolProvider, + }; + let tool_result = if cancelled || emit.cancel_token().is_cancelled() { + cancelled = true; + interrupted_result() + } else { + match request.tool_call.as_ref() { + Err(error) => Err(error.clone()), + Ok(call) => { + tokio::select! { + biased; + _ = emit.cancelled() => { + cancelled = true; + interrupted_result() + }, + result = provider.call(session, &request.id, call.clone(), emit) => result, + } + } + } + }; + message.add_tool_response_with_metadata( + request.id, + tool_result, + request.metadata.as_ref(), + ); + } + let message = emit.message(message).await; + applied([E::from(message)]) + } +} diff --git a/crates/goose-agent/tests/tool_operation.rs b/crates/goose-agent/tests/tool_operation.rs new file mode 100644 index 000000000..bdff2ad7e --- /dev/null +++ b/crates/goose-agent/tests/tool_operation.rs @@ -0,0 +1,692 @@ +use std::{ + borrow::Cow, + sync::{ + atomic::{AtomicBool, AtomicUsize, Ordering}, + Arc, + }, +}; + +use anyhow::Result; +use async_trait::async_trait; +use goose_agent::{ + machine::{MachineSession, StateMachine, Step}, + operation::{ + ConversationEffect, Emitter, Inference, InferenceInput, Operation, OperationResult, + }, + tool::{ToolOperation, ToolProvider}, +}; +use goose_provider_types::conversation::{ + message::{Message, MessageContent}, + Conversation, +}; +use rmcp::{ + handler::server::router::tool::{AsyncTool, SyncTool, ToolBase}, + model::{CallToolRequestParams, CallToolResult, ErrorData, Tool}, +}; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use serde_json::json; +use tokio::sync::mpsc; +use tokio_util::sync::CancellationToken; + +#[derive(Default, Deserialize, JsonSchema)] +struct AddInput { + left: u64, + right: u64, +} + +#[derive(Serialize, JsonSchema)] +struct AddOutput { + sum: u64, +} + +struct Add; + +impl ToolBase for Add { + type Parameter = AddInput; + type Output = AddOutput; + type Error = ErrorData; + + fn name() -> Cow<'static, str> { + "add".into() + } + + fn description() -> Option> { + Some("Add two integers".into()) + } +} + +impl SyncTool<()> for Add { + fn invoke(_session: &(), input: AddInput) -> Result { + Ok(AddOutput { + sum: input.left + input.right, + }) + } +} + +#[derive(Default, Deserialize, JsonSchema)] +struct GreetInput { + name: String, +} + +#[derive(Serialize, JsonSchema)] +struct GreetOutput { + greeting: String, +} + +struct Greet; + +impl ToolBase for Greet { + type Parameter = GreetInput; + type Output = GreetOutput; + type Error = ErrorData; + + fn name() -> Cow<'static, str> { + "greet".into() + } +} + +impl AsyncTool<()> for Greet { + async fn invoke(_session: &(), input: GreetInput) -> Result { + Ok(GreetOutput { + greeting: format!("Hello, {}!", input.name), + }) + } +} + +fn emitter() -> Emitter { + emitter_with_token(CancellationToken::new()) +} + +fn emitter_with_token(cancel: CancellationToken) -> Emitter { + let (tx, _rx) = mpsc::channel(1); + Emitter::new(tx, cancel) +} + +fn operation() -> ToolOperation<()> { + ToolOperation::new() + .with_sync_tool::() + .with_async_tool::() +} + +fn appended_message(result: OperationResult) -> Message { + let OperationResult::Applied(result) = result else { + panic!("operation should apply"); + }; + let ConversationEffect::AppendMessage(message) = result.effects.into_iter().next().unwrap() + else { + panic!("operation should append a message"); + }; + message +} + +#[tokio::test] +async fn advertises_user_defined_tools_directly() { + let tools = as Operation<(), ConversationEffect>>::inference_tools( + &operation(), + &(), + ) + .await + .unwrap(); + + assert_eq!(tools.len(), 2); + assert_eq!(tools[0].name, "add"); + assert_eq!(tools[0].description.as_deref(), Some("Add two integers")); + assert!(tools[0].input_schema["properties"]["left"].is_object()); + assert_eq!(tools[1].name, "greet"); +} + +#[tokio::test] +async fn dispatches_calls_to_user_defined_tools() { + let conversation = Conversation::new_unvalidated([ + Message::user().with_text("do both"), + Message::assistant() + .with_tool_request( + "call-1", + Ok(CallToolRequestParams::new("add").with_arguments( + serde_json::from_value(json!({"left": 2, "right": 3})).unwrap(), + )), + ) + .with_tool_request( + "call-2", + Ok(CallToolRequestParams::new("greet") + .with_arguments(serde_json::from_value(json!({"name": "Goose"})).unwrap())), + ), + ]); + + let message = appended_message( + as Operation<(), ConversationEffect>>::run( + &operation(), + &(), + &conversation, + &emitter(), + ) + .await + .unwrap(), + ); + let responses = message + .content + .iter() + .map(|content| match content { + MessageContent::ToolResponse(response) => response, + _ => panic!("expected tool responses"), + }) + .collect::>(); + assert_eq!(responses[0].id, "call-1"); + assert_eq!( + responses[0] + .tool_result + .as_ref() + .unwrap() + .structured_content, + Some(json!({"sum": 5})) + ); + assert_eq!(responses[1].id, "call-2"); + assert_eq!( + responses[1] + .tool_result + .as_ref() + .unwrap() + .structured_content, + Some(json!({"greeting": "Hello, Goose!"})) + ); +} + +struct DynamicTools { + discoveries: Arc, +} + +#[async_trait] +impl ToolProvider for DynamicTools { + async fn tools(&self, enabled: &bool) -> Result> { + self.discoveries.fetch_add(1, Ordering::SeqCst); + Ok(if *enabled { + vec![Tool::new( + "dynamic", + "A session-dependent tool", + Arc::new(serde_json::from_value(json!({"type": "object"}))?), + )] + } else { + Vec::new() + }) + } + + async fn call( + &self, + _session: &bool, + request_id: &str, + call: CallToolRequestParams, + _emit: &Emitter, + ) -> Result { + Ok(CallToolResult::structured(json!({ + "request_id": request_id, + "name": call.name + }))) + } +} + +#[tokio::test] +async fn rediscovers_dynamic_tools_for_inference_and_execution() { + let discoveries = Arc::new(AtomicUsize::new(0)); + let operation = ToolOperation::new().with_provider(Arc::new(DynamicTools { + discoveries: discoveries.clone(), + })); + let tools = as Operation>::inference_tools( + &operation, &true, + ) + .await + .unwrap(); + assert_eq!(tools[0].name, "dynamic"); + + let conversation = Conversation::new_unvalidated([ + Message::user().with_text("call the dynamic tool"), + Message::assistant() + .with_tool_request("dynamic-call", Ok(CallToolRequestParams::new("dynamic"))), + ]); + let message = appended_message( + as Operation>::run( + &operation, + &true, + &conversation, + &emitter(), + ) + .await + .unwrap(), + ); + + assert_eq!(discoveries.load(Ordering::SeqCst), 2); + assert_eq!( + message.content[0] + .as_tool_response() + .unwrap() + .tool_result + .as_ref() + .unwrap() + .structured_content, + Some(json!({"request_id": "dynamic-call", "name": "dynamic"})) + ); +} + +#[tokio::test] +async fn dynamic_tools_vary_by_session() { + let operation = ToolOperation::new().with_provider(Arc::new(DynamicTools { + discoveries: Arc::new(AtomicUsize::new(0)), + })); + let enabled = as Operation>::inference_tools( + &operation, &true, + ) + .await + .unwrap(); + let disabled = as Operation>::inference_tools( + &operation, &false, + ) + .await + .unwrap(); + + assert_eq!(enabled[0].name, "dynamic"); + assert!(disabled.is_empty()); +} + +#[tokio::test] +async fn rejects_duplicate_dynamic_tool_names_at_both_boundaries() { + let operation = ToolOperation::new() + .with_provider(Arc::new(DynamicTools { + discoveries: Arc::new(AtomicUsize::new(0)), + })) + .with_provider(Arc::new(DynamicTools { + discoveries: Arc::new(AtomicUsize::new(0)), + })); + let kickoff = Message::user().with_text("use tools"); + + let inference_error = + as Operation>::inference_tools( + &operation, &true, + ) + .await + .unwrap_err(); + assert_eq!( + inference_error.to_string(), + "multiple tool providers registered 'dynamic'" + ); + + let conversation = Conversation::new_unvalidated([ + kickoff, + Message::assistant() + .with_tool_request("dynamic-call", Ok(CallToolRequestParams::new("dynamic"))), + ]); + let execution_error = match as Operation>::run( + &operation, + &true, + &conversation, + &emitter(), + ) + .await + { + Ok(_) => panic!("duplicate tools should fail during execution discovery"), + Err(error) => error, + }; + assert_eq!( + execution_error.to_string(), + "multiple tool providers registered 'dynamic'" + ); +} + +#[tokio::test] +async fn ignores_requests_outside_the_current_turn() { + let conversation = Conversation::new_unvalidated([ + Message::user().with_text("old turn"), + Message::assistant().with_tool_request( + "stale-call", + Ok(CallToolRequestParams::new("add") + .with_arguments(serde_json::from_value(json!({"left": 2, "right": 3})).unwrap())), + ), + Message::user().with_text("new turn"), + ]); + + let result = as Operation<(), ConversationEffect>>::run( + &operation(), + &(), + &conversation, + &emitter(), + ) + .await + .unwrap(); + + assert!(matches!(result, OperationResult::NotApplicable)); +} + +#[tokio::test] +async fn responds_to_unparseable_tool_requests() { + let conversation = Conversation::new_unvalidated([ + Message::user().with_text("call a tool"), + Message::assistant().with_tool_request( + "invalid-call", + Err(ErrorData::invalid_params("malformed arguments", None)), + ), + ]); + + let message = appended_message( + as Operation<(), ConversationEffect>>::run( + &operation(), + &(), + &conversation, + &emitter(), + ) + .await + .unwrap(), + ); + let response = message.content[0].as_tool_response().unwrap(); + assert_eq!(response.id, "invalid-call"); + assert_eq!( + response.tool_result.as_ref().unwrap_err().message, + "malformed arguments" + ); +} + +#[derive(Default, Clone)] +struct BlockingSession { + started: Arc, +} + +struct BlockingSyncTool; + +impl ToolBase for BlockingSyncTool { + type Parameter = (); + type Output = (); + type Error = ErrorData; + + fn name() -> Cow<'static, str> { + "blocking_sync".into() + } + + fn input_schema() -> Option>> { + None + } +} + +impl SyncTool for BlockingSyncTool { + fn invoke(session: &BlockingSession, _input: ()) -> Result<(), ErrorData> { + session.started.store(true, Ordering::SeqCst); + std::thread::sleep(std::time::Duration::from_millis(100)); + Ok(()) + } +} + +#[tokio::test] +async fn cancellation_interrupts_blocking_sync_tools() { + let session = BlockingSession::default(); + let started = session.started.clone(); + let operation = ToolOperation::new().with_sync_tool::(); + let conversation = Conversation::new_unvalidated([ + Message::user().with_text("call it"), + Message::assistant() + .with_tool_request("call-1", Ok(CallToolRequestParams::new("blocking_sync"))), + ]); + let cancel = CancellationToken::new(); + let run_cancel = cancel.clone(); + let run = tokio::spawn(async move { + as Operation>::run( + &operation, + &session, + &conversation, + &emitter_with_token(run_cancel), + ) + .await + }); + while !started.load(Ordering::SeqCst) { + tokio::task::yield_now().await; + } + cancel.cancel(); + let result = tokio::time::timeout(std::time::Duration::from_millis(50), run) + .await + .expect("operation should not wait for the blocking tool") + .unwrap() + .unwrap(); + + let message = appended_message(result); + assert!(message.content[0] + .as_tool_response() + .unwrap() + .tool_result + .as_ref() + .unwrap() + .is_error + .is_some_and(|is_error| is_error)); +} + +struct BlockingDiscovery { + started: Arc, +} + +#[async_trait] +impl ToolProvider for BlockingDiscovery { + async fn tools(&self, _session: &S) -> Result> { + self.started.store(true, Ordering::SeqCst); + std::future::pending().await + } + + async fn call( + &self, + _session: &S, + _request_id: &str, + _call: CallToolRequestParams, + _emit: &Emitter, + ) -> Result { + unreachable!() + } +} + +struct TestSession { + conversation: Conversation, +} + +impl MachineSession for TestSession { + fn id(&self) -> &str { + "test" + } + + fn conversation(&self) -> Option<&Conversation> { + Some(&self.conversation) + } +} + +struct TestInference; + +#[async_trait] +impl Operation for TestInference { + fn name(&self) -> &'static str { + "inference" + } +} + +#[async_trait] +impl Inference for TestInference { + fn applies(&self, _conversation: &Conversation) -> bool { + true + } + + async fn infer( + &self, + _session: &TestSession, + _conversation: &Conversation, + _input: InferenceInput, + _emit: &Emitter, + ) -> Result> { + unreachable!() + } +} + +#[tokio::test] +async fn cancellation_interrupts_inference_discovery() { + let started = Arc::new(AtomicBool::new(false)); + let operation = ToolOperation::new().with_provider(Arc::new(BlockingDiscovery { + started: started.clone(), + })); + let cancel = CancellationToken::new(); + let machine = StateMachine::new( + vec![ + Step::Operation(Arc::new(operation)), + Step::Inference(Arc::new(TestInference)), + ], + cancel.clone(), + ); + let session = TestSession { + conversation: Conversation::new_unvalidated([Message::user().with_text("use tools")]), + }; + let emit = emitter_with_token(cancel.clone()); + + let step = tokio::spawn(async move { machine.step(&session, &emit).await }); + while !started.load(Ordering::SeqCst) { + tokio::task::yield_now().await; + } + cancel.cancel(); + + assert!(step.await.unwrap().unwrap().is_none()); +} + +#[tokio::test] +async fn cancellation_interrupts_execution_discovery() { + let started = Arc::new(AtomicBool::new(false)); + let operation = ToolOperation::new().with_provider(Arc::new(BlockingDiscovery { + started: started.clone(), + })); + let conversation = Conversation::new_unvalidated([ + Message::user().with_text("call it"), + Message::assistant() + .with_tool_request("call-1", Ok(CallToolRequestParams::new("blocking"))), + ]); + let cancel = CancellationToken::new(); + let run_cancel = cancel.clone(); + let run = tokio::spawn(async move { + as Operation<(), ConversationEffect>>::run( + &operation, + &(), + &conversation, + &emitter_with_token(run_cancel), + ) + .await + }); + while !started.load(Ordering::SeqCst) { + tokio::task::yield_now().await; + } + cancel.cancel(); + let message = appended_message(run.await.unwrap().unwrap()); + + let response = message.content[0].as_tool_response().unwrap(); + assert_eq!(response.id, "call-1"); + assert!(response + .tool_result + .as_ref() + .unwrap() + .is_error + .is_some_and(|is_error| is_error)); +} + +struct BlockingTools { + calls: Arc, +} + +#[async_trait] +impl ToolProvider<()> for BlockingTools { + async fn tools(&self, _session: &()) -> Result> { + Ok(vec![Tool::new( + "blocking", + "A tool that never finishes", + Arc::new(serde_json::from_value(json!({"type": "object"}))?), + )]) + } + + async fn call( + &self, + _session: &(), + _request_id: &str, + _call: CallToolRequestParams, + _emit: &Emitter, + ) -> Result { + self.calls.fetch_add(1, Ordering::SeqCst); + std::future::pending().await + } +} + +#[tokio::test] +async fn cancellation_interrupts_current_and_remaining_calls() { + let calls = Arc::new(AtomicUsize::new(0)); + let operation = ToolOperation::new().with_provider(Arc::new(BlockingTools { + calls: calls.clone(), + })); + let conversation = Conversation::new_unvalidated([ + Message::user().with_text("call twice"), + Message::assistant() + .with_tool_request("call-1", Ok(CallToolRequestParams::new("blocking"))) + .with_tool_request("call-2", Ok(CallToolRequestParams::new("blocking"))), + ]); + let cancel = CancellationToken::new(); + let run_cancel = cancel.clone(); + let run = tokio::spawn(async move { + as Operation<(), ConversationEffect>>::run( + &operation, + &(), + &conversation, + &emitter_with_token(run_cancel), + ) + .await + }); + while calls.load(Ordering::SeqCst) == 0 { + tokio::task::yield_now().await; + } + cancel.cancel(); + let message = appended_message(run.await.unwrap().unwrap()); + + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert_eq!( + message.get_tool_response_ids(), + ["call-1", "call-2"].into_iter().collect() + ); + for content in &message.content { + let result = content + .as_tool_response() + .unwrap() + .tool_result + .as_ref() + .unwrap(); + assert!(result.is_error.is_some_and(|is_error| is_error)); + assert_eq!( + result.content[0].as_text().unwrap().text, + "Tool call was interrupted before completing" + ); + } +} + +#[tokio::test] +async fn ignores_unavailable_answered_and_externally_dispatched_requests() { + let conversation = Conversation::new_unvalidated([ + Message::user().with_text("call tools"), + Message::assistant() + .with_tool_request("answered", Ok(CallToolRequestParams::new("add"))) + .with_tool_request( + "unavailable", + Ok(CallToolRequestParams::new("not_registered")), + ) + .with_tool_request_with_metadata( + "external", + Ok(CallToolRequestParams::new("add")), + None, + Some(json!({"goose.external_dispatch": true})), + ), + Message::user().with_tool_response( + "answered", + Ok(CallToolResult::structured(json!({"sum": 5}))), + ), + ]); + + let result = as Operation<(), ConversationEffect>>::run( + &operation(), + &(), + &conversation, + &emitter(), + ) + .await + .unwrap(); + + assert!(matches!(result, OperationResult::NotApplicable)); +} diff --git a/crates/goose/src/agents/reply_parts.rs b/crates/goose/src/agents/reply_parts.rs index e9945458b..8be7befc1 100644 --- a/crates/goose/src/agents/reply_parts.rs +++ b/crates/goose/src/agents/reply_parts.rs @@ -1,7 +1,7 @@ use anyhow::Result; use goose_providers::errors::ProviderError; use regex::Regex; -use std::sync::Arc; +use std::{collections::HashSet, sync::Arc}; use async_stream::try_stream; use futures::stream::StreamExt; @@ -183,6 +183,16 @@ fn is_mergeable_assistant_chunk(message: &Message) -> bool { }) } +fn ensure_unique_tool_names(tools: &[Tool]) -> Result<()> { + let mut names = HashSet::new(); + for tool in tools { + if !names.insert(tool.name.as_ref()) { + anyhow::bail!("multiple tools registered '{}'", tool.name); + } + } + Ok(()) +} + impl Agent { pub async fn prepare_tools_and_prompt( &self, @@ -190,6 +200,7 @@ impl Agent { working_dir: &std::path::Path, ) -> Result<(Vec, Vec, String, ModelConfig)> { let tools = self.list_tools(session_id, None).await; + ensure_unique_tool_names(&tools)?; #[cfg(feature = "code-mode")] let code_execution_active = self @@ -2109,3 +2120,20 @@ mod tests { assert!(result.is_ok()); } } + +#[cfg(test)] +mod duplicate_tool_tests { + use super::*; + + #[test] + fn rejects_duplicate_tool_names_for_legacy_inference() { + let schema = Arc::new(serde_json::Map::new()); + let tools = vec![ + Tool::new("duplicate", "first", schema.clone()), + Tool::new("duplicate", "second", schema), + ]; + + let error = ensure_unique_tool_names(&tools).unwrap_err(); + assert_eq!(error.to_string(), "multiple tools registered 'duplicate'"); + } +}