simple-agents-py 0.1.5__tar.gz → 0.1.6__tar.gz

{simple_agents_py-0.1.5 → simple_agents_py-0.1.6}/Cargo.lock

@@ -1494,6 +1494,7 @@ dependencies = [
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
+ "serde",
  "unindent",
 ]
 
@@ -2025,7 +2026,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agent-type"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "async-trait",
  "blake3",
@@ -2040,7 +2041,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-cache"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "async-trait",
  "simple-agent-type",
@@ -2049,7 +2050,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-cli"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "clap",
  "serde",
@@ -2066,7 +2067,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-core"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "async-trait",
  "serde",
@@ -2093,7 +2094,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-ffi"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "async-trait",
  "simple-agent-type",
@@ -2104,7 +2105,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-healing"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "criterion",
  "proptest",
@@ -2120,7 +2121,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-macros"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2132,7 +2133,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-napi"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "napi",
  "napi-derive",
@@ -2144,7 +2145,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-providers"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "async-trait",
  "bytes",
@@ -2172,10 +2173,11 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-py"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "pyo3",
  "reqwest",
+ "serde_json",
  "simple-agent-type",
  "simple-agents-core",
  "simple-agents-providers",
@@ -2184,7 +2186,7 @@ dependencies = [
 
 [[package]]
 name = "simple-agents-router"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "async-trait",
  "rand 0.8.5",

{simple_agents_py-0.1.5 → simple_agents_py-0.1.6}/Cargo.toml

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

{simple_agents_py-0.1.5 → simple_agents_py-0.1.6}/PKG-INFO

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

{simple_agents_py-0.1.5 → simple_agents_py-0.1.6}/crates/simple-agents-py/Cargo.toml

@@ -10,9 +10,10 @@ name = "simple_agents_py"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.22", features = ["extension-module", "abi3-py312"] }
+pyo3 = { version = "0.22", features = ["extension-module", "abi3-py312", "serde"] }
 tokio = { workspace = true }
 reqwest = { workspace = true }
+serde_json = { workspace = true }
 
 simple-agents-core = { path = "../simple-agents-core", version = "0.1.0" }
 simple-agents-providers = { path = "../simple-agents-providers", version = "0.1.0" }

simple_agents_py-0.1.6/crates/simple-agents-py/py.typed

@@ -0,0 +1 @@
+

simple_agents_py-0.1.6/crates/simple-agents-py/simple_agents_py.pyi

@@ -0,0 +1,45 @@
+class Client:
+    def __init__(
+        self,
+        provider: str,
+        api_key: str | None = None,
+        api_base: str | None = None,
+    ) -> None: ...
+
+    def complete(
+        self,
+        model: str,
+        prompt: str,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+    ) -> str: ...
+
+    def complete_messages(
+        self,
+        model: str,
+        messages: list[dict[str, object]],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+    ) -> str: ...
+
+    def complete_json(
+        self,
+        model: str,
+        messages: list[dict[str, object]],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+    ) -> str: ...
+
+    def complete_json_schema(
+        self,
+        model: str,
+        messages: list[dict[str, object]],
+        schema: dict[str, object],
+        schema_name: str,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        strict: bool = True,
+    ) -> str: ...

simple_agents_py-0.1.6/crates/simple-agents-py/src/lib.rs

@@ -0,0 +1,398 @@
+//! Python bindings for SimpleAgents using PyO3.
+
+#![allow(clippy::useless_conversion)]
+
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyList};
+use reqwest::Client as HttpClient;
+use simple_agents_core::{SimpleAgentsClient, SimpleAgentsClientBuilder};
+use simple_agents_providers::anthropic::AnthropicProvider;
+use simple_agents_providers::openai::OpenAIProvider;
+use simple_agents_providers::openrouter::OpenRouterProvider;
+use simple_agent_type::message::Message;
+use simple_agent_type::prelude::{ApiKey, CompletionRequest, Provider, Result, SimpleAgentsError};
+use simple_agent_type::request::{JsonSchemaFormat, ResponseFormat};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+type Runtime = tokio::runtime::Runtime;
+
+#[pyclass]
+struct Client {
+    runtime: Mutex<Runtime>,
+    client: SimpleAgentsClient,
+}
+
+fn provider_from_params(
+    provider_name: &str,
+    api_key: Option<&str>,
+    api_base: Option<&str>,
+) -> Result<Arc<dyn Provider>> {
+    let api_key = match api_key {
+        Some(value) => Some(ApiKey::new(value)?),
+        None => None,
+    };
+
+    match provider_name {
+        "openai" => {
+            let provider = match api_key {
+                Some(api_key) => match api_base {
+                    Some(api_base) => {
+                        if is_local_base(api_base) {
+                            let client = HttpClient::builder()
+                                .timeout(Duration::from_secs(30))
+                                .pool_max_idle_per_host(10)
+                                .pool_idle_timeout(Duration::from_secs(90))
+                                .no_proxy()
+                                .build()
+                                .map_err(|e| {
+                                    SimpleAgentsError::Config(format!(
+                                        "Failed to create HTTP client: {}",
+                                        e
+                                    ))
+                                })?;
+                            OpenAIProvider::with_client(api_key, api_base.to_string(), client)?
+                        } else {
+                            OpenAIProvider::with_base_url(api_key, api_base.to_string())?
+                        }
+                    }
+                    None => OpenAIProvider::new(api_key)?,
+                },
+                None => OpenAIProvider::from_env()?,
+            };
+            Ok(Arc::new(provider))
+        }
+        "anthropic" => {
+            let provider = match api_key {
+                Some(api_key) => match api_base {
+                    Some(api_base) => {
+                        AnthropicProvider::with_base_url(api_key, api_base.to_string())?
+                    }
+                    None => AnthropicProvider::new(api_key)?,
+                },
+                None => AnthropicProvider::from_env()?,
+            };
+            Ok(Arc::new(provider))
+        }
+        "openrouter" => {
+            let provider = match api_key {
+                Some(api_key) => match api_base {
+                    Some(api_base) => {
+                        OpenRouterProvider::with_base_url(api_key, api_base.to_string())?
+                    }
+                    None => OpenRouterProvider::new(api_key)?,
+                },
+                None => OpenRouterProvider::from_env()?,
+            };
+            Ok(Arc::new(provider))
+        }
+        _ => Err(SimpleAgentsError::Config(format!(
+            "Unknown provider '{provider_name}'"
+        ))),
+    }
+}
+
+fn is_local_base(api_base: &str) -> bool {
+    api_base.contains("localhost") || api_base.contains("127.0.0.1")
+}
+
+fn build_request(
+    model: &str,
+    prompt: &str,
+    max_tokens: Option<u32>,
+    temperature: Option<f32>,
+) -> Result<CompletionRequest> {
+    if model.is_empty() {
+        return Err(SimpleAgentsError::Config(
+            "model cannot be empty".to_string(),
+        ));
+    }
+    if prompt.is_empty() {
+        return Err(SimpleAgentsError::Config(
+            "prompt cannot be empty".to_string(),
+        ));
+    }
+
+    let mut builder = CompletionRequest::builder()
+        .model(model)
+        .message(Message::user(prompt));
+
+    if let Some(max_tokens) = max_tokens {
+        builder = builder.max_tokens(max_tokens);
+    }
+    if let Some(temperature) = temperature {
+        builder = builder.temperature(temperature);
+    }
+
+    builder.build()
+}
+
+fn build_request_with_messages(
+    model: &str,
+    messages: Vec<Message>,
+    max_tokens: Option<u32>,
+    temperature: Option<f32>,
+    top_p: Option<f32>,
+    response_format: Option<ResponseFormat>,
+) -> Result<CompletionRequest> {
+    if model.is_empty() {
+        return Err(SimpleAgentsError::Config(
+            "model cannot be empty".to_string(),
+        ));
+    }
+    if messages.is_empty() {
+        return Err(SimpleAgentsError::Config(
+            "messages cannot be empty".to_string(),
+        ));
+    }
+
+    let mut builder = CompletionRequest::builder().model(model);
+    for message in messages {
+        builder = builder.message(message);
+    }
+
+    if let Some(max_tokens) = max_tokens {
+        builder = builder.max_tokens(max_tokens);
+    }
+    if let Some(temperature) = temperature {
+        builder = builder.temperature(temperature);
+    }
+    if let Some(top_p) = top_p {
+        builder = builder.top_p(top_p);
+    }
+    if let Some(format) = response_format {
+        builder = builder.response_format(format);
+    }
+
+    builder.build()
+}
+
+fn parse_messages(messages: &PyAny) -> Result<Vec<Message>> {
+    let list: &PyList = messages.downcast().map_err(|_| {
+        SimpleAgentsError::Config("messages must be a list of dicts".to_string())
+    })?;
+    let mut result = Vec::with_capacity(list.len());
+
+    for (idx, item) in list.iter().enumerate() {
+        let dict: &PyDict = item
+            .downcast()
+            .map_err(|_| SimpleAgentsError::Config(format!("message[{idx}] must be a dict")))?;
+
+        let role_obj = dict.get_item("role").ok_or_else(|| {
+            SimpleAgentsError::Config(format!("message[{idx}] missing 'role'"))
+        })?;
+        let role: &str = role_obj.extract().map_err(|_| {
+            SimpleAgentsError::Config(format!("message[{idx}].role must be a string"))
+        })?;
+
+        let content_obj = dict.get_item("content").ok_or_else(|| {
+            SimpleAgentsError::Config(format!("message[{idx}] missing 'content'"))
+        })?;
+        let content: &str = content_obj.extract().map_err(|_| {
+            SimpleAgentsError::Config(format!(
+                "message[{idx}].content must be a string"
+            ))
+        })?;
+
+        let mut message = match role {
+            "user" => Message::user(content),
+            "assistant" => Message::assistant(content),
+            "system" => Message::system(content),
+            "tool" => {
+                let tool_call_id = dict
+                    .get_item("tool_call_id")
+                    .ok_or_else(|| {
+                        SimpleAgentsError::Config(format!(
+                            "message[{idx}] missing 'tool_call_id' for tool role"
+                        ))
+                    })?
+                    .extract::<String>()
+                    .map_err(|_| {
+                        SimpleAgentsError::Config(format!(
+                            "message[{idx}].tool_call_id must be a string"
+                        ))
+                    })?;
+                Message::tool(content, tool_call_id)
+            }
+            _ => {
+                return Err(SimpleAgentsError::Config(format!(
+                    "message[{idx}].role must be one of: user, assistant, system, tool"
+                )))
+            }
+        };
+
+        if let Some(name_obj) = dict.get_item("name") {
+            if !name_obj.is_none() {
+                let name: String = name_obj.extract().map_err(|_| {
+                    SimpleAgentsError::Config(format!("message[{idx}].name must be a string"))
+                })?;
+                message = message.with_name(name);
+            }
+        }
+
+        result.push(message);
+    }
+
+    Ok(result)
+}
+
+fn py_err(error: SimpleAgentsError) -> PyErr {
+    PyRuntimeError::new_err(error.to_string())
+}
+
+#[pymethods]
+#[allow(clippy::useless_conversion)]
+impl Client {
+    #[new]
+    #[pyo3(signature = (provider, api_key=None, api_base=None))]
+    fn new(provider: &str, api_key: Option<String>, api_base: Option<String>) -> PyResult<Self> {
+        let provider = provider_from_params(
+            provider,
+            api_key.as_deref(),
+            api_base.as_deref(),
+        )
+        .map_err(py_err)?;
+        let client = SimpleAgentsClientBuilder::new()
+            .with_provider(provider)
+            .build()
+            .map_err(py_err)?;
+        let runtime = Runtime::new().map_err(|e| PyRuntimeError::new_err(e.to_string()))?;
+
+        Ok(Self {
+            runtime: Mutex::new(runtime),
+            client,
+        })
+    }
+
+    #[pyo3(signature = (model, prompt, max_tokens=None, temperature=None))]
+    fn complete(
+        &self,
+        model: &str,
+        prompt: &str,
+        max_tokens: Option<u32>,
+        temperature: Option<f32>,
+    ) -> PyResult<String> {
+        let request = build_request(model, prompt, max_tokens, temperature).map_err(py_err)?;
+        let runtime = self
+            .runtime
+            .lock()
+            .map_err(|_| PyRuntimeError::new_err("runtime lock poisoned"))?;
+        let response = runtime
+            .block_on(self.client.complete(&request))
+            .map_err(py_err)?;
+
+        Ok(response.content().unwrap_or_default().to_string())
+    }
+
+    #[pyo3(signature = (model, messages, max_tokens=None, temperature=None, top_p=None))]
+    fn complete_messages(
+        &self,
+        model: &str,
+        messages: &PyAny,
+        max_tokens: Option<u32>,
+        temperature: Option<f32>,
+        top_p: Option<f32>,
+    ) -> PyResult<String> {
+        let messages = parse_messages(messages).map_err(py_err)?;
+        let request = build_request_with_messages(
+            model,
+            messages,
+            max_tokens,
+            temperature,
+            top_p,
+            None,
+        )
+        .map_err(py_err)?;
+        let runtime = self
+            .runtime
+            .lock()
+            .map_err(|_| PyRuntimeError::new_err("runtime lock poisoned"))?;
+        let response = runtime
+            .block_on(self.client.complete(&request))
+            .map_err(py_err)?;
+
+        Ok(response.content().unwrap_or_default().to_string())
+    }
+
+    #[pyo3(signature = (model, messages, max_tokens=None, temperature=None, top_p=None))]
+    fn complete_json(
+        &self,
+        model: &str,
+        messages: &PyAny,
+        max_tokens: Option<u32>,
+        temperature: Option<f32>,
+        top_p: Option<f32>,
+    ) -> PyResult<String> {
+        let messages = parse_messages(messages).map_err(py_err)?;
+        let request = build_request_with_messages(
+            model,
+            messages,
+            max_tokens,
+            temperature,
+            top_p,
+            Some(ResponseFormat::JsonObject),
+        )
+        .map_err(py_err)?;
+        let runtime = self
+            .runtime
+            .lock()
+            .map_err(|_| PyRuntimeError::new_err("runtime lock poisoned"))?;
+        let response = runtime
+            .block_on(self.client.complete(&request))
+            .map_err(py_err)?;
+
+        Ok(response.content().unwrap_or_default().to_string())
+    }
+
+    #[pyo3(signature = (model, messages, schema, schema_name, max_tokens=None, temperature=None, top_p=None, strict=True))]
+    fn complete_json_schema(
+        &self,
+        model: &str,
+        messages: &PyAny,
+        schema: &PyAny,
+        schema_name: &str,
+        max_tokens: Option<u32>,
+        temperature: Option<f32>,
+        top_p: Option<f32>,
+        strict: bool,
+    ) -> PyResult<String> {
+        let messages = parse_messages(messages).map_err(py_err)?;
+        let schema_value: serde_json::Value = schema.extract().map_err(|_| {
+            py_err(SimpleAgentsError::Config(
+                "schema must be JSON-serializable".to_string(),
+            ))
+        })?;
+        let response_format = ResponseFormat::JsonSchema {
+            json_schema: JsonSchemaFormat {
+                name: schema_name.to_string(),
+                schema: schema_value,
+                strict: Some(strict),
+            },
+        };
+        let request = build_request_with_messages(
+            model,
+            messages,
+            max_tokens,
+            temperature,
+            top_p,
+            Some(response_format),
+        )
+        .map_err(py_err)?;
+        let runtime = self
+            .runtime
+            .lock()
+            .map_err(|_| PyRuntimeError::new_err("runtime lock poisoned"))?;
+        let response = runtime
+            .block_on(self.client.complete(&request))
+            .map_err(py_err)?;
+
+        Ok(response.content().unwrap_or_default().to_string())
+    }
+}
+
+#[pymodule]
+fn simple_agents_py(_py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_class::<Client>()?;
+    Ok(())
+}

simple_agents_py-0.1.6/py.typed

@@ -0,0 +1 @@
+

{simple_agents_py-0.1.5 → simple_agents_py-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "simple-agents-py"
-version = "0.1.5"
+version = "0.1.6"
 description = "Python bindings for SimpleAgents"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -23,6 +23,7 @@ dev = ["pytest>=8.0"]
 [tool.maturin]
 bindings = "pyo3"
 module-name = "simple_agents_py"
+include = ["simple_agents_py.pyi", "py.typed"]
 manifest-path = "crates/simple-agents-py/Cargo.toml"
 
 [tool.pytest.ini_options]

simple_agents_py-0.1.6/simple_agents_py.pyi

@@ -0,0 +1,45 @@
+class Client:
+    def __init__(
+        self,
+        provider: str,
+        api_key: str | None = None,
+        api_base: str | None = None,
+    ) -> None: ...
+
+    def complete(
+        self,
+        model: str,
+        prompt: str,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+    ) -> str: ...
+
+    def complete_messages(
+        self,
+        model: str,
+        messages: list[dict[str, object]],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+    ) -> str: ...
+
+    def complete_json(
+        self,
+        model: str,
+        messages: list[dict[str, object]],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+    ) -> str: ...
+
+    def complete_json_schema(
+        self,
+        model: str,
+        messages: list[dict[str, object]],
+        schema: dict[str, object],
+        schema_name: str,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        strict: bool = True,
+    ) -> str: ...

simple_agents_py-0.1.5/crates/simple-agents-py/src/lib.rs

@@ -1,182 +0,0 @@
-//! Python bindings for SimpleAgents using PyO3.
-
-#![allow(clippy::useless_conversion)]
-
-use pyo3::exceptions::PyRuntimeError;
-use pyo3::prelude::*;
-use reqwest::Client as HttpClient;
-use simple_agents_core::{SimpleAgentsClient, SimpleAgentsClientBuilder};
-use simple_agents_providers::anthropic::AnthropicProvider;
-use simple_agents_providers::openai::OpenAIProvider;
-use simple_agents_providers::openrouter::OpenRouterProvider;
-use simple_agent_type::message::Message;
-use simple_agent_type::prelude::{ApiKey, CompletionRequest, Provider, Result, SimpleAgentsError};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-type Runtime = tokio::runtime::Runtime;
-
-#[pyclass]
-struct Client {
-    runtime: Mutex<Runtime>,
-    client: SimpleAgentsClient,
-}
-
-fn provider_from_params(
-    provider_name: &str,
-    api_key: Option<&str>,
-    api_base: Option<&str>,
-) -> Result<Arc<dyn Provider>> {
-    let api_key = match api_key {
-        Some(value) => Some(ApiKey::new(value)?),
-        None => None,
-    };
-
-    match provider_name {
-        "openai" => {
-            let provider = match api_key {
-                Some(api_key) => match api_base {
-                    Some(api_base) => {
-                        if is_local_base(api_base) {
-                            let client = HttpClient::builder()
-                                .timeout(Duration::from_secs(30))
-                                .pool_max_idle_per_host(10)
-                                .pool_idle_timeout(Duration::from_secs(90))
-                                .no_proxy()
-                                .build()
-                                .map_err(|e| {
-                                    SimpleAgentsError::Config(format!(
-                                        "Failed to create HTTP client: {}",
-                                        e
-                                    ))
-                                })?;
-                            OpenAIProvider::with_client(api_key, api_base.to_string(), client)?
-                        } else {
-                            OpenAIProvider::with_base_url(api_key, api_base.to_string())?
-                        }
-                    }
-                    None => OpenAIProvider::new(api_key)?,
-                },
-                None => OpenAIProvider::from_env()?,
-            };
-            Ok(Arc::new(provider))
-        }
-        "anthropic" => {
-            let provider = match api_key {
-                Some(api_key) => match api_base {
-                    Some(api_base) => {
-                        AnthropicProvider::with_base_url(api_key, api_base.to_string())?
-                    }
-                    None => AnthropicProvider::new(api_key)?,
-                },
-                None => AnthropicProvider::from_env()?,
-            };
-            Ok(Arc::new(provider))
-        }
-        "openrouter" => {
-            let provider = match api_key {
-                Some(api_key) => match api_base {
-                    Some(api_base) => {
-                        OpenRouterProvider::with_base_url(api_key, api_base.to_string())?
-                    }
-                    None => OpenRouterProvider::new(api_key)?,
-                },
-                None => OpenRouterProvider::from_env()?,
-            };
-            Ok(Arc::new(provider))
-        }
-        _ => Err(SimpleAgentsError::Config(format!(
-            "Unknown provider '{provider_name}'"
-        ))),
-    }
-}
-
-fn is_local_base(api_base: &str) -> bool {
-    api_base.contains("localhost") || api_base.contains("127.0.0.1")
-}
-
-fn build_request(
-    model: &str,
-    prompt: &str,
-    max_tokens: Option<u32>,
-    temperature: Option<f32>,
-) -> Result<CompletionRequest> {
-    if model.is_empty() {
-        return Err(SimpleAgentsError::Config(
-            "model cannot be empty".to_string(),
-        ));
-    }
-    if prompt.is_empty() {
-        return Err(SimpleAgentsError::Config(
-            "prompt cannot be empty".to_string(),
-        ));
-    }
-
-    let mut builder = CompletionRequest::builder()
-        .model(model)
-        .message(Message::user(prompt));
-
-    if let Some(max_tokens) = max_tokens {
-        builder = builder.max_tokens(max_tokens);
-    }
-    if let Some(temperature) = temperature {
-        builder = builder.temperature(temperature);
-    }
-
-    builder.build()
-}
-
-fn py_err(error: SimpleAgentsError) -> PyErr {
-    PyRuntimeError::new_err(error.to_string())
-}
-
-#[pymethods]
-#[allow(clippy::useless_conversion)]
-impl Client {
-    #[new]
-    #[pyo3(signature = (provider, api_key=None, api_base=None))]
-    fn new(provider: &str, api_key: Option<String>, api_base: Option<String>) -> PyResult<Self> {
-        let provider = provider_from_params(
-            provider,
-            api_key.as_deref(),
-            api_base.as_deref(),
-        )
-        .map_err(py_err)?;
-        let client = SimpleAgentsClientBuilder::new()
-            .with_provider(provider)
-            .build()
-            .map_err(py_err)?;
-        let runtime = Runtime::new().map_err(|e| PyRuntimeError::new_err(e.to_string()))?;
-
-        Ok(Self {
-            runtime: Mutex::new(runtime),
-            client,
-        })
-    }
-
-    #[pyo3(signature = (model, prompt, max_tokens=None, temperature=None))]
-    fn complete(
-        &self,
-        model: &str,
-        prompt: &str,
-        max_tokens: Option<u32>,
-        temperature: Option<f32>,
-    ) -> PyResult<String> {
-        let request = build_request(model, prompt, max_tokens, temperature).map_err(py_err)?;
-        let runtime = self
-            .runtime
-            .lock()
-            .map_err(|_| PyRuntimeError::new_err("runtime lock poisoned"))?;
-        let response = runtime
-            .block_on(self.client.complete(&request))
-            .map_err(py_err)?;
-
-        Ok(response.content().unwrap_or_default().to_string())
-    }
-}
-
-#[pymodule]
-fn simple_agents_py(_py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
-    module.add_class::<Client>()?;
-    Ok(())
-}