praisonaiagents 0.0.60__py3-none-any.whl → 0.0.62__py3-none-any.whl

praisonaiagents/__init__.py

@@ -3,6 +3,7 @@ Praison AI Agents - A package for hierarchical AI agent task execution
 """
 
 from .agent.agent import Agent
+from .agent.image_agent import ImageAgent
 from .agents.agents import PraisonAIAgents
 from .task.task import Task
 from .tools.tools import Tools
@@ -30,6 +31,7 @@ Agents = PraisonAIAgents
 
 __all__ = [
     'Agent',
+    'ImageAgent',
     'PraisonAIAgents',
     'Agents',
     'Tools',

praisonaiagents/agent/__init__.py

@@ -1,4 +1,5 @@
 """Agent module for AI agents"""
 from .agent import Agent
+from .image_agent import ImageAgent
 
-__all__ = ['Agent'] 
+__all__ = ['Agent', 'ImageAgent']

praisonaiagents/agent/agent.py

@@ -16,7 +16,6 @@ from ..main import (
     display_self_reflection,
     ReflectionOutput,
     client,
-    error_logs,
     adisplay_instruction
 )
 import inspect
@@ -715,6 +714,22 @@ Your Goal: {self.goal}
             return None
 
     def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False):
+        # Log all parameter values when in debug mode
+        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+            param_info = {
+                "prompt": str(prompt)[:100] + "..." if isinstance(prompt, str) and len(str(prompt)) > 100 else str(prompt),
+                "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,
+                "reasoning_steps": reasoning_steps,
+                "agent_name": self.name,
+                "agent_role": self.role,
+                "agent_goal": self.goal
+            }
+            logging.debug(f"Agent.chat parameters: {json.dumps(param_info, indent=2, default=str)}")
+        
+        start_time = time.time()
         reasoning_steps = reasoning_steps or self.reasoning_steps
         # Search for existing knowledge if any knowledge is provided
         if self.knowledge:
@@ -739,7 +754,7 @@ Your Goal: {self.goal}
                     system_prompt=f"{self.backstory}\n\nYour Role: {self.role}\n\nYour Goal: {self.goal}" if self.use_system_prompt else None,
                     chat_history=self.chat_history,
                     temperature=temperature,
-                    tools=tools,
+                    tools=self.tools if tools is None else tools,
                     output_json=output_json,
                     output_pydantic=output_pydantic,
                     verbose=self.verbose,
@@ -750,7 +765,7 @@ Your Goal: {self.goal}
                     console=self.console,
                     agent_name=self.name,
                     agent_role=self.role,
-                    agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools],
+                    agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in (tools if tools is not None else self.tools)],
                     execute_tool_fn=self.execute_tool,  # Pass tool execution function
                     reasoning_steps=reasoning_steps
                 )
@@ -758,6 +773,11 @@ Your Goal: {self.goal}
                 self.chat_history.append({"role": "user", "content": prompt})
                 self.chat_history.append({"role": "assistant", "content": response_text})
 
+                # Log completion time if in debug mode
+                if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                    total_time = time.time() - start_time
+                    logging.debug(f"Agent.chat completed in {total_time:.2f} seconds")
+
                 return response_text
             except Exception as e:
                 display_error(f"Error in LLM chat: {e}")
@@ -945,6 +965,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     display_error(f"Error in chat: {e}", console=self.console)
                     return None 
 
+        # Log completion time if in debug mode
+        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+            total_time = time.time() - start_time
+            logging.debug(f"Agent.chat completed in {total_time:.2f} seconds")
+            
+        return response_text
+
     def clean_json_output(self, output: str) -> str:
         """Clean and extract JSON from response text."""
         cleaned = output.strip()
@@ -959,6 +986,22 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
     async def achat(self, prompt: str, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False):
         """Async version of chat method. TODO: Requires Syncing with chat method.""" 
+        # Log all parameter values when in debug mode
+        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+            param_info = {
+                "prompt": str(prompt)[:100] + "..." if isinstance(prompt, str) and len(str(prompt)) > 100 else str(prompt),
+                "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,
+                "reasoning_steps": reasoning_steps,
+                "agent_name": self.name,
+                "agent_role": self.role,
+                "agent_goal": self.goal
+            }
+            logging.debug(f"Agent.achat parameters: {json.dumps(param_info, indent=2, default=str)}")
+        
+        start_time = time.time()
         reasoning_steps = reasoning_steps or self.reasoning_steps
         try:
             # Search for existing knowledge if any knowledge is provided
@@ -997,9 +1040,15 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     self.chat_history.append({"role": "user", "content": prompt})
                     self.chat_history.append({"role": "assistant", "content": response_text})
 
+                    if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                        total_time = time.time() - start_time
+                        logging.debug(f"Agent.achat completed in {total_time:.2f} seconds")
                     return response_text
                 except Exception as e:
                     display_error(f"Error in LLM chat: {e}")
+                    if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                        total_time = time.time() - start_time
+                        logging.debug(f"Agent.achat failed in {total_time:.2f} seconds: {str(e)}")
                     return None
 
             # For OpenAI client
@@ -1082,7 +1131,11 @@ Your Goal: {self.goal}
                             temperature=temperature,
                             tools=formatted_tools
                         )
-                        return await self._achat_completion(response, tools)
+                        result = await self._achat_completion(response, tools)
+                        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                            total_time = time.time() - start_time
+                            logging.debug(f"Agent.achat completed in {total_time:.2f} seconds")
+                        return result
                     elif output_json or output_pydantic:
                         response = await async_client.chat.completions.create(
                             model=self.llm,
@@ -1091,6 +1144,9 @@ Your Goal: {self.goal}
                             response_format={"type": "json_object"}
                         )
                         # Return the raw response
+                        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                            total_time = time.time() - start_time
+                            logging.debug(f"Agent.achat completed in {total_time:.2f} seconds")
                         return response.choices[0].message.content
                     else:
                         response = await async_client.chat.completions.create(
@@ -1098,12 +1154,21 @@ Your Goal: {self.goal}
                             messages=messages,
                             temperature=temperature
                         )
+                        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                            total_time = time.time() - start_time
+                            logging.debug(f"Agent.achat completed in {total_time:.2f} seconds")
                         return response.choices[0].message.content
                 except Exception as e:
                     display_error(f"Error in chat completion: {e}")
+                    if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                        total_time = time.time() - start_time
+                        logging.debug(f"Agent.achat failed in {total_time:.2f} seconds: {str(e)}")
                     return None
         except Exception as e:
             display_error(f"Error in achat: {e}")
+            if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                total_time = time.time() - start_time
+                logging.debug(f"Agent.achat failed in {total_time:.2f} seconds: {str(e)}")
             return None
 
     async def _achat_completion(self, response, tools, reasoning_steps=False):

praisonaiagents/agent/image_agent.py

@@ -0,0 +1,213 @@
+"""
+ImageAgent - A specialized agent class for generating images using AI models.
+
+This class extends the base Agent class to provide specific functionality for image generation,
+including support for different image models, sizes, and quality settings.
+"""
+
+from typing import Optional, Any, Dict, Union, List
+from ..agent.agent import Agent
+from pydantic import BaseModel, Field
+import logging
+import warnings
+
+# Filter out Pydantic warning about fields
+warnings.filterwarnings("ignore", "Valid config keys have changed in V2", UserWarning)
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+class ImageGenerationConfig(BaseModel):
+    """Configuration for image generation settings."""
+    style: str = Field(default="natural", description="Style of the generated image")
+    response_format: str = Field(default="url", description="Format of the response (url or b64_json)")
+    timeout: int = Field(default=600, description="Timeout in seconds for the API call")
+    api_base: Optional[str] = Field(default=None, description="Optional API base URL")
+    api_key: Optional[str] = Field(default=None, description="Optional API key")
+    api_version: Optional[str] = Field(default=None, description="Optional API version (required for Azure dall-e-3)")
+
+class ImageAgent(Agent):
+    """
+    A specialized agent for generating images using AI models.
+    
+    This agent extends the base Agent class with specific functionality for image generation,
+    including support for different models, sizes, and quality settings.
+    """
+    
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        role: Optional[str] = None,
+        goal: Optional[str] = None,
+        backstory: Optional[str] = None,
+        instructions: Optional[str] = None,
+        llm: Optional[Union[str, Any]] = None,
+        style: str = "natural",
+        response_format: str = "url",
+        timeout: int = 600,
+        api_base: Optional[str] = None,
+        api_key: Optional[str] = None,
+        api_version: Optional[str] = None,
+        verbose: Union[bool, int] = True,
+        **kwargs
+    ):
+        """Initialize ImageAgent with parameters."""
+        # Set default role and goal if not provided
+        role = role or "Image Generation Assistant"
+        goal = goal or "Generate high-quality images based on text descriptions"
+        backstory = backstory or "I am an AI assistant specialized in generating images from textual descriptions"
+
+        # Initialize the base agent
+        super().__init__(
+            name=name,
+            role=role,
+            goal=goal,
+            backstory=backstory,
+            instructions=instructions,
+            llm=llm,
+            verbose=verbose,
+            **kwargs
+        )
+
+        # Store image generation configuration
+        self.image_config = ImageGenerationConfig(
+            style=style,
+            response_format=response_format,
+            timeout=timeout,
+            api_base=api_base,
+            api_key=api_key,
+            api_version=api_version
+        )
+        
+        # Lazy load litellm
+        self._litellm = None
+
+        # Configure logging based on verbose level
+        self._configure_logging(verbose)
+
+    def _configure_logging(self, verbose: Union[bool, int]) -> None:
+        """Configure logging levels based on verbose setting."""
+        # Only suppress logs if not in debug mode
+        if not isinstance(verbose, bool) and verbose >= 10:
+            # Enable detailed debug logging
+            logging.getLogger("asyncio").setLevel(logging.DEBUG)
+            logging.getLogger("selector_events").setLevel(logging.DEBUG)
+            logging.getLogger("litellm.utils").setLevel(logging.DEBUG)
+            logging.getLogger("litellm.main").setLevel(logging.DEBUG)
+            if hasattr(self, 'litellm'):
+                self.litellm.suppress_debug_messages = False
+                self.litellm.set_verbose = True
+            # Don't filter warnings in debug mode
+            warnings.resetwarnings()
+        else:
+            # Suppress debug logging for normal operation
+            logging.getLogger("asyncio").setLevel(logging.WARNING)
+            logging.getLogger("selector_events").setLevel(logging.WARNING)
+            logging.getLogger("litellm.utils").setLevel(logging.WARNING)
+            logging.getLogger("litellm.main").setLevel(logging.WARNING)
+            logging.getLogger("httpx").setLevel(logging.WARNING)
+            logging.getLogger("httpcore").setLevel(logging.WARNING)
+            if hasattr(self, 'litellm'):
+                self.litellm.suppress_debug_messages = True
+                self.litellm._logging._disable_debugging()
+            # Suppress all warnings including Pydantic's
+            warnings.filterwarnings("ignore", category=RuntimeWarning)
+            warnings.filterwarnings("ignore", category=UserWarning)
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+    @property
+    def litellm(self):
+        """Lazy load litellm module when needed."""
+        if self._litellm is None:
+            try:
+                import litellm
+                from litellm import image_generation
+                
+                # Configure litellm to disable success handler logs
+                litellm.success_callback = []
+                litellm._logging._disable_debugging()
+                
+                self._litellm = image_generation
+                # Configure logging after litellm is loaded
+                self._configure_logging(self.verbose)
+            except ImportError:
+                raise ImportError(
+                    "litellm is required for image generation. "
+                    "Please install it with: pip install litellm"
+                )
+        return self._litellm
+
+    def generate_image(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        """Generate an image based on the provided prompt."""
+        # Merge default config with any provided kwargs
+        config = self.image_config.dict(exclude_none=True)
+        config.update(kwargs)
+        
+        # Use llm parameter as the model
+        config['model'] = self.llm
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True
+        ) as progress:
+            try:
+                # Add a task for image generation
+                task = progress.add_task(f"[cyan]Generating image with {self.llm}...", total=None)
+                
+                # Use litellm's image generation
+                response = self.litellm(
+                    prompt=prompt,
+                    **config
+                )
+                
+                # Mark task as complete
+                progress.update(task, completed=True)
+                return response
+
+            except Exception as e:
+                error_msg = f"Error generating image: {str(e)}"
+                if self.verbose:
+                    self.console.print(f"[red]{error_msg}[/red]")
+                logging.error(error_msg)
+                raise
+
+    async def agenerate_image(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        """Async wrapper for generate_image."""
+        return self.generate_image(prompt, **kwargs)
+
+    def chat(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        """Generate an image from the prompt."""
+        try:
+            result = self.generate_image(prompt, **kwargs)
+            if self.verbose:
+                self.console.print(f"[green]Successfully generated image from prompt[/green]")
+            return result
+        except Exception as e:
+            error_msg = f"Failed to generate image: {str(e)}"
+            if self.verbose:
+                self.console.print(f"[red]{error_msg}[/red]")
+            return {"error": str(e)}
+
+    async def achat(
+        self,
+        prompt: str,
+        temperature: float = 0.2,
+        tools: Optional[List[Any]] = None,
+        output_json: Optional[str] = None,
+        output_pydantic: Optional[Any] = None,
+        reasoning_steps: bool = False,
+        **kwargs
+    ) -> Union[str, Dict[str, Any]]:
+        """Async chat method for image generation."""
+        try:
+            image_result = await self.agenerate_image(prompt, **kwargs)
+            if self.verbose:
+                self.console.print(f"[green]Successfully generated image from prompt[/green]")
+            return image_result
+        except Exception as e:
+            error_msg = f"Failed to generate image: {str(e)}"
+            if self.verbose:
+                self.console.print(f"[red]{error_msg}[/red]")
+            return {"error": str(e)}

praisonaiagents/agents/autoagents.py

@@ -8,10 +8,10 @@ It automatically handles agent creation, task setup, and execution flow.
 from .agents import PraisonAIAgents
 from ..agent.agent import Agent
 from ..task.task import Task
-from typing import List, Any, Optional, Dict, Union
+from typing import List, Any, Optional, Dict
 import logging
 import os
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from ..main import display_instruction, display_tool_call, display_interaction, client
 
 # Define Pydantic models for structured output

praisonaiagents/llm/llm.py

@@ -172,6 +172,36 @@ class LLM:
         # Enable error dropping for cleaner output
         litellm.drop_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)}")
 
     def get_response(
         self,
@@ -195,6 +225,56 @@ class LLM:
         **kwargs
     ) -> str:
         """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)}")
         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.
@@ -202,6 +282,23 @@ class LLM:
             # Disable litellm debug messages
             litellm.set_verbose = False
             
+            # Format tools if provided
+            formatted_tools = None
+            if tools:
+                formatted_tools = []
+                for tool in tools:
+                    if callable(tool):
+                        tool_def = self._generate_tool_definition(tool.__name__)
+                    elif isinstance(tool, str):
+                        tool_def = self._generate_tool_definition(tool)
+                    else:
+                        continue
+                        
+                    if tool_def:
+                        formatted_tools.append(tool_def)
+                if not formatted_tools:
+                    formatted_tools = None
+            
             # Build messages list
             messages = []
             if system_prompt:
@@ -260,6 +357,7 @@ class LLM:
                             messages=messages,
                             temperature=temperature,
                             stream=False,  # force non-streaming
+                            tools=formatted_tools,
                             **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                         )
                         reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
@@ -291,6 +389,7 @@ class LLM:
                                 for chunk in litellm.completion(
                                     model=self.model,
                                     messages=messages,
+                                    tools=formatted_tools,
                                     temperature=temperature,
                                     stream=True,
                                     **kwargs
@@ -305,6 +404,7 @@ class LLM:
                             for chunk in litellm.completion(
                                 model=self.model,
                                 messages=messages,
+                                tools=formatted_tools,
                                 temperature=temperature,
                                 stream=True,
                                 **kwargs
@@ -318,6 +418,7 @@ class LLM:
                     final_response = litellm.completion(
                         model=self.model,
                         messages=messages,
+                        tools=formatted_tools,
                         temperature=temperature,
                         stream=False,  # No streaming for tool call check
                         **kwargs
@@ -552,6 +653,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         except Exception as error:
             display_error(f"Error in get_response: {str(error)}")
             raise
+        
+        # Log completion time if in debug mode
+        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+            total_time = time.time() - start_time
+            logging.debug(f"get_response completed in {total_time:.2f} seconds")
 
     async def get_response_async(
         self,
@@ -577,6 +683,56 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         """Async version of get_response with identical functionality."""
         try:
             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)}")
             reasoning_steps = kwargs.pop('reasoning_steps', self.reasoning_steps)
             litellm.set_verbose = False
 
@@ -983,6 +1139,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 raise LLMContextLengthExceededException(str(error))
             display_error(f"Error in get_response_async: {str(error)}")
             raise
+            
+        # Log completion time if in debug mode
+        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+            total_time = time.time() - start_time
+            logging.debug(f"get_response_async completed in {total_time:.2f} seconds")
 
     def can_use_tools(self) -> bool:
         """Check if this model can use tool functions"""
@@ -1065,6 +1226,24 @@ 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)}")
+            
             # Build messages list
             messages = []
             if system_prompt:
@@ -1128,7 +1307,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             raise
 
     # Async version of response function. Response without tool calls
-    async def response_async(
+    async def aresponse(
         self,
         prompt: Union[str, List[Dict]],
         system_prompt: Optional[str] = None,
@@ -1150,6 +1329,24 @@ 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)}")
+            
             # Build messages list
             messages = []
             if system_prompt:
@@ -1210,4 +1407,117 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
         except Exception as error:
             display_error(f"Error in response_async: {str(error)}")
-            raise
+            raise
+
+    def _generate_tool_definition(self, function_name: str) -> Optional[Dict]:
+        """Generate a tool definition from a function name."""
+        logging.debug(f"Attempting to generate tool definition for: {function_name}")
+        
+        # First try to get the tool definition if it exists
+        tool_def_name = f"{function_name}_definition"
+        tool_def = globals().get(tool_def_name)
+        logging.debug(f"Looking for {tool_def_name} in globals: {tool_def is not None}")
+        
+        if not tool_def:
+            import __main__
+            tool_def = getattr(__main__, tool_def_name, None)
+            logging.debug(f"Looking for {tool_def_name} in __main__: {tool_def is not None}")
+        
+        if tool_def:
+            logging.debug(f"Found tool definition: {tool_def}")
+            return tool_def
+
+        # Try to find the function
+        func = globals().get(function_name)
+        logging.debug(f"Looking for {function_name} in globals: {func is not None}")
+        
+        if not func:
+            import __main__
+            func = getattr(__main__, function_name, None)
+            logging.debug(f"Looking for {function_name} in __main__: {func is not None}")
+        
+        if not func or not callable(func):
+            logging.debug(f"Function {function_name} not found or not callable")
+            return None
+
+        import inspect
+        # Handle Langchain and CrewAI tools
+        if inspect.isclass(func) and hasattr(func, 'run') and not hasattr(func, '_run'):
+            original_func = func
+            func = func.run
+            function_name = original_func.__name__
+        elif inspect.isclass(func) and hasattr(func, '_run'):
+            original_func = func
+            func = func._run
+            function_name = original_func.__name__
+
+        sig = inspect.signature(func)
+        logging.debug(f"Function signature: {sig}")
+        
+        # Skip self, *args, **kwargs
+        parameters_list = []
+        for name, param in sig.parameters.items():
+            if name == "self":
+                continue
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+            parameters_list.append((name, param))
+
+        parameters = {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+        
+        # Parse docstring for parameter descriptions
+        docstring = inspect.getdoc(func)
+        logging.debug(f"Function docstring: {docstring}")
+        
+        param_descriptions = {}
+        if docstring:
+            import re
+            param_section = re.split(r'\s*Args:\s*', docstring)
+            logging.debug(f"Param section split: {param_section}")
+            if len(param_section) > 1:
+                param_lines = param_section[1].split('\n')
+                for line in param_lines:
+                    line = line.strip()
+                    if line and ':' in line:
+                        param_name, param_desc = line.split(':', 1)
+                        param_descriptions[param_name.strip()] = param_desc.strip()
+        
+        logging.debug(f"Parameter descriptions: {param_descriptions}")
+
+        for name, param in parameters_list:
+            param_type = "string"  # Default type
+            if param.annotation != inspect.Parameter.empty:
+                if param.annotation == int:
+                    param_type = "integer"
+                elif param.annotation == float:
+                    param_type = "number"
+                elif param.annotation == bool:
+                    param_type = "boolean"
+                elif param.annotation == list:
+                    param_type = "array"
+                elif param.annotation == dict:
+                    param_type = "object"
+            
+            parameters["properties"][name] = {
+                "type": param_type,
+                "description": param_descriptions.get(name, "Parameter description not available")
+            }
+            
+            if param.default == inspect.Parameter.empty:
+                parameters["required"].append(name)
+        
+        logging.debug(f"Generated parameters: {parameters}")
+        tool_def = {
+            "type": "function",
+            "function": {
+                "name": function_name,
+                "description": docstring.split('\n\n')[0] if docstring else "No description available",
+                "parameters": parameters
+            }
+        }
+        logging.debug(f"Generated tool definition: {tool_def}")
+        return tool_def

praisonaiagents/tools/train/data/generatecot.py

@@ -1,8 +1,6 @@
 from typing import Dict, Optional, Union, Any
 import json
 from datetime import datetime
-from openai import OpenAI
-from pydantic import BaseModel
 import os
 import logging
 
@@ -124,7 +122,7 @@ class GenerateCOT:
         try:
             score = float(self._ask_ai(prompt))
             return min(max(score, 0), 1)
-        except:
+        except ValueError:
             return 0.0
             
     def cot_run(self, question: str) -> str:
@@ -336,6 +334,7 @@ class GenerateCOT:
     ) -> Optional[str]:
         """Export solutions in CSV format."""
         try:
+            import csv
             self._is_qa_pairs(qa_pairs)  # Validate format
             if qa_pairs:
                 self.qa_pairs.update(qa_pairs)
@@ -425,7 +424,6 @@ class GenerateCOT:
         logger.debug(f"Attempting to upload {filepath} to HuggingFace as {dataset_name}")
         try:
             from datasets import Dataset
-            from huggingface_hub import HfApi, login
             import pandas as pd
             
             logger.debug(f"Loading data from {filepath}")

{praisonaiagents-0.0.60.dist-info → praisonaiagents-0.0.62.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: praisonaiagents
-Version: 0.0.60
+Version: 0.0.62
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.60.dist-info → praisonaiagents-0.0.62.dist-info}/RECORD

@@ -1,15 +1,16 @@
-praisonaiagents/__init__.py,sha256=JtPibbmeFv3meIb3vkKjckB0p7m-Vqt2RYPwOH8P41k,1228
+praisonaiagents/__init__.py,sha256=frdIvimDY-kU9j-9yXV1z4NtXypfPvyvlnac5mgBCuQ,1288
 praisonaiagents/main.py,sha256=0kB9gn9meXtr4EIrdgA2lAioKIHCRJ61audsGDwuTm4,14428
-praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=VZPci7g_LAvTz7_rWvWAZ1JgCGKQc1vSfI6x0fqi2os,57598
+praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
+praisonaiagents/agent/agent.py,sha256=h3s0-1M88zujllDHnKijHmYeVihD75d-K9s2Y3IHLY4,61850
+praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
 praisonaiagents/agents/agents.py,sha256=94YPQl-hl-EPY6-Xk2Rj9wlIs9YtiLQbsutSOXWX8QI,36156
-praisonaiagents/agents/autoagents.py,sha256=bjC2O5oZmoJItJXIMPTWc2lsp_AJC9tMiTQOal2hwPA,13532
+praisonaiagents/agents/autoagents.py,sha256=olYDn--rlJp-SckxILqmREkkgNlzCgEEcAUzfMj-54E,13518
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=FzoNY0q8MkvG4gADqk4JcRhmH3lcEHbRdonDgitQa30,6624
 praisonaiagents/knowledge/knowledge.py,sha256=fQNREDiwdoisfIxJBLVkteXgq_8Gbypfc3UaZbxf5QY,13210
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=t47T80kL2QEUSAGfNYHQG130d-CRUDxXi0AwStW0zkk,58156
+praisonaiagents/llm/llm.py,sha256=pYXKXuvJgbqItO8MDmAZVYZwb5es1HDfn10refHz0Ck,73025
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
@@ -35,8 +36,8 @@ praisonaiagents/tools/wikipedia_tools.py,sha256=pGko-f33wqXgxJTv8db7TbizY5XnzBQR
 praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxNMMs1A,17122
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
-praisonaiagents/tools/train/data/generatecot.py,sha256=EwrF6p-AWQQJktJeZu2O52ipbHGPd5y1IEmTLw-YSCs,19479
-praisonaiagents-0.0.60.dist-info/METADATA,sha256=I7mcUMdieRsRLzjdMO2Qkzt6dEY8Tm2X1XJIkydeIAg,830
-praisonaiagents-0.0.60.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.60.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.60.dist-info/RECORD,,
+praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
+praisonaiagents-0.0.62.dist-info/METADATA,sha256=w9bbiQEKBjIErkraz8jMhhN1qkeA4WBPf2ylGn9Skz4,830
+praisonaiagents-0.0.62.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+praisonaiagents-0.0.62.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.62.dist-info/RECORD,,

{praisonaiagents-0.0.60.dist-info → praisonaiagents-0.0.62.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any