luckenco · luckenco · Feb 22, 2026
diff --git a/README.md b/README.md
@@ -81,7 +81,7 @@ See `examples/` for more runnable examples.
 
 ## Known Issues
 
-- ..
+- **TODO**: Evaluate whether `ToolCallingConfig` should be required rather than optional. Currently providers default to a guard with sensible limits when no config is set, but allowing `None` suggests users can opt out of loop protection entirely. We may want to be opinionated here and always require a `ToolCallingConfig`.
 
 ## License
 

diff --git a/macros/src/common.rs b/macros/src/common.rs
@@ -0,0 +1,12 @@
+/// Convert a snake_case name to PascalCase.
+pub fn to_pascal_case(name: &str) -> String {
+    name.split('_')
+        .map(|s| {
+            let mut c = s.chars();
+            match c.next() {
+                None => String::new(),
+                Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+            }
+        })
+        .collect()
+}
diff --git a/macros/src/lib.rs b/macros/src/lib.rs
@@ -37,6 +37,7 @@
 use proc_macro::TokenStream;
 use quote::quote;
 
+mod common;
 mod tool;
 mod tools;
 

diff --git a/macros/src/tool.rs b/macros/src/tool.rs
@@ -31,17 +31,7 @@ pub fn tool_impl(attr: TokenStream, item: TokenStream) -> Result<TokenStream> {
     // Generate the wrapper struct name
     let wrapper_name = quote::format_ident!(
         "{}Tool",
-        fn_name
-            .to_string()
-            .split('_')
-            .map(|s| {
-                let mut c = s.chars();
-                match c.next() {
-                    None => String::new(),
-                    Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
-                }
-            })
-            .collect::<String>()
+        crate::common::to_pascal_case(&fn_name.to_string())
     );
 
     // Check if function is async

diff --git a/macros/src/tools.rs b/macros/src/tools.rs
@@ -46,19 +46,6 @@ impl Parse for ToolsList {
     }
 }
 
-/// Convert a snake_case function name to PascalCase struct name
-fn to_pascal_case(name: &str) -> String {
-    name.split('_')
-        .map(|s| {
-            let mut c = s.chars();
-            match c.next() {
-                None => String::new(),
-                Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
-            }
-        })
-        .collect()
-}
-
 pub fn tools_impl(input: TokenStream) -> Result<TokenStream> {
     let tools_list = syn::parse2::<ToolsList>(input)?;
 
@@ -73,7 +60,12 @@ pub fn tools_impl(input: TokenStream) -> Result<TokenStream> {
     let wrapper_names: Vec<_> = tools_list
         .tools
         .iter()
-        .map(|tool_name| quote::format_ident!("{}Tool", to_pascal_case(&tool_name.to_string())))
+        .map(|tool_name| {
+            quote::format_ident!(
+                "{}Tool",
+                crate::common::to_pascal_case(&tool_name.to_string())
+            )
+        })
         .collect();
 
     // Generate different code based on whether context is present

diff --git a/src/completions/client.rs b/src/completions/client.rs
@@ -211,7 +211,7 @@ impl<P: CompletionProviderConfig> CompletionClient<P> {
                         result: result.clone(),
                     });
 
-                    // If not parallel, process one at a time
+                    // In sequential mode process one call per model turn.
                     if !is_parallel {
                         break;
                     }
@@ -225,7 +225,7 @@ impl<P: CompletionProviderConfig> CompletionClient<P> {
 }
 
 /// Convert core messages to conversation items.
-fn convert_messages_to_conversation(
+pub(crate) fn convert_messages_to_conversation(
     messages: &[crate::core::ConversationMessage],
 ) -> Result<Vec<ConversationItem>, LlmError> {
     messages

diff --git a/src/core/builder.rs b/src/core/builder.rs
@@ -402,84 +402,44 @@ impl<State: private::Completable, Ctx: Send + Sync + 'static> LlmBuilder<State,
             None
         };
 
+        let conversation_messages: Vec<ConversationMessage> = messages
+            .into_iter()
+            .map(ConversationMessage::Chat)
+            .collect();
+
+        let req = StructuredRequest {
+            model: model_string,
+            messages: conversation_messages,
+            tool_config: tool_schemas.map(|tools| ToolConfig {
+                tools: Some(tools),
+                tool_choice: self.fields.tool_choice.clone(),
+                parallel_tool_calls: self.fields.parallel_tool_calls,
+            }),
+            generation_config: Some(GenerationConfig {
+                max_tokens: self.fields.max_tokens,
+                temperature: self.fields.temperature,
+                top_p: self.fields.top_p,
+            }),
+        };
+
+        let tool_registry = self.fields.tool_registry.as_ref();
         match provider {
             Provider::OpenAI => {
-                let conversation_messages: Vec<ConversationMessage> = messages
-                    .into_iter()
-                    .map(ConversationMessage::Chat)
-                    .collect();
-
-                let req = StructuredRequest {
-                    model: model_string,
-                    messages: conversation_messages,
-                    tool_config: tool_schemas.map(|tools| ToolConfig {
-                        tools: Some(tools),
-                        tool_choice: self.fields.tool_choice.clone(),
-                        parallel_tool_calls: self.fields.parallel_tool_calls,
-                    }),
-                    generation_config: Some(GenerationConfig {
-                        max_tokens: self.fields.max_tokens,
-                        temperature: self.fields.temperature,
-                        top_p: self.fields.top_p,
-                    }),
-                };
                 let client = openai::create_openai_client_from_builder(&self)?;
                 client
-                    .generate_completion::<T, Ctx>(
-                        req,
-                        format.clone(),
-                        self.fields.tool_registry.as_ref(),
-                    )
+                    .generate_completion::<T, Ctx>(req, format, tool_registry)
                     .await
             }
             Provider::OpenRouter => {
-                let conversation_messages: Vec<ConversationMessage> = messages
-                    .into_iter()
-                    .map(ConversationMessage::Chat)
-                    .collect();
-
-                let req = StructuredRequest {
-                    model: model_string,
-                    messages: conversation_messages,
-                    tool_config: tool_schemas.map(|tools| ToolConfig {
-                        tools: Some(tools),
-                        tool_choice: self.fields.tool_choice.clone(),
-                        parallel_tool_calls: self.fields.parallel_tool_calls,
-                    }),
-                    generation_config: Some(GenerationConfig {
-                        max_tokens: self.fields.max_tokens,
-                        temperature: self.fields.temperature,
-                        top_p: self.fields.top_p,
-                    }),
-                };
                 let client = openrouter::create_openrouter_client_from_builder(&self)?;
                 client
-                    .generate_completion::<T, Ctx>(req, format, self.fields.tool_registry.as_ref())
+                    .generate_completion::<T, Ctx>(req, format, tool_registry)
                     .await
             }
             Provider::Gemini => {
-                let conversation_messages: Vec<ConversationMessage> = messages
-                    .into_iter()
-                    .map(ConversationMessage::Chat)
-                    .collect();
-
-                let req = StructuredRequest {
-                    model: model_string,
-                    messages: conversation_messages,
-                    tool_config: tool_schemas.map(|tools| ToolConfig {
-                        tools: Some(tools),
-                        tool_choice: self.fields.tool_choice.clone(),
-                        parallel_tool_calls: self.fields.parallel_tool_calls,
-                    }),
-                    generation_config: Some(GenerationConfig {
-                        max_tokens: self.fields.max_tokens,
-                        temperature: self.fields.temperature,
-                        top_p: self.fields.top_p,
-                    }),
-                };
                 let client = gemini::create_gemini_client_from_builder(&self)?;
                 client
-                    .generate_completion::<T, Ctx>(req, format, self.fields.tool_registry.as_ref())
+                    .generate_completion::<T, Ctx>(req, format, tool_registry)
                     .await
             }
         }

diff --git a/src/core/error.rs b/src/core/error.rs
@@ -56,6 +56,6 @@ pub enum LlmError {
     #[error("Tool call processing timeout exceeded: {timeout:?}")]
     ToolCallTimeout { timeout: std::time::Duration },
 
-    #[error("Toll registration failed for {tool_name}: {message}")]
+    #[error("Tool registration failed for {tool_name}: {message}")]
     ToolRegistration { tool_name: String, message: String },
 }
diff --git a/src/core/http.rs b/src/core/http.rs
@@ -82,24 +82,22 @@ impl HttpClient {
         Req: Serialize,
         Res: DeserializeOwned,
     {
-        // Serialize request to Value for inspection
-        let body_value = serde_json::to_value(body).map_err(|e| LlmError::Parse {
-            message: "Failed to serialize request for inspection".to_string(),
-            source: Box::new(e),
-        })?;
-
-        // Call request inspector
+        // Only serialize to Value if we need to inspect the request
         if let Some(ref config) = self.inspector_config
             && let Some(ref inspector) = config.request_inspector
         {
+            let body_value = serde_json::to_value(body).map_err(|e| LlmError::Parse {
+                message: "Failed to serialize request for inspection".to_string(),
+                source: Box::new(e),
+            })?;
             inspector(&body_value);
         }
 
         let mut last_error: Option<LlmError> = None;
 
         for attempt in 0..=self.config.max_retries {
             // Build request (must be rebuilt each attempt since .send() consumes it)
-            let mut req_builder = self.client.post(url).json(&body_value);
+            let mut req_builder = self.client.post(url).json(body);
 
             // Add headers
             for (name, value) in headers {
@@ -125,31 +123,34 @@ impl HttpClient {
                     if status.is_success() {
                         debug!(status = %status, "HTTP request successful");
 
-                        // Parse response to text first, then to Value for inspection
                         let response_text = res.text().await.map_err(|e| LlmError::Parse {
                             message: "Failed to read response body".to_string(),
                             source: Box::new(e),
                         })?;
 
-                        let response_value: serde_json::Value =
-                            serde_json::from_str(&response_text).map_err(|e| LlmError::Parse {
-                                message: "Failed to parse response as JSON".to_string(),
-                                source: Box::new(e),
-                            })?;
-
-                        // Call response inspector
+                        // Only go through intermediate Value if we need to inspect
                         if let Some(ref config) = self.inspector_config
                             && let Some(ref inspector) = config.response_inspector
                         {
+                            let response_value: serde_json::Value =
+                                serde_json::from_str(&response_text).map_err(|e| {
+                                    LlmError::Parse {
+                                        message: "Failed to parse response as JSON".to_string(),
+                                        source: Box::new(e),
+                                    }
+                                })?;
                             inspector(&response_value);
+                            return serde_json::from_value(response_value).map_err(|e| {
+                                LlmError::Parse {
+                                    message: "Failed to parse API response".to_string(),
+                                    source: Box::new(e),
+                                }
+                            });
                         }
 
-                        // Deserialize to target type
-                        return serde_json::from_value(response_value).map_err(|e| {
-                            LlmError::Parse {
-                                message: "Failed to parse API response".to_string(),
-                                source: Box::new(e),
-                            }
+                        return serde_json::from_str(&response_text).map_err(|e| LlmError::Parse {
+                            message: "Failed to parse API response".to_string(),
+                            source: Box::new(e),
                         });
                     }
 

diff --git a/src/core/tool_guard.rs b/src/core/tool_guard.rs
@@ -61,11 +61,7 @@ impl ToolCallingGuard {
 
     /// Create a new ToolCallingGuard from a config
     pub fn from_config(config: &ToolCallingConfig) -> Self {
-        Self {
-            max_iterations: config.max_iterations,
-            timeout: config.timeout,
-            current_iteration: 0,
-        }
+        Self::with_limits(config.max_iterations, config.timeout)
     }
 
     /// Increment iteration count and check if limit is exceeded
-Original file line number
+Diff line change
@@ Expand Up / @@ -81,7 +81,7 @@ See `examples/` for more runnable examples. @@
     ## Known Issues
-    - ..
+    - **TODO**: Evaluate whether `ToolCallingConfig` should be required rather than optional. Currently providers default to a guard with sensible limits when no config is set, but allowing `None` suggests users can opt out of loop protection entirely. We may want to be opinionated here and always require a `ToolCallingConfig`.
     ## License
@@ Expand Down @@