voxagent 0.2.3__tar.gz → 0.2.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxagent
-Version: 0.2.3
+Version: 0.2.5
 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.5}/src/voxagent/_version.py

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

{voxagent-0.2.3 → voxagent-0.2.5}/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.5}/src/voxagent/code/__init__.py

@@ -30,6 +30,7 @@ from voxagent.code.tool_proxy import (
     ToolProxyServer,
     create_tool_proxy_pair,
 )
+from voxagent.code.query import QueryResult
 
 __all__ = [
     # Sandbox
@@ -52,4 +53,6 @@ __all__ = [
     "ToolProxyClient",
     "ToolProxyServer",
     "create_tool_proxy_pair",
+    # Query
+    "QueryResult",
 ]

{voxagent-0.2.3 → voxagent-0.2.5}/src/voxagent/code/agent.py

@@ -7,9 +7,12 @@ that calls tools via the virtual filesystem.
 
 from __future__ import annotations
 
+import asyncio
+import multiprocessing
 from typing import TYPE_CHECKING, Any
 
 from voxagent.code.sandbox import SubprocessSandbox, SandboxResult
+from voxagent.code.tool_proxy import ToolProxyServer
 from voxagent.code.virtual_fs import VirtualFilesystem, ToolRegistry
 from voxagent.tools.definition import ToolDefinition
 
@@ -32,6 +35,21 @@ You have access to a single tool: `execute_code`. Use it to write Python code th
 - `call_tool(category, tool_name, **kwargs)` - Call a tool with arguments
 - `print(*args)` - Output results (captured and returned to you)
 
+### Query Functions (for efficient data processing)
+- `query(data)` - Wrap tool result in QueryResult for chaining
+- `tree(path?)` - Show full tool structure at a glance
+- `search(keyword)` - Find tools by name
+
+### QueryResult Methods (chainable)
+- `.filter(**patterns)` - Filter by regex patterns on fields
+- `.map(fields)` - Extract specific fields
+- `.reduce(by?, count?)` - Aggregate/group results
+- `.first()` - Get first result
+- `.last()` - Get last result
+- `.each(fn)` - Apply function to each result
+- `.sort(by, reverse?)` - Sort results by field
+- `.unique(by)` - Remove duplicates by field
+
 ### Workflow
 1. **Explore**: `print(ls("tools/"))` to see categories
 2. **Learn**: `print(read("tools/<category>/<tool>.py"))` to see tool signatures
@@ -51,6 +69,19 @@ result = call_tool("devices", "registry.py", device_type="light")
 print("Devices:", result)
 ```
 
+### Efficient Device Control Example
+```python
+# Instead of 12+ calls, use 2:
+devices = call_tool("devices", "list_devices")
+device = query(devices).filter(name="balcony").first()
+call_tool("control", "turn_on_device", **device)
+
+# Find all living room lights and turn them off
+devices = call_tool("devices", "list_devices")
+living_lights = query(devices).filter(room="living", type="light")
+living_lights.each(lambda d: call_tool("control", "turn_off_device", device_id=d["device_id"]))
+```
+
 ### Rules
 1. Always use `print()` to show results
 2. Explore before assuming - use `ls()` and `read()` first
@@ -83,13 +114,13 @@ class CodeModeConfig:
 
 class CodeModeExecutor:
     """Executes code for an agent in code mode.
-    
+
     This class:
     1. Manages the sandbox and virtual filesystem
     2. Provides the execute_code tool implementation
-    3. Routes tool calls from sandbox to real implementations
+    3. Routes tool calls from sandbox to real implementations via queue-based proxy
     """
-    
+
     def __init__(
         self,
         config: CodeModeConfig,
@@ -97,19 +128,28 @@ class CodeModeExecutor:
     ):
         self.config = config
         self.tool_registry = tool_registry
+
+        # Create tool proxy queues (queues are picklable, client/server objects are not)
+        self._tool_request_queue: multiprocessing.Queue[Any] = multiprocessing.Queue()
+        self._tool_response_queue: multiprocessing.Queue[Any] = multiprocessing.Queue()
+
+        # Create proxy server for main process
+        self._proxy_server = ToolProxyServer(
+            self._tool_request_queue,
+            self._tool_response_queue,
+        )
+
+        # Create sandbox (queues passed during execute)
         self.sandbox = SubprocessSandbox(
             timeout_seconds=config.timeout_seconds,
             memory_limit_mb=config.memory_limit_mb,
         )
 
-        # Tool proxy for routing calls
+        # Tool implementations registry (kept for backward compatibility)
         self._tool_implementations: dict[str, Any] = {}
 
-        # Create virtual filesystem with call_tool support
-        self.virtual_fs = VirtualFilesystem(
-            registry=tool_registry,
-            tool_caller=self.call_tool,
-        )
+        # Create virtual filesystem (no longer needs tool_caller)
+        self.virtual_fs = VirtualFilesystem(registry=tool_registry)
     
     def register_tool_implementation(
         self,
@@ -120,6 +160,8 @@ class CodeModeExecutor:
         """Register a real tool implementation for the proxy."""
         key = f"{category}.{tool_name}"
         self._tool_implementations[key] = implementation
+        # Also register with proxy server for queue-based communication
+        self._proxy_server.register_implementation(category, tool_name, implementation)
 
     async def execute_code(self, code: str) -> str:
         """Execute Python code in the sandbox.
@@ -132,11 +174,29 @@ class CodeModeExecutor:
         Returns:
             Captured output or error message
         """
-        # Build globals with virtual filesystem functions (ls, read, call_tool)
+        # Build globals with virtual filesystem functions (ls, read)
         globals_dict = self.virtual_fs.get_sandbox_globals()
 
-        # Execute in sandbox
-        result = await self.sandbox.execute(code, globals_dict)
+        # Start proxy server task to handle tool calls from subprocess
+        server_task = asyncio.create_task(
+            self._proxy_server.run_until_complete(timeout=self.config.timeout_seconds + 5)
+        )
+
+        try:
+            # Execute in sandbox with queues for tool proxy
+            result = await self.sandbox.execute(
+                code,
+                globals_dict,
+                tool_request_queue=self._tool_request_queue,
+                tool_response_queue=self._tool_response_queue,
+            )
+        finally:
+            # Stop server
+            self._proxy_server.stop()
+            try:
+                await asyncio.wait_for(server_task, timeout=1.0)
+            except asyncio.TimeoutError:
+                pass
 
         # Format output
         if result.success:

voxagent-0.2.5/src/voxagent/code/query.py

@@ -0,0 +1,179 @@
+"""Query utilities for Code Mode sandbox.
+
+Provides functional-style data pipelines for efficient tool result processing.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Callable, Iterator
+
+
+class QueryResult:
+    """Chainable wrapper for query results.
+    
+    Enables functional-style data pipelines:
+        filter("tools/devices/list_devices", name="balcony").map(["device_id", "name"]).first()
+    """
+    
+    def __init__(self, data: list[dict[str, Any]]) -> None:
+        """Initialize with list of dicts."""
+        self._data = data if isinstance(data, list) else [data] if data else []
+    
+    def __iter__(self) -> Iterator[dict[str, Any]]:
+        """Allow iteration over results."""
+        return iter(self._data)
+    
+    def __len__(self) -> int:
+        """Return number of results."""
+        return len(self._data)
+    
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"QueryResult({len(self._data)} items)"
+    
+    @property
+    def data(self) -> list[dict[str, Any]]:
+        """Get raw data."""
+        return self._data
+    
+    def filter(self, **patterns: str) -> "QueryResult":
+        """Filter results by regex patterns on field values.
+        
+        Args:
+            **patterns: Field name -> regex pattern pairs
+            
+        Returns:
+            New QueryResult with matching items
+            
+        Example:
+            result.filter(name="balcony", room="living.*")
+        """
+        if not patterns:
+            return self
+        
+        filtered = []
+        for item in self._data:
+            match = True
+            for field, pattern in patterns.items():
+                value = str(item.get(field, ""))
+                if not re.search(pattern, value, re.IGNORECASE):
+                    match = False
+                    break
+            if match:
+                filtered.append(item)
+        
+        return QueryResult(filtered)
+    
+    def map(self, fields: list[str] | str) -> "QueryResult":
+        """Extract specific fields from each result.
+        
+        Args:
+            fields: Field name or list of field names to extract
+            
+        Returns:
+            New QueryResult with only specified fields
+            
+        Example:
+            result.map(["device_id", "name"])
+            result.map("device_id")  # Returns list of values
+        """
+        if isinstance(fields, str):
+            # Single field - return list of values wrapped in dicts
+            return QueryResult([{fields: item.get(fields)} for item in self._data])
+        
+        mapped = []
+        for item in self._data:
+            mapped.append({f: item.get(f) for f in fields if f in item})
+        return QueryResult(mapped)
+    
+    def reduce(self, by: str | None = None, count: bool = False) -> dict[str, Any]:
+        """Aggregate results.
+        
+        Args:
+            by: Field to group by (optional)
+            count: If True, return counts per group
+            
+        Returns:
+            Aggregated dict
+            
+        Example:
+            result.reduce(by="room", count=True)  # {"living": 3, "bedroom": 2}
+        """
+        if by is None:
+            if count:
+                return {"count": len(self._data)}
+            return {"items": self._data}
+        
+        groups: dict[str, list[dict[str, Any]]] = {}
+        for item in self._data:
+            key = str(item.get(by, "unknown"))
+            if key not in groups:
+                groups[key] = []
+            groups[key].append(item)
+        
+        if count:
+            return {k: len(v) for k, v in groups.items()}
+        return groups
+    
+    def first(self) -> dict[str, Any] | None:
+        """Get first result or None.
+        
+        Returns:
+            First item or None if empty
+        """
+        return self._data[0] if self._data else None
+    
+    def last(self) -> dict[str, Any] | None:
+        """Get last result or None."""
+        return self._data[-1] if self._data else None
+    
+    def each(self, fn: Callable[[dict[str, Any]], Any]) -> list[Any]:
+        """Apply function to each result.
+        
+        Args:
+            fn: Function to apply to each item
+            
+        Returns:
+            List of function results
+            
+        Example:
+            result.each(lambda d: call_tool("control", "turn_on", **d))
+        """
+        return [fn(item) for item in self._data]
+    
+    def sort(self, by: str, reverse: bool = False) -> "QueryResult":
+        """Sort results by field.
+        
+        Args:
+            by: Field name to sort by
+            reverse: If True, sort descending
+            
+        Returns:
+            New QueryResult with sorted items
+        """
+        sorted_data = sorted(
+            self._data,
+            key=lambda x: str(x.get(by, "")),
+            reverse=reverse
+        )
+        return QueryResult(sorted_data)
+    
+    def unique(self, by: str) -> "QueryResult":
+        """Remove duplicates based on field value.
+        
+        Args:
+            by: Field to check for uniqueness
+            
+        Returns:
+            New QueryResult with unique items
+        """
+        seen: set[str] = set()
+        unique_items = []
+        for item in self._data:
+            key = str(item.get(by, ""))
+            if key not in seen:
+                seen.add(key)
+                unique_items.append(item)
+        return QueryResult(unique_items)
+

{voxagent-0.2.3 → voxagent-0.2.5}/src/voxagent/code/sandbox.py

@@ -91,6 +91,8 @@ def _execute_in_subprocess(
     globals_dict: dict[str, Any],
     result_queue: multiprocessing.Queue,  # type: ignore[type-arg]
     memory_limit_mb: int,
+    tool_request_queue: "multiprocessing.Queue[Any] | None" = None,
+    tool_response_queue: "multiprocessing.Queue[Any] | None" = None,
 ) -> None:
     """Subprocess entry point for sandboxed execution."""
     # Import here to avoid loading in main process
@@ -257,6 +259,114 @@ def _execute_in_subprocess(
             "_write_": lambda x: x,
             **globals_dict,
         }
+
+        # Create call_tool function using proxy if queues are provided
+        if tool_request_queue is not None and tool_response_queue is not None:
+            from voxagent.code.tool_proxy import ToolProxyClient
+            proxy_client = ToolProxyClient(tool_request_queue, tool_response_queue)
+
+            def call_tool(category: str, tool_name: str, **kwargs: Any) -> Any:
+                proxy = proxy_client.create_tool_proxy(category, tool_name)
+                return proxy(**kwargs)
+
+            exec_globals["call_tool"] = call_tool
+
+        # Add query functions for efficient data processing
+        from voxagent.code.query import QueryResult
+        import re as _re
+
+        def query(data: list | dict) -> QueryResult:
+            """Wrap data in QueryResult for chaining."""
+            if isinstance(data, dict) and "devices" in data:
+                # Handle list_devices response format
+                return QueryResult(data["devices"])
+            if isinstance(data, dict) and "items" in data:
+                return QueryResult(data["items"])
+            if isinstance(data, list):
+                return QueryResult(data)
+            return QueryResult([data] if data else [])
+
+        def tree(path: str = "tools") -> str:
+            """Show full tool structure with signatures.
+
+            Args:
+                path: Starting path (default: "tools")
+
+            Returns:
+                Tree-formatted string showing all tools
+            """
+            lines = []
+            path = path.rstrip("/")
+
+            # Get ls function from globals_dict
+            ls_func = globals_dict.get("ls")
+            if ls_func is None:
+                return "(ls function not available)"
+
+            # Get root entries
+            entries = ls_func(path)
+            if isinstance(entries, str):
+                # Handle error message
+                return entries
+            for entry in entries:
+                if entry == "__index__.md":
+                    continue
+                if entry.endswith("/"):
+                    # It's a category
+                    cat_name = entry.rstrip("/")
+                    lines.append(f"📁 {cat_name}/")
+                    # Get tools in category
+                    cat_entries = ls_func(f"{path}/{cat_name}")
+                    if isinstance(cat_entries, list):
+                        for tool in cat_entries:
+                            if tool != "__index__.md":
+                                lines.append(f"  📄 {tool}")
+                else:
+                    lines.append(f"📄 {entry}")
+
+            return "\n".join(lines) if lines else "(empty)"
+
+        def search(query_str: str) -> list:
+            """Search for tools by keyword.
+
+            Args:
+                query_str: Search term (matches tool names)
+
+            Returns:
+                List of matching tool paths
+            """
+            results = []
+            pattern = _re.compile(query_str, _re.IGNORECASE)
+
+            # Get ls function from globals_dict
+            ls_func = globals_dict.get("ls")
+            if ls_func is None:
+                return []
+
+            # Search all categories
+            categories = ls_func("tools")
+            if isinstance(categories, str):
+                return []
+            for cat in categories:
+                if cat == "__index__.md" or not cat.endswith("/"):
+                    continue
+                cat_name = cat.rstrip("/")
+                tools = ls_func(f"tools/{cat_name}")
+                if isinstance(tools, str):
+                    continue
+                for tool in tools:
+                    if tool == "__index__.md":
+                        continue
+                    if pattern.search(tool) or pattern.search(cat_name):
+                        results.append(f"tools/{cat_name}/{tool}")
+
+            return results
+
+        exec_globals["query"] = query
+        exec_globals["tree"] = tree
+        exec_globals["search"] = search
+        exec_globals["QueryResult"] = QueryResult
+
         exec(byte_code, exec_globals)
         # Get the _print object that was created during execution and call it
         _print_obj = exec_globals.get("_print")
@@ -298,18 +408,48 @@ class SubprocessSandbox(CodeSandbox):
         self.tool_proxy_client = tool_proxy_client
 
     async def execute(
-        self, code: str, globals_dict: dict[str, Any] | None = None
+        self,
+        code: str,
+        globals_dict: dict[str, Any] | None = None,
+        tool_request_queue: "multiprocessing.Queue[Any] | None" = None,
+        tool_response_queue: "multiprocessing.Queue[Any] | None" = None,
     ) -> SandboxResult:
-        """Execute code in subprocess with RestrictedPython."""
+        """Execute code in subprocess with RestrictedPython.
+
+        Args:
+            code: Python source code to execute
+            globals_dict: Optional globals to inject (e.g., ls, read functions)
+            tool_request_queue: Queue for tool call requests from subprocess
+            tool_response_queue: Queue for tool call responses to subprocess
+
+        Returns:
+            SandboxResult with output or error
+        """
+        import asyncio
+
         start_time = time.monotonic()
 
         result_queue: multiprocessing.Queue[SandboxResult] = multiprocessing.Queue()
         process = multiprocessing.Process(
             target=_execute_in_subprocess,
-            args=(code, globals_dict or {}, result_queue, self.memory_limit_mb),
+            args=(
+                code,
+                globals_dict or {},
+                result_queue,
+                self.memory_limit_mb,
+                tool_request_queue,
+                tool_response_queue,
+            ),
         )
         process.start()
-        process.join(timeout=self.timeout_seconds)
+
+        # Use non-blocking wait to allow event loop to run proxy server
+        # Poll the process status instead of blocking on join()
+        poll_interval = 0.01  # 10ms
+        elapsed = 0.0
+        while process.is_alive() and elapsed < self.timeout_seconds:
+            await asyncio.sleep(poll_interval)
+            elapsed = time.monotonic() - start_time
 
         execution_time_ms = (time.monotonic() - start_time) * 1000
 

{voxagent-0.2.3 → voxagent-0.2.5}/src/voxagent/code/virtual_fs.py

@@ -95,14 +95,12 @@ class ToolRegistry:
         return []
 
 
-# Type alias for tool caller function
-ToolCaller = Any  # Callable[[str, str, ...], Any]
-
-
 class VirtualFilesystem:
     """Virtual filesystem for tool discovery.
 
     Provides ls() and read() functions that can be injected into the sandbox.
+    The call_tool function is now injected directly by the sandbox using
+    the tool proxy pattern for reliable cross-process communication.
 
     Directory structure:
         tools/
@@ -116,13 +114,8 @@ class VirtualFilesystem:
             └── temperature.py
     """
 
-    def __init__(
-        self,
-        registry: ToolRegistry,
-        tool_caller: ToolCaller | None = None,
-    ) -> None:
+    def __init__(self, registry: ToolRegistry) -> None:
         self._registry = registry
-        self._tool_caller = tool_caller
     
     def ls(self, path: str) -> list[str]:
         """List directory contents.
@@ -223,15 +216,12 @@ class VirtualFilesystem:
         """Get globals dict to inject into sandbox.
 
         Returns:
-            Dict with ls, read, and call_tool functions bound to this filesystem
+            Dict with ls and read functions bound to this filesystem.
+            Note: call_tool is now injected directly by the sandbox using
+            the tool proxy pattern for reliable cross-process communication.
         """
-        globals_dict: dict[str, Any] = {
+        return {
             "ls": self.ls,
             "read": self.read,
         }
 
-        if self._tool_caller is not None:
-            globals_dict["call_tool"] = self._tool_caller
-
-        return globals_dict
-

{voxagent-0.2.3 → voxagent-0.2.5}/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: