praisonaiagents 0.0.118__tar.gz → 0.0.120__tar.gz

{praisonaiagents-0.0.118 → praisonaiagents-0.0.120}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.118
+Version: 0.0.120
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10

{praisonaiagents-0.0.118 → praisonaiagents-0.0.120}/praisonaiagents/agent/agent.py

@@ -1233,7 +1233,8 @@ Your Goal: {self.goal}
                         # Add to chat history and return raw response
                         self.chat_history.append({"role": "user", "content": original_prompt})
                         self.chat_history.append({"role": "assistant", "content": response_text})
-                        if self.verbose:
+                        # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
+                        if self.verbose and not self._using_custom_llm:
                             display_interaction(original_prompt, response_text, markdown=self.markdown, 
                                              generation_time=time.time() - start_time, console=self.console)
                         return response_text
@@ -1243,7 +1244,9 @@ Your Goal: {self.goal}
                         self.chat_history.append({"role": "assistant", "content": response_text})
                         if self.verbose:
                             logging.debug(f"Agent {self.name} final response: {response_text}")
-                        display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                        # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
+                        if self.verbose and not self._using_custom_llm:
+                            display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                         # Return only reasoning content if reasoning_steps is True
                         if reasoning_steps and hasattr(response.choices[0].message, 'reasoning_content'):
                             # Apply guardrail to reasoning content
@@ -1279,7 +1282,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             # Return the original response without reflection
                             self.chat_history.append({"role": "user", "content": prompt})
                             self.chat_history.append({"role": "assistant", "content": response_text})
-                            display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                            # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
+                            if self.verbose and not self._using_custom_llm:
+                                display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                             return response_text
                         
                         reflection_response = self._openai_client.sync_client.beta.chat.completions.parse(
@@ -1302,7 +1307,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 display_self_reflection("Agent marked the response as satisfactory after meeting minimum reflections", console=self.console)
                             self.chat_history.append({"role": "user", "content": prompt})
                             self.chat_history.append({"role": "assistant", "content": response_text})
-                            display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                            # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
+                            if self.verbose and not self._using_custom_llm:
+                                display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                             # Apply guardrail validation after satisfactory reflection
                             try:
                                 validated_response = self._apply_guardrail_with_retry(response_text, prompt, temperature, tools)
@@ -1317,7 +1324,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 display_self_reflection("Maximum reflection count reached, returning current response", console=self.console)
                             self.chat_history.append({"role": "user", "content": prompt})
                             self.chat_history.append({"role": "assistant", "content": response_text})
-                            display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                            # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
+                            if self.verbose and not self._using_custom_llm:
+                                display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                             # Apply guardrail validation after max reflections
                             try:
                                 validated_response = self._apply_guardrail_with_retry(response_text, prompt, temperature, tools)

{praisonaiagents-0.0.118 → praisonaiagents-0.0.120}/praisonaiagents/agents/autoagents.py

@@ -13,7 +13,8 @@ import logging
 import os
 from pydantic import BaseModel, ConfigDict
 from ..main import display_instruction, display_tool_call, display_interaction
-from ..llm import get_openai_client
+from ..llm import get_openai_client, LLM
+import json
 
 # Define Pydantic models for structured output
 class TaskConfig(BaseModel):
@@ -238,33 +239,74 @@ Return the configuration in a structured JSON format matching the AutoAgentsConf
 """
         
         try:
-            # Get OpenAI client
+            # Try to use OpenAI's structured output if available
+            use_openai_structured = False
+            client = None
+            
             try:
-                client = get_openai_client()
-            except ValueError as e:
-                # AutoAgents requires OpenAI for structured output generation
-                raise ValueError(
-                    "AutoAgents requires OpenAI API for automatic agent generation. "
-                    "Please set OPENAI_API_KEY environment variable or use PraisonAIAgents class directly "
-                    "with manually configured agents for non-OpenAI providers."
-                ) from e
+                # Check if we have OpenAI API and the model supports structured output
+                if self.llm and (self.llm.startswith('gpt-') or self.llm.startswith('o1-') or self.llm.startswith('o3-')):
+                    client = get_openai_client()
+                    use_openai_structured = True
+            except:
+                # If OpenAI client is not available, we'll use the LLM class
+                pass
+            
+            if use_openai_structured and client:
+                # Use OpenAI's structured output for OpenAI models (backward compatibility)
+                response = client.beta.chat.completions.parse(
+                    model=self.llm,
+                    response_format=AutoAgentsConfig,
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant designed to generate AI agent configurations."},
+                        {"role": "user", "content": prompt}
+                    ]
+                )
+                config = response.choices[0].message.parsed
+            else:
+                # Use LLM class for all other providers (Gemini, Anthropic, etc.)
+                llm_instance = LLM(
+                    model=self.llm,
+                    base_url=self.base_url,
+                    api_key=self.api_key
+                )
                 
-            response = client.beta.chat.completions.parse(
-                model=self.llm,
-                response_format=AutoAgentsConfig,
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant designed to generate AI agent configurations."},
-                    {"role": "user", "content": prompt}
-                ]
-            )
+                response_text = llm_instance.response(
+                    prompt=prompt,
+                    system_prompt="You are a helpful assistant designed to generate AI agent configurations.",
+                    output_pydantic=AutoAgentsConfig,
+                    temperature=0.7,
+                    stream=False,
+                    verbose=False
+                )
+                
+                # Parse the JSON response
+                try:
+                    # First try to parse as is
+                    config_dict = json.loads(response_text)
+                    config = AutoAgentsConfig(**config_dict)
+                except json.JSONDecodeError:
+                    # If that fails, try to extract JSON from the response
+                    # Handle cases where the model might wrap JSON in markdown blocks
+                    cleaned_response = response_text.strip()
+                    if cleaned_response.startswith("```json"):
+                        cleaned_response = cleaned_response[7:]
+                    if cleaned_response.startswith("```"):
+                        cleaned_response = cleaned_response[3:]
+                    if cleaned_response.endswith("```"):
+                        cleaned_response = cleaned_response[:-3]
+                    cleaned_response = cleaned_response.strip()
+                    
+                    config_dict = json.loads(cleaned_response)
+                    config = AutoAgentsConfig(**config_dict)
             
             # Ensure we have exactly max_agents number of agents
-            if len(response.choices[0].message.parsed.agents) > self.max_agents:
-                response.choices[0].message.parsed.agents = response.choices[0].message.parsed.agents[:self.max_agents]
-            elif len(response.choices[0].message.parsed.agents) < self.max_agents:
-                logging.warning(f"Generated {len(response.choices[0].message.parsed.agents)} agents, expected {self.max_agents}")
+            if len(config.agents) > self.max_agents:
+                config.agents = config.agents[:self.max_agents]
+            elif len(config.agents) < self.max_agents:
+                logging.warning(f"Generated {len(config.agents)} agents, expected {self.max_agents}")
             
-            return response.choices[0].message.parsed
+            return config
         except Exception as e:
             logging.error(f"Error generating configuration: {e}")
             raise

{praisonaiagents-0.0.118 → praisonaiagents-0.0.120}/praisonaiagents/llm/llm.py

@@ -87,6 +87,65 @@ class LLM:
         "llama-3.2-90b-text-preview": 6144   # 8,192 actual
     }
 
+    def _log_llm_config(self, method_name: str, **config):
+        """Centralized debug logging for LLM configuration and parameters.
+        
+        Args:
+            method_name: The name of the method calling this logger (e.g., '__init__', 'get_response')
+            **config: Configuration parameters to log
+        """
+        # Check for debug logging - either global debug level OR explicit verbose mode
+        verbose = config.get('verbose', self.verbose if hasattr(self, 'verbose') else False)
+        should_log = logging.getLogger().getEffectiveLevel() == logging.DEBUG or (not isinstance(verbose, bool) and verbose >= 10)
+        
+        if should_log:
+            # Mask sensitive information
+            safe_config = config.copy()
+            if 'api_key' in safe_config:
+                safe_config['api_key'] = "***" if safe_config['api_key'] is not None else None
+            if 'extra_settings' in safe_config and isinstance(safe_config['extra_settings'], dict):
+                safe_config['extra_settings'] = {k: v for k, v in safe_config['extra_settings'].items() if k not in ["api_key"]}
+            
+            # Handle special formatting for certain fields
+            if 'prompt' in safe_config:
+                prompt = safe_config['prompt']
+                # Convert to string first for consistent logging behavior
+                prompt_str = str(prompt) if not isinstance(prompt, str) else prompt
+                if len(prompt_str) > 100:
+                    safe_config['prompt'] = prompt_str[:100] + "..."
+                else:
+                    safe_config['prompt'] = prompt_str
+            if 'system_prompt' in safe_config:
+                sp = safe_config['system_prompt']
+                if sp and isinstance(sp, str) and len(sp) > 100:
+                    safe_config['system_prompt'] = sp[:100] + "..."
+            if 'chat_history' in safe_config:
+                ch = safe_config['chat_history']
+                safe_config['chat_history'] = f"[{len(ch)} messages]" if ch else None
+            if 'tools' in safe_config:
+                tools = safe_config['tools']
+                # Check if tools is iterable before processing
+                if tools and hasattr(tools, '__iter__') and not isinstance(tools, str):
+                    safe_config['tools'] = [t.__name__ if hasattr(t, "__name__") else str(t) for t in tools]
+                else:
+                    safe_config['tools'] = None
+            if 'output_json' in safe_config:
+                oj = safe_config['output_json']
+                safe_config['output_json'] = str(oj.__class__.__name__) if oj else None
+            if 'output_pydantic' in safe_config:
+                op = safe_config['output_pydantic']
+                safe_config['output_pydantic'] = str(op.__class__.__name__) if op else None
+            
+            # Log based on method name - check more specific conditions first
+            if method_name == '__init__':
+                logging.debug(f"LLM instance initialized with: {json.dumps(safe_config, indent=2, default=str)}")
+            elif "parameters" in method_name:
+                logging.debug(f"{method_name}: {json.dumps(safe_config, indent=2, default=str)}")
+            elif "_async" in method_name:
+                logging.debug(f"LLM async instance configuration: {json.dumps(safe_config, indent=2, default=str)}")
+            else:
+                logging.debug(f"{method_name} configuration: {json.dumps(safe_config, indent=2, default=str)}")
+
     def __init__(
         self,
         model: str,
@@ -181,35 +240,34 @@ class LLM:
         litellm.modify_params = True
         self._setup_event_tracking(events)
         
-        # Log all initialization parameters when in debug mode
-        if not isinstance(verbose, bool) and verbose >= 10:
-            debug_info = {
-                "model": self.model,
-                "timeout": self.timeout,
-                "temperature": self.temperature,
-                "top_p": self.top_p,
-                "n": self.n,
-                "max_tokens": self.max_tokens,
-                "presence_penalty": self.presence_penalty,
-                "frequency_penalty": self.frequency_penalty,
-                "logit_bias": self.logit_bias,
-                "response_format": self.response_format,
-                "seed": self.seed,
-                "logprobs": self.logprobs,
-                "top_logprobs": self.top_logprobs,
-                "api_version": self.api_version,
-                "stop_phrases": self.stop_phrases,
-                "api_key": "***" if self.api_key else None,  # Mask API key for security
-                "base_url": self.base_url,
-                "verbose": self.verbose,
-                "markdown": self.markdown,
-                "self_reflect": self.self_reflect,
-                "max_reflect": self.max_reflect,
-                "min_reflect": self.min_reflect,
-                "reasoning_steps": self.reasoning_steps,
-                "extra_settings": {k: v for k, v in self.extra_settings.items() if k not in ["api_key"]}
-            }
-            logging.debug(f"LLM instance initialized with: {json.dumps(debug_info, indent=2, default=str)}")
+        # Log all initialization parameters when in debug mode or verbose >= 10
+        self._log_llm_config(
+            '__init__',
+            model=self.model,
+            timeout=self.timeout,
+            temperature=self.temperature,
+            top_p=self.top_p,
+            n=self.n,
+            max_tokens=self.max_tokens,
+            presence_penalty=self.presence_penalty,
+            frequency_penalty=self.frequency_penalty,
+            logit_bias=self.logit_bias,
+            response_format=self.response_format,
+            seed=self.seed,
+            logprobs=self.logprobs,
+            top_logprobs=self.top_logprobs,
+            api_version=self.api_version,
+            stop_phrases=self.stop_phrases,
+            api_key=self.api_key,
+            base_url=self.base_url,
+            verbose=self.verbose,
+            markdown=self.markdown,
+            self_reflect=self.self_reflect,
+            max_reflect=self.max_reflect,
+            min_reflect=self.min_reflect,
+            reasoning_steps=self.reasoning_steps,
+            extra_settings=self.extra_settings
+        )
 
     def _is_ollama_provider(self) -> bool:
         """Detect if this is an Ollama provider regardless of naming convention"""
@@ -229,6 +287,39 @@ class LLM:
         
         return any(endpoint in base_url or endpoint in api_base for endpoint in ollama_endpoints)
 
+    def _process_stream_delta(self, delta, response_text: str, tool_calls: List[Dict], formatted_tools: Optional[List] = None) -> tuple:
+        """
+        Process a streaming delta chunk to extract content and tool calls.
+        
+        Args:
+            delta: The delta object from a streaming chunk
+            response_text: The accumulated response text so far
+            tool_calls: The accumulated tool calls list so far
+            formatted_tools: Optional list of formatted tools for tool call support check
+            
+        Returns:
+            tuple: (updated_response_text, updated_tool_calls)
+        """
+        # Process content
+        if delta.content:
+            response_text += delta.content
+        
+        # Capture tool calls from streaming chunks if provider supports it
+        if formatted_tools and self._supports_streaming_tools() and hasattr(delta, 'tool_calls') and delta.tool_calls:
+            for tc in delta.tool_calls:
+                if tc.index >= len(tool_calls):
+                    tool_calls.append({
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {"name": "", "arguments": ""}
+                    })
+                if tc.function.name:
+                    tool_calls[tc.index]["function"]["name"] = tc.function.name
+                if tc.function.arguments:
+                    tool_calls[tc.index]["function"]["arguments"] += tc.function.arguments
+        
+        return response_text, tool_calls
+
     def _parse_tool_call_arguments(self, tool_call: Dict, is_ollama: bool = False) -> tuple:
         """
         Safely parse tool call arguments with proper error handling
@@ -497,54 +588,53 @@ class LLM:
         """Enhanced get_response with all OpenAI-like features"""
         logging.info(f"Getting response from {self.model}")
         # Log all self values when in debug mode
-        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
-            debug_info = {
-                "model": self.model,
-                "timeout": self.timeout,
-                "temperature": self.temperature,
-                "top_p": self.top_p,
-                "n": self.n,
-                "max_tokens": self.max_tokens,
-                "presence_penalty": self.presence_penalty,
-                "frequency_penalty": self.frequency_penalty,
-                "logit_bias": self.logit_bias,
-                "response_format": self.response_format,
-                "seed": self.seed,
-                "logprobs": self.logprobs,
-                "top_logprobs": self.top_logprobs,
-                "api_version": self.api_version,
-                "stop_phrases": self.stop_phrases,
-                "api_key": "***" if self.api_key else None,  # Mask API key for security
-                "base_url": self.base_url,
-                "verbose": self.verbose,
-                "markdown": self.markdown,
-                "self_reflect": self.self_reflect,
-                "max_reflect": self.max_reflect,
-                "min_reflect": self.min_reflect,
-                "reasoning_steps": self.reasoning_steps
-            }
-            logging.debug(f"LLM instance configuration: {json.dumps(debug_info, indent=2, default=str)}")
-            
-            # Log the parameter values passed to get_response
-            param_info = {
-                "prompt": str(prompt)[:100] + "..." if isinstance(prompt, str) and len(str(prompt)) > 100 else str(prompt),
-                "system_prompt": system_prompt[:100] + "..." if system_prompt and len(system_prompt) > 100 else system_prompt,
-                "chat_history": f"[{len(chat_history)} messages]" if chat_history else None,
-                "temperature": temperature,
-                "tools": [t.__name__ if hasattr(t, "__name__") else str(t) for t in tools] if tools else None,
-                "output_json": str(output_json.__class__.__name__) if output_json else None,
-                "output_pydantic": str(output_pydantic.__class__.__name__) if output_pydantic else None,
-                "verbose": verbose,
-                "markdown": markdown,
-                "self_reflect": self_reflect,
-                "max_reflect": max_reflect,
-                "min_reflect": min_reflect,
-                "agent_name": agent_name,
-                "agent_role": agent_role,
-                "agent_tools": agent_tools,
-                "kwargs": str(kwargs)
-            }
-            logging.debug(f"get_response parameters: {json.dumps(param_info, indent=2, default=str)}")
+        self._log_llm_config(
+            'LLM instance',
+            model=self.model,
+            timeout=self.timeout,
+            temperature=self.temperature,
+            top_p=self.top_p,
+            n=self.n,
+            max_tokens=self.max_tokens,
+            presence_penalty=self.presence_penalty,
+            frequency_penalty=self.frequency_penalty,
+            logit_bias=self.logit_bias,
+            response_format=self.response_format,
+            seed=self.seed,
+            logprobs=self.logprobs,
+            top_logprobs=self.top_logprobs,
+            api_version=self.api_version,
+            stop_phrases=self.stop_phrases,
+            api_key=self.api_key,
+            base_url=self.base_url,
+            verbose=self.verbose,
+            markdown=self.markdown,
+            self_reflect=self.self_reflect,
+            max_reflect=self.max_reflect,
+            min_reflect=self.min_reflect,
+            reasoning_steps=self.reasoning_steps
+        )
+        
+        # Log the parameter values passed to get_response
+        self._log_llm_config(
+            'get_response parameters',
+            prompt=prompt,
+            system_prompt=system_prompt,
+            chat_history=chat_history,
+            temperature=temperature,
+            tools=tools,
+            output_json=output_json,
+            output_pydantic=output_pydantic,
+            verbose=verbose,
+            markdown=markdown,
+            self_reflect=self_reflect,
+            max_reflect=max_reflect,
+            min_reflect=min_reflect,
+            agent_name=agent_name,
+            agent_role=agent_role,
+            agent_tools=agent_tools,
+            kwargs=str(kwargs)
+        )
         try:
             import litellm
             # This below **kwargs** is passed to .completion() directly. so reasoning_steps has to be popped. OR find alternate best way of handling this.
@@ -651,23 +741,11 @@ class LLM:
                                     ):
                                         if chunk and chunk.choices and chunk.choices[0].delta:
                                             delta = chunk.choices[0].delta
+                                            response_text, tool_calls = self._process_stream_delta(
+                                                delta, response_text, tool_calls, formatted_tools
+                                            )
                                             if delta.content:
-                                                response_text += delta.content
                                                 live.update(display_generating(response_text, current_time))
-                                            
-                                            # Capture tool calls from streaming chunks if provider supports it
-                                            if formatted_tools and self._supports_streaming_tools() and hasattr(delta, 'tool_calls') and delta.tool_calls:
-                                                for tc in delta.tool_calls:
-                                                    if tc.index >= len(tool_calls):
-                                                        tool_calls.append({
-                                                            "id": tc.id,
-                                                            "type": "function",
-                                                            "function": {"name": "", "arguments": ""}
-                                                        })
-                                                    if tc.function.name:
-                                                        tool_calls[tc.index]["function"]["name"] = tc.function.name
-                                                    if tc.function.arguments:
-                                                        tool_calls[tc.index]["function"]["arguments"] += tc.function.arguments
                             else:
                                 # Non-verbose streaming
                                 for chunk in litellm.completion(
@@ -681,22 +759,9 @@ class LLM:
                                 ):
                                     if chunk and chunk.choices and chunk.choices[0].delta:
                                         delta = chunk.choices[0].delta
-                                        if delta.content:
-                                            response_text += delta.content
-                                        
-                                        # Capture tool calls from streaming chunks if provider supports it
-                                        if formatted_tools and self._supports_streaming_tools() and hasattr(delta, 'tool_calls') and delta.tool_calls:
-                                            for tc in delta.tool_calls:
-                                                if tc.index >= len(tool_calls):
-                                                    tool_calls.append({
-                                                        "id": tc.id,
-                                                        "type": "function",
-                                                        "function": {"name": "", "arguments": ""}
-                                                    })
-                                                if tc.function.name:
-                                                    tool_calls[tc.index]["function"]["name"] = tc.function.name
-                                                if tc.function.arguments:
-                                                    tool_calls[tc.index]["function"]["arguments"] += tc.function.arguments
+                                        response_text, tool_calls = self._process_stream_delta(
+                                            delta, response_text, tool_calls, formatted_tools
+                                        )
                             
                             response_text = response_text.strip()
                             
@@ -1178,54 +1243,53 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             import litellm
             logging.info(f"Getting async response from {self.model}")
             # Log all self values when in debug mode
-            if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
-                debug_info = {
-                    "model": self.model,
-                    "timeout": self.timeout,
-                    "temperature": self.temperature,
-                    "top_p": self.top_p,
-                    "n": self.n,
-                    "max_tokens": self.max_tokens,
-                    "presence_penalty": self.presence_penalty,
-                    "frequency_penalty": self.frequency_penalty,
-                    "logit_bias": self.logit_bias,
-                    "response_format": self.response_format,
-                    "seed": self.seed,
-                    "logprobs": self.logprobs,
-                    "top_logprobs": self.top_logprobs,
-                    "api_version": self.api_version,
-                    "stop_phrases": self.stop_phrases,
-                    "api_key": "***" if self.api_key else None,  # Mask API key for security
-                    "base_url": self.base_url,
-                    "verbose": self.verbose,
-                    "markdown": self.markdown,
-                    "self_reflect": self.self_reflect,
-                    "max_reflect": self.max_reflect,
-                    "min_reflect": self.min_reflect,
-                    "reasoning_steps": self.reasoning_steps
-                }
-                logging.debug(f"LLM async instance configuration: {json.dumps(debug_info, indent=2, default=str)}")
-                
-                # Log the parameter values passed to get_response_async
-                param_info = {
-                    "prompt": str(prompt)[:100] + "..." if isinstance(prompt, str) and len(str(prompt)) > 100 else str(prompt),
-                    "system_prompt": system_prompt[:100] + "..." if system_prompt and len(system_prompt) > 100 else system_prompt,
-                    "chat_history": f"[{len(chat_history)} messages]" if chat_history else None,
-                    "temperature": temperature,
-                    "tools": [t.__name__ if hasattr(t, "__name__") else str(t) for t in tools] if tools else None,
-                    "output_json": str(output_json.__class__.__name__) if output_json else None,
-                    "output_pydantic": str(output_pydantic.__class__.__name__) if output_pydantic else None,
-                    "verbose": verbose,
-                    "markdown": markdown,
-                    "self_reflect": self_reflect,
-                    "max_reflect": max_reflect,
-                    "min_reflect": min_reflect,
-                    "agent_name": agent_name,
-                    "agent_role": agent_role,
-                    "agent_tools": agent_tools,
-                    "kwargs": str(kwargs)
-                }
-                logging.debug(f"get_response_async parameters: {json.dumps(param_info, indent=2, default=str)}")
+            self._log_llm_config(
+                'get_response_async',
+                model=self.model,
+                timeout=self.timeout,
+                temperature=self.temperature,
+                top_p=self.top_p,
+                n=self.n,
+                max_tokens=self.max_tokens,
+                presence_penalty=self.presence_penalty,
+                frequency_penalty=self.frequency_penalty,
+                logit_bias=self.logit_bias,
+                response_format=self.response_format,
+                seed=self.seed,
+                logprobs=self.logprobs,
+                top_logprobs=self.top_logprobs,
+                api_version=self.api_version,
+                stop_phrases=self.stop_phrases,
+                api_key=self.api_key,
+                base_url=self.base_url,
+                verbose=self.verbose,
+                markdown=self.markdown,
+                self_reflect=self.self_reflect,
+                max_reflect=self.max_reflect,
+                min_reflect=self.min_reflect,
+                reasoning_steps=self.reasoning_steps
+            )
+            
+            # Log the parameter values passed to get_response_async
+            self._log_llm_config(
+                'get_response_async parameters',
+                prompt=prompt,
+                system_prompt=system_prompt,
+                chat_history=chat_history,
+                temperature=temperature,
+                tools=tools,
+                output_json=output_json,
+                output_pydantic=output_pydantic,
+                verbose=verbose,
+                markdown=markdown,
+                self_reflect=self_reflect,
+                max_reflect=max_reflect,
+                min_reflect=min_reflect,
+                agent_name=agent_name,
+                agent_role=agent_role,
+                agent_tools=agent_tools,
+                kwargs=str(kwargs)
+            )
             reasoning_steps = kwargs.pop('reasoning_steps', self.reasoning_steps)
             litellm.set_verbose = False
 
@@ -1297,24 +1361,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         ):
                             if chunk and chunk.choices and chunk.choices[0].delta:
                                 delta = chunk.choices[0].delta
+                                response_text, tool_calls = self._process_stream_delta(
+                                    delta, response_text, tool_calls, formatted_tools
+                                )
                                 if delta.content:
-                                    response_text += delta.content
                                     print("\033[K", end="\r")  
                                     print(f"Generating... {time.time() - start_time:.1f}s", end="\r")
-                                
-                                # Capture tool calls from streaming chunks if provider supports it
-                                if formatted_tools and self._supports_streaming_tools() and hasattr(delta, 'tool_calls') and delta.tool_calls:
-                                    for tc in delta.tool_calls:
-                                        if tc.index >= len(tool_calls):
-                                            tool_calls.append({
-                                                "id": tc.id,
-                                                "type": "function",
-                                                "function": {"name": "", "arguments": ""}
-                                            })
-                                        if tc.function.name:
-                                            tool_calls[tc.index]["function"]["name"] = tc.function.name
-                                        if tc.function.arguments:
-                                            tool_calls[tc.index]["function"]["arguments"] += tc.function.arguments
                     else:
                         # Non-verbose streaming
                         async for chunk in await litellm.acompletion(
@@ -1328,22 +1380,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         ):
                             if chunk and chunk.choices and chunk.choices[0].delta:
                                 delta = chunk.choices[0].delta
-                                if delta.content:
-                                    response_text += delta.content
-                                
-                                # Capture tool calls from streaming chunks if provider supports it
-                                if formatted_tools and self._supports_streaming_tools() and hasattr(delta, 'tool_calls') and delta.tool_calls:
-                                    for tc in delta.tool_calls:
-                                        if tc.index >= len(tool_calls):
-                                            tool_calls.append({
-                                                "id": tc.id,
-                                                "type": "function",
-                                                "function": {"name": "", "arguments": ""}
-                                            })
-                                        if tc.function.name:
-                                            tool_calls[tc.index]["function"]["name"] = tc.function.name
-                                        if tc.function.arguments:
-                                            tool_calls[tc.index]["function"]["arguments"] += tc.function.arguments
+                                response_text, tool_calls = self._process_stream_delta(
+                                    delta, response_text, tool_calls, formatted_tools
+                                )
                     
                     response_text = response_text.strip()
                     
@@ -1884,22 +1923,21 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             logger.debug("Using synchronous response function")
             
             # Log all self values when in debug mode
-            if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
-                debug_info = {
-                    "model": self.model,
-                    "timeout": self.timeout,
-                    "temperature": temperature,
-                    "top_p": self.top_p,
-                    "n": self.n,
-                    "max_tokens": self.max_tokens,
-                    "presence_penalty": self.presence_penalty,
-                    "frequency_penalty": self.frequency_penalty,
-                    "stream": stream,
-                    "verbose": verbose,
-                    "markdown": markdown,
-                    "kwargs": str(kwargs)
-                }
-                logger.debug(f"Response method configuration: {json.dumps(debug_info, indent=2, default=str)}")
+            self._log_llm_config(
+                'Response method',
+                model=self.model,
+                timeout=self.timeout,
+                temperature=temperature,
+                top_p=self.top_p,
+                n=self.n,
+                max_tokens=self.max_tokens,
+                presence_penalty=self.presence_penalty,
+                frequency_penalty=self.frequency_penalty,
+                stream=stream,
+                verbose=verbose,
+                markdown=markdown,
+                kwargs=str(kwargs)
+            )
             
             # Build messages list using shared helper (simplified version without JSON output)
             messages, _ = self._build_messages(
@@ -1985,22 +2023,21 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             logger.debug("Using asynchronous response function")
             
             # Log all self values when in debug mode
-            if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
-                debug_info = {
-                    "model": self.model,
-                    "timeout": self.timeout,
-                    "temperature": temperature,
-                    "top_p": self.top_p,
-                    "n": self.n,
-                    "max_tokens": self.max_tokens,
-                    "presence_penalty": self.presence_penalty,
-                    "frequency_penalty": self.frequency_penalty,
-                    "stream": stream,
-                    "verbose": verbose,
-                    "markdown": markdown,
-                    "kwargs": str(kwargs)
-                }
-                logger.debug(f"Async response method configuration: {json.dumps(debug_info, indent=2, default=str)}")
+            self._log_llm_config(
+                'Async response method',
+                model=self.model,
+                timeout=self.timeout,
+                temperature=temperature,
+                top_p=self.top_p,
+                n=self.n,
+                max_tokens=self.max_tokens,
+                presence_penalty=self.presence_penalty,
+                frequency_penalty=self.frequency_penalty,
+                stream=stream,
+                verbose=verbose,
+                markdown=markdown,
+                kwargs=str(kwargs)
+            )
             
             # Build messages list using shared helper (simplified version without JSON output)
             messages, _ = self._build_messages(

{praisonaiagents-0.0.118 → praisonaiagents-0.0.120}/praisonaiagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.118
+Version: 0.0.120
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10

{praisonaiagents-0.0.118 → praisonaiagents-0.0.120}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.118"
+version = "0.0.120"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [