Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust

test(embed): cover 429/503 retries in the Google, Copilot and Voyage embedders

Vinícius DS Andradeba68dd5f7935
diff --git a/crates/ai-memory-llm/tests/suite/embedder_retry_after.rs b/crates/ai-memory-llm/tests/suite/embedder_retry_after.rs
new file mode 100644
index 00000000..6034dfc9
--- /dev/null
+++ b/crates/ai-memory-llm/tests/suite/embedder_retry_after.rs
@@ -0,0 +1,213 @@
+//! Retry behaviour of the Google, Copilot and Voyage embedders against an
+//! in-process wiremock. They share the policy `openai_compat_retry_after.rs`
+//! pins for the OpenAI-shape embedders: 429 and 503 are retried, and a call
+//! gives up with the last status after five new attempts (six requests).
+//!
+//! Every mock answers with `Retry-After: 0`, so the waits are zero and
+//! no test sleeps for more than an instant.
+
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use ai_memory_llm::{
+ CopilotEmbedder, Embedder, GoogleEmbedder, LlmError, ProviderAuth, VoyageEmbedder,
+};
+use secrecy::SecretString;
+use serde_json::json;
+use wiremock::matchers::{method, path};
+use wiremock::{Mock, MockServer, Request, ResponseTemplate};
+
+const GOOGLE_ROUTE: &str = "/v1beta/models/gemini-embedding-001:embedContent";
+const COPILOT_ROUTE: &str = "/embeddings";
+const VOYAGE_ROUTE: &str = "/v1/embeddings";
+
+fn google(server: &MockServer) -> GoogleEmbedder {
+ GoogleEmbedder::new(SecretString::from("test-key"), "gemini-embedding-001", 2)
+ .expect("google embedder builds")
+ .with_base_url(server.uri())
+}
+
+/// A direct Copilot API token skips the GitHub token exchange, so only the
+/// embeddings request reaches the mock.
+fn copilot(server: &MockServer) -> CopilotEmbedder {
+ let auth = ProviderAuth::copilot(
+ "/nonexistent/auth.json",
+ None,
+ Some(SecretString::from("copilot-api-token")),
+ Some(server.uri()),
+ )
+ .require_copilot_auth()
+ .expect("direct-token copilot auth resolves");
+ CopilotEmbedder::new(auth, "text-embedding-3-small", 2).expect("copilot embedder builds")
+}
+
+fn voyage(server: &MockServer) -> VoyageEmbedder {
+ VoyageEmbedder::new(SecretString::from("test-key"), "voyage-3-large", 2)
+ .expect("voyage embedder builds")
+ .with_base_url(server.uri())
+}
+
+/// Gemini's `embedContent` answer.
+fn google_body() -> serde_json::Value {
+ json!({ "embedding": { "values": [0.6, 0.8] } })
+}
+
+/// The OpenAI-shape list both Copilot and Voyage answer with.
+fn list_body() -> serde_json::Value {
+ json!({
+ "object": "list",
+ "data": [{ "object": "embedding", "index": 0, "embedding": [0.6, 0.8] }],
+ "usage": { "total_tokens": 1 },
+ })
+}
+
+/// Answer the first `failures` requests to `route` with `status` and
+/// `Retry-After: 0`, then `success`. Returns the request counter.
+async fn mount_flaky(
+ server: &MockServer,
+ route: &str,
+ status: u16,
+ failures: usize,
+ success: serde_json::Value,
+) -> Arc<AtomicUsize> {
+ let hits = Arc::new(AtomicUsize::new(0));
+ let counter = hits.clone();
+ Mock::given(method("POST"))
+ .and(path(route))
+ .respond_with(move |_req: &Request| {
+ if counter.fetch_add(1, Ordering::SeqCst) < failures {
+ ResponseTemplate::new(status)
+ .insert_header("Retry-After", "0")
+ .set_body_string("temporarily unavailable")
+ } else {
+ ResponseTemplate::new(200).set_body_json(success.clone())
+ }
+ })
+ .mount(server)
+ .await;
+ hits
+}
+
+/// Answer every request to `route` with 503 and `Retry-After: 0`,
+/// expecting the initial request plus the five allowed new attempts.
+async fn mount_unavailable(server: &MockServer, route: &str) {
+ Mock::given(method("POST"))
+ .and(path(route))
+ .respond_with(
+ ResponseTemplate::new(503)
+ .insert_header("Retry-After", "0")
+ .set_body_string("temporarily unavailable"),
+ )
+ .expect(6)
+ .mount(server)
+ .await;
+}
+
+#[tokio::test]
+async fn google_503_twice_then_success_takes_three_requests() {
+ let server = MockServer::start().await;
+ let hits = mount_flaky(&server, GOOGLE_ROUTE, 503, 2, google_body()).await;
+ let v = google(&server)
+ .embed("retry me")
+ .await
+ .expect("embed succeeds after two 503s");
+ assert_eq!(v.len(), 2);
+ assert_eq!(
+ hits.load(Ordering::SeqCst),
+ 3,
+ "503, 503, 200: exactly three requests"
+ );
+}
+
+#[tokio::test]
+async fn google_endless_503_fails_after_six_requests() {
+ let server = MockServer::start().await;
+ mount_unavailable(&server, GOOGLE_ROUTE).await;
+ let err = google(&server)
+ .embed("retry me")
+ .await
+ .expect_err("an outage that never ends must fail");
+ assert!(
+ matches!(err, LlmError::Provider { status: 503, .. }),
+ "the last status is reported: {err:?}"
+ );
+ server.verify().await;
+}
+
+#[tokio::test]
+async fn copilot_503_twice_then_success_takes_three_requests() {
+ let server = MockServer::start().await;
+ let hits = mount_flaky(&server, COPILOT_ROUTE, 503, 2, list_body()).await;
+ let v = copilot(&server)
+ .embed("retry me")
+ .await
+ .expect("embed succeeds after two 503s");
+ assert_eq!(v.len(), 2);
+ assert_eq!(
+ hits.load(Ordering::SeqCst),
+ 3,
+ "503, 503, 200: exactly three requests"
+ );
+}
+
+#[tokio::test]
+async fn copilot_endless_503_fails_after_six_requests() {
+ let server = MockServer::start().await;
+ mount_unavailable(&server, COPILOT_ROUTE).await;
+ let err = copilot(&server)
+ .embed("retry me")
+ .await
+ .expect_err("an outage that never ends must fail");
+ assert!(
+ matches!(err, LlmError::Provider { status: 503, .. }),
+ "the last status is reported: {err:?}"
+ );
+ server.verify().await;
+}
+
+#[tokio::test]
+async fn voyage_503_twice_then_success_takes_three_requests() {
+ let server = MockServer::start().await;
+ let hits = mount_flaky(&server, VOYAGE_ROUTE, 503, 2, list_body()).await;
+ let v = voyage(&server)
+ .embed("retry me")
+ .await
+ .expect("embed succeeds after two 503s");
+ assert_eq!(v.len(), 2);
+ assert_eq!(
+ hits.load(Ordering::SeqCst),
+ 3,
+ "503, 503, 200: exactly three requests"
+ );
+}
+
+#[tokio::test]
+async fn voyage_429_once_then_success_takes_two_requests() {
+ let server = MockServer::start().await;
+ let hits = mount_flaky(&server, VOYAGE_ROUTE, 429, 1, list_body()).await;
+ let v = voyage(&server)
+ .embed("rate limited")
+ .await
+ .expect("embed succeeds after one 429");
+ assert_eq!(v.len(), 2);
+ assert_eq!(
+ hits.load(Ordering::SeqCst),
+ 2,
+ "429, 200: exactly two requests"
+ );
+}
+
+#[tokio::test]
+async fn voyage_endless_503_fails_after_six_requests() {
+ let server = MockServer::start().await;
+ mount_unavailable(&server, VOYAGE_ROUTE).await;
+ let err = voyage(&server)
+ .embed("retry me")
+ .await
+ .expect_err("an outage that never ends must fail");
+ assert!(
+ matches!(err, LlmError::Provider { status: 503, .. }),
+ "the last status is reported: {err:?}"
+ );
+ server.verify().await;
+}
diff --git a/crates/ai-memory-llm/tests/suite/mod.rs b/crates/ai-memory-llm/tests/suite/mod.rs
index 9032d3d9..de384c30 100644
--- a/crates/ai-memory-llm/tests/suite/mod.rs
+++ b/crates/ai-memory-llm/tests/suite/mod.rs
@@ -6,6 +6,7 @@ mod anthropic_provider;
mod copilot_embedder;
mod copilot_provider;
mod cursor_provider;
+mod embedder_retry_after;
mod extra_headers_on_the_wire;
mod fallback_provider;
mod openai_compat_embedder;