praisonaiagents 0.0.83__py3-none-any.whl → 0.0.85__py3-none-any.whl

praisonaiagents/llm/llm.py

@@ -367,12 +367,13 @@ class LLM:
                     # If reasoning_steps is True, do a single non-streaming call
                     if reasoning_steps:
                         resp = litellm.completion(
-                            model=self.model,
-                            messages=messages,
-                            temperature=temperature,
-                            stream=False,  # force non-streaming
-                            tools=formatted_tools,
-                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                            **self._build_completion_params(
+                                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")
                         response_text = resp["choices"][0]["message"]["content"]
@@ -401,12 +402,13 @@ class LLM:
                             with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
                                 response_text = ""
                                 for chunk in litellm.completion(
-                                    model=self.model,
-                                    messages=messages,
-                                    tools=formatted_tools,
-                                    temperature=temperature,
-                                    stream=True,
-                                    **kwargs
+                                    **self._build_completion_params(
+                                        messages=messages,
+                                        tools=formatted_tools,
+                                        temperature=temperature,
+                                        stream=True,
+                                        **kwargs
+                                    )
                                 ):
                                     if chunk and chunk.choices and chunk.choices[0].delta.content:
                                         content = chunk.choices[0].delta.content
@@ -416,12 +418,13 @@ class LLM:
                             # Non-verbose mode, just collect the response
                             response_text = ""
                             for chunk in litellm.completion(
-                                model=self.model,
-                                messages=messages,
-                                tools=formatted_tools,
-                                temperature=temperature,
-                                stream=True,
-                                **kwargs
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    tools=formatted_tools,
+                                    temperature=temperature,
+                                    stream=True,
+                                    **kwargs
+                                )
                             ):
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
                                     response_text += chunk.choices[0].delta.content
@@ -430,12 +433,13 @@ class LLM:
 
                     # Get final completion to check for tool calls
                     final_response = litellm.completion(
-                        model=self.model,
-                        messages=messages,
-                        tools=formatted_tools,
-                        temperature=temperature,
-                        stream=False,  # No streaming for tool call check
-                        **kwargs
+                        **self._build_completion_params(
+                            messages=messages,
+                            tools=formatted_tools,
+                            temperature=temperature,
+                            stream=False,  # No streaming for tool call check
+                            **kwargs
+                        )
                     )
                     
                     tool_calls = final_response["choices"][0]["message"].get("tool_calls")
@@ -547,10 +551,11 @@ class LLM:
                                         with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
                                             response_text = ""
                                             for chunk in litellm.completion(
-                                                model=self.model,
-                                                messages=follow_up_messages,
-                                                temperature=temperature,
-                                                stream=True
+                                                **self._build_completion_params(
+                                                    messages=follow_up_messages,
+                                                    temperature=temperature,
+                                                    stream=True
+                                                )
                                             ):
                                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
                                                     content = chunk.choices[0].delta.content
@@ -559,10 +564,11 @@ class LLM:
                                     else:
                                         response_text = ""
                                         for chunk in litellm.completion(
-                                            model=self.model,
-                                            messages=follow_up_messages,
-                                            temperature=temperature,
-                                            stream=True
+                                            **self._build_completion_params(
+                                                messages=follow_up_messages,
+                                                temperature=temperature,
+                                                stream=True
+                                            )
                                         ):
                                             if chunk and chunk.choices and chunk.choices[0].delta.content:
                                                 response_text += chunk.choices[0].delta.content
@@ -573,11 +579,12 @@ class LLM:
                         # If reasoning_steps is True, do a single non-streaming call
                         elif reasoning_steps:
                             resp = litellm.completion(
-                                model=self.model,
-                                messages=messages,
-                                temperature=temperature,
-                                stream=False,  # force non-streaming
-                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=False,  # force non-streaming
+                                    **{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")
                             response_text = resp["choices"][0]["message"]["content"]
@@ -607,10 +614,11 @@ class LLM:
                                 with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
                                     response_text = ""
                                     for chunk in litellm.completion(
-                                        model=self.model,
-                                        messages=messages,
-                                        temperature=temperature,
-                                        stream=True
+                                        **self._build_completion_params(
+                                            messages=messages,
+                                            temperature=temperature,
+                                            stream=True
+                                        )
                                     ):
                                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                                             content = chunk.choices[0].delta.content
@@ -619,10 +627,11 @@ class LLM:
                             else:
                                 response_text = ""
                                 for chunk in litellm.completion(
-                                    model=self.model,
-                                    messages=messages,
-                                    temperature=temperature,
-                                    stream=True
+                                    **self._build_completion_params(
+                                        messages=messages,
+                                        temperature=temperature,
+                                        stream=True
+                                    )
                                 ):
                                     if chunk and chunk.choices and chunk.choices[0].delta.content:
                                         response_text += chunk.choices[0].delta.content
@@ -663,12 +672,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     # If reasoning_steps is True, do a single non-streaming call to capture reasoning
                     if reasoning_steps:
                         reflection_resp = litellm.completion(
-                            model=self.model,
-                            messages=reflection_messages,
-                            temperature=temperature,
-                            stream=False,  # Force non-streaming
-                            response_format={"type": "json_object"},
-                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                            **self._build_completion_params(
+                                messages=reflection_messages,
+                                temperature=temperature,
+                                stream=False,  # Force non-streaming
+                                response_format={"type": "json_object"},
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                            )
                         )
                         # Grab reflection text and optional reasoning
                         reasoning_content = reflection_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
@@ -697,12 +707,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
                                 reflection_text = ""
                                 for chunk in litellm.completion(
-                                    model=self.model,
-                                    messages=reflection_messages,
-                                    temperature=temperature,
-                                    stream=True,
-                                    response_format={"type": "json_object"},
-                                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                                    **self._build_completion_params(
+                                        messages=reflection_messages,
+                                        temperature=temperature,
+                                        stream=True,
+                                        response_format={"type": "json_object"},
+                                        **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                                    )
                                 ):
                                     if chunk and chunk.choices and chunk.choices[0].delta.content:
                                         content = chunk.choices[0].delta.content
@@ -711,12 +722,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         else:
                             reflection_text = ""
                             for chunk in litellm.completion(
-                                model=self.model,
-                                messages=reflection_messages,
-                                temperature=temperature,
-                                stream=True,
-                                response_format={"type": "json_object"},
-                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                                **self._build_completion_params(
+                                    messages=reflection_messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    response_format={"type": "json_object"},
+                                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                                )
                             ):
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
                                     reflection_text += chunk.choices[0].delta.content
@@ -953,11 +965,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             if reasoning_steps:
                 # Non-streaming call to capture reasoning
                 resp = await litellm.acompletion(
-                    model=self.model,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=False,  # force non-streaming
-                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                    **self._build_completion_params(
+                        messages=messages,
+                        temperature=temperature,
+                        stream=False,  # force non-streaming
+                        **{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")
                 response_text = resp["choices"][0]["message"]["content"]
@@ -984,11 +997,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     # 1) Make the streaming call WITHOUT tools
                     # ----------------------------------------------------
                     async for chunk in await litellm.acompletion(
-                        model=self.model,
-                        messages=messages,
-                        temperature=temperature,
-                        stream=True,
-                        **kwargs
+                        **self._build_completion_params(
+                            messages=messages,
+                            temperature=temperature,
+                            stream=True,
+                            **kwargs
+                        )
                     ):
                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                             response_text += chunk.choices[0].delta.content
@@ -997,11 +1011,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 else:
                     # Non-verbose streaming call, still no tools
                     async for chunk in await litellm.acompletion(
-                        model=self.model,
-                        messages=messages,
-                        temperature=temperature,
-                        stream=True,
-                        **kwargs
+                        **self._build_completion_params(
+                            messages=messages,
+                            temperature=temperature,
+                            stream=True,
+                            **kwargs
+                        )
                     ):
                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                             response_text += chunk.choices[0].delta.content
@@ -1014,12 +1029,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             if tools and execute_tool_fn:
                 # Next call with tools if needed
                 tool_response = await litellm.acompletion(
-                    model=self.model,
-                    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'}
+                    **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")
@@ -1125,10 +1141,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 if verbose:
                                     response_text = ""
                                     async for chunk in await litellm.acompletion(
-                                        model=self.model,
-                                        messages=follow_up_messages,
-                                        temperature=temperature,
-                                        stream=True
+                                        **self._build_completion_params(
+                                            messages=follow_up_messages,
+                                            temperature=temperature,
+                                            stream=True
+                                        )
                                     ):
                                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                                             content = chunk.choices[0].delta.content
@@ -1138,10 +1155,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 else:
                                     response_text = ""
                                     async for chunk in await litellm.acompletion(
-                                        model=self.model,
-                                        messages=follow_up_messages,
-                                        temperature=temperature,
-                                        stream=True
+                                        **self._build_completion_params(
+                                            messages=follow_up_messages,
+                                            temperature=temperature,
+                                            stream=True
+                                        )
                                     ):
                                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                                             response_text += chunk.choices[0].delta.content
@@ -1153,12 +1171,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     elif reasoning_steps:
                         # Non-streaming call to capture reasoning
                         resp = await litellm.acompletion(
-                            model=self.model,
-                            messages=messages,
-                            temperature=temperature,
-                            stream=False,  # force non-streaming
-                            tools=formatted_tools,  # Include tools
-                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                            **self._build_completion_params(
+                                messages=messages,
+                                temperature=temperature,
+                                stream=False,  # force non-streaming
+                                tools=formatted_tools,  # Include 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")
                         response_text = resp["choices"][0]["message"]["content"]
@@ -1183,12 +1202,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         # Get response after tool calls with streaming
                         if verbose:
                             async for chunk in await litellm.acompletion(
-                                model=self.model,
-                                messages=messages,
-                                temperature=temperature,
-                                stream=True,
-                                tools=formatted_tools,
-                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    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:
                                     content = chunk.choices[0].delta.content
@@ -1197,12 +1217,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                     print(f"Reflecting... {time.time() - start_time:.1f}s", end="\r")
                         else:
                             response_text = ""
-                            for chunk in litellm.completion(
-                                model=self.model,
-                                messages=messages,
-                                temperature=temperature,
-                                stream=True,
-                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                            async for chunk in await litellm.acompletion(
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    **{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
@@ -1242,13 +1263,14 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
             # If reasoning_steps is True, do a single non-streaming call to capture reasoning
             if reasoning_steps:
-                reflection_resp = litellm.completion(
-                    model=self.model,
-                    messages=reflection_messages,
-                    temperature=temperature,
-                    stream=False,  # Force non-streaming
-                    response_format={"type": "json_object"},
-                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                reflection_resp = await litellm.acompletion(
+                    **self._build_completion_params(
+                        messages=reflection_messages,
+                        temperature=temperature,
+                        stream=False,  # Force non-streaming
+                        response_format={"type": "json_object"},
+                        **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                    )
                 )
                 # Grab reflection text and optional reasoning
                 reasoning_content = reflection_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
@@ -1276,13 +1298,14 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 if verbose:
                     with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
                         reflection_text = ""
-                        for chunk in litellm.completion(
-                            model=self.model,
-                            messages=reflection_messages,
-                            temperature=temperature,
-                            stream=True,
-                            response_format={"type": "json_object"},
-                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                        async for chunk in await litellm.acompletion(
+                            **self._build_completion_params(
+                                messages=reflection_messages,
+                                temperature=temperature,
+                                stream=True,
+                                response_format={"type": "json_object"},
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                            )
                         ):
                             if chunk and chunk.choices and chunk.choices[0].delta.content:
                                 content = chunk.choices[0].delta.content
@@ -1290,13 +1313,14 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 live.update(display_generating(reflection_text, start_time))
                 else:
                     reflection_text = ""
-                    for chunk in litellm.completion(
-                        model=self.model,
-                        messages=reflection_messages,
-                        temperature=temperature,
-                        stream=True,
-                        response_format={"type": "json_object"},
-                        **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                    async for chunk in await litellm.acompletion(
+                        **self._build_completion_params(
+                            messages=reflection_messages,
+                            temperature=temperature,
+                            stream=True,
+                            response_format={"type": "json_object"},
+                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                        )
                     ):
                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                             reflection_text += chunk.choices[0].delta.content
@@ -1408,6 +1432,47 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 
         litellm.callbacks = events
 
+    def _build_completion_params(self, **override_params) -> Dict[str, Any]:
+        """Build parameters for litellm completion calls with all necessary config"""
+        params = {
+            "model": self.model,
+        }
+        
+        # Add optional parameters if they exist
+        if self.base_url:
+            params["base_url"] = self.base_url
+        if self.api_key:
+            params["api_key"] = self.api_key
+        if self.api_version:
+            params["api_version"] = self.api_version
+        if self.timeout:
+            params["timeout"] = self.timeout
+        if self.max_tokens:
+            params["max_tokens"] = self.max_tokens
+        if self.top_p:
+            params["top_p"] = self.top_p
+        if self.presence_penalty:
+            params["presence_penalty"] = self.presence_penalty
+        if self.frequency_penalty:
+            params["frequency_penalty"] = self.frequency_penalty
+        if self.logit_bias:
+            params["logit_bias"] = self.logit_bias
+        if self.response_format:
+            params["response_format"] = self.response_format
+        if self.seed:
+            params["seed"] = self.seed
+        if self.logprobs:
+            params["logprobs"] = self.logprobs
+        if self.top_logprobs:
+            params["top_logprobs"] = self.top_logprobs
+        if self.stop_phrases:
+            params["stop"] = self.stop_phrases
+        
+        # Override with any provided parameters
+        params.update(override_params)
+        
+        return params
+
     # Response without tool calls
     def response(
         self,
@@ -1466,11 +1531,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 if verbose:
                     with Live(display_generating("", start_time), console=console or self.console, refresh_per_second=4) as live:
                         for chunk in litellm.completion(
-                            model=self.model,
-                            messages=messages,
-                            temperature=temperature,
-                            stream=True,
-                            **kwargs
+                            **self._build_completion_params(
+                                messages=messages,
+                                temperature=temperature,
+                                stream=True,
+                                **kwargs
+                            )
                         ):
                             if chunk and chunk.choices and chunk.choices[0].delta.content:
                                 content = chunk.choices[0].delta.content
@@ -1478,21 +1544,23 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 live.update(display_generating(response_text, start_time))
                 else:
                     for chunk in litellm.completion(
-                        model=self.model,
-                        messages=messages,
-                        temperature=temperature,
-                        stream=True,
-                        **kwargs
+                        **self._build_completion_params(
+                            messages=messages,
+                            temperature=temperature,
+                            stream=True,
+                            **kwargs
+                        )
                     ):
                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                             response_text += chunk.choices[0].delta.content
             else:
                 response = litellm.completion(
-                    model=self.model,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=False,
-                    **kwargs
+                    **self._build_completion_params(
+                        messages=messages,
+                        temperature=temperature,
+                        stream=False,
+                        **kwargs
+                    )
                 )
                 response_text = response.choices[0].message.content.strip()
 
@@ -1569,11 +1637,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 if verbose:
                     with Live(display_generating("", start_time), console=console or self.console, refresh_per_second=4) as live:
                         async for chunk in await litellm.acompletion(
-                            model=self.model,
-                            messages=messages,
-                            temperature=temperature,
-                            stream=True,
-                            **kwargs
+                            **self._build_completion_params(
+                                messages=messages,
+                                temperature=temperature,
+                                stream=True,
+                                **kwargs
+                            )
                         ):
                             if chunk and chunk.choices and chunk.choices[0].delta.content:
                                 content = chunk.choices[0].delta.content
@@ -1581,21 +1650,23 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 live.update(display_generating(response_text, start_time))
                 else:
                     async for chunk in await litellm.acompletion(
-                        model=self.model,
-                        messages=messages,
-                        temperature=temperature,
-                        stream=True,
-                        **kwargs
+                        **self._build_completion_params(
+                            messages=messages,
+                            temperature=temperature,
+                            stream=True,
+                            **kwargs
+                        )
                     ):
                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                             response_text += chunk.choices[0].delta.content
             else:
                 response = await litellm.acompletion(
-                    model=self.model,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=False,
-                    **kwargs
+                    **self._build_completion_params(
+                        messages=messages,
+                        temperature=temperature,
+                        stream=False,
+                        **kwargs
+                    )
                 )
                 response_text = response.choices[0].message.content.strip()
 

praisonaiagents/mcp/mcp.py

@@ -16,13 +16,14 @@ from mcp.client.stdio import stdio_client
 class MCPToolRunner(threading.Thread):
     """A dedicated thread for running MCP operations."""
     
-    def __init__(self, server_params):
+    def __init__(self, server_params, timeout=60):
         super().__init__(daemon=True)
         self.server_params = server_params
         self.queue = queue.Queue()
         self.result_queue = queue.Queue()
         self.initialized = threading.Event()
         self.tools = []
+        self.timeout = timeout
         self.start()
         
     def run(self):
@@ -74,9 +75,9 @@ class MCPToolRunner(threading.Thread):
     def call_tool(self, tool_name, arguments):
         """Call an MCP tool and wait for the result."""
         if not self.initialized.is_set():
-            self.initialized.wait(timeout=30)
+            self.initialized.wait(timeout=self.timeout)
             if not self.initialized.is_set():
-                return "Error: MCP initialization timed out"
+                return f"Error: MCP initialization timed out after {self.timeout} seconds"
         
         # Put request in queue
         self.queue.put((tool_name, arguments))
@@ -189,7 +190,7 @@ class MCP:
         if isinstance(command_or_string, str) and re.match(r'^https?://', command_or_string):
             # Import the SSE client implementation
             from .mcp_sse import SSEMCPClient
-            self.sse_client = SSEMCPClient(command_or_string, debug=debug)
+            self.sse_client = SSEMCPClient(command_or_string, debug=debug, timeout=timeout)
             self._tools = list(self.sse_client.tools)
             self.is_sse = True
             self.is_npx = False
@@ -216,11 +217,11 @@ class MCP:
             args=arguments,
             **kwargs
         )
-        self.runner = MCPToolRunner(self.server_params)
+        self.runner = MCPToolRunner(self.server_params, timeout)
         
         # Wait for initialization
-        if not self.runner.initialized.wait(timeout=30):
-            print("Warning: MCP initialization timed out")
+        if not self.runner.initialized.wait(timeout=self.timeout):
+            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')

praisonaiagents/mcp/mcp_sse.py

@@ -31,7 +31,7 @@ def get_event_loop():
 class SSEMCPTool:
     """A wrapper for an MCP tool that can be used with praisonaiagents."""
     
-    def __init__(self, name: str, description: str, session: ClientSession, input_schema: Optional[Dict[str, Any]] = None):
+    def __init__(self, name: str, description: str, session: ClientSession, input_schema: Optional[Dict[str, Any]] = None, timeout: int = 60):
         self.name = name
         self.__name__ = name  # Required for Agent to recognize it as a tool
         self.__qualname__ = name  # Required for Agent to recognize it as a tool
@@ -39,6 +39,7 @@ class SSEMCPTool:
         self.description = description
         self.session = session
         self.input_schema = input_schema or {}
+        self.timeout = timeout
         
         # Create a signature based on input schema
         params = []
@@ -66,7 +67,7 @@ class SSEMCPTool:
         future = asyncio.run_coroutine_threadsafe(self._async_call(**kwargs), loop)
         try:
             # Wait for the result with a timeout
-            return future.result(timeout=30)
+            return future.result(timeout=self.timeout)
         except Exception as e:
             logger.error(f"Error calling tool {self.name}: {e}")
             return f"Error: {str(e)}"
@@ -102,16 +103,18 @@ class SSEMCPTool:
 class SSEMCPClient:
     """A client for connecting to an MCP server over SSE."""
     
-    def __init__(self, server_url: str, debug: bool = False):
+    def __init__(self, server_url: str, debug: bool = False, timeout: int = 60):
         """
         Initialize an SSE MCP client.
         
         Args:
             server_url: The URL of the SSE MCP server
             debug: Whether to enable debug logging
+            timeout: Timeout in seconds for operations (default: 60)
         """
         self.server_url = server_url
         self.debug = debug
+        self.timeout = timeout
         self.session = None
         self.tools = []
         
@@ -139,7 +142,7 @@ class SSEMCPClient:
         
         # Run the initialization in the event loop
         future = asyncio.run_coroutine_threadsafe(self._async_initialize(), loop)
-        self.tools = future.result(timeout=30)
+        self.tools = future.result(timeout=self.timeout)
     
     async def _async_initialize(self):
         """Asynchronously initialize the connection and tools."""
@@ -169,7 +172,8 @@ class SSEMCPClient:
                 name=tool.name,
                 description=tool.description if hasattr(tool, 'description') else f"Call the {tool.name} tool",
                 session=self.session,
-                input_schema=input_schema
+                input_schema=input_schema,
+                timeout=self.timeout
             )
             tools.append(wrapper)
             

{praisonaiagents-0.0.83.dist-info → praisonaiagents-0.0.85.dist-info}/METADATA

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

{praisonaiagents-0.0.83.dist-info → praisonaiagents-0.0.85.dist-info}/RECORD

@@ -10,10 +10,10 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=Po0JZsgjYJrXdNSggmUGOWidZEF0f8xo4nhsZZfh8tY,13217
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=5SII0qUgaVbDTHdNfq4foV_vAjSwilz9Mw6p_S5LZfk,88393
+praisonaiagents/llm/llm.py,sha256=Y8z7mfzL_OMhoPSIr7k7Demk8HvHmJZv80EXFY6SUEU,91863
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
-praisonaiagents/mcp/mcp.py,sha256=Fub1x-LroOs8pQhmOLSislBLnoHHGzR0ARGyUTUMzsM,16270
-praisonaiagents/mcp/mcp_sse.py,sha256=xi5auCf83GMnsXzNEu5ooxNKjSdzKM5plB_DBn4RLzQ,6565
+praisonaiagents/mcp/mcp.py,sha256=foarT5IoCZ6V8P9AbnqnWQHKmshJoD24gf3OP4sD_IM,16419
+praisonaiagents/mcp/mcp_sse.py,sha256=DLh3F_aoVRM1X-7hgIOWOw4FQ1nGmn9YNbQTesykzn4,6792
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
@@ -40,7 +40,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.83.dist-info/METADATA,sha256=ex5JQDLtjZhHOxNpH4gYHk0sVTGMvdvKmG6xNE4GhXI,1244
-praisonaiagents-0.0.83.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-praisonaiagents-0.0.83.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.83.dist-info/RECORD,,
+praisonaiagents-0.0.85.dist-info/METADATA,sha256=p4gpH5C_8N2UL7IKRZlaJXBd_qjL36bpdoRly8NMzoE,1244
+praisonaiagents-0.0.85.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+praisonaiagents-0.0.85.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.85.dist-info/RECORD,,

{praisonaiagents-0.0.83.dist-info → praisonaiagents-0.0.85.dist-info}/WHEEL

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