simple-agents-py 0.2.0__tar.gz → 0.2.2__tar.gz

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/Cargo.lock

@@ -2142,7 +2142,7 @@ checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
 name = "simple-agent-type"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-trait",
  "blake3",
@@ -2157,7 +2157,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-cache"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-trait",
  "simple-agent-type",
@@ -2166,7 +2166,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-cli"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "clap",
  "serde",
@@ -2183,10 +2183,11 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-core"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-trait",
  "futures-core",
+ "futures-util",
  "serde",
  "serde_json",
  "simple-agent-type",
@@ -2194,11 +2195,12 @@ dependencies = [
  "simple-agents-healing",
  "simple-agents-router",
  "tokio",
+ "tracing",
 ]
 
 [[package]]
 name = "simple-agents-examples"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "dotenv",
  "futures-util",
@@ -2211,7 +2213,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-ffi"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-trait",
  "simple-agent-type",
@@ -2222,7 +2224,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-healing"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "criterion",
  "proptest",
@@ -2238,7 +2240,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-macros"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2250,7 +2252,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-napi"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "napi",
  "napi-derive",
@@ -2262,7 +2264,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-providers"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-trait",
  "bytes",
@@ -2290,7 +2292,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-py"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-trait",
  "futures-util",
@@ -2309,7 +2311,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-router"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-trait",
  "futures-core",

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 rust-version = "1.75"
 authors = ["SimpleAgents Contributors"]

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple-agents-py
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/crates/simple-agents-cache/src/memory.rs

@@ -132,11 +132,31 @@ impl InMemoryCache {
 #[async_trait]
 impl Cache for InMemoryCache {
     async fn get(&self, key: &str) -> Result<Option<Vec<u8>>> {
-        // First evict expired entries
-        self.evict_expired().await;
+        {
+            let store = self.store.read().await;
+            match store.get(key) {
+                Some(entry) if !entry.is_expired() => {
+                    drop(store);
+
+                    let mut store = self.store.write().await;
+                    if let Some(entry) = store.get_mut(key) {
+                        if entry.is_expired() {
+                            store.remove(key);
+                            return Ok(None);
+                        }
+
+                        entry.touch();
+                        return Ok(Some(entry.data.clone()));
+                    }
+
+                    return Ok(None);
+                }
+                Some(_) => {} // expired; clean up below
+                None => return Ok(None),
+            }
+        }
 
         let mut store = self.store.write().await;
-
         if let Some(entry) = store.get_mut(key) {
             if entry.is_expired() {
                 store.remove(key);
@@ -162,6 +182,9 @@ impl Cache for InMemoryCache {
             store.insert(key.to_string(), entry);
         }
 
+        // Periodically clear expired entries before enforcing limits
+        self.evict_expired().await;
+
         // Evict if needed
         self.evict_lru().await;
 
@@ -324,6 +347,27 @@ mod tests {
         assert!(cache.get("key3").await.unwrap().is_some());
     }
 
+    #[tokio::test]
+    async fn test_concurrent_gets_do_not_serialize_readers() {
+        let cache = Arc::new(InMemoryCache::new(1024, 10));
+        cache
+            .set("shared", b"value".to_vec(), Duration::from_secs(60))
+            .await
+            .unwrap();
+
+        let mut handles = Vec::new();
+        for _ in 0..25 {
+            let cache = cache.clone();
+            handles.push(tokio::spawn(
+                async move { cache.get("shared").await.unwrap() },
+            ));
+        }
+
+        for handle in handles {
+            assert_eq!(handle.await.unwrap(), Some(b"value".to_vec()));
+        }
+    }
+
     #[tokio::test]
     async fn test_cache_name() {
         let cache = InMemoryCache::new(1024, 10);

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/crates/simple-agents-core/Cargo.toml

@@ -16,11 +16,13 @@ async-trait.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 tokio.workspace = true
+futures-util.workspace = true
+tracing = "0.1"
 
 simple-agent-type = { workspace = true }
-simple-agents-router = { path = "../simple-agents-router", version = "0.2.0" }
-simple-agents-cache = { path = "../simple-agents-cache", version = "0.2.0" }
-simple-agents-healing = { path = "../simple-agents-healing", version = "0.2.0" }
+simple-agents-router = { path = "../simple-agents-router", version = "0.2.2" }
+simple-agents-cache = { path = "../simple-agents-cache", version = "0.2.2" }
+simple-agents-healing = { path = "../simple-agents-healing", version = "0.2.2" }
 futures-core = "0.3"
 
 [dev-dependencies]

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/crates/simple-agents-core/src/client.rs

@@ -4,6 +4,9 @@ use crate::healing::{HealedJsonResponse, HealedSchemaResponse, HealingSettings};
 use crate::middleware::Middleware;
 use crate::routing::{RouterEngine, RoutingMode};
 use async_trait::async_trait;
+use futures_util::future::BoxFuture;
+use futures_util::stream::{self, Stream};
+use futures_util::StreamExt;
 use simple_agent_type::cache::Cache;
 use simple_agent_type::cache::CacheKey;
 use simple_agent_type::prelude::{
@@ -13,8 +16,10 @@ use simple_agents_healing::coercion::CoercionEngine;
 use simple_agents_healing::parser::JsonishParser;
 use simple_agents_healing::schema::Schema;
 use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use std::time::{Duration, Instant};
+use tokio::sync::RwLock;
+use tracing::debug;
 
 /// Mode for completion post-processing.
 pub enum CompletionMode {
@@ -75,29 +80,30 @@ impl SimpleAgentsClient {
     }
 
     /// List registered provider names.
-    pub fn provider_names(&self) -> Result<Vec<String>> {
-        let state = self.state.read().map_err(|_| {
-            SimpleAgentsError::Config("provider registry lock poisoned".to_string())
-        })?;
+    pub async fn provider_names(&self) -> Result<Vec<String>> {
+        let state = self.state.read().await;
         Ok(state.provider_map.keys().cloned().collect())
     }
 
     /// Retrieve a provider by name.
-    pub fn provider(&self, name: &str) -> Result<Option<Arc<dyn Provider>>> {
-        let state = self.state.read().map_err(|_| {
-            SimpleAgentsError::Config("provider registry lock poisoned".to_string())
-        })?;
+    pub async fn provider(&self, name: &str) -> Result<Option<Arc<dyn Provider>>> {
+        let state = self.state.read().await;
         Ok(state.provider_map.get(name).cloned())
     }
 
     /// Register an additional provider and rebuild the router.
-    pub fn register_provider(&self, provider: Arc<dyn Provider>) -> Result<()> {
-        let mut state = self.state.write().map_err(|_| {
-            SimpleAgentsError::Config("provider registry lock poisoned".to_string())
-        })?;
-        state
-            .provider_map
-            .insert(provider.name().to_string(), provider.clone());
+    pub async fn register_provider(&self, provider: Arc<dyn Provider>) -> Result<()> {
+        let mut state = self.state.write().await;
+        let name = provider.name().to_string();
+
+        if state.provider_map.contains_key(&name) {
+            return Err(SimpleAgentsError::Config(format!(
+                "provider already registered: {}",
+                name
+            )));
+        }
+
+        state.provider_map.insert(name, provider.clone());
         state.providers.push(provider);
         state.router = Arc::new(self.routing_mode.build_router(state.providers.clone())?);
         Ok(())
@@ -154,9 +160,7 @@ impl SimpleAgentsClient {
 
         let start = Instant::now();
         let router = {
-            let state = self.state.read().map_err(|_| {
-                SimpleAgentsError::Config("provider registry lock poisoned".to_string())
-            })?;
+            let state = self.state.read().await;
             state.router.clone()
         };
         let response = router.complete(request).await;
@@ -225,19 +229,24 @@ impl SimpleAgentsClient {
     ) -> Result<Box<dyn futures_core::Stream<Item = Result<CompletionChunk>> + Send + Unpin>> {
         request.validate()?;
         self.before_request(request).await?;
-        eprintln!(
-            "SimpleAgentsClient.stream: model={}, stream={:?}",
-            request.model, request.stream
+        debug!(
+            model = %request.model,
+            stream = ?request.stream,
+            "SimpleAgentsClient.stream start"
         );
 
         let router = {
-            let state = self.state.read().map_err(|_| {
-                SimpleAgentsError::Config("provider registry lock poisoned".to_string())
-            })?;
+            let state = self.state.read().await;
             state.router.clone()
         };
 
-        router.stream(request).await
+        let start = Instant::now();
+        let middleware = self.middleware.clone();
+        let instrumented_request = request.clone();
+        let inner = router.stream(request).await?;
+
+        let wrapped = Self::instrument_stream(inner, instrumented_request, middleware, start);
+        Ok(Box::new(wrapped))
     }
 
     fn ensure_healing_enabled(&self) -> Result<()> {
@@ -300,6 +309,69 @@ impl SimpleAgentsClient {
     }
 }
 
+impl SimpleAgentsClient {
+    fn instrument_stream(
+        inner: Box<dyn Stream<Item = Result<CompletionChunk>> + Send + Unpin>,
+        request: CompletionRequest,
+        middleware: Vec<Arc<dyn Middleware>>,
+        start: Instant,
+    ) -> impl Stream<Item = Result<CompletionChunk>> + Send + Unpin {
+        struct StreamState {
+            inner: Box<dyn Stream<Item = Result<CompletionChunk>> + Send + Unpin>,
+            middleware: Vec<Arc<dyn Middleware>>,
+            request: CompletionRequest,
+            start: Instant,
+            done: bool,
+        }
+
+        stream::unfold(
+            StreamState {
+                inner,
+                middleware,
+                request,
+                start,
+                done: false,
+            },
+            |mut state| -> BoxFuture<Option<(Result<CompletionChunk>, StreamState)>> {
+                Box::pin(async move {
+                    if state.done {
+                        return None;
+                    }
+
+                    match state.inner.next().await {
+                        Some(Ok(chunk)) => Some((Ok(chunk), state)),
+                        Some(Err(err)) => {
+                            let latency = state.start.elapsed();
+                            for middleware in &state.middleware {
+                                if let Err(mw_err) =
+                                    middleware.on_error(&state.request, &err, latency).await
+                                {
+                                    state.done = true;
+                                    return Some((Err(mw_err), state));
+                                }
+                            }
+                            state.done = true;
+                            Some((Err(err), state))
+                        }
+                        None => {
+                            let latency = state.start.elapsed();
+                            for middleware in &state.middleware {
+                                if let Err(mw_err) =
+                                    middleware.after_stream(&state.request, latency).await
+                                {
+                                    state.done = true;
+                                    return Some((Err(mw_err), state));
+                                }
+                            }
+                            None
+                        }
+                    }
+                })
+            },
+        )
+    }
+}
+
 /// Builder for `SimpleAgentsClient`.
 pub struct SimpleAgentsClientBuilder {
     providers: Vec<Arc<dyn Provider>>,
@@ -413,8 +485,11 @@ impl Middleware for () {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use futures_util::{stream, StreamExt};
+    use simple_agent_type::error::ProviderError;
     use simple_agent_type::prelude::*;
     use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::time::Duration;
 
     struct MockProvider {
         name: &'static str,
@@ -481,10 +556,230 @@ mod tests {
             .unwrap();
 
         let second = Arc::new(MockProvider::new("p2"));
-        client.register_provider(second).unwrap();
+        client.register_provider(second).await.unwrap();
 
-        let names = client.provider_names().unwrap();
+        let names = client.provider_names().await.unwrap();
         assert!(names.contains(&"p1".to_string()));
         assert!(names.contains(&"p2".to_string()));
     }
+
+    #[tokio::test]
+    async fn duplicate_provider_registration_fails() {
+        let provider = Arc::new(MockProvider::new("p1"));
+        let client = SimpleAgentsClientBuilder::new()
+            .with_provider(provider.clone())
+            .build()
+            .unwrap();
+
+        let result = client.register_provider(provider).await;
+        assert!(matches!(
+            result,
+            Err(SimpleAgentsError::Config(msg)) if msg.contains("provider already registered")
+        ));
+    }
+
+    #[derive(Default)]
+    struct RecordingMiddleware {
+        before: AtomicUsize,
+        after_stream: AtomicUsize,
+        errors: AtomicUsize,
+    }
+
+    #[async_trait]
+    impl Middleware for RecordingMiddleware {
+        async fn before_request(&self, _request: &CompletionRequest) -> Result<()> {
+            self.before.fetch_add(1, Ordering::Relaxed);
+            Ok(())
+        }
+
+        async fn after_stream(
+            &self,
+            _request: &CompletionRequest,
+            _latency: Duration,
+        ) -> Result<()> {
+            self.after_stream.fetch_add(1, Ordering::Relaxed);
+            Ok(())
+        }
+
+        async fn on_error(
+            &self,
+            _request: &CompletionRequest,
+            _error: &SimpleAgentsError,
+            _latency: Duration,
+        ) -> Result<()> {
+            self.errors.fetch_add(1, Ordering::Relaxed);
+            Ok(())
+        }
+
+        fn name(&self) -> &str {
+            "recording"
+        }
+    }
+
+    struct StreamingProvider {
+        name: &'static str,
+        fail_after_first: bool,
+    }
+
+    impl StreamingProvider {
+        fn new(name: &'static str, fail_after_first: bool) -> Self {
+            Self {
+                name,
+                fail_after_first,
+            }
+        }
+
+        fn build_chunk(id: &str, content: &str) -> CompletionChunk {
+            CompletionChunk {
+                id: id.to_string(),
+                model: "test-model".to_string(),
+                choices: vec![ChoiceDelta {
+                    index: 0,
+                    delta: MessageDelta {
+                        role: Some(Role::Assistant),
+                        content: Some(content.to_string()),
+                    },
+                    finish_reason: None,
+                }],
+                created: None,
+            }
+        }
+    }
+
+    #[async_trait]
+    impl Provider for StreamingProvider {
+        fn name(&self) -> &str {
+            self.name
+        }
+
+        fn transform_request(&self, _req: &CompletionRequest) -> Result<ProviderRequest> {
+            Ok(ProviderRequest::new("http://example.com"))
+        }
+
+        async fn execute(&self, _req: ProviderRequest) -> Result<ProviderResponse> {
+            Ok(ProviderResponse::new(
+                200,
+                serde_json::json!({"content": "ok"}),
+            ))
+        }
+
+        fn transform_response(&self, _resp: ProviderResponse) -> Result<CompletionResponse> {
+            Ok(CompletionResponse {
+                id: "resp_stream".to_string(),
+                model: "test-model".to_string(),
+                choices: vec![CompletionChoice {
+                    index: 0,
+                    message: Message::assistant("ok"),
+                    finish_reason: FinishReason::Stop,
+                    logprobs: None,
+                }],
+                usage: Usage::new(1, 1),
+                created: None,
+                provider: Some(self.name.to_string()),
+                healing_metadata: None,
+            })
+        }
+
+        async fn execute_stream(
+            &self,
+            _req: ProviderRequest,
+        ) -> Result<Box<dyn futures_core::Stream<Item = Result<CompletionChunk>> + Send + Unpin>>
+        {
+            let stream = if self.fail_after_first {
+                let items: Vec<Result<CompletionChunk>> = vec![
+                    Ok(Self::build_chunk("chunk-1", "hello")),
+                    Err(SimpleAgentsError::Provider(ProviderError::ServerError(
+                        "stream error".to_string(),
+                    ))),
+                ];
+                stream::iter(items)
+            } else {
+                let items: Vec<Result<CompletionChunk>> =
+                    vec![Ok(Self::build_chunk("chunk-1", "hello"))];
+                stream::iter(items)
+            };
+
+            Ok(Box::new(stream))
+        }
+    }
+
+    #[tokio::test]
+    async fn streaming_invokes_after_stream_on_success() {
+        let provider = Arc::new(StreamingProvider::new("p1", false));
+        let middleware = Arc::new(RecordingMiddleware::default());
+
+        let client = SimpleAgentsClientBuilder::new()
+            .with_provider(provider)
+            .with_middleware(middleware.clone())
+            .build()
+            .unwrap();
+
+        let request = CompletionRequest::builder()
+            .model("gpt-4")
+            .message(Message::user("Hi"))
+            .stream(true)
+            .build()
+            .unwrap();
+
+        let outcome = client
+            .complete(&request, CompletionOptions::default())
+            .await
+            .unwrap();
+
+        let mut collected = Vec::new();
+        match outcome {
+            CompletionOutcome::Stream(mut stream) => {
+                while let Some(chunk) = stream.next().await {
+                    collected.push(chunk.unwrap());
+                }
+            }
+            _ => panic!("expected stream outcome"),
+        }
+
+        assert_eq!(collected.len(), 1);
+        assert_eq!(middleware.before.load(Ordering::Relaxed), 1);
+        assert_eq!(middleware.after_stream.load(Ordering::Relaxed), 1);
+        assert_eq!(middleware.errors.load(Ordering::Relaxed), 0);
+    }
+
+    #[tokio::test]
+    async fn streaming_invokes_on_error_on_failure() {
+        let provider = Arc::new(StreamingProvider::new("p1", true));
+        let middleware = Arc::new(RecordingMiddleware::default());
+
+        let client = SimpleAgentsClientBuilder::new()
+            .with_provider(provider)
+            .with_middleware(middleware.clone())
+            .build()
+            .unwrap();
+
+        let request = CompletionRequest::builder()
+            .model("gpt-4")
+            .message(Message::user("Hi"))
+            .stream(true)
+            .build()
+            .unwrap();
+
+        let outcome = client
+            .complete(&request, CompletionOptions::default())
+            .await
+            .unwrap();
+
+        let mut chunks = Vec::new();
+        match outcome {
+            CompletionOutcome::Stream(mut stream) => {
+                while let Some(chunk) = stream.next().await {
+                    chunks.push(chunk);
+                }
+            }
+            _ => panic!("expected stream outcome"),
+        }
+
+        assert_eq!(middleware.before.load(Ordering::Relaxed), 1);
+        assert_eq!(middleware.after_stream.load(Ordering::Relaxed), 0);
+        assert_eq!(middleware.errors.load(Ordering::Relaxed), 1);
+        assert_eq!(chunks.len(), 2);
+        assert!(chunks[0].as_ref().is_ok());
+        assert!(chunks[1].is_err());
+    }
 }

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/crates/simple-agents-core/src/middleware.rs

@@ -24,6 +24,11 @@ pub trait Middleware: Send + Sync {
         Ok(())
     }
 
+    /// Called when a streaming request completes successfully.
+    async fn after_stream(&self, _request: &CompletionRequest, _latency: Duration) -> Result<()> {
+        Ok(())
+    }
+
     /// Called when a response is served from cache.
     async fn on_cache_hit(
         &self,

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/crates/simple-agents-healing/Cargo.toml

@@ -32,7 +32,7 @@ regex-support = ["regex"]
 tokio = { version = "1.41", features = ["full"] }
 proptest = "1.5"
 criterion = { version = "0.5", features = ["html_reports"] }
-simple-agents-macros = { path = "../simple-agents-macros", version = "0.2.0" }
+simple-agents-macros = { path = "../simple-agents-macros", version = "0.2.2" }
 
 [[test]]
 name = "parser_tests"

{simple_agents_py-0.2.0 → simple_agents_py-0.2.2}/crates/simple-agents-providers/Cargo.toml

@@ -10,7 +10,7 @@ readme = "README.md"
 
 [dependencies]
 simple-agent-type = { workspace = true }
-simple-agents-healing = { path = "../simple-agents-healing", version = "0.2.0" }
+simple-agents-healing = { path = "../simple-agents-healing", version = "0.2.2" }
 reqwest = { version = "0.12", features = ["json", "stream", "default-tls", "http2", "gzip", "brotli", "deflate"], default-features = false }
 tokio = { version = "1.42", features = ["full"] }
 futures = "0.3"
@@ -34,6 +34,6 @@ prometheus = ["dep:metrics-exporter-prometheus"]
  [dev-dependencies]
  tokio-test = "0.4"
  tracing-subscriber = "0.3"
- simple-agents-cache = { path = "../simple-agents-cache", version = "0.2.0" }
- simple-agents-macros = { path = "../simple-agents-macros", version = "0.2.0" }
+ simple-agents-cache = { path = "../simple-agents-cache", version = "0.2.2" }
+ simple-agents-macros = { path = "../simple-agents-macros", version = "0.2.2" }
  dotenv = "0.15"