praisonaiagents 0.0.61__py3-none-any.whl → 0.0.63__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -714,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:
@@ -738,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,
@@ -749,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
                 )
@@ -757,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}")
@@ -944,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()
@@ -958,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
@@ -996,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
@@ -1081,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,
@@ -1090,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(
@@ -1097,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/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
@@ -337,20 +438,29 @@ class LLM:
                             function_name = tool_call["function"]["name"]
                             arguments = json.loads(tool_call["function"]["arguments"])
 
-                            if verbose:
-                                display_tool_call(f"Agent {agent_name} is calling function '{function_name}' with arguments: {arguments}", console=console)
-
+                            logging.debug(f"[TOOL_EXEC_DEBUG] About to execute tool {function_name} with args: {arguments}")
                             tool_result = execute_tool_fn(function_name, arguments)
+                            logging.debug(f"[TOOL_EXEC_DEBUG] Tool execution result: {tool_result}")
 
-                            if tool_result:
-                                if verbose:
-                                    display_tool_call(f"Function '{function_name}' returned: {tool_result}", console=console)
+                            if verbose:
+                                display_message = f"Agent {agent_name} called function '{function_name}' with arguments: {arguments}\n"
+                                if tool_result:
+                                    display_message += f"Function returned: {tool_result}"
+                                    logging.debug(f"[TOOL_EXEC_DEBUG] Display message with result: {display_message}")
+                                else:
+                                    display_message += "Function returned no output"
+                                    logging.debug("[TOOL_EXEC_DEBUG] Tool returned no output")
+                                
+                                logging.debug(f"[TOOL_EXEC_DEBUG] About to display tool call with message: {display_message}")
+                                display_tool_call(display_message, console=console)
+                                
                                 messages.append({
                                     "role": "tool",
                                     "tool_call_id": tool_call["id"],
                                     "content": json.dumps(tool_result)
                                 })
                             else:
+                                logging.debug("[TOOL_EXEC_DEBUG] Verbose mode off, not displaying tool call")
                                 messages.append({
                                     "role": "tool",
                                     "tool_call_id": tool_call["id"],
@@ -552,6 +662,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 +692,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
 
@@ -767,14 +932,15 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         function_name = tool_call.function.name
                         arguments = json.loads(tool_call.function.arguments)
 
-                        if verbose:
-                            display_tool_call(f"Agent {agent_name} is calling function '{function_name}' with arguments: {arguments}", console=console)
-
                         tool_result = await execute_tool_fn(function_name, arguments)
 
-                        if tool_result:
-                            if verbose:
-                                display_tool_call(f"Function '{function_name}' returned: {tool_result}", console=console)
+                        if verbose:
+                            display_message = f"Agent {agent_name} called function '{function_name}' with arguments: {arguments}\n"
+                            if tool_result:
+                                display_message += f"Function returned: {tool_result}"
+                            else:
+                                display_message += "Function returned no output"
+                            display_tool_call(display_message, console=console)
                             messages.append({
                                 "role": "tool",
                                 "tool_call_id": tool_call.id,
@@ -983,6 +1149,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 +1236,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:
@@ -1150,6 +1339,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 +1417,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/main.py

@@ -86,6 +86,7 @@ async def execute_callback(display_type: str, **kwargs):
 def _clean_display_content(content: str, max_length: int = 20000) -> str:
     """Helper function to clean and truncate content for display."""
     if not content or not str(content).strip():
+        logging.debug(f"Empty content received in _clean_display_content: {repr(content)}")
         return ""
         
     content = str(content)
@@ -174,11 +175,14 @@ def display_instruction(message: str, console=None, agent_name: str = None, agen
         console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
 
 def display_tool_call(message: str, console=None):
+    logging.debug(f"display_tool_call called with message: {repr(message)}")
     if not message or not message.strip():
+        logging.debug("Empty message in display_tool_call, returning early")
         return
     if console is None:
         console = Console()
     message = _clean_display_content(str(message))
+    logging.debug(f"Cleaned message in display_tool_call: {repr(message)}")
     
     # Execute callback if registered
     if 'tool_call' in sync_display_callbacks:
@@ -202,7 +206,8 @@ def display_error(message: str, console=None):
 
 def display_generating(content: str = "", start_time: Optional[float] = None):
     if not content or not str(content).strip():
-        return Panel("", title="", border_style="green")
+        logging.debug("Empty content in display_generating, returning early")
+        return None
     
     elapsed_str = ""
     if start_time is not None:
@@ -293,11 +298,14 @@ async def adisplay_instruction(message: str, console=None, agent_name: str = Non
 
 async def adisplay_tool_call(message: str, console=None):
     """Async version of display_tool_call."""
+    logging.debug(f"adisplay_tool_call called with message: {repr(message)}")
     if not message or not message.strip():
+        logging.debug("Empty message in adisplay_tool_call, returning early")
         return
     if console is None:
         console = Console()
     message = _clean_display_content(str(message))
+    logging.debug(f"Cleaned message in adisplay_tool_call: {repr(message)}")
     
     if 'tool_call' in async_display_callbacks:
         await async_display_callbacks['tool_call'](message=message)
@@ -321,7 +329,8 @@ async def adisplay_error(message: str, console=None):
 async def adisplay_generating(content: str = "", start_time: Optional[float] = None):
     """Async version of display_generating."""
     if not content or not str(content).strip():
-        return Panel("", title="", border_style="green")
+        logging.debug("Empty content in adisplay_generating, returning early")
+        return None
     
     elapsed_str = ""
     if start_time is not None:

{praisonaiagents-0.0.61.dist-info → praisonaiagents-0.0.63.dist-info}/METADATA

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

{praisonaiagents-0.0.61.dist-info → praisonaiagents-0.0.63.dist-info}/RECORD

@@ -1,7 +1,7 @@
 praisonaiagents/__init__.py,sha256=frdIvimDY-kU9j-9yXV1z4NtXypfPvyvlnac5mgBCuQ,1288
-praisonaiagents/main.py,sha256=0kB9gn9meXtr4EIrdgA2lAioKIHCRJ61audsGDwuTm4,14428
+praisonaiagents/main.py,sha256=l29nGEbV2ReBi4szURbnH0Fk0w2F_QZTmECysyZjYcA,15066
 praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
-praisonaiagents/agent/agent.py,sha256=_v8WrWK1oP4OpPgp30nH4xbPyREnjOnRT1cyHUa2T9Q,57582
+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
@@ -10,7 +10,7 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 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=SYfiMOmduEOhwraewmXSydu6tNBb9n5uKRxnO9moGYM,58151
+praisonaiagents/llm/llm.py,sha256=hByGXJFHC4BPcsu2b1RZN239mfNp4sz5WuTJDallfaQ,73982
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
@@ -37,7 +37,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 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=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.61.dist-info/METADATA,sha256=I_883Gdgeer-wm8RVmBk-kAdkHQloL0ewZ96wqwW26c,830
-praisonaiagents-0.0.61.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.61.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.61.dist-info/RECORD,,
+praisonaiagents-0.0.63.dist-info/METADATA,sha256=oZNwr62vIILdar4v3DrKgAuVnYEzvNNUH_o9Ndy7NMI,830
+praisonaiagents-0.0.63.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+praisonaiagents-0.0.63.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.63.dist-info/RECORD,,

{praisonaiagents-0.0.61.dist-info → praisonaiagents-0.0.63.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