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
-