From f61d8eba4d1c8c1878b9cf62479385901a3cc300 Mon Sep 17 00:00:00 2001 From: lb <542828+lukebuehler@users.noreply.github.com> Date: Thu, 19 Nov 2026 20:20:15 +0100 Subject: [PATCH 1/4] mcp error fix --- crates/llm-runtime/src/anthropic_messages.rs | 116 ++++++----- crates/llm-runtime/src/mcp.rs | 182 +++++++++++++++++- crates/llm-runtime/src/openai_completions.rs | 107 ++++++++++- crates/llm-runtime/src/openai_responses.rs | 82 ++++---- crates/llm-runtime/src/secrets.rs | 14 ++ crates/temporal-runtime/src/worker/mcp.rs | 190 +++++++++++++++---- 6 files changed, 570 insertions(+), 121 deletions(-) diff --git a/crates/llm-runtime/src/anthropic_messages.rs b/crates/llm-runtime/src/anthropic_messages.rs index d5b27f87a..9f0a79297 100644 --- a/crates/llm-runtime/src/anthropic_messages.rs +++ b/crates/llm-runtime/src/anthropic_messages.rs @@ -225,25 +225,33 @@ impl LlmGenerationAdapter for AnthropicMessagesLlmAdapter { }); } + let mcp = crate::mcp::RequestMcp::new(self.inventory.as_ref(), Some(self.secrets.as_ref())); let mut catalog = crate::tool_catalog::ToolCatalog::resolve_for_request( self.blobs.as_ref(), &request.request, ) .await?; - let provider_request = materialize_request_with_catalog( + let mut provider_request = materialize_request_with_catalog( self.blobs.as_ref(), - self.inventory.as_ref(), + &mcp, &request.request, &mut catalog, self.thinking_prefix_mismatch, ) .await?; - let (mut send_request, mut redacted_request) = inject_remote_mcp_auth( - self.secrets.as_ref(), - &request.request.tools, - provider_request, - ) - .await?; + let notice = mcp + .notice(self.blobs.as_ref(), &request.request.context) + .await?; + if let Some((text, _)) = ¬ice { + push_block( + &mut provider_request.messages, + am::MessageRole::User, + am::ContentBlockParam::text(text), + )?; + } + + let (mut send_request, mut redacted_request) = + inject_remote_mcp_auth(&mcp, &request.request.tools, provider_request)?; let provider = resolve_model_provider(self.provider_keys.as_ref(), &request.request.model).await?; let mut request_dumps = Vec::new(); @@ -306,6 +314,9 @@ impl LlmGenerationAdapter for AnthropicMessagesLlmAdapter { fail_on_invalid_response(parsed, self.blobs.as_ref(), &request, response_id, usage) .await?; catalog.normalize(&mut result); + if let Some((_, entry)) = notice { + result.context_entries.insert(0, entry); + } let request_dump = match request_dumps.len() { 0 => None, 1 => request_dumps.pop(), @@ -395,15 +406,16 @@ impl LlmCompactionAdapter for AnthropicMessagesLlmAdapter { ), }); } - let provider_request = self.materialize_compact_request(&request.request).await?; + let mcp = crate::mcp::RequestMcp::new(self.inventory.as_ref(), Some(self.secrets.as_ref())); + let provider_request = materialize_compact_request_with_binding( + self.blobs.as_ref(), + &mcp, + &request.request, + self.thinking_prefix_mismatch, + ) + .await?; let provider_request = if supports_native_compaction(&request.request.model.model) { - inject_remote_mcp_auth( - self.secrets.as_ref(), - &request.request.tools, - provider_request, - ) - .await? - .0 + inject_remote_mcp_auth(&mcp, &request.request.tools, provider_request)?.0 } else { provider_request }; @@ -1280,8 +1292,8 @@ fn anthropic_tool_search_model_support(model: &str) -> Option { /// `authorization_token` resolved at the last moment, and the redacted request /// that is persisted to blobs, preserving only the fact that auth was /// configured. -async fn inject_remote_mcp_auth( - secrets: &dyn SecretResolver, +fn inject_remote_mcp_auth( + mcp: &crate::mcp::RequestMcp, tools: &[ToolSpec], materialized: am::CreateMessageRequest, ) -> LlmAdapterResult<(am::CreateMessageRequest, am::CreateMessageRequest)> { @@ -1309,12 +1321,7 @@ async fn inject_remote_mcp_auth( else { continue; }; - let token = crate::secrets::resolve_mcp_bearer(secrets, &remote_mcp.server_id, &server_url) - .await - .map_err(|error| LlmAdapterError::SecretResolution { - tool: tool.id.to_string(), - message: error.to_string(), - })?; + let token = mcp.token(remote_mcp.server_id.clone(), server_url)?; let Some(token) = token else { continue; }; @@ -3563,37 +3570,48 @@ mod tests { } #[tokio::test(flavor = "current_thread")] - async fn generate_does_not_treat_a_missing_credential_resource_as_absent() { - let blobs = Arc::new(InMemoryBlobStore::new()); - let api = fake_api(completed_text_response_json()); - let adapter = AnthropicMessagesLlmAdapter::new(api.clone(), blobs) - .with_secret_resolver(Arc::new(crate::secrets::StaticSecretResolver::new())) - .with_mcp_inventory_resolver(Arc::new(StaticMcpInventory)); - - let error = LlmGenerationAdapter::generate(&adapter, mcp_auth_generation_request()) - .await - .expect_err("missing optional MCP server must not silently downgrade"); - - assert!(matches!(error, LlmAdapterError::SecretResolution { .. })); - assert!(api.seen.lock().expect("lock").is_empty()); - } - - #[tokio::test(flavor = "current_thread")] - async fn generate_fails_before_provider_io_when_the_credential_cannot_be_resolved() { + async fn a_broken_credential_omits_only_its_server_and_reports_the_cause() { let blobs = Arc::new(InMemoryBlobStore::new()); let api = fake_api(completed_text_response_json()); let adapter = AnthropicMessagesLlmAdapter::new(api.clone(), blobs.clone()) + .with_secret_resolver(Arc::new(crate::StaticSecretResolver::new().with_secret( + crate::SECRET_NAMESPACE_MCP_SERVER, + "healthy", + "healthy-token", + ))) .with_mcp_inventory_resolver(Arc::new(StaticMcpInventory)); - - let error = LlmGenerationAdapter::generate(&adapter, mcp_auth_generation_request()) - .await - .expect_err("an unresolvable credential must fail generation"); - - assert!(matches!(error, LlmAdapterError::SecretResolution { .. })); + let mut request = mcp_auth_generation_request(); + let mut other = request.request.tools[0].clone(); + other.id = ToolId::try_new("mcp_healthy").unwrap(); + let ToolKind::RemoteMcp(spec) = &mut other.kind else { + unreachable!() + }; + spec.server_label = "healthy".into(); + spec.server_id = "healthy".into(); + request.request.tools.push(other); + let execution = adapter.generate(request).await.unwrap(); + let wire = serde_json::to_value(&api.seen.lock().unwrap()[0]).unwrap(); + assert_eq!(wire["mcp_servers"].as_array().unwrap().len(), 1); + assert_eq!(wire["mcp_servers"][0]["name"], "healthy"); + assert_eq!( + wire["mcp_servers"][0]["authorization_token"], + "healthy-token" + ); assert!( - api.seen.lock().expect("lock").is_empty(), - "no provider call may happen when auth resolution fails" + !wire["tools"] + .to_string() + .contains(r#""mcp_server_name":"echo""#) ); + let entry = &execution.result.context_entries[0]; + assert!( + matches!(&entry.kind, ContextEntryKind::Catalog {title} if title == "Unavailable MCP servers") + ); + let body = crate::blob_io::read_text(blobs.as_ref(), &entry.content.content_ref) + .await + .unwrap(); + assert!(body.contains("credential was not found")); + assert!(wire.to_string().contains("credential was not found")); + assert!(!body.contains("healthy-token")); } fn generation_request() -> LlmGenerationRequest { diff --git a/crates/llm-runtime/src/mcp.rs b/crates/llm-runtime/src/mcp.rs index ab1026d86..5691723b9 100644 --- a/crates/llm-runtime/src/mcp.rs +++ b/crates/llm-runtime/src/mcp.rs @@ -1,3 +1,5 @@ +use std::{collections::BTreeMap, sync::Mutex}; + use async_trait::async_trait; use harness::{RemoteMcpToolSpec, ToolName}; use serde_json::Value; @@ -52,11 +54,189 @@ pub trait McpInventoryResolver: Send + Sync { spec: &RemoteMcpToolSpec, ) -> Result, McpInventoryError>; + /// The last usable tools and any failure observed refreshing them. + async fn list_tools_with_status( + &self, + spec: &RemoteMcpToolSpec, + ) -> Result { + Ok(McpListing { + tools: self.list_tools(spec).await?, + warning: None, + }) + } + /// The URL a provider should connect to, or `None` when the server's record /// is gone, switched off or no longer provider-hosted. async fn server_url(&self, server_id: &str) -> Result, McpInventoryError>; } +#[derive(Clone, Default)] +pub struct McpListing { + pub tools: Vec, + /// A local, credential-safe description suitable for model and session context. + pub warning: Option<&'static str>, +} + +impl McpListing { + pub fn notice(&self) -> Option { + self.warning.map(|reason| { + if self.tools.is_empty() { + reason.to_owned() + } else { + format!("{reason}; using the last known tool list") + } + }) + } +} + +/// Observe failures at the actual point of use. Provider URLs are admitted only +/// after their credential is resolved; the value stays bound to that URL for this request. +pub(crate) struct RequestMcp<'a> { + inventory: &'a dyn McpInventoryResolver, + secrets: Option<&'a dyn crate::SecretResolver>, + tokens: Mutex>>, + warnings: Mutex>, +} + +impl<'a> RequestMcp<'a> { + pub fn new( + inventory: &'a dyn McpInventoryResolver, + secrets: Option<&'a dyn crate::SecretResolver>, + ) -> Self { + Self { + inventory, + secrets, + tokens: Mutex::default(), + warnings: Mutex::default(), + } + } + + pub fn token( + &self, + id: String, + url: String, + ) -> LlmAdapterResult> { + self.tokens + .lock() + .unwrap() + .get(&(id, url)) + .cloned() + .ok_or_else(|| LlmAdapterError::InvalidProviderRequest { + message: "MCP server URL differs from the authorized endpoint".into(), + }) + } + + pub async fn notice( + &self, + blobs: &dyn harness::storage::BlobStore, + context: &harness::ContextSnapshot, + ) -> LlmAdapterResult> { + let lines: Vec<_> = self + .warnings + .lock() + .unwrap() + .iter() + .map(|(id, why)| format!("- {id}: {why}")) + .collect(); + // Compare only notices emitted with a generation result. A catalog supplied + // by session preparation has its own lifetime and remains visible independently. + const ORIGIN: &str = "mcp_request"; + let previous = context.entries.iter().rev().find(|entry| { + entry.origin.as_deref() == Some(ORIGIN) + && matches!( + entry.source, + harness::ContextEntrySource::AssistantOutput { .. } + ) + && matches!(entry.kind, harness::ContextEntryKind::Catalog { .. }) + }); + let title = if lines.is_empty() { + "MCP availability updated" + } else { + "Unavailable MCP servers" + }; + let body = if lines.is_empty() { + if previous.is_none() { + return Ok(None); + } + "The current toolset has no credential or tool-list failures.".to_owned() + } else { + format!( + "Current credential and tool-list failures:\n{}", + lines.join("\n") + ) + }; + if previous.is_some_and(|entry| { + entry.content.content_ref == harness::BlobRef::from_bytes(body.as_bytes()) + }) { + return Ok(None); + } + let entry = harness::ContextEntryInput { + kind: harness::ContextEntryKind::Catalog { + title: title.into(), + }, + content: harness::ContentRef::text(crate::blob_io::put_text(blobs, &body).await?), + preview: Some(title.to_owned()), + origin: Some(ORIGIN.into()), + provenance_ref: None, + token_estimate: None, + }; + Ok(Some((format!("{title}:\n\n{body}"), entry))) + } +} + +#[async_trait] +impl McpInventoryResolver for RequestMcp<'_> { + async fn server_url(&self, id: &str) -> Result, McpInventoryError> { + let Some(url) = self.inventory.server_url(id).await? else { + self.warnings + .lock() + .unwrap() + .insert(id.into(), "server is no longer available".into()); + return Ok(None); + }; + let secrets = self.secrets.ok_or_else(|| { + McpInventoryError::new("provider-hosted MCP is unsupported by this adapter") + })?; + match crate::secrets::resolve_mcp_bearer(secrets, id, &url).await { + Ok(token) => { + self.tokens + .lock() + .unwrap() + .insert((id.to_owned(), url.clone()), token); + } + Err(error) => { + self.warnings + .lock() + .unwrap() + .insert(id.into(), error.mcp_notice().into()); + return Ok(None); + } + } + Ok(Some(url)) + } + + async fn list_tools( + &self, + spec: &RemoteMcpToolSpec, + ) -> Result, McpInventoryError> { + let listing = self + .inventory + .list_tools_with_status(spec) + .await + .unwrap_or_else(|_| McpListing { + tools: Vec::new(), + warning: Some("tools/list failed"), + }); + if let Some(reason) = listing.notice() { + self.warnings + .lock() + .unwrap() + .insert(spec.server_id.clone(), reason); + } + Ok(listing.tools) + } +} + /// The URL for a provider-hosted server in this request. A server with no usable /// record is left out, so the turn runs without its tools. pub(crate) async fn provider_hosted_server_url( @@ -74,7 +254,7 @@ pub(crate) async fn provider_hosted_server_url( if server_url.is_none() { tracing::warn!( server_id = %spec.server_id, - "left out a provider-hosted MCP server with no usable record" + "left out an unavailable provider-hosted MCP server" ); } Ok(server_url) diff --git a/crates/llm-runtime/src/openai_completions.rs b/crates/llm-runtime/src/openai_completions.rs index 8fdb0c28f..9e72982ab 100644 --- a/crates/llm-runtime/src/openai_completions.rs +++ b/crates/llm-runtime/src/openai_completions.rs @@ -191,6 +191,7 @@ impl LlmGenerationAdapter for OpenAiCompletionsLlmAdapter { ), }); } + let mcp = crate::mcp::RequestMcp::new(self.inventory.as_ref(), None); let mut catalog = crate::tool_catalog::ToolCatalog::resolve_for_request( self.blobs.as_ref(), &request.request, @@ -198,11 +199,20 @@ impl LlmGenerationAdapter for OpenAiCompletionsLlmAdapter { .await?; let mut provider_request = materialize_request_with_catalog( self.blobs.as_ref(), - self.inventory.as_ref(), + &mcp, &request.request, &mut catalog, ) .await?; + let notice = mcp + .notice(self.blobs.as_ref(), &request.request.context) + .await?; + if let Some((text, _)) = ¬ice { + provider_request + .messages + .push(text_message("user", text.clone())); + } + // Route every turn of a session to the same prompt cache. provider_request.prompt_cache_key = Some(crate::prompt_cache::prompt_cache_key(&request.session_id)); @@ -240,6 +250,9 @@ impl LlmGenerationAdapter for OpenAiCompletionsLlmAdapter { ) .await?; catalog.normalize(&mut result); + if let Some((_, entry)) = notice { + result.context_entries.insert(0, entry); + } let debug_dumps = store_debug_dumps( self.blobs.as_ref(), request_dump, @@ -1515,6 +1528,22 @@ mod tests { }]) } + async fn list_tools_with_status( + &self, + spec: &harness::RemoteMcpToolSpec, + ) -> Result { + if spec.server_id == "offline" { + return Ok(crate::mcp::McpListing { + tools: vec![], + warning: Some("tools/list failed: HTTP 401 (unauthorized)"), + }); + } + Ok(crate::mcp::McpListing { + tools: self.list_tools(spec).await?, + warning: None, + }) + } + async fn server_url(&self, _: &str) -> Result, crate::McpInventoryError> { Ok(None) } @@ -1743,6 +1772,82 @@ mod tests { } } + #[tokio::test(flavor = "current_thread")] + async fn runtime_listing_failure_is_visible_once_and_recovery_updates_the_session() { + let blobs = Arc::new(InMemoryBlobStore::new()); + let adapter = OpenAiCompletionsLlmAdapter::new(fake_api(), blobs.clone()) + .with_mcp_inventory_resolver(Arc::new(StaticMcpInventory)) + .with_debug_dumps(true); + let mut generation = generation_request(request(Vec::new())); + for id in ["offline", "healthy"] { + generation.request.tools.push(ToolSpec { + id: ToolId::new(format!("mcp_{id}")), + kind: ToolKind::RemoteMcp(harness::RemoteMcpToolSpec { + server_id: id.into(), + record_revision: 1, + server_label: id.into(), + description_ref: None, + allowed_tools: None, + execution: RemoteMcpExecution::Runtime, + exposure: RemoteMcpExposure::Inject, + approval: harness::RemoteMcpApprovalPolicy::Never, + defer_loading: None, + }), + execution: Default::default(), + parallelism: ToolParallelism::ParallelSafe, + }); + } + let first = adapter.generate(generation.clone()).await.unwrap(); + let wire = crate::blob_io::read_json( + blobs.as_ref(), + &first.debug_dumps.unwrap().provider_request_ref, + ) + .await + .unwrap(); + assert_eq!(wire["tools"].as_array().unwrap().len(), 1); + assert_eq!(wire["tools"][0]["function"]["name"], "mcp_healthy__lookup"); + let notice = &first.result.context_entries[0]; + let reason = "offline: tools/list failed: HTTP 401"; + assert!(wire["messages"].to_string().contains(reason)); + assert!( + crate::blob_io::read_text(blobs.as_ref(), ¬ice.content.content_ref) + .await + .unwrap() + .contains(reason) + ); + + // Replay the notice exactly as the reducer would place it in context. + let mut prior = entry( + 1, + notice.kind.clone(), + ContextEntrySource::AssistantOutput { + run_id: generation.run_id, + turn_id: generation.turn_id, + }, + notice.content.content_ref.clone(), + ); + prior.origin = notice.origin.clone(); + generation.request.context.entries.push(prior); + let repeat = adapter.generate(generation.clone()).await.unwrap(); + assert!( + repeat + .result + .context_entries + .iter() + .all(|e| !matches!(e.kind, ContextEntryKind::Catalog { .. })) + ); + generation.request.tools.remove(0); + let cleared = adapter.generate(generation).await.unwrap(); + let recovery = &cleared.result.context_entries[0]; + assert!(matches!(recovery.kind, ContextEntryKind::Catalog { .. })); + assert!( + crate::blob_io::read_text(blobs.as_ref(), &recovery.content.content_ref) + .await + .unwrap() + .contains("no credential or tool-list failures") + ); + } + #[tokio::test(flavor = "current_thread")] async fn generate_passes_stored_api_key_to_client() { let blobs = Arc::new(InMemoryBlobStore::new()); diff --git a/crates/llm-runtime/src/openai_responses.rs b/crates/llm-runtime/src/openai_responses.rs index 384d56646..cf9dcf443 100644 --- a/crates/llm-runtime/src/openai_responses.rs +++ b/crates/llm-runtime/src/openai_responses.rs @@ -177,6 +177,7 @@ impl LlmGenerationAdapter for OpenAiResponsesLlmAdapter { }); } + let mcp = crate::mcp::RequestMcp::new(self.inventory.as_ref(), Some(self.secrets.as_ref())); let mut catalog = crate::tool_catalog::ToolCatalog::resolve_for_request( self.blobs.as_ref(), &request.request, @@ -184,17 +185,25 @@ impl LlmGenerationAdapter for OpenAiResponsesLlmAdapter { .await?; let mut provider_request = materialize_request_with_catalog( self.blobs.as_ref(), - self.inventory.as_ref(), + &mcp, &request.request, &mut catalog, ) .await?; + let notice = mcp + .notice(self.blobs.as_ref(), &request.request.context) + .await?; + if let Some((text, _)) = ¬ice + && let Some(oai::ResponseInput::Items(items)) = &mut provider_request.input + { + items.push(developer_message(text.clone())); + } + // Route every turn of a session to the same prompt cache. provider_request.prompt_cache_key = Some(crate::prompt_cache::prompt_cache_key(&request.session_id)); let (send_request, redacted_request) = - inject_remote_mcp_auth(self.secrets.as_ref(), &request.request, provider_request) - .await?; + inject_remote_mcp_auth(&mcp, &request.request, provider_request)?; let provider = resolve_model_provider(self.provider_keys.as_ref(), &request.request.model).await?; let request_dump = debug_dump_request(self.debug_dumps, &redacted_request)?; @@ -234,6 +243,9 @@ impl LlmGenerationAdapter for OpenAiResponsesLlmAdapter { ) .await?; catalog.normalize(&mut result); + if let Some((_, entry)) = notice { + result.context_entries.insert(0, entry); + } let debug_dumps = store_debug_dumps( self.blobs.as_ref(), request_dump, @@ -920,8 +932,8 @@ async fn materialize_remote_mcp_tool( /// Produce the request pair `generate` actually uses: the send request with /// `authorization` resolved at the last moment, and the redacted request that /// is persisted to blobs, preserving only the fact that auth was configured. -async fn inject_remote_mcp_auth( - secrets: &dyn SecretResolver, +fn inject_remote_mcp_auth( + mcp: &crate::mcp::RequestMcp, request: &LlmRequest, materialized: oai::CreateResponseRequest, ) -> LlmAdapterResult<(oai::CreateResponseRequest, oai::CreateResponseRequest)> { @@ -950,12 +962,7 @@ async fn inject_remote_mcp_auth( else { continue; }; - let token = crate::secrets::resolve_mcp_bearer(secrets, &remote_mcp.server_id, &server_url) - .await - .map_err(|error| LlmAdapterError::SecretResolution { - tool: tool.id.to_string(), - message: error.to_string(), - })?; + let token = mcp.token(remote_mcp.server_id.clone(), server_url)?; let Some(token) = token else { continue; }; @@ -2673,37 +2680,40 @@ mod tests { } #[tokio::test(flavor = "current_thread")] - async fn generate_does_not_treat_a_missing_credential_resource_as_absent() { - let blobs = Arc::new(InMemoryBlobStore::new()); - let api = fake_api_with(completed_message_response()); - let adapter = OpenAiResponsesLlmAdapter::new(api.clone(), blobs) - .with_secret_resolver(Arc::new(crate::secrets::StaticSecretResolver::new())) - .with_mcp_inventory_resolver(Arc::new(StaticMcpInventory)); - - let error = LlmGenerationAdapter::generate(&adapter, mcp_auth_generation_request()) - .await - .expect_err("missing optional MCP server must not silently downgrade"); - - assert!(matches!(error, LlmAdapterError::SecretResolution { .. })); - assert!(api.seen.lock().expect("lock").is_empty()); - } - - #[tokio::test(flavor = "current_thread")] - async fn generate_fails_before_provider_io_when_the_credential_cannot_be_resolved() { + async fn a_broken_credential_omits_only_its_server_and_reports_the_cause() { let blobs = Arc::new(InMemoryBlobStore::new()); let api = fake_api_with(completed_message_response()); let adapter = OpenAiResponsesLlmAdapter::new(api.clone(), blobs.clone()) + .with_secret_resolver(Arc::new(crate::StaticSecretResolver::new().with_secret( + crate::SECRET_NAMESPACE_MCP_SERVER, + "healthy", + "healthy-token", + ))) .with_mcp_inventory_resolver(Arc::new(StaticMcpInventory)); - - let error = LlmGenerationAdapter::generate(&adapter, mcp_auth_generation_request()) - .await - .expect_err("an unresolvable credential must fail generation"); - - assert!(matches!(error, LlmAdapterError::SecretResolution { .. })); + let mut request = mcp_auth_generation_request(); + let mut other = request.request.tools[0].clone(); + other.id = ToolId::try_new("mcp_healthy").unwrap(); + let ToolKind::RemoteMcp(spec) = &mut other.kind else { + unreachable!() + }; + spec.server_label = "healthy".into(); + spec.server_id = "healthy".into(); + request.request.tools.push(other); + let execution = adapter.generate(request).await.unwrap(); + let wire = serde_json::to_value(&api.seen.lock().unwrap()[0]).unwrap(); + assert_eq!(wire["tools"].as_array().unwrap().len(), 1); + assert_eq!(wire["tools"][0]["server_label"], "healthy"); + assert_eq!(wire["tools"][0]["authorization"], "healthy-token"); + let entry = &execution.result.context_entries[0]; assert!( - api.seen.lock().expect("lock").is_empty(), - "no provider call may happen when auth resolution fails" + matches!(&entry.kind, ContextEntryKind::Catalog {title} if title == "Unavailable MCP servers") ); + let body = crate::blob_io::read_text(blobs.as_ref(), &entry.content.content_ref) + .await + .unwrap(); + assert!(body.contains("credential was not found")); + assert!(wire.to_string().contains("credential was not found")); + assert!(!body.contains("healthy-token")); } fn generation_request() -> LlmGenerationRequest { diff --git a/crates/llm-runtime/src/secrets.rs b/crates/llm-runtime/src/secrets.rs index 40e7b2b45..24d2915f7 100644 --- a/crates/llm-runtime/src/secrets.rs +++ b/crates/llm-runtime/src/secrets.rs @@ -67,6 +67,20 @@ pub enum SecretResolveError { }, } +impl SecretResolveError { + /// Backend details may contain URLs, headers or remote response text. + pub fn mcp_notice(&self) -> &'static str { + match self { + Self::CredentialAbsent { .. } => "credential is not configured", + Self::NotFound { .. } => "credential was not found", + Self::UnsupportedNamespace { .. } => "credential type is unsupported", + Self::Backend { .. } => { + "credential resolution failed; check the credential or reconnect the server" + } + } + } +} + /// Names a credential a [`SecretResolver`] can resolve. It holds no secret value. #[derive(Clone, Debug, PartialEq, Eq)] pub struct SecretRef { diff --git a/crates/temporal-runtime/src/worker/mcp.rs b/crates/temporal-runtime/src/worker/mcp.rs index 9fe194a74..0b0211d00 100644 --- a/crates/temporal-runtime/src/worker/mcp.rs +++ b/crates/temporal-runtime/src/worker/mcp.rs @@ -10,6 +10,7 @@ use credentials::{PrivateNetworkAccess, PrivateNetworkList, SecretValue}; use harness::RemoteMcpToolSpec; use llm_runtime::{ McpInventoryError, McpInventoryResolver, RuntimeMcpTool, + mcp::McpListing, secrets::{SecretResolveError, SecretResolver, resolve_mcp_bearer}, }; use mcp::search::McpToolSearchQuery; @@ -166,7 +167,7 @@ pub struct RuntimeMcpInventoryResolver { struct CachedInventory { fetched_at: Instant, ttl: Duration, - tools: Vec, + listing: McpListing, } impl RuntimeMcpInventoryResolver { @@ -211,16 +212,14 @@ impl RuntimeMcpInventoryResolver { async fn uncached( &self, spec: &RemoteMcpToolSpec, - ) -> Result<(Vec, bool, Option), McpInventoryError> { + ) -> Result<(Vec, bool, Option), &'static str> { let record = usable_record(self.servers.as_ref(), &spec.server_id) .await - .map_err(McpInventoryError::new)? - .ok_or_else(|| { - McpInventoryError::new(format!("MCP server {} is not available", spec.server_id)) - })?; + .map_err(|_| "MCP server lookup failed")? + .ok_or("MCP server is unavailable")?; let auth = record_auth(self.secrets.as_ref(), &record) .await - .map_err(|error| McpInventoryError::new(format!("resolve MCP credential: {error}")))?; + .map_err(|error| error.mcp_notice())?; let private_access = self .private_networks .access(&record.server_url, record.allow_private_network); @@ -233,7 +232,24 @@ impl RuntimeMcpInventoryResolver { mcp::McpToolDiscoveryLimits::default(), ) .await - .map_err(|error| McpInventoryError::new(error.to_string()))?; + .map_err(|error| { + use mcp::McpToolDiscoveryFailureKind::*; + match error.kind { + Unauthorized => "tools/list failed: HTTP 401 (unauthorized)", + Forbidden => "tools/list failed: HTTP 403 (forbidden)", + AdditionalConsentRequired => "tools/list failed: additional consent required", + CredentialAbsent => "tools/list failed: missing credential", + GrantNeedsReauth => "tools/list failed: reconnect the credential", + GrantAudienceMismatch => "tools/list failed: credential audience mismatch", + RemoteRateLimited => "tools/list failed: HTTP 429 (rate limited)", + Unreachable => "tools/list failed: server unreachable", + InvalidResponse => "tools/list failed: invalid response", + UnsupportedProtocol => "tools/list failed: unsupported protocol", + PaginationLimit => "tools/list failed: pagination limit exceeded", + ResponseTooLarge => "tools/list failed: response too large", + RemoteFailure => "tools/list failed: remote server error", + } + })?; let DiscoveredMcpInventory { tools: discovered, tools_list_changed, @@ -465,18 +481,27 @@ impl RuntimeMcpExecutor { let spec = spec_from_target(target, harness::RemoteMcpExposure::Search); let inventory = self .inventory - .list_tools(&spec) + .list_tools_with_status(&spec) .await .map_err(|error| error.to_string())?; let mut tools = Vec::with_capacity(names.len()); for name in names { let tool = inventory + .tools .iter() .find(|tool| tool.remote_name == name) - .ok_or_else(|| format!("MCP server {server} does not advertise tool {name}"))?; + .ok_or_else(|| { + inventory.warning.map_or_else( + || format!("MCP server {server} does not advertise tool {name}"), + |reason| format!("MCP server {server}: {reason}"), + ) + })?; tools.push(full_tool_definition(server, tool)); } - let output = serde_json::json!({"tools": tools, "nextCursor": null}); + let mut output = serde_json::json!({"tools": tools, "nextCursor": null}); + if let Some(reason) = inventory.notice() { + output["unavailableServers"] = serde_json::json!({(server): reason}); + } return Ok(RuntimeMcpExecutionOutcome::Completed { visible: serde_json::to_string(&output).map_err(|error| error.to_string())?, output, @@ -490,17 +515,21 @@ impl RuntimeMcpExecutor { .and_then(serde_json::Value::as_u64) .unwrap_or(0) as usize; let mut matches = Vec::new(); + let mut warnings = Vec::new(); for target in targets .iter() .filter(|target| selected_server.is_none_or(|server| server == target.server_id)) { let spec = spec_from_target(target, harness::RemoteMcpExposure::Search); - for tool in self + let listing = self .inventory - .list_tools(&spec) + .list_tools_with_status(&spec) .await - .map_err(|error| error.to_string())? - { + .map_err(|error| error.to_string())?; + if let Some(reason) = listing.notice() { + warnings.push(format!("- {}: {reason}", target.server_id)); + } + for tool in listing.tools { let rank = match query.as_ref() { Some(query) => { let Some(rank) = query.score( @@ -525,8 +554,19 @@ impl RuntimeMcpExecutor { .then_with(|| left.2.remote_name.cmp(&right.2.remote_name)) }); let output = paged_tool_output(&matches, cursor)?; + let page = serde_json::to_string(&output).map_err(|error| error.to_string())?; + // Keep the structured page and its byte budget stable. The tool transcript + // also explains any partial results, even if generation runs on another worker. + let visible = if warnings.is_empty() { + page + } else { + format!( + "Unavailable MCP servers:\n{}\n\n{page}", + warnings.join("\n") + ) + }; Ok(RuntimeMcpExecutionOutcome::Completed { - visible: serde_json::to_string(&output).map_err(|error| error.to_string())?, + visible, output, is_error: false, assets: Vec::new(), @@ -551,18 +591,24 @@ impl RuntimeMcpExecutor { )); } let spec = spec_from_target(target, harness::RemoteMcpExposure::Search); - let tools = self + let listing = self .inventory - .list_tools(&spec) + .list_tools_with_status(&spec) .await .map_err(|error| error.to_string())?; - let tool = tools + let tool = listing + .tools .iter() .find(|tool| tool.remote_name == tool_name) .ok_or_else(|| { - format!( - "MCP server {} does not advertise tool {tool_name}", - target.server_id + listing.warning.map_or_else( + || { + format!( + "MCP server {} does not advertise tool {tool_name}", + target.server_id + ) + }, + |reason| format!("MCP server {}: {reason}", target.server_id), ) })?; validate_mcp_arguments(tool_name, tool, arguments) @@ -1138,6 +1184,13 @@ impl McpInventoryResolver for RuntimeMcpInventoryResolver { &self, spec: &RemoteMcpToolSpec, ) -> Result, McpInventoryError> { + Ok(self.list_tools_with_status(spec).await?.tools) + } + + async fn list_tools_with_status( + &self, + spec: &RemoteMcpToolSpec, + ) -> Result { let key = ( spec.server_id.clone(), spec.record_revision, @@ -1146,7 +1199,7 @@ impl McpInventoryResolver for RuntimeMcpInventoryResolver { if let Some(cached) = self.cache.lock().await.get(&key) && cached.fetched_at.elapsed() < cached.ttl { - return Ok(cached.tools.clone()); + return Ok(cached.listing.clone()); } let lock = { let mut locks = self.locks.lock().await; @@ -1159,7 +1212,7 @@ impl McpInventoryResolver for RuntimeMcpInventoryResolver { if let Some(cached) = self.cache.lock().await.get(&key) && cached.fetched_at.elapsed() < cached.ttl { - return Ok(cached.tools.clone()); + return Ok(cached.listing.clone()); } let (tools, tools_list_changed, advertised_ttl) = match self.uncached(spec).await { Ok(fetched) => fetched, @@ -1176,11 +1229,12 @@ impl McpInventoryResolver for RuntimeMcpInventoryResolver { let entry = cache.entry(key).or_insert_with(|| CachedInventory { fetched_at: Instant::now(), ttl: self.failure_ttl, - tools: Vec::new(), + listing: McpListing::default(), }); entry.fetched_at = Instant::now(); entry.ttl = self.failure_ttl; - return Ok(entry.tools.clone()); + entry.listing.warning = Some(error); + return Ok(entry.listing.clone()); } }; let ttl = advertised_ttl.unwrap_or(if tools_list_changed { @@ -1192,15 +1246,19 @@ impl McpInventoryResolver for RuntimeMcpInventoryResolver { cache.retain(|(server_id, revision, _), _| { server_id != &spec.server_id || *revision == spec.record_revision }); + let listing = McpListing { + tools, + warning: None, + }; cache.insert( key, CachedInventory { fetched_at: Instant::now(), ttl, - tools: tools.clone(), + listing: listing.clone(), }, ); - Ok(tools) + Ok(listing) } async fn server_url(&self, server_id: &str) -> Result, McpInventoryError> { @@ -1736,8 +1794,8 @@ mod tests { tokio::time::sleep(self.delay).await; if self.failing.load(Ordering::SeqCst) { return Err(mcp::McpToolDiscoveryFailure::new( - mcp::McpToolDiscoveryFailureKind::Unreachable, - "MCP endpoint timed out", + mcp::McpToolDiscoveryFailureKind::Unauthorized, + "private detail from the remote endpoint", )); } let tool = |name: &str| mcp::DiscoveredMcpTool { @@ -1772,15 +1830,36 @@ mod tests { tokio::time::sleep(Duration::from_millis(5)).await; discoverer.failing.store(true, Ordering::SeqCst); - let kept = resolver.list_tools(&spec(1)).await.expect("kept"); - assert_eq!(tool_names(&kept), ["tool_a", "tool_b"]); + let kept = resolver + .list_tools_with_status(&spec(1)) + .await + .expect("kept"); + assert_eq!(tool_names(&kept.tools), ["tool_a", "tool_b"]); assert_eq!(discoverer.calls.load(Ordering::SeqCst), 2); - resolver.list_tools(&spec(1)).await.expect("inside window"); + assert_eq!( + kept.warning, + Some("tools/list failed: HTTP 401 (unauthorized)") + ); + assert_eq!( + resolver + .list_tools_with_status(&spec(1)) + .await + .expect("inside window") + .warning, + kept.warning + ); assert_eq!(discoverer.calls.load(Ordering::SeqCst), 2); discoverer.failing.store(false, Ordering::SeqCst); tokio::time::sleep(Duration::from_millis(70)).await; - resolver.list_tools(&spec(1)).await.expect("recovered"); + assert!( + resolver + .list_tools_with_status(&spec(1)) + .await + .expect("recovered") + .warning + .is_none() + ); assert_eq!(discoverer.calls.load(Ordering::SeqCst), 3); } @@ -1811,6 +1890,49 @@ mod tests { assert_eq!(tool_names(&recovered), ["tool_a", "tool_b"]); } + #[tokio::test(flavor = "current_thread")] + async fn on_demand_search_reports_a_listing_failure_alongside_healthy_results() { + use mcp::McpRegistryStore; + let servers = Arc::new(mcp::InMemoryMcpRegistryStore::new()); + servers + .put_server(server_input("http://127.0.0.1/mcp", true), None) + .await + .unwrap(); + let inventory = Arc::new(RuntimeMcpInventoryResolver { + servers, + ..RuntimeMcpInventoryResolver::for_test( + FlakyDiscoverer::new(false, Duration::ZERO), + Duration::from_secs(60), + Duration::from_secs(60), + ) + }); + let runtime = RuntimeMcpExecutor::new( + inventory.servers.clone(), + inventory.secrets.clone(), + inventory.clone(), + inventory.private_networks.clone(), + ); + let targets = ["test", "other"].map(|id| harness::RemoteMcpCallTarget { + server_id: id.into(), + server_label: id.into(), + record_revision: 1, + allowed_tools: None, + approval: harness::RemoteMcpApprovalPolicy::Never, + }); + let RuntimeMcpExecutionOutcome::Completed { + output, visible, .. + } = runtime + .find_tools(&targets, serde_json::json!({})) + .await + .unwrap() + else { + panic!("expected a search result") + }; + assert_eq!(output["tools"].as_array().unwrap().len(), 2); + assert!(visible.contains("Unavailable MCP servers")); + assert!(visible.contains("other: MCP server is unavailable")); + } + #[tokio::test(flavor = "multi_thread", worker_threads = 4)] async fn concurrent_turns_do_not_queue_fetches_behind_a_hanging_server() { let discoverer = FlakyDiscoverer::new(true, Duration::from_millis(50)); From 1d199dc10a6dade9e7f0d3d3d03453d70897931d Mon Sep 17 00:00:00 2001 From: lb <542828+lukebuehler@users.noreply.github.com> Date: Thu, 19 Nov 2026 21:50:00 +0100 Subject: [PATCH 2/4] mcp tool shortening --- Cargo.lock | 2 + crates/api-projection/src/lib.rs | 101 +++++++--- .../harness/src/core/components/code_tool.rs | 18 +- crates/harness/src/core/components/ids.rs | 3 +- crates/harness/src/core/components/mod.rs | 15 +- crates/harness/src/core/components/tooling.rs | 148 +++++++------- .../src/core/components/workflow_tool.rs | 6 +- crates/harness/src/core/drive.rs | 94 ++++++--- crates/harness/src/core/state_shape.rs | 22 ++- .../tests/fixtures/checkpoint_state.json | 104 +++++++--- crates/harness/tests/state_bounds.rs | 4 +- crates/llm-runtime/Cargo.toml | 2 + crates/llm-runtime/src/anthropic_messages.rs | 15 +- crates/llm-runtime/src/lib.rs | 5 +- crates/llm-runtime/src/mcp.rs | 114 ++++++++++- crates/llm-runtime/src/openai_completions.rs | 13 +- crates/llm-runtime/src/openai_responses.rs | 74 ++++++- .../src/openai_responses/tests/patch_tests.rs | 2 +- crates/llm-runtime/src/tool_catalog.rs | 54 +++--- .../tests/anthropic_messages_skills_live.rs | 2 +- .../tests/openai_responses_skills_live.rs | 2 +- crates/llm-runtime/tests/provider_failures.rs | 2 +- crates/mcp/src/lib.rs | 42 +--- .../src/gateway/service/mcp_api.rs | 2 +- .../src/gateway/service/mcp_discovery.rs | 42 ++-- .../src/worker/activities/storage.rs | 4 +- .../src/worker/activities/tools.rs | 181 ++++++++++++++++-- crates/temporal-runtime/src/worker/fake.rs | 2 +- .../tests/code_capabilities_live.rs | 2 +- .../tests/code_worker_process_live.rs | 2 +- .../tests/code_workflow_live.rs | 2 +- crates/temporal-runtime/tests/fake_loop.rs | 2 +- crates/temporal-runtime/tests/mcp_live.rs | 62 ++++-- .../temporal-runtime/tests/subagents_live.rs | 2 +- .../tests/support/code_tools.rs | 2 +- .../tests/vfs_transfer_live.rs | 2 +- .../tests/workflow_tool_plugins_live.rs | 3 +- .../src/workflows/session/code_tools.rs | 8 +- .../src/workflows/session/restart.rs | 13 +- .../src/workflows/session/tests.rs | 2 +- crates/test-support/src/runner/drive.rs | 4 +- crates/test-support/src/tool_calls.rs | 17 +- crates/tools/src/callable.rs | 2 +- 43 files changed, 859 insertions(+), 341 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index df18f7c5e..4fbe4d696 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2719,10 +2719,12 @@ dependencies = [ "async-trait", "base64 0.23.1", "harness", + "hex", "image", "llm-clients", "serde", "serde_json", + "sha2 0.11.0", "test-support", "thiserror 2.0.21", "tokio", diff --git a/crates/api-projection/src/lib.rs b/crates/api-projection/src/lib.rs index 97e45cd50..df1bbe3fe 100644 --- a/crates/api-projection/src/lib.rs +++ b/crates/api-projection/src/lib.rs @@ -1288,12 +1288,16 @@ impl<'a> CoreAgentProjector<'a> { try_join_all(calls.iter().map(|call| async move { let arguments = self.read_blob_text(&call.arguments_ref).await?; Ok(ToolCallEventView { - tool_id: call.tool_id.as_ref().map(|id| id.as_str().to_owned()), + tool_id: call.tool_id().map(|id| id.as_str().to_owned()), call_id: call.call_id.as_str().to_owned(), tool_name: call.tool_name.as_str().to_owned(), arguments_ref: call.arguments_ref.as_str().to_owned(), arguments: Some(truncate_utf8(&arguments, MAX_INLINE_TEXT_BYTES)), - display: tool_call_display(call.tool_name.as_str(), &arguments), + display: tool_call_display( + call.target.as_ref(), + call.tool_name.as_str(), + &arguments, + ), }) })) .await @@ -1328,7 +1332,7 @@ impl<'a> CoreAgentProjector<'a> { let result = result_by_call.get(call.call_id.as_str()); let arguments = self.read_blob_text(&call.arguments_ref).await?; Ok(ToolCallView { - tool_id: call.tool_id.as_ref().map(|id| id.as_str().to_owned()), + tool_id: call.tool_id().map(|id| id.as_str().to_owned()), call_id: call.call_id.as_str().to_owned(), tool_name: call.tool_name.as_str().to_owned(), arguments_ref: call.arguments_ref.as_str().to_owned(), @@ -1344,7 +1348,7 @@ impl<'a> CoreAgentProjector<'a> { // A call that names no tool never starts. Any other is // only requested until its start commits. status: result.map(|result| result.status).unwrap_or( - if call.tool_id.is_some() { + if call.target.is_some() { ToolItemStatus::Requested } else { ToolItemStatus::Unavailable @@ -1358,7 +1362,11 @@ impl<'a> CoreAgentProjector<'a> { .get(call.call_id.as_str()) .cloned() .unwrap_or_default(), - display: tool_call_display(call.tool_name.as_str(), &arguments), + display: tool_call_display( + call.target.as_ref(), + call.tool_name.as_str(), + &arguments, + ), started_at_ms: None, finished_at_ms: None, duration_ms: None, @@ -2995,8 +3003,25 @@ fn json_field_text(value: &Value, field: &str) -> Option { (!text.is_empty()).then_some(text) } -fn tool_call_display(tool_name: &str, arguments: &str) -> Option { +fn tool_call_display( + target: Option<&harness::ResolvedToolTarget>, + tool_name: &str, + arguments: &str, +) -> Option { let json = serde_json::from_str::(arguments).ok(); + if let Some(harness::ResolvedToolTarget::Mcp { + server_label, + remote_name, + .. + }) = target + { + return Some(ToolCallDisplayView { + group: ToolCallDisplayGroup::Mcp, + verb: server_label.clone(), + target: Some(remote_name.clone()), + detail: json.as_ref().and_then(first_scalar_text), + }); + } let normalized = tool_name.to_ascii_lowercase(); let view = match normalized.as_str() { "code_execute" => ToolCallDisplayView { @@ -3345,19 +3370,6 @@ fn tool_call_display(tool_name: &str, arguments: &str) -> Option - { - let (server, tool) = tool_name.strip_prefix("mcp_")?.split_once("__")?; - ToolCallDisplayView { - group: ToolCallDisplayGroup::Mcp, - verb: server.to_owned(), - target: Some(tool.to_owned()), - detail: json.as_ref().and_then(first_scalar_text), - } - } _ => ToolCallDisplayView { group: ToolCallDisplayGroup::Other, verb: tool_name.to_owned(), @@ -3678,20 +3690,20 @@ mod tests { #[test] fn code_display_summarizes_source_without_exposing_it_in_the_row() { - let display = tool_call_display("code_execute", r#"{"code":"const result = await tools.vfs_read_file({path:'/notes'});\ntext(result);\n"}"#).unwrap(); + let display = tool_call_display(None, "code_execute", r#"{"code":"const result = await tools.vfs_read_file({path:'/notes'});\ntext(result);\n"}"#).unwrap(); assert_eq!(display.group, ToolCallDisplayGroup::Code); assert_eq!(display.verb, "Run code"); assert_eq!(display.target.as_deref(), Some("JavaScript")); assert_eq!(display.detail.as_deref(), Some("2 lines")); assert_eq!( - tool_call_display("code_execute", r#"{"code":"return 1"}"#) + tool_call_display(None, "code_execute", r#"{"code":"return 1"}"#) .unwrap() .detail .as_deref(), Some("1 line") ); for arguments in ["{", "{}", r#"{"code":" "}"#] { - let display = tool_call_display("code_execute", arguments).unwrap(); + let display = tool_call_display(None, "code_execute", arguments).unwrap(); assert_eq!(display.group, ToolCallDisplayGroup::Code); assert_eq!(display.detail, None); } @@ -3751,7 +3763,7 @@ mod tests { ), ] { for name in names { - let display = tool_call_display(name, args).unwrap(); + let display = tool_call_display(None, name, args).unwrap(); assert_eq!(display.group, group, "{name}"); assert_eq!(display.verb, verb, "{name}"); assert_eq!(display.target.as_deref(), Some(target), "{name}"); @@ -3847,7 +3859,7 @@ mod tests { "process1", ), ] { - let display = tool_call_display(name, args).unwrap(); + let display = tool_call_display(None, name, args).unwrap(); assert_eq!(display.group, group, "{name}"); assert_eq!(display.verb, verb, "{name}"); assert_eq!(display.target.as_deref(), Some(target), "{name}"); @@ -3859,13 +3871,32 @@ mod tests { #[test] fn injected_mcp_display_preserves_names_and_unknown_tools_stay_generic() { - let display = tool_call_display("mcp_docs__Search", r#"{"query":"QuickJS"}"#).unwrap(); + let binding = harness::ResolvedToolTarget::Mcp { + server_tool_id: harness::ToolId::new("mcp_docs__internal"), + server_label: "docs__internal".into(), + remote_name: "search_by_document_metadata".into(), + }; + let display = tool_call_display( + Some(&binding), + "mcp_docs__search_hash_metadata", + r#"{"query":"QuickJS"}"#, + ) + .unwrap(); assert_eq!(display.group, ToolCallDisplayGroup::Mcp); - assert_eq!(display.verb, "docs"); - assert_eq!(display.target.as_deref(), Some("Search")); + assert_eq!(display.verb, "docs__internal"); + assert_eq!( + display.target.as_deref(), + Some("search_by_document_metadata") + ); assert_eq!(display.detail.as_deref(), Some("QuickJS")); - for name in ["custom_tool", "mcp_unknown", "mcp___", "mcp_docs__"] { - let display = tool_call_display(name, "{}").unwrap(); + for name in [ + "mcp_docs__Search", + "custom_tool", + "mcp_unknown", + "mcp___", + "mcp_docs__", + ] { + let display = tool_call_display(None, name, "{}").unwrap(); assert_eq!(display.group, ToolCallDisplayGroup::Other); assert_eq!(display.verb, name); } @@ -3874,6 +3905,7 @@ mod tests { #[test] fn runtime_mcp_search_call_displays_the_resolved_server_and_tool() { let display = tool_call_display( + None, "mcp_call", r#"{"server":"configurator","tool":"lightspeed_models_list","arguments":{}}"#, ) @@ -3884,6 +3916,7 @@ mod tests { assert_eq!(display.detail, None); let display = tool_call_display( + None, "mcp_call", r#"{"server":"stripe","tool":"retrieve_subscription","arguments":{"id":"sub_1R0aB3"}}"#, ) @@ -3912,6 +3945,7 @@ mod tests { #[test] fn subagent_calls_display_the_profile_and_the_brief() { let display = tool_call_display( + None, "agent_run", r#"{"agent":"reviewer","input":"Review the diff on skills2.\n\nFocus on tests."}"#, ) @@ -3925,6 +3959,7 @@ mod tests { ); let display = tool_call_display( + None, "agent_spawn", r#"{"agent":"researcher","input":"Find prior art","label":"Prior art"}"#, ) @@ -3933,6 +3968,7 @@ mod tests { assert_eq!(display.detail.as_deref(), Some("Prior art")); let display = tool_call_display( + None, "await", r#"{"promises":["promise_3","promise_4"],"mode":"any"}"#, ) @@ -3946,6 +3982,7 @@ mod tests { #[test] fn bot_emit_distinguishes_self_from_addressed_peers() { let display = tool_call_display( + None, "bot_emit", r#"{"kind":"bug.confirmed","summary":"Duplicates on page boundary","to":"escalations","reply":true}"#, ) @@ -3959,6 +3996,7 @@ mod tests { ); let display = tool_call_display( + None, "bot_emit", r#"{"kind":"research.followup","summary":"Nightly","sessionKey":"nightly"}"#, ) @@ -3982,6 +4020,7 @@ mod tests { #[test] fn runtime_mcp_detail_display_names_the_requested_tools() { let display = tool_call_display( + None, "mcp_find_tools", r#"{"server":"configurator","names":["models_list","sessions_read"]}"#, ) @@ -4077,7 +4116,7 @@ mod tests { let batch_id = harness::ToolBatchId::new(1); let call = |id: &str, tool_id: Option<&str>| harness::ObservedToolCall { call_id: harness::ToolCallId::new(id), - tool_id: tool_id.map(harness::ToolId::new), + target: tool_id.map(harness::ToolId::new).map(Into::into), tool_name: harness::ToolName::new("read_file"), provider_kind: None, arguments_ref: arguments_ref.clone(), @@ -5775,7 +5814,7 @@ mod tests { toolset_revision: 0, calls: vec![harness::ObservedToolCall { call_id: call_id.clone(), - tool_id: None, + target: None, tool_name: harness::ToolName::new("mcp_echo__hello"), provider_kind: None, arguments_ref: arguments_ref.clone(), diff --git a/crates/harness/src/core/components/code_tool.rs b/crates/harness/src/core/components/code_tool.rs index 471b9d29f..a9bff4079 100644 --- a/crates/harness/src/core/components/code_tool.rs +++ b/crates/harness/src/core/components/code_tool.rs @@ -72,7 +72,8 @@ pub(crate) fn interrupt_code_tools_for_run(state: &mut CoreAgentState, run_id: c #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct CodeToolBinding { - pub tool_id: ToolId, + #[serde(alias = "tool_id")] + pub target: crate::ResolvedToolTarget, pub tool_name: ToolName, } @@ -334,13 +335,13 @@ fn validate_scope(state: &CoreAgentState, scope: &CodeToolScopeSpec) -> Result<( .ok_or_else(|| invalid("code tool parent binding is missing"))?; for (binding_id, binding) in &scope.bindings { validate_id("binding_id", binding_id)?; - let tool_id = &binding.tool_id; + let tool_id = binding.target.tool_id(); let tool = state .tooling .tools .get(tool_id) .ok_or_else(|| invalid(format!("code tool {tool_id} is not granted")))?; - if !tool.invokes_client_effect() || tool_id == &parent_tool.definition.tool.id { + if !tool.admits_call(&binding.target) || tool_id == &parent_tool.definition.tool.id { return Err(invalid(format!( "tool {tool_id} is not available for code tool execution" ))); @@ -375,7 +376,7 @@ fn validate_recorded_call<'a>( .bindings .get(&call.binding_id) .is_some_and(|binding| { - binding.tool_id == call.tool_id && binding.tool_name == call.tool_name + binding.target.tool_id() == &call.tool_id && binding.tool_name == call.tool_name }) { return Err(invalid("code tool is outside the execution grant")); @@ -826,6 +827,11 @@ pub fn code_tool_request( "code tool request session does not match its parent", )); } + let binding = scope + .spec + .bindings + .get(&call.spec.binding_id) + .ok_or_else(|| invalid("code tool binding is absent from its scope"))?; let mut request = crate::core::drive::tool_invocation_request( state, session_id, @@ -835,8 +841,8 @@ pub fn code_tool_request( call.promise_id_base, std::slice::from_ref(&crate::ObservedToolCall { call_id: call.call_id.clone(), - tool_id: Some(call.spec.tool_id.clone()), - tool_name: call.spec.tool_name.clone(), + target: Some(binding.target.clone()), + tool_name: binding.tool_name.clone(), provider_kind: None, arguments_ref: call.spec.arguments_ref.clone(), native_call_ref: None, diff --git a/crates/harness/src/core/components/ids.rs b/crates/harness/src/core/components/ids.rs index 3a1ca42e8..afbe6d2ed 100644 --- a/crates/harness/src/core/components/ids.rs +++ b/crates/harness/src/core/components/ids.rs @@ -4,7 +4,8 @@ use std::fmt; pub use crate::session::{EventSeq, SessionId, StringIdError, validate_general_string_id}; -const TOOL_NAME_MAX_LEN: usize = 64; +/// Shared wire-name budget across provider adapters. OpenAI function names allow 64 ASCII characters. +pub const TOOL_NAME_MAX_LEN: usize = 64; macro_rules! numeric_id { ($name:ident) => { diff --git a/crates/harness/src/core/components/mod.rs b/crates/harness/src/core/components/mod.rs index a6729e39a..349ea932b 100644 --- a/crates/harness/src/core/components/mod.rs +++ b/crates/harness/src/core/components/mod.rs @@ -79,13 +79,14 @@ pub use tooling::{ FAILED_WITHOUT_DETAIL_CONTENT, FunctionToolSpec, ObservedToolCall, PROMISE_DEADLINE_EXCEEDED_CONTENT, ProviderNativeToolExecution, ProviderNativeToolSpec, RECEIVER_CANCELLED_CONTENT, RemoteMcpApprovalPolicy, RemoteMcpExecution, RemoteMcpExposure, - RemoteMcpToolSpec, TOOL_RUNTIME_BOUNDARY_FAILURE_CONTENT, ToolCallResult, ToolCallState, - ToolCallStatus, ToolChoice, ToolConfigEvent, ToolEvent, ToolExecutionClass, ToolExecutionSpec, - ToolKind, ToolParallelism, ToolPatch, ToolSpec, ToolingState, UNAVAILABLE_TOOL_RESULT_CONTENT, - await_batch_conflict_ref, await_rejected_ref, cancelled_tool_result_ref, empty_success_ref, - failed_without_detail_ref, promise_deadline_exceeded_ref, receiver_cancelled_ref, - remote_mcp_call_runtime, tool_runtime_boundary_failure_ref, tools_frozen, - unavailable_tool_result_ref, validate_tool_map, + RemoteMcpToolSpec, ResolvedToolTarget, TOOL_RUNTIME_BOUNDARY_FAILURE_CONTENT, ToolCallResult, + ToolCallState, ToolCallStatus, ToolChoice, ToolConfigEvent, ToolEvent, ToolExecutionClass, + ToolExecutionSpec, ToolKind, ToolParallelism, ToolPatch, ToolSpec, ToolingState, + UNAVAILABLE_TOOL_RESULT_CONTENT, await_batch_conflict_ref, await_rejected_ref, + cancelled_tool_result_ref, empty_success_ref, failed_without_detail_ref, + promise_deadline_exceeded_ref, receiver_cancelled_ref, remote_mcp_call_runtime, + tool_runtime_boundary_failure_ref, tools_frozen, unavailable_tool_result_ref, + validate_tool_map, }; pub use turn::{ LlmFinish, LlmGenerationFacts, LlmGenerationStatus, LlmUsage, PlannedRequestState, TurnEvent, diff --git a/crates/harness/src/core/components/tooling.rs b/crates/harness/src/core/components/tooling.rs index dcdc15a66..713115b03 100644 --- a/crates/harness/src/core/components/tooling.rs +++ b/crates/harness/src/core/components/tooling.rs @@ -221,7 +221,6 @@ pub fn validate_tool_map(tools: &BTreeMap) -> Result<(), Domai } validate_unique_remote_mcp_server_labels(tools)?; - validate_unique_runtime_mcp_prefixes(tools)?; for tool in tools.values() { tool.validate()?; @@ -230,33 +229,6 @@ pub fn validate_tool_map(tools: &BTreeMap) -> Result<(), Domai Ok(()) } -fn validate_unique_runtime_mcp_prefixes( - tools: &BTreeMap, -) -> Result<(), DomainError> { - let prefixes = tools - .values() - .filter_map(|tool| match &tool.kind { - ToolKind::RemoteMcp(spec) - if spec.execution == RemoteMcpExecution::Runtime - && spec.exposure == RemoteMcpExposure::Inject => - { - Some((format!("{}__", tool.id), &tool.id)) - } - _ => None, - }) - .collect::>(); - for (index, (prefix, name)) in prefixes.iter().enumerate() { - for (other_prefix, other_name) in prefixes.iter().skip(index + 1) { - if prefix.starts_with(other_prefix) || other_prefix.starts_with(prefix) { - return Err(DomainError::InvariantViolation(format!( - "runtime MCP tool prefixes for {name} and {other_name} are ambiguous" - ))); - } - } - } - Ok(()) -} - fn validate_unique_remote_mcp_server_labels( tools: &BTreeMap, ) -> Result<(), DomainError> { @@ -410,6 +382,31 @@ impl ToolSpec { } } + pub(crate) fn admits_call(&self, target: &ResolvedToolTarget) -> bool { + match (&self.kind, target) { + ( + ToolKind::RemoteMcp(spec), + ResolvedToolTarget::Mcp { + server_label, + remote_name, + .. + }, + ) => { + spec.execution == RemoteMcpExecution::Runtime + && spec.exposure == RemoteMcpExposure::Inject + && server_label == &spec.server_label + && spec + .allowed_tools + .as_ref() + .is_none_or(|allowed| allowed.contains(remote_name)) + && validate_remote_mcp_allowed_tool_name(remote_name).is_ok() + } + (ToolKind::RemoteMcp(_), _) => false, + (_, ResolvedToolTarget::Registered(_)) => self.invokes_client_effect(), + _ => false, + } + } + pub fn invokes_client_effect(&self) -> bool { match &self.kind { ToolKind::Builtin(_) | ToolKind::Function(_) => true, @@ -622,18 +619,54 @@ pub enum ToolParallelism { ParallelSafe, } +/// Execution identity resolved from the advertised name in a model request or script scope. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum ResolvedToolTarget { + Mcp { + server_tool_id: ToolId, + server_label: String, + remote_name: String, + }, + #[serde(untagged)] + Registered(ToolId), +} + +impl ResolvedToolTarget { + pub fn tool_id(&self) -> &ToolId { + match self { + Self::Registered(id) + | Self::Mcp { + server_tool_id: id, .. + } => id, + } + } +} + +impl From for ResolvedToolTarget { + fn from(id: ToolId) -> Self { + Self::Registered(id) + } +} + #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct ObservedToolCall { pub call_id: ToolCallId, - /// Admitted registry identity resolved by the response adapter. Absent for - /// an unadvertised name. The original name remains transcript data below. - pub tool_id: Option, + /// Absent for an unadvertised name. The name itself remains transcript data. + #[serde(default, alias = "tool_id", skip_serializing_if = "Option::is_none")] + pub target: Option, pub tool_name: ToolName, pub provider_kind: Option, pub arguments_ref: BlobRef, pub native_call_ref: Option, } +impl ObservedToolCall { + pub fn tool_id(&self) -> Option<&ToolId> { + self.target.as_ref().map(ResolvedToolTarget::tool_id) + } +} + #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct ActiveToolBatch { pub batch_id: ToolBatchId, @@ -1235,11 +1268,10 @@ fn initial_tool_call_state( turn_id: TurnId, call: &ObservedToolCall, ) -> ToolCallState { - let invokes_client_effect = call - .tool_id - .as_ref() - .and_then(|tool_id| planned_tool_for_turn(state, turn_id, tool_id)) - .is_some_and(|tool| tool.invokes_client_effect()); + let invokes_client_effect = call.target.as_ref().is_some_and(|target| { + planned_tool_for_turn(state, turn_id, target.tool_id()) + .is_some_and(|tool| tool.admits_call(target)) + }); if invokes_client_effect { ToolCallState { call: call.clone(), @@ -1260,7 +1292,8 @@ pub fn remote_mcp_call_runtime( batch_id: ToolBatchId, call: &ObservedToolCall, ) -> Option { - let tool_id = call.tool_id.as_ref()?; + let target = call.target.as_ref()?; + let tool_id = target.tool_id(); let call_id = &call.call_id; let approval_decision = state .runs @@ -1286,12 +1319,17 @@ pub fn remote_mcp_call_runtime( }) .flatten(); - if let Some((spec, remote_tool_name)) = - resolve_injected_runtime_mcp(state, tool_id, &call.tool_name) - { + if let ResolvedToolTarget::Mcp { remote_name, .. } = target { + let tool = state.tooling.tools.get(tool_id)?; + let ToolKind::RemoteMcp(spec) = &tool.kind else { + return None; + }; + if !tool.admits_call(target) { + return None; + } return Some(crate::RemoteMcpCallRuntime::Injected { target: remote_mcp_target(spec), - remote_tool_name, + remote_tool_name: remote_name.clone(), approval_decision, }); } @@ -1321,32 +1359,6 @@ pub fn remote_mcp_call_runtime( }) } -fn resolve_injected_runtime_mcp<'a>( - state: &'a CoreAgentState, - tool_id: &ToolId, - exposed_name: &ToolName, -) -> Option<(&'a RemoteMcpToolSpec, String)> { - let tool = state.tooling.tools.get(tool_id)?; - let ToolKind::RemoteMcp(spec) = &tool.kind else { - return None; - }; - if spec.execution != RemoteMcpExecution::Runtime || spec.exposure != RemoteMcpExposure::Inject { - return None; - } - let prefix = format!("{tool_id}__"); - let remote_name = exposed_name.as_str().strip_prefix(&prefix)?; - if remote_name.is_empty() - || spec - .allowed_tools - .as_ref() - .is_some_and(|allowed| !allowed.iter().any(|name| name == remote_name)) - { - return None; - } - validate_remote_mcp_allowed_tool_name(remote_name).ok()?; - Some((spec, remote_name.to_owned())) -} - fn remote_mcp_target(spec: &RemoteMcpToolSpec) -> crate::RemoteMcpCallTarget { crate::RemoteMcpCallTarget { server_id: spec.server_id.clone(), @@ -2165,7 +2177,7 @@ mod tests { fn unavailable_tool_results_reference_the_well_known_constant_blob() { let call = ObservedToolCall { call_id: crate::ToolCallId::new("call_1"), - tool_id: Some(ToolId::new("missing_tool")), + target: Some(ToolId::new("missing_tool").into()), tool_name: ToolName::new("missing_tool"), provider_kind: None, arguments_ref: BlobRef::from_bytes(b"{}"), diff --git a/crates/harness/src/core/components/workflow_tool.rs b/crates/harness/src/core/components/workflow_tool.rs index 49c557720..9156468cf 100644 --- a/crates/harness/src/core/components/workflow_tool.rs +++ b/crates/harness/src/core/components/workflow_tool.rs @@ -1328,7 +1328,7 @@ pub(crate) fn validate_invoke_effect( "workflow tool invoke effect references missing tool call {expected_call_id}" )) })?; - if call.call.tool_id.as_ref() != Some(&binding.definition.tool.id) + if call.call.tool_id() != Some(&binding.definition.tool.id) || call.call.arguments_ref != invocation.arguments_ref { return Err(DomainError::InvariantViolation( @@ -1590,7 +1590,7 @@ fn validate_recorded_invocation( invocation.tool_call_id )) })?; - if call.call.tool_id.as_ref() != Some(&binding.definition.tool.id) + if call.call.tool_id() != Some(&binding.definition.tool.id) || call.call.arguments_ref != invocation.arguments_ref { return Err(DomainError::InvariantViolation( @@ -2789,7 +2789,7 @@ mod tests { .iter() .map(|call_id| ObservedToolCall { call_id: ToolCallId::new(*call_id), - tool_id: Some(definition.tool.id.clone()), + target: Some(definition.tool.id.clone().into()), tool_name: ToolName::new("work_report"), provider_kind: None, arguments_ref: BlobRef::from_bytes(call_id.as_bytes()), diff --git a/crates/harness/src/core/drive.rs b/crates/harness/src/core/drive.rs index 628962422..6afe66f2e 100644 --- a/crates/harness/src/core/drive.rs +++ b/crates/harness/src/core/drive.rs @@ -958,8 +958,7 @@ pub(crate) fn tool_invocation_request( .iter() .map(|call| { let workflow_tool = call - .tool_id - .as_ref() + .tool_id() .and_then(|id| state.workflow_tools.binding_for_tool_id(id)) .map(|binding| { crate::WorkflowToolCallRuntime::v1( @@ -976,8 +975,7 @@ pub(crate) fn tool_invocation_request( let remote_mcp = crate::remote_mcp_call_runtime(state, batch_id, call); ToolInvocationRequest { builtin: call - .tool_id - .as_ref() + .tool_id() .and_then(|id| state.tooling.tools.get(id)) .and_then(|tool| match &tool.kind { crate::ToolKind::Builtin(spec) => Some(crate::BuiltinToolCallRuntime { @@ -998,7 +996,7 @@ pub(crate) fn tool_invocation_request( _ => None, }), call_id: call.call_id.clone(), - tool_id: call.tool_id.clone(), + tool_id: call.tool_id().cloned(), tool_name: call.tool_name.clone(), arguments_ref: call.arguments_ref.clone(), workflow_tool, @@ -1190,8 +1188,7 @@ pub fn tool_batch_parked_proposals( call_state.status == ToolCallStatus::Pending && call_state .call - .tool_id - .as_ref() + .tool_id() .is_some_and(|id| id.as_str() == AWAIT_TOOL_ID) }) .map(|call_state| call_state.call.call_id.clone()) @@ -1280,8 +1277,7 @@ pub fn tool_batch_parked_proposals( call_state.call.call_id == call_id && call_state .call - .tool_id - .as_ref() + .tool_id() .is_some_and(|id| id.as_str() == AWAIT_TOOL_ID) }) { return Err(DomainError::InvariantViolation(format!( @@ -2755,7 +2751,7 @@ mod tests { ) -> ToolInvocationBatchRequest { let tool_call = ObservedToolCall { call_id: crate::ToolCallId::new("call_wait"), - tool_id: Some(test_tool_id(tool_name)), + target: Some(test_tool_id(tool_name).into()), tool_name: ToolName::new(tool_name), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"wait":true}"#), @@ -4938,7 +4934,7 @@ mod tests { request, vec![ObservedToolCall { call_id: crate::ToolCallId::new("read-skill"), - tool_id: Some(ToolId::new("vfs.read_file")), + target: Some(ToolId::new("vfs.read_file").into()), tool_name: ToolName::new("vfs_read_file"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"path":"/skills/review/SKILL.md"}"#), @@ -6658,7 +6654,7 @@ mod tests { usage: None, tool_calls: vec![ObservedToolCall { call_id: crate::ToolCallId::new("call_wait"), - tool_id: Some(ToolId::new("concurrency.await")), + target: Some(ToolId::new("concurrency.await").into()), tool_name: ToolName::new("await"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"wait":true}"#), @@ -6867,7 +6863,7 @@ mod tests { usage: None, tool_calls: vec![ObservedToolCall { call_id: crate::ToolCallId::new("call_a"), - tool_id: Some(ToolId::new("fn_a")), + target: Some(ToolId::new("fn_a").into()), tool_name: ToolName::new("fn_a"), provider_kind: None, arguments_ref: BlobRef::from_bytes(b"{}"), @@ -6938,7 +6934,7 @@ mod tests { usage: None, tool_calls: vec![ObservedToolCall { call_id: crate::ToolCallId::new(format!("call_{}", request.turn_id)), - tool_id: Some(ToolId::new("fn_a")), + target: Some(ToolId::new("fn_a").into()), tool_name: ToolName::new("fn_a"), provider_kind: None, arguments_ref: BlobRef::from_bytes(b"{}"), @@ -9710,7 +9706,7 @@ mod tests { let observed_calls = vec![ ObservedToolCall { call_id: ToolCallId::new("call-send-1"), - tool_id: Some(ToolId::new("message_send")), + target: Some(ToolId::new("message_send").into()), tool_name: ToolName::new("message_send"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"text":"one"}"#), @@ -9718,7 +9714,7 @@ mod tests { }, ObservedToolCall { call_id: ToolCallId::new("call-echo"), - tool_id: Some(ToolId::new("local_echo")), + target: Some(ToolId::new("local_echo").into()), tool_name: ToolName::new("local_echo"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"text":"echo"}"#), @@ -9726,7 +9722,7 @@ mod tests { }, ObservedToolCall { call_id: ToolCallId::new("call-send-2"), - tool_id: Some(ToolId::new("message_send")), + target: Some(ToolId::new("message_send").into()), tool_name: ToolName::new("message_send"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"text":"two"}"#), @@ -9952,7 +9948,7 @@ mod tests { vec![ ObservedToolCall { call_id: ToolCallId::new("call-send"), - tool_id: Some(ToolId::new("message_send")), + target: Some(ToolId::new("message_send").into()), tool_name: ToolName::new("message_send"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"text":"one"}"#), @@ -9960,7 +9956,7 @@ mod tests { }, ObservedToolCall { call_id: ToolCallId::new("call-await"), - tool_id: Some(ToolId::new(AWAIT_TOOL_ID)), + target: Some(ToolId::new(AWAIT_TOOL_ID).into()), tool_name: ToolName::new("await"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"promises":["other"]}"#), @@ -10921,7 +10917,7 @@ mod tests { let run_id = generation.run_id; let observed = |tool: &str| ObservedToolCall { call_id: crate::ToolCallId::new(format!("call_{tool}")), - tool_id: Some(test_tool_id(tool)), + target: Some(test_tool_id(tool).into()), tool_name: ToolName::new(tool), provider_kind: None, arguments_ref: BlobRef::from_bytes(tool.as_bytes()), @@ -11322,7 +11318,7 @@ mod tests { vec![ ObservedToolCall { call_id: crate::ToolCallId::new("call_a"), - tool_id: Some(ToolId::new("tool_a")), + target: Some(ToolId::new("tool_a").into()), tool_name: ToolName::new("tool_a"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"a":true}"#), @@ -11330,7 +11326,7 @@ mod tests { }, ObservedToolCall { call_id: crate::ToolCallId::new("call_b"), - tool_id: Some(ToolId::new("tool_b")), + target: Some(ToolId::new("tool_b").into()), tool_name: ToolName::new("tool_b"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{"b":true}"#), @@ -11586,9 +11582,19 @@ mod tests { } fn observed_call(call_id: &str, tool_name: &str) -> ObservedToolCall { + let tool_id = test_tool_id(tool_name); + let target = if tool_name == "mcp_echo__hello" { + crate::ResolvedToolTarget::Mcp { + server_tool_id: tool_id, + server_label: "echo".into(), + remote_name: "hello".into(), + } + } else { + tool_id.into() + }; ObservedToolCall { call_id: crate::ToolCallId::new(call_id), - tool_id: Some(test_tool_id(tool_name)), + target: Some(target), tool_name: ToolName::new(tool_name), provider_kind: None, arguments_ref: BlobRef::from_bytes(b"{}"), @@ -11887,7 +11893,7 @@ mod tests { ); let call = ObservedToolCall { call_id: crate::ToolCallId::new("call-bash"), - tool_id: Some(ToolId::new("env.run_process")), + target: Some(ToolId::new("env.run_process").into()), tool_name: ToolName::new("Bash"), provider_kind: Some("tool_use".into()), arguments_ref: BlobRef::from_bytes(br#"{"command":"echo hello"}"#), @@ -11896,7 +11902,7 @@ mod tests { let mut unknown = call.clone(); unknown.call_id = crate::ToolCallId::new("unknown-alias"); unknown.tool_name = ToolName::new("exec_command"); - unknown.tool_id = None; + unknown.target = None; let action = drive .resume_generation( LlmGenerationResult { @@ -11942,7 +11948,7 @@ mod tests { } }; assert_eq!(request.calls.len(), 1, "unknown aliases do not execute"); - assert_eq!(request.calls[0].tool_id, call.tool_id); + assert_eq!(request.calls[0].tool_id.as_ref(), call.tool_id()); assert_eq!(request.calls[0].tool_name.as_str(), "Bash"); assert_eq!( request.calls[0].builtin, @@ -12053,6 +12059,10 @@ mod tests { ] .into_iter() .map(test_tool_spec) + .chain([runtime_inject_mcp_tool( + "mcp_echo", + crate::RemoteMcpApprovalPolicy::Never, + )]) .map(|tool| (tool.id.clone(), tool)) .collect(); let action = drive @@ -12137,7 +12147,7 @@ mod tests { ( name.to_owned(), crate::CodeToolBinding { - tool_id: test_tool_id(name), + target: test_tool_id(name).into(), tool_name: ToolName::new(name), }, ) @@ -12169,6 +12179,34 @@ mod tests { commit_action(drive, action) } + #[test] + fn code_tool_uses_the_remote_identity_from_its_pinned_scope() { + let (mut drive, parent) = code_tool_fixture(); + let mut scope = code_tool_scope(parent); + let mut call = code_tool_spec("1", "local_echo"); + call.tool_id = ToolId::new("mcp_echo"); + call.tool_name = ToolName::new("shortened_alias"); + scope.bindings.insert( + call.binding_id.clone(), + crate::CodeToolBinding { + tool_name: call.tool_name.clone(), + target: crate::ResolvedToolTarget::Mcp { + server_tool_id: call.tool_id.clone(), + server_label: "echo".into(), + remote_name: "hello".into(), + }, + }, + ); + code_tool_commit(&mut drive, CoreAgentCommand::OpenCodeToolScope { scope }); + code_tool_commit(&mut drive, CoreAgentCommand::AdmitCodeToolCall { call }); + let request = + crate::code_tool_request(drive.session_id(), drive.state(), "execution-1", "1") + .unwrap(); + assert!( + matches!(&request.calls[0].remote_mcp, Some(crate::RemoteMcpCallRuntime::Injected {remote_tool_name, ..}) if remote_tool_name == "hello") + ); + } + #[test] fn code_tool_parallel_calls_reserve_promises_deduplicate_and_replay_without_touching_outer_batch() { @@ -12725,7 +12763,7 @@ mod tests { recursive.bindings.insert( "code_execute".into(), crate::CodeToolBinding { - tool_id: ToolId::new("code_execute"), + target: ToolId::new("code_execute").into(), tool_name: ToolName::new("code_execute"), }, ); diff --git a/crates/harness/src/core/state_shape.rs b/crates/harness/src/core/state_shape.rs index 455ce40a3..30c31cff0 100644 --- a/crates/harness/src/core/state_shape.rs +++ b/crates/harness/src/core/state_shape.rs @@ -206,8 +206,12 @@ fn notify() -> RunTerminalNotifyIntent { fn observed_call(id: &str) -> ObservedToolCall { ObservedToolCall { call_id: ToolCallId::new(id), - tool_id: Some(ToolId::new("read_file")), - tool_name: ToolName::new("read_file"), + target: Some(ResolvedToolTarget::Mcp { + server_tool_id: ToolId::new("mcp_server"), + server_label: "Server".into(), + remote_name: "search".into(), + }), + tool_name: ToolName::new("mcp_server__search"), provider_kind: Some("openai.responses.function_call".to_owned()), arguments_ref: blob("arguments"), native_call_ref: Some(blob("native call")), @@ -665,7 +669,7 @@ fn tooling_state() -> ToolingState { description_ref: Some(blob("server description")), allowed_tools: Some(vec!["search".to_owned()]), execution: RemoteMcpExecution::Runtime, - exposure: RemoteMcpExposure::Search, + exposure: RemoteMcpExposure::Inject, approval: RemoteMcpApprovalPolicy::Always, defer_loading: Some(true), }), @@ -859,8 +863,8 @@ fn code_call(request_id: &str, status: CodeToolCallStatus) -> (String, CodeToolC request_id: request_id.to_owned(), }, binding_id: "read".to_owned(), - tool_id: ToolId::new("read_file"), - tool_name: ToolName::new("read_file"), + tool_id: ToolId::new("mcp_server"), + tool_name: ToolName::new("mcp_server__search"), arguments_ref: blob("code arguments"), }, call_id: ToolCallId::new(format!("code_{request_id}")), @@ -913,8 +917,12 @@ fn code_tool_state() -> CodeToolState { bindings: BTreeMap::from([( "read".to_owned(), CodeToolBinding { - tool_id: ToolId::new("read_file"), - tool_name: ToolName::new("read_file"), + target: ResolvedToolTarget::Mcp { + server_tool_id: ToolId::new("mcp_server"), + server_label: "Server".into(), + remote_name: "search".into(), + }, + tool_name: ToolName::new("mcp_server__search"), }, )]), max_calls: 10, diff --git a/crates/harness/tests/fixtures/checkpoint_state.json b/crates/harness/tests/fixtures/checkpoint_state.json index efb7a08e7..3f261b849 100644 --- a/crates/harness/tests/fixtures/checkpoint_state.json +++ b/crates/harness/tests/fixtures/checkpoint_state.json @@ -15,8 +15,8 @@ "execution_id": "execution", "request_id": "completed" }, - "tool_id": "read_file", - "tool_name": "read_file" + "tool_id": "mcp_server", + "tool_name": "mcp_server__search" }, "status": { "kind": "completed", @@ -67,8 +67,8 @@ "execution_id": "execution", "request_id": "pending" }, - "tool_id": "read_file", - "tool_name": "read_file" + "tool_id": "mcp_server", + "tool_name": "mcp_server__search" }, "status": { "kind": "pending" @@ -84,8 +84,8 @@ "execution_id": "execution", "request_id": "waiting" }, - "tool_id": "read_file", - "tool_name": "read_file" + "tool_id": "mcp_server", + "tool_name": "mcp_server__search" }, "status": { "kind": "waiting", @@ -113,8 +113,14 @@ "spec": { "bindings": { "read": { - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" } }, "execution_id": "execution", @@ -868,8 +874,14 @@ "call_id": "call_pending", "native_call_ref": "sha256:6224eea874e5e831a0e1d5d06fb97fc2c3849241073ff98d2503f8d5627aa825", "provider_kind": "openai.responses.function_call", - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" }, "result": { "attachments": [ @@ -978,8 +990,14 @@ "call_id": "call_observed", "native_call_ref": "sha256:6224eea874e5e831a0e1d5d06fb97fc2c3849241073ff98d2503f8d5627aa825", "provider_kind": "openai.responses.function_call", - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" } ], "usage": { @@ -1042,8 +1060,14 @@ "call_id": "call_observed", "native_call_ref": "sha256:6224eea874e5e831a0e1d5d06fb97fc2c3849241073ff98d2503f8d5627aa825", "provider_kind": "openai.responses.function_call", - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" } ], "usage": { @@ -1098,8 +1122,14 @@ "call_id": "call_observed", "native_call_ref": "sha256:6224eea874e5e831a0e1d5d06fb97fc2c3849241073ff98d2503f8d5627aa825", "provider_kind": "openai.responses.function_call", - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" } ], "usage": { @@ -1158,8 +1188,14 @@ "call_id": "call_observed", "native_call_ref": "sha256:6224eea874e5e831a0e1d5d06fb97fc2c3849241073ff98d2503f8d5627aa825", "provider_kind": "openai.responses.function_call", - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" } ], "usage": { @@ -1214,8 +1250,14 @@ "call_id": "call_observed", "native_call_ref": "sha256:6224eea874e5e831a0e1d5d06fb97fc2c3849241073ff98d2503f8d5627aa825", "provider_kind": "openai.responses.function_call", - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" } ], "usage": { @@ -1274,8 +1316,14 @@ "call_id": "call_observed", "native_call_ref": "sha256:6224eea874e5e831a0e1d5d06fb97fc2c3849241073ff98d2503f8d5627aa825", "provider_kind": "openai.responses.function_call", - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" } ], "usage": { @@ -1334,8 +1382,14 @@ "call_id": "call_observed", "native_call_ref": "sha256:6224eea874e5e831a0e1d5d06fb97fc2c3849241073ff98d2503f8d5627aa825", "provider_kind": "openai.responses.function_call", - "tool_id": "read_file", - "tool_name": "read_file" + "target": { + "mcp": { + "remote_name": "search", + "server_label": "Server", + "server_tool_id": "mcp_server" + } + }, + "tool_name": "mcp_server__search" } ], "usage": { @@ -1508,7 +1562,7 @@ "defer_loading": true, "description_ref": "sha256:ed969f4dee41b8e5e02d2c6b61999776a7bb6aeeefb501ab70a355859b16d6c6", "execution": "runtime", - "exposure": "search", + "exposure": "inject", "record_revision": 4, "server_id": "server", "server_label": "Server" diff --git a/crates/harness/tests/state_bounds.rs b/crates/harness/tests/state_bounds.rs index 1ca1b6324..c88742d30 100644 --- a/crates/harness/tests/state_bounds.rs +++ b/crates/harness/tests/state_bounds.rs @@ -305,7 +305,7 @@ fn call_of(request: &LlmGenerationRequest, tool: &str) -> ObservedToolCall { let call = format!("call_{:020}", request.turn_id.as_u64()); ObservedToolCall { call_id: ToolCallId::new(&call), - tool_id: Some(ToolId::new(tool)), + target: Some(ToolId::new(tool).into()), tool_name: ToolName::new(tool), provider_kind: Some("openai.responses.function_call".to_owned()), arguments_ref: blob(format!("args-{call}")), @@ -895,7 +895,7 @@ impl Session { bindings: BTreeMap::from([( "read_file".to_owned(), CodeToolBinding { - tool_id: ToolId::new("read_file"), + target: ToolId::new("read_file").into(), tool_name: ToolName::new("read_file"), }, )]), diff --git a/crates/llm-runtime/Cargo.toml b/crates/llm-runtime/Cargo.toml index 4fb2b39f2..978503c51 100644 --- a/crates/llm-runtime/Cargo.toml +++ b/crates/llm-runtime/Cargo.toml @@ -7,10 +7,12 @@ edition = "2024" async-trait = "0.1" base64 = "0.23" harness = { path = "../harness" } +hex = "0.4" image = { version = "0.25", default-features = false, features = ["gif", "jpeg", "png", "webp"] } llm-clients = { path = "../llm-clients" } serde = { version = "1", features = ["derive"] } serde_json = "1" +sha2 = "0.11" thiserror = "2" tokio = { version = "1", features = ["rt"] } tracing = "0.1" diff --git a/crates/llm-runtime/src/anthropic_messages.rs b/crates/llm-runtime/src/anthropic_messages.rs index 9f0a79297..d067ea83c 100644 --- a/crates/llm-runtime/src/anthropic_messages.rs +++ b/crates/llm-runtime/src/anthropic_messages.rs @@ -18,7 +18,7 @@ use harness::{ LlmGenerationRequest, LlmGenerationResult, LlmGenerationStatus, LlmRequest, LlmUsage, ObservedToolCall, ProviderApiKind, ProviderNativeToolExecution, RemoteMcpApprovalPolicy, RemoteMcpExecution, RemoteMcpExposure, RemoteMcpToolSpec, TokenEstimate, TokenEstimateQuality, - ToolCallId, ToolId, ToolKind, ToolName, ToolSpec, storage::BlobStore, + ToolCallId, ToolKind, ToolName, ToolSpec, storage::BlobStore, }; use llm_clients::content::{ ANTHROPIC_MESSAGES_MCP_TOOL_RESULT_PROVIDER_KIND, @@ -1175,9 +1175,10 @@ async fn materialize_tools( ) .await?; for (name, runtime_tool) in runtime_tools { - catalog - .names - .insert(ToolName::new(name.clone()), Some(tool.id.clone()))?; + catalog.names.insert( + ToolName::new(name.clone()), + Some(runtime_tool.target(&tool.id, remote_mcp)), + )?; let description = catalog.runtime_mcp_description(&tool.id, &name, &runtime_tool); materialized.push(am::Tool::Custom(am::ToolDefinition { @@ -1899,7 +1900,7 @@ async fn tool_use_context( }; let tool_call = ObservedToolCall { call_id, - tool_id: Some(ToolId::new(tool_name.as_str())), + target: None, tool_name, provider_kind: Some(PROVIDER_KIND_TOOL_USE.to_owned()), arguments_ref, @@ -2103,7 +2104,7 @@ async fn has_signed_compaction( #[cfg(test)] mod tests { - use harness::ToolChoice; + use harness::{ToolChoice, ToolId}; use std::collections::{BTreeMap, VecDeque}; use std::sync::{Arc, Mutex}; @@ -3898,7 +3899,7 @@ mod tests { ); assert_eq!(result.facts.tool_calls.len(), 1); assert_eq!( - result.facts.tool_calls[0].tool_id, + result.facts.tool_calls[0].tool_id().cloned(), Some(ToolId::new("env.read_file")) ); assert_eq!( diff --git a/crates/llm-runtime/src/lib.rs b/crates/llm-runtime/src/lib.rs index b1e7288a6..26f5490e6 100644 --- a/crates/llm-runtime/src/lib.rs +++ b/crates/llm-runtime/src/lib.rs @@ -27,7 +27,10 @@ pub use anthropic_messages::{ }; pub use error::{LlmAdapterError, LlmAdapterResult}; pub use executor::{LlmAdapterRegistry, LlmCompactionAdapter, LlmGenerationAdapter, LlmRuntime}; -pub use mcp::{McpInventoryError, McpInventoryResolver, RuntimeMcpTool, injected_runtime_tools}; +pub use mcp::{ + McpInventoryError, McpInventoryResolver, RuntimeMcpTool, injected_runtime_tools, + injected_tool_name, +}; pub use openai_completions::{OpenAiCompletionsApi, OpenAiCompletionsLlmAdapter}; pub use openai_responses::{OpenAiResponsesApi, OpenAiResponsesLlmAdapter}; pub use params::{ diff --git a/crates/llm-runtime/src/mcp.rs b/crates/llm-runtime/src/mcp.rs index 5691723b9..672c1aaa7 100644 --- a/crates/llm-runtime/src/mcp.rs +++ b/crates/llm-runtime/src/mcp.rs @@ -1,7 +1,7 @@ use std::{collections::BTreeMap, sync::Mutex}; use async_trait::async_trait; -use harness::{RemoteMcpToolSpec, ToolName}; +use harness::{RemoteMcpToolSpec, ResolvedToolTarget, ToolId, ToolName}; use serde_json::Value; use crate::{LlmAdapterError, LlmAdapterResult}; @@ -21,6 +21,17 @@ pub struct RuntimeMcpTool { pub annotations: Option, } +impl RuntimeMcpTool { + /// Pin this inventory entry to the server registration that advertised it. + pub fn target(&self, server_tool_id: &ToolId, spec: &RemoteMcpToolSpec) -> ResolvedToolTarget { + ResolvedToolTarget::Mcp { + server_tool_id: server_tool_id.clone(), + server_label: spec.server_label.clone(), + remote_name: self.remote_name.clone(), + } + } +} + #[derive(Clone, Debug, thiserror::Error)] #[error("{message}")] pub struct McpInventoryError { @@ -260,6 +271,62 @@ pub(crate) async fn provider_hosted_server_url( Ok(server_url) } +/// The provider-visible function name. Only the request catalog can resolve it. +pub fn injected_tool_name( + server_name: &ToolName, + server_label: &str, + remote: &str, +) -> Option { + use harness::TOOL_NAME_MAX_LEN; + use sha2::{Digest, Sha256}; + use tools::callable::valid_exposed_name; + + let server = server_name.as_str(); + if !valid_exposed_name(server) + || remote.is_empty() + || !remote + .bytes() + .all(|c| c.is_ascii_alphanumeric() || matches!(c, b'_' | b'-')) + { + return None; + } + if server.len() + 2 + remote.len() <= TOOL_NAME_MAX_LEN { + return Some(format!("{server}__{remote}")); + } + + // Hash the full label, even if the registry ID has already been truncated. + // Neither component can contain NUL, so the pair has an unambiguous encoding. + let digest = Sha256::new() + .chain_update(server_label) + .chain_update([0]) + .chain_update(remote) + .finalize(); + let tag = hex::encode(&digest[..6]); + let readable = TOOL_NAME_MAX_LEN - "__".len() - tag.len() - 2; + // A very long label must leave room for the remote verb and suffix. + let server_budget = readable - remote.len().min(readable / 2); + let server = &server[..server_budget.min(server.len())]; + let remote_budget = readable - server.len(); + if remote.len() <= remote_budget { + return Some(format!("{server}_{tag}__{remote}")); + } + // Prefer whole words, falling back to a byte cut for an unbroken identifier. + let head_budget = remote_budget.div_ceil(2); + let tail_start = remote.len() - (remote_budget - head_budget); + // Include the adjacent byte so a word that fits exactly is retained. + let head_end = remote[..=head_budget] + .rfind(['_', '-']) + .filter(|&end| end > 0) + .unwrap_or(head_budget); + let tail_offset = remote[tail_start - 1..] + .find(['_', '-']) + .filter(|&offset| tail_start + offset < remote.len()) + .unwrap_or(0); + let head = &remote[..head_end]; + let tail = &remote[tail_start + tail_offset..]; + Some(format!("{server}__{head}_{tag}_{tail}")) +} + /// Resolve the shared injection policy before adapters construct native wire tools. /// The counter belongs to the request, so all injected servers share the cap. pub async fn injected_runtime_tools( @@ -282,8 +349,8 @@ pub async fn injected_runtime_tools( let tools: Vec<_> = tools .into_iter() .filter_map(|tool| { - let name = format!("{server_name}__{}", tool.remote_name); - crate::tool_catalog::valid_exposed_name(&name).then_some((name, tool)) + let name = injected_tool_name(server_name, &spec.server_label, &tool.remote_name)?; + Some((name, tool)) }) .collect(); let omitted_count = advertised_count - tools.len(); @@ -376,6 +443,45 @@ mod tests { } } + #[test] + fn injected_alias_preserves_names_at_the_limit_and_disambiguates_trimmed_words() { + let server = ToolName::new("mcp_docs"); + let name = |remote: &str| injected_tool_name(&server, "docs", remote).unwrap(); + let at_limit = "x".repeat(54); + assert_eq!(name(&at_limit), format!("mcp_docs__{at_limit}")); + let over = "x".repeat(55); + assert!(tools::callable::valid_exposed_name(&name(&over))); + + let docs = ToolName::new("mcp_my-docs-server"); + let alias = injected_tool_name( + &docs, + "my-docs-server", + "export_document_attachments_with_full_metadata", + ) + .unwrap(); + assert!(alias.starts_with("mcp_my-docs-server__export_document_")); + + let first = "export_all_attached_document_records_for_personal_accounts_with_full_metadata"; + let second = first.replace("personal", "business"); + let alias = name(first); + assert!(alias.starts_with("mcp_docs__export_all_")); + assert!(alias.ends_with("_with_full_metadata")); + assert_ne!(alias, name(&second)); + assert_eq!(alias, name(first)); + assert!(injected_tool_name(&server, "docs", &format!("{first}.invalid")).is_none()); + + let id = ToolName::new(format!("mcp_{}", "s".repeat(60))); + let label = "s".repeat(128); + for remote in ["x", first] { + let alias = injected_tool_name(&id, &label, remote).unwrap(); + assert!(tools::callable::valid_exposed_name(&alias)); + assert_ne!( + injected_tool_name(&id, &format!("{}z", &label[..127]), remote).unwrap(), + alias + ); + } + } + #[tokio::test(flavor = "current_thread")] async fn injected_inventory_sorts_filters_and_preserves_tool_metadata() { let inventory = Inventory(Ok(vec![tool("z"), tool("bad.name"), tool("a")])); @@ -402,7 +508,7 @@ mod tests { async fn cap_is_cumulative_and_counts_only_provider_compatible_names() { let mut count = 0; let server_name = ToolName::new("mcp_docs"); - let first = Inventory(Ok((0..MAX_RUNTIME_MCP_TOOLS_PER_REQUEST - 1) + let first = Inventory(Ok((0..MAX_RUNTIME_MCP_TOOLS_PER_REQUEST - 2) .map(|i| tool(&format!("read_{i}"))) .collect())); injected_runtime_tools(&first, &spec("first"), &server_name, &mut count) diff --git a/crates/llm-runtime/src/openai_completions.rs b/crates/llm-runtime/src/openai_completions.rs index 9e72982ab..fbe83b9c7 100644 --- a/crates/llm-runtime/src/openai_completions.rs +++ b/crates/llm-runtime/src/openai_completions.rs @@ -13,7 +13,7 @@ use harness::{ ContextMessageRole, LlmFinish, LlmGenerationFacts, LlmGenerationRequest, LlmGenerationResult, LlmGenerationStatus, LlmRequest, LlmUsage, OPENAI_COMPLETIONS_COMPACTION_PROVIDER_KIND, ObservedToolCall, ProviderApiKind, RemoteMcpExecution, RemoteMcpExposure, TokenEstimate, - TokenEstimateQuality, ToolCallId, ToolId, ToolKind, ToolName, storage::BlobStore, + TokenEstimateQuality, ToolCallId, ToolKind, ToolName, storage::BlobStore, }; use llm_clients::{ApiResponse, openai::completions as oai_c}; use serde_json::{Value, json}; @@ -879,9 +879,10 @@ async fn materialize_tools( ) .await?; for (name, runtime_tool) in runtime_tools { - catalog - .names - .insert(ToolName::new(name.clone()), Some(tool.id.clone()))?; + catalog.names.insert( + ToolName::new(name.clone()), + Some(runtime_tool.target(&tool.id, spec)), + )?; let description = catalog.runtime_mcp_description(&tool.id, &name, &runtime_tool); materialized.push(oai_c::CompletionTool { @@ -1437,7 +1438,7 @@ async fn tool_call_context( }, ObservedToolCall { call_id, - tool_id: Some(ToolId::new(tool_name.as_str())), + target: None, tool_name, provider_kind: Some(OPENAI_COMPLETIONS_TOOL_CALL_PROVIDER_KIND.to_owned()), arguments_ref, @@ -1495,8 +1496,8 @@ fn u64_to_u32(value: u64) -> u32 { #[cfg(test)] mod tests { - use harness::ToolChoice; use harness::ToolSpec; + use harness::{ToolChoice, ToolId}; use std::sync::{Arc, Mutex}; use harness::{ diff --git a/crates/llm-runtime/src/openai_responses.rs b/crates/llm-runtime/src/openai_responses.rs index cf9dcf443..d541d7d01 100644 --- a/crates/llm-runtime/src/openai_responses.rs +++ b/crates/llm-runtime/src/openai_responses.rs @@ -10,7 +10,7 @@ use harness::{ LlmGenerationRequest, LlmGenerationResult, LlmGenerationStatus, LlmRequest, LlmUsage, OPENAI_RESPONSES_COMPACTION_PROVIDER_KIND, ObservedApprovalRequest, ObservedToolCall, ProviderApiKind, ProviderNativeToolExecution, RemoteMcpApprovalPolicy, RemoteMcpExecution, - RemoteMcpExposure, RemoteMcpToolSpec, TokenEstimate, TokenEstimateQuality, ToolCallId, ToolId, + RemoteMcpExposure, RemoteMcpToolSpec, TokenEstimate, TokenEstimateQuality, ToolCallId, ToolKind, ToolName, ToolSpec, storage::BlobStore, }; use llm_clients::content::{ @@ -814,9 +814,10 @@ async fn materialize_tools( ) .await?; for (name, runtime_tool) in runtime_tools { - catalog - .names - .insert(ToolName::new(name.clone()), Some(tool.id.clone()))?; + catalog.names.insert( + ToolName::new(name.clone()), + Some(runtime_tool.target(&tool.id, spec)), + )?; let description = catalog.runtime_mcp_description(&tool.id, &name, &runtime_tool); let mut function = oai::FunctionTool::new(name, runtime_tool.input_schema); @@ -1172,7 +1173,7 @@ async fn result_from_response_with_catalog( PROVIDER_KIND_CUSTOM_TOOL_CALL, ) .await?; - tool_call.tool_id = Some(tool.id.clone()); + tool_call.target = Some(tool.id.clone().into()); context_entries.push(context_entry); tool_calls.push(tool_call); } @@ -1608,7 +1609,7 @@ async fn tool_call_context( }; let tool_call = ObservedToolCall { call_id, - tool_id: Some(ToolId::new(tool_name.as_str())), + target: None, tool_name, provider_kind: Some(provider_kind.to_string()), arguments_ref, @@ -1803,7 +1804,7 @@ fn developer_message(text: String) -> oai::ResponseInputItem { #[cfg(test)] mod tests { - use harness::ToolChoice; + use harness::{ToolChoice, ToolId}; mod patch_tests; use std::collections::BTreeMap; @@ -1967,6 +1968,63 @@ mod tests { assert_eq!(value[0]["strict"], false); } + #[tokio::test(flavor = "current_thread")] + async fn response_to_shortened_mcp_function_binds_only_the_advertised_name() { + let blobs = InMemoryBlobStore::new(); + let mut registration = runtime_mcp_tool(RemoteMcpExposure::Inject); + registration.id = ToolId::new(format!("mcp_{}", "s".repeat(60))); + let request = LlmGenerationRequest { + session_id: SessionId::new("session-a"), + run_id: RunId::new(1), + turn_id: TurnId::new(1), + request: harness::LlmRequest { + tools: vec![registration.clone()], + ..intent_request(Vec::new()) + }, + }; + let mut catalog = + crate::tool_catalog::ToolCatalog::resolve_for_request(&blobs, &request.request) + .await + .unwrap(); + let tools = materialize_tools(&blobs, &StaticMcpInventory, &mut catalog) + .await + .unwrap(); + let wire = serde_json::to_value(tools).unwrap(); + let alias = wire[0]["name"].as_str().unwrap(); + let raw_json = json!({"id": "resp_1", "status": "completed", "output": [ + {"type":"function_call","id":"fc_1","call_id":"call_1","name":alias,"arguments":"{}"}, + {"type":"function_call","id":"fc_2","call_id":"call_2","name":"search_issues","arguments":"{}"} + ]}); + let response = ApiResponse { + parsed: serde_json::from_value(raw_json.clone()).unwrap(), + raw_json, + status: 200, + headers: HeaderSnapshot::default(), + }; + let mut result = result_from_response(&blobs, &request, &response) + .await + .unwrap(); + assert!( + result + .facts + .tool_calls + .iter() + .all(|call| call.target.is_none()) + ); + catalog.normalize(&mut result); + let calls = result.facts.tool_calls; + assert_eq!(calls[0].tool_name.as_str(), alias); + assert_eq!( + calls[0].target, + Some(harness::ResolvedToolTarget::Mcp { + server_tool_id: registration.id, + server_label: "github".into(), + remote_name: "search_issues".into() + }) + ); + assert!(calls[1].target.is_none()); + } + struct FakeOpenAiResponsesApi { response: ApiResponse, compact_response: ApiResponse, @@ -3030,7 +3088,7 @@ mod tests { ); assert_eq!(result.facts.tool_calls.len(), 1); assert_eq!( - result.facts.tool_calls[0].tool_id, + result.facts.tool_calls[0].tool_id().cloned(), Some(ToolId::new("env.read_file")) ); assert_eq!( diff --git a/crates/llm-runtime/src/openai_responses/tests/patch_tests.rs b/crates/llm-runtime/src/openai_responses/tests/patch_tests.rs index f5dc34cfc..4c9f89498 100644 --- a/crates/llm-runtime/src/openai_responses/tests/patch_tests.rs +++ b/crates/llm-runtime/src/openai_responses/tests/patch_tests.rs @@ -147,7 +147,7 @@ async fn freeform_patches_normalize_for_execution_and_replay_original_call_types "vfs.apply_patch", "env.apply_patch", ]) { - assert_eq!(call.tool_id, Some(ToolId::new(id))); + assert_eq!(call.tool_id(), Some(&ToolId::new(id))); assert_eq!( read_json(blobs.as_ref(), &call.arguments_ref) .await diff --git a/crates/llm-runtime/src/tool_catalog.rs b/crates/llm-runtime/src/tool_catalog.rs index dbf6b641f..92d661a83 100644 --- a/crates/llm-runtime/src/tool_catalog.rs +++ b/crates/llm-runtime/src/tool_catalog.rs @@ -1,10 +1,10 @@ //! Runtime tool presentation and the reverse lookup for one provider request. -use std::collections::{BTreeMap, BTreeSet}; +use std::collections::{BTreeMap, btree_map::Entry}; use harness::{ - LlmGenerationResult, ProviderNativeToolExecution, ToolChoice, ToolId, ToolName, ToolSpec, - storage::BlobStore, + LlmGenerationResult, ProviderNativeToolExecution, ResolvedToolTarget, ToolChoice, ToolId, + ToolName, ToolSpec, storage::BlobStore, }; use tools::{callable, runtime::ToolTarget}; @@ -136,7 +136,7 @@ impl ToolCatalog { .entry(tool.id.clone()) .or_insert_with(|| tool.name.clone()); self.names - .insert(tool.name.clone(), client.then_some(tool.id.clone()))?; + .insert(tool.name.clone(), client.then(|| tool.id.clone().into()))?; } self.tools.push(tool); Ok(()) @@ -168,7 +168,7 @@ impl ToolCatalog { pub fn normalize(&self, result: &mut LlmGenerationResult) { for call in &mut result.facts.tool_calls { - call.tool_id = self.names.call_ids.get(&call.tool_name).cloned(); + call.target = self.names.binding(&call.tool_name).cloned(); } } } @@ -215,26 +215,33 @@ fn code_description( /// back into the harness. #[derive(Default)] pub(crate) struct AdvertisedNames { - exposed: BTreeSet, - call_ids: BTreeMap, + entries: BTreeMap>, } impl AdvertisedNames { - pub fn insert(&mut self, name: ToolName, id: Option) -> LlmAdapterResult<()> { + fn binding(&self, name: &ToolName) -> Option<&ResolvedToolTarget> { + self.entries.get(name)?.as_ref() + } + + pub fn insert( + &mut self, + name: ToolName, + binding: Option, + ) -> LlmAdapterResult<()> { if !valid_exposed_name(name.as_str()) { return Err(LlmAdapterError::InvalidProviderRequest { message: format!("invalid exposed tool name {name}"), }); } - if !self.exposed.insert(name.clone()) { - return Err(LlmAdapterError::InvalidProviderRequest { - message: format!("duplicate exposed tool name {name}"), - }); - } - if let Some(id) = id { - self.call_ids.insert(name, id); + match self.entries.entry(name) { + Entry::Vacant(entry) => { + entry.insert(binding); + Ok(()) + } + Entry::Occupied(entry) => Err(LlmAdapterError::InvalidProviderRequest { + message: format!("duplicate exposed tool name {}", entry.key()), + }), } - Ok(()) } } @@ -314,7 +321,7 @@ mod tests { .map(|(index, name)| ObservedToolCall { call_id: ToolCallId::new(format!("call_{index}")), tool_name: ToolName::new(name), - tool_id: None, + target: None, provider_kind: None, arguments_ref: BlobRef::from_bytes(b"{}"), native_call_ref: Some(BlobRef::from_bytes(name.as_bytes())), @@ -329,7 +336,7 @@ mod tests { .facts .tool_calls .iter() - .map(|call| call.tool_id.as_ref().map(ToolId::as_str)) + .map(|call| call.tool_id().map(ToolId::as_str)) .collect::>(), [ Some("env.continue_process"), @@ -354,7 +361,7 @@ mod tests { .facts .tool_calls .iter() - .map(|call| call.tool_id.as_ref().map(ToolId::as_str)) + .map(|call| call.tool_id().map(ToolId::as_str)) .collect::>(), [None, None, Some("env.continue_process"), None] ); @@ -402,7 +409,10 @@ mod tests { ("edit_file", "env.edit_file"), ] { assert_eq!( - catalog.names.call_ids.get(&ToolName::new(name)), + catalog + .names + .binding(&ToolName::new(name)) + .map(ResolvedToolTarget::tool_id), Some(&ToolId::new(id)) ); } @@ -413,7 +423,7 @@ mod tests { "vfs_apply_patch", "Bash", ] { - assert!(!catalog.names.call_ids.contains_key(&ToolName::new(name))); + assert!(catalog.names.binding(&ToolName::new(name)).is_none()); } for id in ["env.apply_patch", "vfs.apply_patch"] { assert!(matches!( @@ -468,7 +478,7 @@ mod tests { ) .await .expect("hosted catalog"); - assert!(catalog.names.call_ids.is_empty()); + assert!(catalog.names.entries.values().all(Option::is_none)); assert!(matches!( ToolCatalog::resolve(&blobs, &target, &[builtin("unknown.operation")]).await, Err(LlmAdapterError::InvalidProviderRequest { .. }) diff --git a/crates/llm-runtime/tests/anthropic_messages_skills_live.rs b/crates/llm-runtime/tests/anthropic_messages_skills_live.rs index b2edeaeb2..72285d20e 100644 --- a/crates/llm-runtime/tests/anthropic_messages_skills_live.rs +++ b/crates/llm-runtime/tests/anthropic_messages_skills_live.rs @@ -316,7 +316,7 @@ async fn anthropic_messages_live_selects_and_reads_the_matching_skill() { }) .expect("admitted skill read call"); assert_eq!( - selected_call.tool_id.as_ref().map(|id| id.as_str()), + selected_call.tool_id().map(|id| id.as_str()), Some("vfs.read_file") ); assert_eq!(selected_call.tool_name.as_str(), "VfsRead"); diff --git a/crates/llm-runtime/tests/openai_responses_skills_live.rs b/crates/llm-runtime/tests/openai_responses_skills_live.rs index 262b2a1f4..83f4e4ba9 100644 --- a/crates/llm-runtime/tests/openai_responses_skills_live.rs +++ b/crates/llm-runtime/tests/openai_responses_skills_live.rs @@ -308,7 +308,7 @@ async fn openai_responses_live_selects_and_reads_the_matching_skill() { }) .expect("admitted skill read call"); assert_eq!( - selected_call.tool_id.as_ref().map(|id| id.as_str()), + selected_call.tool_id().map(|id| id.as_str()), Some("vfs.read_file") ); assert_eq!(selected_call.tool_name.as_str(), "vfs_read_file"); diff --git a/crates/llm-runtime/tests/provider_failures.rs b/crates/llm-runtime/tests/provider_failures.rs index a34837265..192547a84 100644 --- a/crates/llm-runtime/tests/provider_failures.rs +++ b/crates/llm-runtime/tests/provider_failures.rs @@ -344,7 +344,7 @@ async fn a_well_formed_unknown_name_still_reaches_the_unavailable_path() { assert_eq!(execution.result.status, LlmGenerationStatus::Succeeded); let call = &execution.result.facts.tool_calls[0]; assert_eq!(call.tool_name.as_str(), "functions.read_file"); - assert_eq!(call.tool_id, None, "no tool answers to this name"); + assert_eq!(call.target, None, "no tool answers to this name"); } #[tokio::test(flavor = "current_thread")] diff --git a/crates/mcp/src/lib.rs b/crates/mcp/src/lib.rs index a5e23d9f3..ad2405c4e 100644 --- a/crates/mcp/src/lib.rs +++ b/crates/mcp/src/lib.rs @@ -283,12 +283,7 @@ impl McpServerRecord { validate_remote_mcp_server_label(&self.default_server_label)?; validate_nonempty_optional("description", self.description.as_deref())?; validate_allowed_tools(self.allowed_tools.as_deref())?; - validate_execution_policy( - &self.default_server_label, - self.execution, - self.exposure, - self.allowed_tools.as_deref(), - )?; + validate_execution_policy(self.execution, self.exposure, self.allowed_tools.as_deref())?; self.auth_policy.validate()?; if matches!(self.auth_policy, McpServerAuthPolicy::None) && self.auth_grant_id.is_some() { return Err(McpRegistryError::InvalidInput { @@ -707,7 +702,6 @@ fn validate_allowed_tools(values: Option<&[String]>) -> Result<(), McpRegistryEr } fn validate_execution_policy( - server_label: &str, execution: McpExecution, exposure: McpExposure, allowed_tools: Option<&[String]>, @@ -723,7 +717,6 @@ fn validate_execution_policy( let Some(allowed_tools) = allowed_tools else { return Ok(()); }; - let prefix = runtime_tool_prefix(server_label); for remote_name in allowed_tools { validate_mcp_component( "runtime injected MCP tool", @@ -731,31 +724,10 @@ fn validate_execution_policy( "ASCII letters, digits, '_', '-'", |ch| ch.is_ascii_alphanumeric() || matches!(ch, '_' | '-'), )?; - let combined = format!("{prefix}{remote_name}"); - if combined.len() > 64 { - return Err(McpRegistryError::InvalidInput { - message: format!( - "runtime MCP tool name {combined:?} exceeds the 64-byte provider limit; shorten the server label or remote tool name, or use search exposure" - ), - }); - } } Ok(()) } -pub fn runtime_tool_prefix(server_label: &str) -> String { - let mut prefix = String::from("mcp_"); - for ch in server_label.chars() { - prefix.push(if ch.is_ascii_alphanumeric() || matches!(ch, '_' | '-') { - ch - } else { - '_' - }); - } - prefix.push_str("__"); - prefix -} - fn validate_scope_defaults(values: &[String]) -> Result<(), McpRegistryError> { let mut seen = std::collections::BTreeSet::new(); for value in values { @@ -950,7 +922,7 @@ mod tests { } #[test] - fn runtime_inject_selected_tools_must_fit_provider_function_names() { + fn runtime_inject_selected_tools_accept_long_names_and_require_provider_characters() { let mut record = put_request("durable-runtime-server-identifier", McpServerStatus::Active).into_record(); record.execution = McpExecution::Runtime; @@ -961,11 +933,11 @@ mod tests { .validate() .expect("the compact server label determines the injected tool name"); - record.allowed_tools = Some(vec!["x".repeat(60)]); - assert!(matches!( - record.validate(), - Err(McpRegistryError::InvalidInput { .. }) - )); + record.default_server_label = "s".repeat(128); + record.allowed_tools = Some(vec!["x".repeat(128)]); + record + .validate() + .expect("long names are aliased at injection"); record.allowed_tools = Some(vec!["not/a/function".to_owned()]); assert!(matches!( diff --git a/crates/temporal-runtime/src/gateway/service/mcp_api.rs b/crates/temporal-runtime/src/gateway/service/mcp_api.rs index 552968929..02067c15d 100644 --- a/crates/temporal-runtime/src/gateway/service/mcp_api.rs +++ b/crates/temporal-runtime/src/gateway/service/mcp_api.rs @@ -532,7 +532,7 @@ pub(super) fn map_mcp_error(error: mcp::McpRegistryError) -> AgentApiError { fn default_mcp_tool_id(server_label: &str) -> Result { let mut tool_id = String::from("mcp_"); for ch in server_label.chars() { - if tool_id.len() >= 64 { + if tool_id.len() >= harness::TOOL_NAME_MAX_LEN { break; } tool_id.push(if ch.is_ascii_alphanumeric() || matches!(ch, '_' | '-') { diff --git a/crates/temporal-runtime/src/gateway/service/mcp_discovery.rs b/crates/temporal-runtime/src/gateway/service/mcp_discovery.rs index ab81611fa..de9231441 100644 --- a/crates/temporal-runtime/src/gateway/service/mcp_discovery.rs +++ b/crates/temporal-runtime/src/gateway/service/mcp_discovery.rs @@ -1219,7 +1219,7 @@ fn failure(kind: FailureKind, message: impl Into) -> McpToolDiscoveryFai } #[cfg(test)] -mod tests { +pub(crate) mod tests { use super::*; use axum::{ Json, Router, @@ -1235,7 +1235,9 @@ mod tests { use tokio::sync::Mutex; #[derive(Default)] - struct TestMcpState { + pub(crate) struct TestMcpState { + pub(crate) tool_names: Vec, + pub(crate) called_names: Vec, discover_count: usize, initialize_count: usize, initialized_count: usize, @@ -1250,6 +1252,18 @@ mod tests { tools_list_changed: bool, } + pub(crate) async fn start_test_server( + state: Arc>, + ) -> (String, tokio::task::JoinHandle<()>) { + let app = Router::new() + .route("/mcp", post(streamable_handler).delete(shutdown_handler)) + .with_state(state); + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let address = listener.local_addr().unwrap(); + let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() }); + (format!("http://{address}/mcp"), server) + } + async fn streamable_handler( State(shared_state): State>>, headers: HeaderMap, @@ -1352,7 +1366,14 @@ mod tests { .into_response(); } let cursor = request.pointer("/params/cursor").and_then(Value::as_str); - let result = if cursor.is_none() { + let result = if !state.tool_names.is_empty() { + let tools: Vec<_> = state + .tool_names + .iter() + .map(|name| json!({"name": name, "inputSchema": {"type": "object"}})) + .collect(); + json!({"tools": tools}) + } else if cursor.is_none() { json!({ "tools": [{ "name": "search", @@ -1382,6 +1403,9 @@ mod tests { } Some("tools/call") => { state.tool_call_count += 1; + state + .called_names + .push(request["params"]["name"].as_str().unwrap().into()); Json(json!({ "jsonrpc": "2.0", "id": id, @@ -1792,16 +1816,7 @@ mod tests { #[tokio::test(flavor = "current_thread")] async fn custom_headers_reach_every_discovery_and_tool_call_request() { let state = Arc::new(Mutex::new(TestMcpState::default())); - let app = Router::new() - .route("/mcp", post(streamable_handler).delete(shutdown_handler)) - .with_state(state.clone()); - let listener = tokio::net::TcpListener::bind("127.0.0.1:0") - .await - .expect("bind fixture"); - let address = listener.local_addr().expect("fixture address"); - let server = tokio::spawn(async move { - axum::serve(listener, app).await.expect("serve fixture"); - }); + let (endpoint, server) = start_test_server(state.clone()).await; let mut auth = McpRequestAuth::bearer("bearer-token"); auth.headers.insert( HeaderName::from_static("x-upstream-url"), @@ -1811,7 +1826,6 @@ mod tests { token.set_sensitive(true); auth.headers .insert(HeaderName::from_static("x-upstream-token"), token); - let endpoint = format!("http://{address}/mcp"); let transport = HttpMcpToolDiscoverer::new(); transport diff --git a/crates/temporal-runtime/src/worker/activities/storage.rs b/crates/temporal-runtime/src/worker/activities/storage.rs index f062efa54..debf44c0f 100644 --- a/crates/temporal-runtime/src/worker/activities/storage.rs +++ b/crates/temporal-runtime/src/worker/activities/storage.rs @@ -2061,7 +2061,7 @@ mod tests { tool_calls: vec![ ObservedToolCall { call_id: harness::ToolCallId::new("report-call"), - tool_id: Some(ToolId::new("work_report")), + target: Some(ToolId::new("work_report").into()), tool_name: ToolName::new("work_report"), provider_kind: None, arguments_ref: BlobRef::from_bytes(b"{\"outcome\":\"complete\"}"), @@ -2069,7 +2069,7 @@ mod tests { }, ObservedToolCall { call_id: harness::ToolCallId::new("approval-call"), - tool_id: Some(ToolId::new("request_approval")), + target: Some(ToolId::new("request_approval").into()), tool_name: ToolName::new("request_approval"), provider_kind: None, arguments_ref: BlobRef::from_bytes(b"{\"reason\":\"ship it\"}"), diff --git a/crates/temporal-runtime/src/worker/activities/tools.rs b/crates/temporal-runtime/src/worker/activities/tools.rs index 6de9ee790..ee9840989 100644 --- a/crates/temporal-runtime/src/worker/activities/tools.rs +++ b/crates/temporal-runtime/src/worker/activities/tools.rs @@ -69,15 +69,16 @@ pub(super) async fn prepare_code_tool_scope( let mut bindings = BTreeMap::new(); let mut names = std::collections::BTreeSet::new(); let mut runtime_tool_count = 0; - let mut insert = |tool_id: harness::ToolId, tool_name: harness::ToolName| { + let mut insert = |target, tool_name: harness::ToolName| { if !names.insert(tool_name.clone()) { return Err(activity_error(anyhow::anyhow!( "duplicate exposed code tool name {tool_name}" ))); } - let input = serde_json::to_vec(&(&tool_id, &tool_name)).map_err(activity_error)?; + let binding = harness::CodeToolBinding { target, tool_name }; + let input = serde_json::to_vec(&binding).map_err(activity_error)?; let handle = format!("binding:{}", harness::BlobRef::from_bytes(&input)); - bindings.insert(handle, harness::CodeToolBinding { tool_id, tool_name }); + bindings.insert(handle, binding); Ok(()) }; for tool in resolved { @@ -88,16 +89,16 @@ pub(super) async fn prepare_code_tool_scope( let executor = deps.runtime_mcp.as_ref().ok_or_else(|| { activity_error(anyhow::anyhow!("runtime MCP inventory is unavailable")) })?; - for (name, _) in executor + for (name, remote) in executor .injected_tools(spec, &tool.name, &mut runtime_tool_count) .await .map_err(activity_error)? { - insert(tool.id.clone(), harness::ToolName::new(name))?; + insert(remote.target(&tool.id, spec), harness::ToolName::new(name))?; } } } else if let Some(callable) = tool.into_callable() { - insert(callable.tool_id, callable.definition.name)?; + insert(callable.tool_id.into(), callable.definition.name)?; } } Ok(temporal_workflow::CodeToolPrepareScopeActivityResult { bindings }) @@ -492,10 +493,17 @@ fn validate_code_tool_presentation(call: &harness::ToolInvocationRequest) -> Res .as_ref() .ok_or_else(|| "code tool call has no admitted tool ID".to_owned())?; if let Some(harness::RemoteMcpCallRuntime::Injected { - remote_tool_name, .. + target, + remote_tool_name, + .. }) = &call.remote_mcp { - return (call.tool_name.as_str() == format!("{id}__{remote_tool_name}")) + let advertised = llm_runtime::injected_tool_name( + &id.as_wire_name(), + &target.server_label, + remote_tool_name, + ); + return (advertised.as_deref() == Some(call.tool_name.as_str())) .then_some(()) .ok_or_else(|| "code tool MCP name does not match its admitted binding".to_owned()); } @@ -688,6 +696,9 @@ mod tests { } } + const ECHO_REMOTE: &str = + "echo_document_attachment_metadata_for_all_selected_workspaces_by_identifier"; + async fn mcp_call( blobs: &dyn BlobStore, call_id: &str, @@ -701,7 +712,10 @@ mod tests { builtin: None, call_id: ToolCallId::new(call_id), tool_id: Some(ToolId::new("mcp_echo")), - tool_name: ToolName::new("mcp_echo__hello"), + tool_name: ToolName::new( + llm_runtime::injected_tool_name(&ToolName::new("mcp_echo"), "echo", ECHO_REMOTE) + .unwrap(), + ), arguments_ref, workflow_tool: None, promise_control: None, @@ -713,7 +727,7 @@ mod tests { allowed_tools: None, approval: RemoteMcpApprovalPolicy::Always, }, - remote_tool_name: "hello".to_owned(), + remote_tool_name: ECHO_REMOTE.into(), approval_decision, }), } @@ -816,6 +830,151 @@ mod tests { .expect("error text") } + #[tokio::test(flavor = "current_thread")] + async fn shortened_injected_tools_call_the_exact_remote_name_directly_and_from_code() { + use crate::gateway::service::mcp_discovery::tests::{TestMcpState, start_test_server}; + use mcp::McpRegistryStore; + + let first = "export_all_attached_document_records_for_personal_accounts_with_full_metadata"; + let second = first.replace("personal", "business"); + let remotes = [first, second.as_str()]; + let mut state = TestMcpState::default(); + state + .tool_names + .extend(remotes.iter().map(|s| s.to_string())); + let state = Arc::new(tokio::sync::Mutex::new(state)); + let (endpoint, server) = start_test_server(state.clone()).await; + + let registry = Arc::new(mcp::InMemoryMcpRegistryStore::new()); + registry + .put_server( + mcp::PutMcpServerRecord { + server_id: mcp::McpServerId::new("echo"), + display_name: None, + server_url: endpoint, + transport: Default::default(), + default_server_label: "echo".into(), + description: None, + allowed_tools: None, + execution: mcp::McpExecution::Runtime, + exposure: mcp::McpExposure::Inject, + approval: mcp::McpApprovalPolicy::Never, + defer_loading: None, + allow_private_network: true, + auth_policy: mcp::McpServerAuthPolicy::None, + auth_grant_id: None, + headers: Default::default(), + status: mcp::McpServerStatus::Active, + now_ms: 1, + }, + None, + ) + .await + .unwrap(); + let policy = McpPrivateNetworkPolicy::parse(Some("127.0.0.1/32")).unwrap(); + let secrets: Arc = Arc::new(AbsentSecretResolver); + let inventory = Arc::new(RuntimeMcpInventoryResolver::new( + registry.clone(), + secrets.clone(), + policy.clone(), + )); + let executor = Arc::new(RuntimeMcpExecutor::new( + registry, secrets, inventory, policy, + )); + let blobs: Arc = Arc::new(InMemoryBlobStore::new()); + let (deps, _) = deps(RuntimeScript::Complete, blobs.clone(), Some(executor)); + let id = ToolId::new("mcp_echo"); + let scope = prepare_code_tool_scope( + &deps, + temporal_workflow::CodeToolPrepareScopeActivityRequest { + tools: vec![harness::ToolSpec { + id: id.clone(), + execution: Default::default(), + parallelism: harness::ToolParallelism::ParallelSafe, + kind: harness::ToolKind::RemoteMcp(harness::RemoteMcpToolSpec { + server_id: "echo".into(), + server_label: "echo".into(), + record_revision: 1, + allowed_tools: None, + description_ref: None, + execution: harness::RemoteMcpExecution::Runtime, + exposure: harness::RemoteMcpExposure::Inject, + approval: RemoteMcpApprovalPolicy::Never, + defer_loading: None, + }), + }], + model: harness::ModelSelection { + api_kind: harness::ProviderApiKind::OpenAiResponses, + provider_id: "openai".into(), + model: "test".into(), + }, + }, + ) + .await + .unwrap(); + + assert_eq!(scope.bindings.len(), 2); + for remote in remotes { + let alias = + llm_runtime::injected_tool_name(&id.as_wire_name(), "echo", remote).unwrap(); + let binding = scope + .bindings + .values() + .find(|b| b.tool_name.as_str() == alias) + .unwrap(); + let harness::ResolvedToolTarget::Mcp { + remote_name: exact, .. + } = &binding.target + else { + panic!("expected MCP target") + }; + assert_eq!(exact, remote); + let mut call = mcp_call(blobs.as_ref(), "call_1", None).await; + call.tool_name = binding.tool_name.clone(); + let Some(RemoteMcpCallRuntime::Injected { + target, + remote_tool_name, + .. + }) = &mut call.remote_mcp + else { + unreachable!() + }; + target.approval = RemoteMcpApprovalPolicy::Never; + remote_tool_name.clone_from(exact); + let request = batch(vec![call]) + .request + .call_request(0, Default::default()) + .unwrap(); + let ToolInvokeCallActivityResult::Completed { result } = invoke_call( + &deps, + crate::worker::ToolInvokeCallActivityRequest { + request: request.clone(), + }, + ) + .await + .unwrap() else { + panic!("direct call did not finish") + }; + assert_eq!(result.status, ToolCallStatus::Succeeded); + let temporal_workflow::CodeToolInvokeActivityResult::Completed { result } = + invoke_code_tool( + &deps, + temporal_workflow::CodeToolInvokeActivityRequest { request }, + ) + .await + .unwrap() + else { + panic!("code call did not finish") + }; + assert_eq!(result.status, ToolCallStatus::Succeeded); + } + assert_eq!( + state.lock().await.called_names, + [first, first, &second, &second] + ); + server.abort(); + } + #[tokio::test(flavor = "current_thread")] async fn code_tool_calls_reject_approval_before_mcp_execution_even_with_an_old_decision() { let blobs: Arc = Arc::new(InMemoryBlobStore::new()); @@ -1048,7 +1207,7 @@ mod tests { .. } = subject; assert_eq!(server_id, "echo"); - assert_eq!(tool_name, "hello"); + assert_eq!(tool_name, ECHO_REMOTE); assert!(received_call_ids(&tools).is_empty()); } diff --git a/crates/temporal-runtime/src/worker/fake.rs b/crates/temporal-runtime/src/worker/fake.rs index 4d8c68261..b4435f4c0 100644 --- a/crates/temporal-runtime/src/worker/fake.rs +++ b/crates/temporal-runtime/src/worker/fake.rs @@ -282,7 +282,7 @@ impl FakeLlm { }); tool_calls.push(ObservedToolCall { call_id, - tool_id: Some(tool_id.clone()), + target: Some(tool_id.clone().into()), tool_name: tool_name.clone(), provider_kind: Some("fake".to_owned()), arguments_ref, diff --git a/crates/temporal-runtime/tests/code_capabilities_live.rs b/crates/temporal-runtime/tests/code_capabilities_live.rs index 124e8bc55..e48eb98d0 100644 --- a/crates/temporal-runtime/tests/code_capabilities_live.rs +++ b/crates/temporal-runtime/tests/code_capabilities_live.rs @@ -120,7 +120,7 @@ impl CoreAgentLlm for ScriptedLlm { LlmFinish::ToolCalls, vec![ObservedToolCall { call_id, - tool_id: Some(tool_id), + target: Some(tool_id.into()), tool_name: name, provider_kind: None, arguments_ref: reference.clone(), diff --git a/crates/temporal-runtime/tests/code_worker_process_live.rs b/crates/temporal-runtime/tests/code_worker_process_live.rs index c12dba686..bea9c5060 100644 --- a/crates/temporal-runtime/tests/code_worker_process_live.rs +++ b/crates/temporal-runtime/tests/code_worker_process_live.rs @@ -74,7 +74,7 @@ impl CoreAgentLlm for CodeCallLlm { assert!(tool_id.is_some(), "code mode must advertise code_execute"); vec![ObservedToolCall { call_id: call_id.clone(), - tool_id, + target: tool_id.map(Into::into), tool_name: name.clone(), provider_kind: None, arguments_ref: reference.clone(), diff --git a/crates/temporal-runtime/tests/code_workflow_live.rs b/crates/temporal-runtime/tests/code_workflow_live.rs index 072178adc..19a144df1 100644 --- a/crates/temporal-runtime/tests/code_workflow_live.rs +++ b/crates/temporal-runtime/tests/code_workflow_live.rs @@ -111,7 +111,7 @@ impl CoreAgentLlm for CodeCallLlm { LlmFinish::ToolCalls, vec![ObservedToolCall { call_id, - tool_id, + target: tool_id.map(Into::into), tool_name: name, provider_kind: None, arguments_ref: reference.clone(), diff --git a/crates/temporal-runtime/tests/fake_loop.rs b/crates/temporal-runtime/tests/fake_loop.rs index 840b3e13e..6c9364713 100644 --- a/crates/temporal-runtime/tests/fake_loop.rs +++ b/crates/temporal-runtime/tests/fake_loop.rs @@ -144,7 +144,7 @@ async fn assert_tool_loop(builtin: bool) { } else { (FAKE_TOOL_NAME, FAKE_TOOL_NAME) }; - assert_eq!(calls[0].tool_id.as_ref().map(ToolId::as_str), Some(id)); + assert_eq!(calls[0].tool_id().map(ToolId::as_str), Some(id)); assert_eq!(calls[0].tool_name.as_str(), name); let content = completed.output.as_ref().expect("output content"); let output = api_projection::project_content_text(blobs.as_ref(), content) diff --git a/crates/temporal-runtime/tests/mcp_live.rs b/crates/temporal-runtime/tests/mcp_live.rs index debc87356..d3bde1e23 100644 --- a/crates/temporal-runtime/tests/mcp_live.rs +++ b/crates/temporal-runtime/tests/mcp_live.rs @@ -325,6 +325,38 @@ impl CoreAgentLlm for MatrixScriptedLlm { } } +fn scripted_injected_tool( + request: &LlmGenerationRequest, + server_id: &str, + remote: &str, +) -> Option { + request.request.tools.iter().find_map(|tool| { + let ToolKind::RemoteMcp(spec) = &tool.kind else { + return None; + }; + if spec.server_id != server_id + || spec.execution != harness::RemoteMcpExecution::Runtime + || spec.exposure != harness::RemoteMcpExposure::Inject + || spec + .allowed_tools + .as_ref() + .is_some_and(|names| !names.iter().any(|name| name == remote)) + { + return None; + } + let name = + llm_runtime::injected_tool_name(&tool.id.as_wire_name(), &spec.server_label, remote)?; + Some(harness::CodeToolBinding { + tool_name: ToolName::new(name), + target: harness::ResolvedToolTarget::Mcp { + server_tool_id: tool.id.clone(), + server_label: spec.server_label.clone(), + remote_name: remote.into(), + }, + }) + }) +} + impl MatrixScriptedLlm { async fn tool_call( &self, @@ -340,6 +372,10 @@ impl MatrixScriptedLlm { .map_err(io_error)?; let call_id = ToolCallId::new(call_id); let tool_name = ToolName::new(tool); + let binding = ["echo", "rich"] + .into_iter() + .filter_map(|remote| scripted_injected_tool(request, &self.ids.small, remote)) + .find(|binding| binding.tool_name == tool_name); Ok(LlmGenerationResult { run_id: request.run_id, turn_id: request.turn_id, @@ -367,7 +403,9 @@ impl MatrixScriptedLlm { usage: None, tool_calls: vec![ObservedToolCall { call_id, - tool_id: test_support::scripted_tool_id(request, tool_name.as_str()), + target: binding.map(|b| b.target).or_else(|| { + test_support::scripted_tool_id(request, tool_name.as_str()).map(Into::into) + }), tool_name, provider_kind: Some("mcp-live-matrix".to_owned()), arguments_ref, @@ -1969,7 +2007,8 @@ impl RuntimeMcpScriptedLlm { usage: None, tool_calls: vec![ObservedToolCall { call_id, - tool_id: test_support::scripted_tool_id(request, tool_name.as_str()), + target: test_support::scripted_tool_id(request, tool_name.as_str()) + .map(Into::into), tool_name, provider_kind: Some("runtime-mcp-script".to_owned()), arguments_ref, @@ -2854,21 +2893,12 @@ impl CoreAgentLlm for MixedBatchScriptedLlm { } impl MixedBatchScriptedLlm { - /// The injected call name is `__`; the server - /// tool is found by its record id so the test never hard-codes the - /// label-derived tool name. fn injected_tool_name( &self, request: &LlmGenerationRequest, ) -> Result { - request - .request - .tools - .iter() - .find(|tool| { - matches!(&tool.kind, ToolKind::RemoteMcp(spec) if spec.server_id == self.server_id) - }) - .map(|tool| format!("{}__{}", tool.id, self.selected_tool)) + scripted_injected_tool(request, &self.server_id, &self.selected_tool) + .map(|binding| binding.tool_name.to_string()) .ok_or_else(|| CoreAgentIoError::Failed { message: format!( "mixed batch scripted model expected the {} MCP server tool", @@ -2907,9 +2937,13 @@ impl MixedBatchScriptedLlm { provenance_ref: None, token_estimate: None, }); + let binding = scripted_injected_tool(request, &self.server_id, &self.selected_tool) + .filter(|binding| binding.tool_name == tool_name); tool_calls.push(ObservedToolCall { call_id, - tool_id: test_support::scripted_tool_id(request, tool_name.as_str()), + target: binding.map(|b| b.target).or_else(|| { + test_support::scripted_tool_id(request, tool_name.as_str()).map(Into::into) + }), tool_name, provider_kind: Some("mixed-batch-script".to_owned()), arguments_ref, diff --git a/crates/temporal-runtime/tests/subagents_live.rs b/crates/temporal-runtime/tests/subagents_live.rs index 7a477a8a9..1a0964763 100644 --- a/crates/temporal-runtime/tests/subagents_live.rs +++ b/crates/temporal-runtime/tests/subagents_live.rs @@ -308,7 +308,7 @@ impl SubagentScriptedLlm { }); tool_calls.push(ObservedToolCall { call_id, - tool_id: test_support::scripted_tool_id(request, tool_name.as_str()), + target: test_support::scripted_tool_id(request, tool_name.as_str()).map(Into::into), tool_name, provider_kind: Some("subagent-script".to_owned()), arguments_ref, diff --git a/crates/temporal-runtime/tests/support/code_tools.rs b/crates/temporal-runtime/tests/support/code_tools.rs index ae8a6379e..16d3f810f 100644 --- a/crates/temporal-runtime/tests/support/code_tools.rs +++ b/crates/temporal-runtime/tests/support/code_tools.rs @@ -119,7 +119,7 @@ impl CoreAgentLlm for OuterCallLlm { LlmFinish::ToolCalls, vec![ObservedToolCall { call_id, - tool_id: test_support::scripted_tool_id(&request, OUTER), + target: test_support::scripted_tool_id(&request, OUTER).map(Into::into), tool_name: name, provider_kind: None, arguments_ref: reference.clone(), diff --git a/crates/temporal-runtime/tests/vfs_transfer_live.rs b/crates/temporal-runtime/tests/vfs_transfer_live.rs index d37979f3d..bfc38df99 100644 --- a/crates/temporal-runtime/tests/vfs_transfer_live.rs +++ b/crates/temporal-runtime/tests/vfs_transfer_live.rs @@ -1032,7 +1032,7 @@ impl CoreAgentLlm for TransferLlm { let tool_name = ToolName::new(name); calls.push(ObservedToolCall { call_id: call_id.clone(), - tool_id: test_support::scripted_tool_id(&request, name), + target: test_support::scripted_tool_id(&request, name).map(Into::into), tool_name: tool_name.clone(), provider_kind: None, arguments_ref, diff --git a/crates/temporal-runtime/tests/workflow_tool_plugins_live.rs b/crates/temporal-runtime/tests/workflow_tool_plugins_live.rs index 048d32793..4562a34ce 100644 --- a/crates/temporal-runtime/tests/workflow_tool_plugins_live.rs +++ b/crates/temporal-runtime/tests/workflow_tool_plugins_live.rs @@ -619,7 +619,8 @@ impl WorkflowToolScriptedLlm { usage: None, tool_calls: vec![ObservedToolCall { call_id, - tool_id: test_support::scripted_tool_id(request, tool_name.as_str()), + target: test_support::scripted_tool_id(request, tool_name.as_str()) + .map(Into::into), tool_name, provider_kind: Some("workflow-tool-script".to_owned()), arguments_ref, diff --git a/crates/temporal-workflow/src/workflows/session/code_tools.rs b/crates/temporal-workflow/src/workflows/session/code_tools.rs index e1b933fbe..d93394265 100644 --- a/crates/temporal-workflow/src/workflows/session/code_tools.rs +++ b/crates/temporal-workflow/src/workflows/session/code_tools.rs @@ -354,7 +354,7 @@ fn invocation_command( request_id: request.request_id, }, binding_id: request.binding_id, - tool_id: binding.tool_id.clone(), + tool_id: binding.target.tool_id().clone(), tool_name: binding.tool_name.clone(), arguments_ref: request.arguments_ref, }, @@ -377,7 +377,7 @@ async fn admit_open( .spec .bindings .values() - .map(|binding| binding.tool_id.clone()) + .map(|binding| binding.target.tool_id().clone()) .collect::>(); return Ok( if existing.spec.parent_invocation_id == request.parent_invocation_id @@ -508,7 +508,7 @@ async fn admit_open( if request.allowed_tools.as_ref().is_some_and(|allowed| { bindings .values() - .map(|binding| binding.tool_id.clone()) + .map(|binding| binding.target.tool_id().clone()) .collect::>() != *allowed }) { @@ -1072,7 +1072,7 @@ mod tests { bindings.insert( request_id.to_owned(), harness::CodeToolBinding { - tool_id: tool_id.clone(), + target: tool_id.clone().into(), tool_name: tool_id.as_wire_name(), }, ); diff --git a/crates/temporal-workflow/src/workflows/session/restart.rs b/crates/temporal-workflow/src/workflows/session/restart.rs index 75b494f5d..57f5de1a6 100644 --- a/crates/temporal-workflow/src/workflows/session/restart.rs +++ b/crates/temporal-workflow/src/workflows/session/restart.rs @@ -448,7 +448,7 @@ mod tests { .iter() .map(|(call_id, tool)| ObservedToolCall { call_id: ToolCallId::new(*call_id), - tool_id: Some(ToolId::new(*tool)), + target: Some(ToolId::new(*tool).into()), tool_name: ToolName::new(*tool), provider_kind: None, arguments_ref: BlobRef::from_bytes(call_id.as_bytes()), @@ -643,7 +643,16 @@ mod tests { let mut session = Session::opened(vec![runtime_mcp_tool("mcp_mail")]); session.request_run(b"hi", "sub-1"); let generation = session.until_generation(); - session.finish_turn_with_calls(&generation, &[("c1", "mcp_mail")]); + let mut result = tool_call_generation(&generation, &[("c1", "mcp_mail__send")]); + let call = &mut result.facts.tool_calls[0]; + call.target = Some(harness::ResolvedToolTarget::Mcp { + server_tool_id: ToolId::new("mcp_mail"), + server_label: "mail".into(), + remote_name: "send".into(), + }); + let now = session.tick(); + let action = session.drive.resume_generation(result, now).unwrap(); + session.commit(action); let batch = session.until_batch(); let subject = ApprovalSubject::McpToolCall { server_id: "mail".to_owned(), diff --git a/crates/temporal-workflow/src/workflows/session/tests.rs b/crates/temporal-workflow/src/workflows/session/tests.rs index 45535d55f..8c1438272 100644 --- a/crates/temporal-workflow/src/workflows/session/tests.rs +++ b/crates/temporal-workflow/src/workflows/session/tests.rs @@ -1049,7 +1049,7 @@ fn workflow_with_parked_tool_batch(spec: harness::AwaitSpec) -> AgentSessionWork calls: vec![harness::ToolCallState { call: harness::ObservedToolCall { call_id: call_id.clone(), - tool_id: Some(harness::ToolId::new("await")), + target: Some(harness::ToolId::new("await").into()), tool_name: harness::ToolName::new("await"), provider_kind: None, arguments_ref: harness::BlobRef::from_bytes(b"{}"), diff --git a/crates/test-support/src/runner/drive.rs b/crates/test-support/src/runner/drive.rs index 2c7b12bcb..e9229f404 100644 --- a/crates/test-support/src/runner/drive.rs +++ b/crates/test-support/src/runner/drive.rs @@ -1069,7 +1069,7 @@ mod tests { approval_requests: Vec::new(), tool_calls: vec![ObservedToolCall { call_id: harness::ToolCallId::new("call-1"), - tool_id: Some(ToolId::new("test_tool")), + target: Some(ToolId::new("test_tool").into()), tool_name: ToolName::new("test_tool"), provider_kind: None, arguments_ref: BlobRef::from_bytes(br#"{}"#), @@ -1125,7 +1125,7 @@ mod tests { approval_requests: Vec::new(), tool_calls: vec![ObservedToolCall { call_id: harness::ToolCallId::new(self.call_id.clone()), - tool_id: Some(ToolId::new("vfs.read_file")), + target: Some(ToolId::new("vfs.read_file").into()), tool_name: ToolName::new("vfs_read_file"), provider_kind: None, arguments_ref, diff --git a/crates/test-support/src/tool_calls.rs b/crates/test-support/src/tool_calls.rs index 0b9f718c7..5164da970 100644 --- a/crates/test-support/src/tool_calls.rs +++ b/crates/test-support/src/tool_calls.rs @@ -1,6 +1,6 @@ //! Resolve names emitted by scripted models against their admitted request. -use harness::{LlmGenerationRequest, RemoteMcpExecution, RemoteMcpExposure, ToolId, ToolKind}; +use harness::{LlmGenerationRequest, ToolId, ToolKind}; /// Scripted tests supply their own MCP inventory. Built-in names still come /// from the real resolver, so test models cannot accidentally rely on registry @@ -18,20 +18,7 @@ pub fn scripted_tool_id(request: &LlmGenerationRequest, name: &str) -> Option { - spec.execution == RemoteMcpExecution::Runtime - && spec.exposure == RemoteMcpExposure::Inject - && name - .strip_prefix(&format!("{}__", tool.id)) - .is_some_and(|remote_name| { - !remote_name.is_empty() - && spec.allowed_tools.as_ref().is_none_or(|allowed| { - allowed - .iter() - .any(|allowed_name| allowed_name == remote_name) - }) - }) - } + ToolKind::RemoteMcp(_) => false, }; exposed.then(|| tool.id.clone()) }) diff --git a/crates/tools/src/callable.rs b/crates/tools/src/callable.rs index 5a39bb06f..8ac0a3c53 100644 --- a/crates/tools/src/callable.rs +++ b/crates/tools/src/callable.rs @@ -355,7 +355,7 @@ fn validate_provider_options(function: &FunctionDefinition) -> Result<(), Catalo pub fn valid_exposed_name(name: &str) -> bool { !name.is_empty() - && name.len() <= 64 + && name.len() <= harness::TOOL_NAME_MAX_LEN && name .bytes() .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-')) From 95016fe2a077127a541f6c1779a7a663b38b9933 Mon Sep 17 00:00:00 2001 From: lb <542828+lukebuehler@users.noreply.github.com> Date: Thu, 19 Nov 2026 21:53:41 +0100 Subject: [PATCH 3/4] Prevent duplicate resource selections in the profile editor Fixes #147. --- .../session/session-config-editor.tsx | 54 +++++++------ .../session/session-config-skills.test.tsx | 77 +++++++++++++++++-- 2 files changed, 102 insertions(+), 29 deletions(-) diff --git a/platform/web/src/components/session/session-config-editor.tsx b/platform/web/src/components/session/session-config-editor.tsx index f067d4a21..89b9abd2d 100644 --- a/platform/web/src/components/session/session-config-editor.tsx +++ b/platform/web/src/components/session/session-config-editor.tsx @@ -1370,6 +1370,8 @@ function VfsFields({ } } const options = [...workspaceOptions.values()]; + const attachedIds = new Set(attachments.map((attachment) => attachment.workspaceId)); + const nextWorkspace = workspaces.find((workspace) => !attachedIds.has(workspace.workspaceId)); const updateAttachments = (nextAttachments: RecordValue[]) => patch((next) => { if (nextAttachments.length) next.workspaces = nextAttachments; @@ -1396,15 +1398,15 @@ function VfsFields({ Attach workspaces at session paths with their own access grants. Files written here remain visible through the workspace, even when the session is restricted.

-