praisonaiagents 0.0.109__py3-none-any.whl → 0.0.111__py3-none-any.whl

praisonaiagents/llm/llm.py

@@ -276,6 +276,41 @@ class LLM:
         ]
         
         return self.model in legacy_o1_models
+    
+    def _supports_streaming_tools(self) -> bool:
+        """
+        Check if the current provider supports streaming with tools.
+        
+        Most providers that support tool calling also support streaming with tools,
+        but some providers (like Ollama and certain local models) require non-streaming
+        calls when tools are involved.
+        
+        Returns:
+            bool: True if provider supports streaming with tools, False otherwise
+        """
+        if not self.model:
+            return False
+        
+        # Ollama doesn't reliably support streaming with tools
+        if self._is_ollama_provider():
+            return False
+        
+        # OpenAI models support streaming with tools
+        if any(self.model.startswith(prefix) for prefix in ["gpt-", "o1-", "o3-"]):
+            return True
+        
+        # Anthropic Claude models support streaming with tools
+        if self.model.startswith("claude-"):
+            return True
+        
+        # Google Gemini models support streaming with tools
+        if any(self.model.startswith(prefix) for prefix in ["gemini-", "gemini/"]):
+            return True
+        
+        # For other providers, default to False to be safe
+        # This ensures we make a single non-streaming call rather than risk
+        # missing tool calls or making duplicate calls
+        return False
 
     def get_response(
         self,
@@ -480,49 +515,110 @@ class LLM:
                     
                     # Otherwise do the existing streaming approach
                     else:
-                        if verbose:
-                            with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
-                                response_text = ""
+                        # Determine if we should use streaming based on tool support
+                        use_streaming = stream
+                        if formatted_tools and not self._supports_streaming_tools():
+                            # Provider doesn't support streaming with tools, use non-streaming
+                            use_streaming = False
+                        
+                        if use_streaming:
+                            # Streaming approach (with or without tools)
+                            tool_calls = []
+                            response_text = ""
+                            
+                            if verbose:
+                                with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
+                                    for chunk in litellm.completion(
+                                        **self._build_completion_params(
+                                            messages=messages,
+                                            tools=formatted_tools,
+                                            temperature=temperature,
+                                            stream=True,
+                                            **kwargs
+                                        )
+                                    ):
+                                        if chunk and chunk.choices and chunk.choices[0].delta:
+                                            delta = chunk.choices[0].delta
+                                            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(
                                     **self._build_completion_params(
                                         messages=messages,
                                         tools=formatted_tools,
                                         temperature=temperature,
-                                        stream=stream,
+                                        stream=True,
                                         **kwargs
                                     )
                                 ):
-                                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                        content = chunk.choices[0].delta.content
-                                        response_text += content
-                                        live.update(display_generating(response_text, current_time))
+                                    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 = response_text.strip()
+                            
+                            # Create a mock final_response with the captured data
+                            final_response = {
+                                "choices": [{
+                                    "message": {
+                                        "content": response_text,
+                                        "tool_calls": tool_calls if tool_calls else None
+                                    }
+                                }]
+                            }
                         else:
-                            # Non-verbose mode, just collect the response
-                            response_text = ""
-                            for chunk in litellm.completion(
+                            # Non-streaming approach (when tools require it or streaming is disabled)
+                            final_response = litellm.completion(
                                 **self._build_completion_params(
                                     messages=messages,
                                     tools=formatted_tools,
                                     temperature=temperature,
-                                    stream=stream,
+                                    stream=False,
                                     **kwargs
                                 )
-                            ):
-                                if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                    response_text += chunk.choices[0].delta.content
-
-                        response_text = response_text.strip()
-
-                        # Get final completion to check for tool calls
-                        final_response = litellm.completion(
-                            **self._build_completion_params(
-                                messages=messages,
-                                tools=formatted_tools,
-                                temperature=temperature,
-                                stream=False,  # No streaming for tool call check
-                                **kwargs
                             )
-                        )
+                            response_text = final_response["choices"][0]["message"]["content"]
+                            
+                            if verbose:
+                                # Display the complete response at once
+                                display_interaction(
+                                    original_prompt,
+                                    response_text,
+                                    markdown=markdown,
+                                    generation_time=time.time() - current_time,
+                                    console=console
+                                )
                     
                     tool_calls = final_response["choices"][0]["message"].get("tool_calls")
                     
@@ -1198,53 +1294,106 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         console=console
                     )
             else:
-                if verbose:
-                    # ----------------------------------------------------
-                    # 1) Make the streaming call WITHOUT tools
-                    # ----------------------------------------------------
-                    async for chunk in await litellm.acompletion(
-                        **self._build_completion_params(
-                            messages=messages,
-                            temperature=temperature,
-                            stream=stream,
-                            **kwargs
-                        )
-                    ):
-                        if chunk and chunk.choices and chunk.choices[0].delta.content:
-                            response_text += chunk.choices[0].delta.content
-                            print("\033[K", end="\r")  
-                            print(f"Generating... {time.time() - start_time:.1f}s", end="\r")
+                # Determine if we should use streaming based on tool support
+                use_streaming = stream
+                if formatted_tools and not self._supports_streaming_tools():
+                    # Provider doesn't support streaming with tools, use non-streaming
+                    use_streaming = False
+                
+                if use_streaming:
+                    # Streaming approach (with or without tools)
+                    tool_calls = []
+                    
+                    if verbose:
+                        async for chunk in await litellm.acompletion(
+                            **self._build_completion_params(
+                                messages=messages,
+                                temperature=temperature,
+                                stream=True,
+                                tools=formatted_tools,
+                                **kwargs
+                            )
+                        ):
+                            if chunk and chunk.choices and chunk.choices[0].delta:
+                                delta = chunk.choices[0].delta
+                                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(
+                            **self._build_completion_params(
+                                messages=messages,
+                                temperature=temperature,
+                                stream=True,
+                                tools=formatted_tools,
+                                **kwargs
+                            )
+                        ):
+                            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 = response_text.strip()
+                    
+                    # We already have tool_calls from streaming if supported
+                    # No need for a second API call!
                 else:
-                    # Non-verbose streaming call, still no tools
-                    async for chunk in await litellm.acompletion(
+                    # Non-streaming approach (when tools require it or streaming is disabled)
+                    tool_response = await litellm.acompletion(
                         **self._build_completion_params(
                             messages=messages,
                             temperature=temperature,
-                            stream=stream,
-                            **kwargs
+                            stream=False,
+                            tools=formatted_tools,
+                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                         )
-                    ):
-                        if chunk and chunk.choices and chunk.choices[0].delta.content:
-                            response_text += chunk.choices[0].delta.content
-
-            response_text = response_text.strip()
-
-            # ----------------------------------------------------
-            # 2) If tool calls are needed, do a non-streaming call
-            # ----------------------------------------------------
-            if tools and execute_tool_fn:
-                # Next call with tools if needed
-                tool_response = await litellm.acompletion(
-                    **self._build_completion_params(
-                        messages=messages,
-                        temperature=temperature,
-                        stream=False,
-                        tools=formatted_tools,  # We safely pass tools here
-                        **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                     )
-                )
-                # handle tool_calls from tool_response as usual...
-                tool_calls = tool_response.choices[0].message.get("tool_calls")
+                    response_text = tool_response.choices[0].message.get("content", "")
+                    tool_calls = tool_response.choices[0].message.get("tool_calls", [])
+                    
+                    if verbose:
+                        # Display the complete response at once
+                        display_interaction(
+                            original_prompt,
+                            response_text,
+                            markdown=markdown,
+                            generation_time=time.time() - start_time,
+                            console=console
+                        )
+
+            # Now handle tools if we have them (either from streaming or non-streaming)
+            if tools and execute_tool_fn and tool_calls:
                 
                 if tool_calls:
                     # Convert tool_calls to a serializable format for all providers

praisonaiagents/mcp/mcp.py

@@ -7,6 +7,7 @@ import shlex
 import logging
 import os
 import re
+import platform
 from typing import Any, List, Optional, Callable, Iterable, Union
 from functools import wraps, partial
 
@@ -199,7 +200,13 @@ class MCP:
         # Handle the single string format for stdio client
         if isinstance(command_or_string, str) and args is None:
             # Split the string into command and args using shell-like parsing
-            parts = shlex.split(command_or_string)
+            if platform.system() == 'Windows':
+                # Use shlex with posix=False for Windows to handle quotes and paths with spaces
+                parts = shlex.split(command_or_string, posix=False)
+                # Remove quotes from parts if present (Windows shlex keeps them)
+                parts = [part.strip('"') for part in parts]
+            else:
+                parts = shlex.split(command_or_string)
             if not parts:
                 raise ValueError("Empty command string")
             
@@ -217,11 +224,17 @@ class MCP:
         env = kwargs.get('env', {})
         if not env:
             env = os.environ.copy()
-        env.update({
-            'PYTHONIOENCODING': 'utf-8',
-            'LC_ALL': 'C.UTF-8',
-            'LANG': 'C.UTF-8'
-        })
+        
+        # Always set Python encoding
+        env['PYTHONIOENCODING'] = 'utf-8'
+        
+        # Only set locale variables on Unix systems
+        if platform.system() != 'Windows':
+            env.update({
+                'LC_ALL': 'C.UTF-8',
+                'LANG': 'C.UTF-8'
+            })
+        
         kwargs['env'] = env
         
         self.server_params = StdioServerParameters(
@@ -236,7 +249,14 @@ class MCP:
             print(f"Warning: MCP initialization timed out after {self.timeout} seconds")
         
         # Automatically detect if this is an NPX command
-        self.is_npx = cmd == 'npx' or (isinstance(cmd, str) and os.path.basename(cmd) == 'npx')
+        base_cmd = os.path.basename(cmd) if isinstance(cmd, str) else cmd
+        # Check for npx with or without Windows extensions
+        npx_variants = ['npx', 'npx.cmd', 'npx.exe']
+        if platform.system() == 'Windows' and isinstance(base_cmd, str):
+            # Case-insensitive comparison on Windows
+            self.is_npx = base_cmd.lower() in [v.lower() for v in npx_variants]
+        else:
+            self.is_npx = base_cmd in npx_variants
         
         # For NPX-based MCP servers, use a different approach
         if self.is_npx:

praisonaiagents/memory/memory.py

@@ -741,6 +741,54 @@ class Memory:
                     filtered.append(h)
             return filtered[:limit]
 
+    def search(self, query: str, user_id: Optional[str] = None, agent_id: Optional[str] = None, 
+               run_id: Optional[str] = None, limit: int = 5, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]:
+        """
+        Generic search method that delegates to appropriate specific search methods.
+        Provides compatibility with mem0.Memory interface.
+        
+        Args:
+            query: The search query string
+            user_id: Optional user ID for user-specific search
+            agent_id: Optional agent ID for agent-specific search  
+            run_id: Optional run ID for run-specific search
+            limit: Maximum number of results to return
+            rerank: Whether to use advanced reranking
+            **kwargs: Additional search parameters
+            
+        Returns:
+            List of search results
+        """
+        # If using mem0, pass all parameters directly
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            search_params = {
+                "query": query,
+                "limit": limit,
+                "rerank": rerank
+            }
+            
+            # Add optional parameters if provided
+            if user_id is not None:
+                search_params["user_id"] = user_id
+            if agent_id is not None:
+                search_params["agent_id"] = agent_id
+            if run_id is not None:
+                search_params["run_id"] = run_id
+                
+            # Include any additional kwargs
+            search_params.update(kwargs)
+            
+            return self.mem0_client.search(**search_params)
+        
+        # For local memory, use specific search methods
+        if user_id:
+            # Use user-specific search
+            return self.search_user_memory(user_id, query, limit=limit, rerank=rerank, **kwargs)
+        else:
+            # Default to long-term memory search
+            # Note: agent_id and run_id filtering could be added to metadata filtering in the future
+            return self.search_long_term(query, limit=limit, rerank=rerank, **kwargs)
+
     def reset_user_memory(self):
         """
         Clear all user-based info. For simplicity, we do a full LTM reset. 

praisonaiagents/telemetry/integration.py

@@ -140,7 +140,7 @@ def instrument_workflow(workflow: 'PraisonAIAgents', telemetry: Optional['Minima
             task = None
             try:
                 # Get task info
-                if hasattr(workflow, 'tasks') and task_id < len(workflow.tasks):
+                if hasattr(workflow, 'tasks') and isinstance(task_id, int) and task_id < len(workflow.tasks):
                     task = workflow.tasks[task_id]
                 
                 result = original_execute_task(task_id, *args, **kwargs)

praisonaiagents/tools/duckdb_tools.py

@@ -13,6 +13,7 @@ import logging
 from typing import List, Dict, Any, Optional, Union, TYPE_CHECKING
 from importlib import util
 import json
+import re
 
 if TYPE_CHECKING:
     import duckdb
@@ -29,6 +30,25 @@ class DuckDBTools:
         """
         self.database = database
         self._conn = None
+    
+    def _validate_identifier(self, identifier: str) -> str:
+        """Validate and quote a SQL identifier to prevent injection.
+        
+        Args:
+            identifier: Table or column name to validate
+            
+        Returns:
+            Quoted identifier safe for SQL
+            
+        Raises:
+            ValueError: If identifier contains invalid characters
+        """
+        # Only allow alphanumeric characters, underscores, and dots
+        if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)?$', identifier):
+            raise ValueError(f"Invalid identifier: {identifier}")
+        
+        # Quote the identifier to handle reserved words
+        return f'"{identifier}"'
 
     def _get_duckdb(self) -> Optional['duckdb']:
         """Get duckdb module, installing if needed"""
@@ -125,39 +145,50 @@ class DuckDBTools:
             if conn is None:
                 return False
 
-            # Check if table exists
-            exists = conn.execute(f"""
+            # Check if table exists using parameterized query
+            exists = conn.execute("""
                 SELECT name FROM sqlite_master 
-                WHERE type='table' AND name='{table_name}'
-            """).fetchone() is not None
+                WHERE type='table' AND name=?
+            """, [table_name]).fetchone() is not None
 
             if exists:
                 if if_exists == 'fail':
                     raise ValueError(f"Table {table_name} already exists")
                 elif if_exists == 'replace':
-                    conn.execute(f"DROP TABLE IF EXISTS {table_name}")
+                    # Validate and quote table name to prevent injection
+                    safe_table = self._validate_identifier(table_name)
+                    conn.execute(f"DROP TABLE IF EXISTS {safe_table}")
                 elif if_exists != 'append':
                     raise ValueError("if_exists must be 'fail', 'replace', or 'append'")
 
             # Create table if needed
             if not exists or if_exists == 'replace':
+                safe_table = self._validate_identifier(table_name)
                 if schema:
-                    # Create table with schema
-                    columns = ', '.join(f"{k} {v}" for k, v in schema.items())
-                    conn.execute(f"CREATE TABLE {table_name} ({columns})")
+                    # Create table with schema - validate column names
+                    column_defs = []
+                    for col_name, col_type in schema.items():
+                        safe_col = self._validate_identifier(col_name)
+                        # Validate column type to prevent injection
+                        if not re.match(r'^[A-Z][A-Z0-9_]*(\([0-9,]+\))?$', col_type.upper()):
+                            raise ValueError(f"Invalid column type: {col_type}")
+                        column_defs.append(f"{safe_col} {col_type}")
+                    columns = ', '.join(column_defs)
+                    conn.execute(f"CREATE TABLE {safe_table} ({columns})")
                 else:
-                    # Infer schema from CSV
+                    # Infer schema from CSV - use parameterized query for filepath
                     conn.execute(f"""
-                        CREATE TABLE {table_name} AS 
-                        SELECT * FROM read_csv_auto('{filepath}')
+                        CREATE TABLE {safe_table} AS 
+                        SELECT * FROM read_csv_auto(?)
                         WHERE 1=0
-                    """)
+                    """, [filepath])
 
-            # Load data
+            # Load data - use validated table name and parameterized filepath
+            safe_table = self._validate_identifier(table_name)
             conn.execute(f"""
-                INSERT INTO {table_name}
-                SELECT * FROM read_csv_auto('{filepath}')
-            """)
+                INSERT INTO {safe_table}
+                SELECT * FROM read_csv_auto(?)
+            """, [filepath])
 
             return True