voxagent 0.2.3__tar.gz → 0.2.4__tar.gz

{voxagent-0.2.3 → voxagent-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxagent
-Version: 0.2.3
+Version: 0.2.4
 Summary: A lightweight, model-agnostic LLM provider abstraction with streaming and tool support
 Project-URL: Homepage, https://github.com/lensator/voxagent
 Project-URL: Documentation, https://github.com/lensator/voxagent#readme

{voxagent-0.2.3 → voxagent-0.2.4}/src/voxagent/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.2.3"
+__version__ = "0.2.4"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{voxagent-0.2.3 → voxagent-0.2.4}/src/voxagent/agent/core.py

@@ -125,6 +125,68 @@ class Agent(Generic[DepsT, OutputT]):
         # Toolsets (MCP servers, etc.) - store for later
         self._toolsets = toolsets or []
 
+        # MCP connection caching (persistent across run() calls)
+        self._mcp_manager: MCPServerManager | None = None
+        self._mcp_tools: list[ToolDefinition] = []
+        self._mcp_connected: bool = False
+
+    # -------------------------------------------------------------------------
+    # MCP Connection Management
+    # -------------------------------------------------------------------------
+
+    async def connect_mcp(self) -> list[ToolDefinition]:
+        """Connect to MCP servers and cache the connection.
+
+        This method connects to all MCP servers in toolsets and caches the
+        connection for reuse across multiple run() calls. Call this during
+        initialization/warmup to avoid connection overhead on first message.
+
+        Returns:
+            List of ToolDefinition objects from connected MCP servers.
+        """
+        if self._mcp_connected:
+            return self._mcp_tools
+
+        if self._toolsets:
+            self._mcp_manager = MCPServerManager()
+            await self._mcp_manager.add_servers(self._toolsets)
+            self._mcp_tools = await self._mcp_manager.connect_all()
+            self._mcp_connected = True
+
+        return self._mcp_tools
+
+    async def disconnect_mcp(self) -> None:
+        """Disconnect from MCP servers.
+
+        Call this when the agent is no longer needed to clean up MCP
+        server connections. This is called automatically when using
+        the agent as an async context manager.
+        """
+        if self._mcp_manager and self._mcp_connected:
+            await self._mcp_manager.disconnect_all()
+            self._mcp_manager = None
+            self._mcp_connected = False
+            self._mcp_tools = []
+
+    @property
+    def mcp_connected(self) -> bool:
+        """Check if MCP servers are currently connected."""
+        return self._mcp_connected
+
+    async def __aenter__(self) -> "Agent[DepsT, OutputT]":
+        """Enter async context manager - connect MCP servers."""
+        await self.connect_mcp()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: Any,
+    ) -> None:
+        """Exit async context manager - disconnect MCP servers."""
+        await self.disconnect_mcp()
+
     @staticmethod
     def _parse_model_string(model_string: str) -> ModelConfig:
         """Parse 'provider:model' string into ModelConfig.
@@ -495,19 +557,22 @@ class Agent(Generic[DepsT, OutputT]):
         timeout_handler: TimeoutHandler | None = None
         timed_out = False
         error_message: str | None = None
-        mcp_manager: MCPServerManager | None = None
+        # Track if we connected MCP in this run (for cleanup)
+        mcp_connected_in_this_run = False
 
         if timeout_ms:
             timeout_handler = TimeoutHandler(timeout_ms)
             await timeout_handler.start(abort_controller)
 
         try:
-            # Connect to MCP servers if any
-            mcp_tools: list[ToolDefinition] = []
-            if self._toolsets:
-                mcp_manager = MCPServerManager()
-                await mcp_manager.add_servers(self._toolsets)
-                mcp_tools = await mcp_manager.connect_all()
+            # Use cached MCP connection if available, otherwise connect
+            if self._mcp_connected:
+                mcp_tools = self._mcp_tools
+            elif self._toolsets:
+                mcp_tools = await self.connect_mcp()
+                mcp_connected_in_this_run = True
+            else:
+                mcp_tools = []
 
             # Get all tools (native + MCP)
             all_tools = self._get_all_tools(mcp_tools)
@@ -652,9 +717,10 @@ class Agent(Generic[DepsT, OutputT]):
             )
 
         finally:
-            # Disconnect MCP servers
-            if mcp_manager:
-                await mcp_manager.disconnect_all()
+            # Only disconnect MCP servers if we connected them in this run
+            # (not if using cached connection from connect_mcp())
+            if mcp_connected_in_this_run and not self._mcp_connected:
+                await self.disconnect_mcp()
             if timeout_handler:
                 timeout_handler.cancel()
             abort_controller.cleanup()
@@ -685,19 +751,22 @@ class Agent(Generic[DepsT, OutputT]):
         abort_controller = AbortController()
         timeout_handler: TimeoutHandler | None = None
         timed_out = False
-        mcp_manager: MCPServerManager | None = None
+        # Track if we connected MCP in this run (for cleanup)
+        mcp_connected_in_this_run = False
 
         if timeout_ms:
             timeout_handler = TimeoutHandler(timeout_ms)
             await timeout_handler.start(abort_controller)
 
         try:
-            # Connect to MCP servers if any
-            mcp_tools: list[ToolDefinition] = []
-            if self._toolsets:
-                mcp_manager = MCPServerManager()
-                await mcp_manager.add_servers(self._toolsets)
-                mcp_tools = await mcp_manager.connect_all()
+            # Use cached MCP connection if available, otherwise connect
+            if self._mcp_connected:
+                mcp_tools = self._mcp_tools
+            elif self._toolsets:
+                mcp_tools = await self.connect_mcp()
+                mcp_connected_in_this_run = True
+            else:
+                mcp_tools = []
 
             # Get all tools (native + MCP)
             all_tools = self._get_all_tools(mcp_tools)
@@ -838,9 +907,10 @@ class Agent(Generic[DepsT, OutputT]):
             )
 
         finally:
-            # Disconnect MCP servers
-            if mcp_manager:
-                await mcp_manager.disconnect_all()
+            # Only disconnect MCP servers if we connected them in this run
+            # (not if using cached connection from connect_mcp())
+            if mcp_connected_in_this_run and not self._mcp_connected:
+                await self.disconnect_mcp()
             if timeout_handler:
                 timeout_handler.cancel()
             abort_controller.cleanup()

{voxagent-0.2.3 → voxagent-0.2.4}/src/voxagent/providers/chatgpt.py

@@ -206,7 +206,7 @@ class ChatGPTProvider(BaseProvider):
                     input_msgs.append({
                         "type": "message",
                         "role": "assistant",
-                        "content": [{"type": "input_text", "text": msg.content}],
+                        "content": [{"type": "output_text", "text": msg.content}],
                     })
                 # Add function_call items for each tool call
                 for tc in msg.tool_calls:
@@ -242,25 +242,28 @@ class ChatGPTProvider(BaseProvider):
                             "output": block.get("content", ""),
                         })
                     elif hasattr(block, "text"):
-                        # TextBlock
+                        # TextBlock - use output_text for assistant, input_text for user
+                        content_type = "output_text" if msg.role == "assistant" else "input_text"
                         input_msgs.append({
                             "type": "message",
                             "role": "user" if msg.role == "user" else "assistant",
-                            "content": [{"type": "input_text", "text": block.text}],
+                            "content": [{"type": content_type, "text": block.text}],
                         })
                     elif isinstance(block, dict) and "text" in block:
+                        content_type = "output_text" if msg.role == "assistant" else "input_text"
                         input_msgs.append({
                             "type": "message",
                             "role": "user" if msg.role == "user" else "assistant",
-                            "content": [{"type": "input_text", "text": block["text"]}],
+                            "content": [{"type": content_type, "text": block["text"]}],
                         })
             elif isinstance(msg.content, str):
-                # Simple string content
+                # Simple string content - use output_text for assistant, input_text for user
                 role = "user" if msg.role == "user" else "assistant"
+                content_type = "output_text" if msg.role == "assistant" else "input_text"
                 input_msgs.append({
                     "type": "message",
                     "role": role,
-                    "content": [{"type": "input_text", "text": msg.content}],
+                    "content": [{"type": content_type, "text": msg.content}],
                 })
 
         return input_msgs
@@ -335,7 +338,13 @@ class ChatGPTProvider(BaseProvider):
                     if response.status_code == 401:
                         yield ErrorChunk(error="Authentication failed - token may be expired")
                         return
-                    response.raise_for_status()
+                    if response.status_code >= 400:
+                        # Read error body before raising
+                        error_body = await response.aread()
+                        error_text = error_body.decode("utf-8", errors="replace")
+                        logger.error("ChatGPT API error %d: %s", response.status_code, error_text)
+                        yield ErrorChunk(error=f"HTTP {response.status_code}: {error_text[:500]}")
+                        return
 
                     async for line in response.aiter_lines():
                         if abort_signal and abort_signal.aborted: