agentx-dev 3.3.1__tar.gz → 3.4.0__tar.gz

{agentx_dev-3.3.1 → agentx_dev-3.4.0}/CHANGELOG.md

@@ -4,6 +4,71 @@ All notable changes to `agentx-dev` are documented here. Format loosely
 follows [Keep a Changelog](https://keepachangelog.com/); versioning is
 [Semver](https://semver.org/).
 
+## [3.4.0] - 2026-09-18
+
+Media input for GPT and Claude, models that adapt to each generation's
+parameter support, and workspace-rooted paths. Non-breaking; two
+defaults changed -- see docs/guides/upgrading.md.
+
+### Added
+
+- **Media input for GPT and Claude.** New `Media` type
+  (`Media.image()`, `.document()`, `.audio()`, `.from_path()`,
+  `.from_url()`, `.from_bytes()`) and a `media=[...]` argument on
+  `AgentRunner.invoke` / `stream` and `AsyncAgentRunner.ainvoke` /
+  `astream`. Items can be paths, URLs, `Media`, or content-part dicts
+  in either provider's native shape; each model renders them in its
+  own wire format (OpenAI `image_url` / `file` / `input_audio`,
+  Anthropic `image` / `document`). Unsupported combinations -- audio to
+  Claude, a document URL to GPT -- raise `ValueError` before any
+  request. Media is stored as plain JSON dicts, so `completion.history`
+  and `Session.save()` keep working. Guide: docs/guides/media.md.
+
+- **Models adapt to per-generation parameter support.** `GPT` and
+  `Claude` read a parameter-compatibility 400 (which names the
+  parameter and, for enums, the allowed values), make the smallest
+  change it asks for, retry, and remember it per model: an unsupported
+  `reasoning_effort` moves to the nearest supported value, `max_tokens`
+  becomes `max_completion_tokens` on reasoning models (up front for
+  known families), parameters a model lacks are dropped, and Claude's
+  `max_tokens` is clamped to the model's cap. Logged at WARNING; other
+  400s raise unchanged. `adapt_params=False` opts out.
+
+- **`Claude` gains `top_p`, `top_k`, `thinking`, `stop_sequences`.**
+
+### Changed
+
+- `Claude(temperature=)` defaults to `None` (not sent; the API default is
+  the old 1.0). Always sending it conflicted with `top_p` on newer models
+  and with extended thinking.
+- `GPT(reasoning_effort=)` accepts any string, not just
+  `none | low | medium | high`, so `minimal` and `xhigh` are expressible.
+
+### Fixed
+
+- **`reasoning_effort="none"` crashed on models that don't take it**
+  ("Unsupported value: 'reasoning_effort' does not support 'none' with
+  this model"). The models docs even recommended `"none"` as a fix for
+  tool-calling conflicts; that advice is gone.
+- **Workspace-rooted paths resolved to the drive root.** With a workspace
+  set, `/bruce.jpeg` became `C:\bruce.jpeg` on Windows (a leading slash
+  with no drive means the current drive's root) and the sandbox rejected
+  it. A leading slash now means the workspace root; the re-rooted path
+  is still sandbox-checked, so traversal is rejected as before.
+- **`run_python` ran in the host process's directory, not the
+  workspace.** It passed no `cwd`, so `open("bruce.jpeg")` looked
+  wherever the program was launched from. It now starts in the workspace,
+  matching `run_shell`.
+- **Message-list input stringified media into the prompt.** A user turn
+  whose content was a list (text + image) went through `str()`, so an
+  attached image reached the model as base64 text. Text and media are
+  now split, and earlier turns keep their list content.
+- **Claude returned the wrong block with extended thinking.** It read
+  `response.content[0].text`; with thinking the first block is a
+  `thinking` block. Text blocks are now joined.
+- `GPT.Initialize` / `stream_text` / `astream_text` now run messages
+  through the same OpenAI translator as `call_with_tools`.
+
 ## [3.3.1] - 2026-09-09
 
 Correctness fixes in the agent loop, found by driving it with a

{agentx_dev-3.3.1 → agentx_dev-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-dev
-Version: 3.3.1
+Version: 3.4.0
 Summary: A production-grade Python framework for building LLM agents. Multi-provider chat, permission-gated tools, RAG (in-mem + Chroma/Qdrant/pgvector), semantic memory, Supervisor + Handoffs multi-agent orchestration with streaming, evals harness, prompt caching, Batch API, prompt-optimizer, MCP integration.
 Author-email: Bruce-Arhin Shadrach <brucearhin098@gmail.com>
 License: MIT License
@@ -73,6 +73,32 @@ you can paste and run.
 
 ---
 
+## What's new in 3.4 — media input and models that adapt
+
+Send images, PDFs and audio to GPT or Claude with one type. The model
+classes now adjust themselves to whatever each model generation accepts,
+and sandboxed file paths behave the way you'd write them. Nothing
+breaks — see [Upgrading](docs/guides/upgrading.md).
+
+| Feature | What you get |
+|---|---|
+| **Media input** | `runner.invoke("Describe this", media=["photo.jpg", "report.pdf"])`. Paths, URLs, bytes or `Media` objects. The same code works on `GPT()` and `Claude()`: each model gets its own format, and either provider's native part shape is accepted too. Unsupported pairs — audio to Claude, a PDF URL to GPT — fail fast with a clear `ValueError`. [Guide](docs/guides/media.md). |
+| **Models that adapt** | Parameter support changes between model generations — `reasoning_effort`'s allowed values, `max_tokens` vs `max_completion_tokens`, Claude's `temperature` + `top_p` conflict. When a model rejects a parameter, `GPT` and `Claude` make the smallest change the error asks for (`'none'` → `'low'`), retry, and remember it for that model. Logged at WARNING; `adapt_params=False` opts out. [Details](docs/concepts/models.md#old-and-new-models). |
+| **More Claude settings** | `Claude(top_p=, top_k=, thinking=, stop_sequences=)`. `temperature` is only sent when you set it. |
+| **Workspace paths** | With a workspace set, `/notes.txt` means the workspace's `notes.txt`, not `C:\notes.txt`. `run_python` now starts in the workspace, so `open("notes.txt")` finds it. |
+
+### Upgrade notes
+
+- `Claude(temperature=)` now defaults to unset. The API default is the
+  old `1.0`, so output is the same.
+- A parameter a model rejects is adjusted with a WARNING instead of
+  raising. Use `adapt_params=False` if you'd rather it fail.
+- `run_python` starts in the workspace, not the launch directory.
+- Drop any `reasoning_effort="none"` workarounds. Earlier docs
+  recommended it, and it's the value newer models reject.
+
+Full notes: [docs/guides/upgrading.md](docs/guides/upgrading.md).
+
 ## What's new in 3.3 — dependency DAGs for the Supervisor
 
 Plans stopped being flat lists. A step declares what it consumes, and
@@ -922,6 +948,35 @@ guarantees a crashed save can't corrupt an existing valid file.
 
 ---
 
+## Send images, PDFs and audio
+
+```python
+from agentx_dev import AgentRunner, AgentType, Claude, Media
+
+runner = AgentRunner(model=Claude(), agent=AgentType.ReAct, tools=[])
+
+result = runner.invoke(
+    "What does this chart show, and does the report agree?",
+    media=["q3_chart.png", "q3_report.pdf"],
+)
+```
+
+Swap in `GPT(model="gpt-4o")` and nothing else changes. You can also put
+media straight into a message for a bare model call:
+
+```python
+llm.invoke([{"role": "user", "content": ["What's in this photo?", Media.image("cat.jpg")]}])
+```
+
+| | GPT | Claude |
+|---|---|---|
+| image (file or URL) | yes | yes |
+| PDF | file | file or URL |
+| audio (wav / mp3) | audio models | no — `ValueError` |
+
+Paths are relative to where your program runs, not the agent's
+workspace. See [Media](docs/guides/media.md).
+
 ## Get a typed result back
 
 Force the agent's final answer to fit a Pydantic schema:
@@ -959,7 +1014,13 @@ print(receipt.merchant)
 ## Stream output token-by-token
 
 ```python
-runner = AgentRunner(model=Claude(), agent=AgentType.ReAct, tools=[weather_tool])
+# use_function_calling=False is REQUIRED for text_delta: FC mode (the
+# auto-detected default since 3.1.7) emits structured tool calls, not
+# streaming text, so stream_tokens=True would yield zero text_delta.
+runner = AgentRunner(
+    model=Claude(), agent=AgentType.ReAct, tools=[weather_tool],
+    use_function_calling=False,
+)
 
 for event in runner.stream("What's the weather in NYC?", stream_tokens=True):
     if event["type"] == "text_delta":
@@ -1150,7 +1211,7 @@ print(f"Spent: ${llm.usage.estimate_cost(0.003, 0.015):.4f}")
     exercising the dynamic-spawn machinery and the persistent-state feature.
 - Project-scoped instruction sheet: [`AGENTX.md`](AGENTX.md) —
   read for the conventions this codebase expects.
-- The full framework docs: see [`agentx_dev/README.md`](agentx_dev/README.md)
+- The full framework docs: see [`docs/README.md`](docs/README.md)
   (every class, every method, every operational lever)
 
 ## Links

{agentx_dev-3.3.1 → agentx_dev-3.4.0}/README.md

@@ -9,6 +9,32 @@ you can paste and run.
 
 ---
 
+## What's new in 3.4 — media input and models that adapt
+
+Send images, PDFs and audio to GPT or Claude with one type. The model
+classes now adjust themselves to whatever each model generation accepts,
+and sandboxed file paths behave the way you'd write them. Nothing
+breaks — see [Upgrading](docs/guides/upgrading.md).
+
+| Feature | What you get |
+|---|---|
+| **Media input** | `runner.invoke("Describe this", media=["photo.jpg", "report.pdf"])`. Paths, URLs, bytes or `Media` objects. The same code works on `GPT()` and `Claude()`: each model gets its own format, and either provider's native part shape is accepted too. Unsupported pairs — audio to Claude, a PDF URL to GPT — fail fast with a clear `ValueError`. [Guide](docs/guides/media.md). |
+| **Models that adapt** | Parameter support changes between model generations — `reasoning_effort`'s allowed values, `max_tokens` vs `max_completion_tokens`, Claude's `temperature` + `top_p` conflict. When a model rejects a parameter, `GPT` and `Claude` make the smallest change the error asks for (`'none'` → `'low'`), retry, and remember it for that model. Logged at WARNING; `adapt_params=False` opts out. [Details](docs/concepts/models.md#old-and-new-models). |
+| **More Claude settings** | `Claude(top_p=, top_k=, thinking=, stop_sequences=)`. `temperature` is only sent when you set it. |
+| **Workspace paths** | With a workspace set, `/notes.txt` means the workspace's `notes.txt`, not `C:\notes.txt`. `run_python` now starts in the workspace, so `open("notes.txt")` finds it. |
+
+### Upgrade notes
+
+- `Claude(temperature=)` now defaults to unset. The API default is the
+  old `1.0`, so output is the same.
+- A parameter a model rejects is adjusted with a WARNING instead of
+  raising. Use `adapt_params=False` if you'd rather it fail.
+- `run_python` starts in the workspace, not the launch directory.
+- Drop any `reasoning_effort="none"` workarounds. Earlier docs
+  recommended it, and it's the value newer models reject.
+
+Full notes: [docs/guides/upgrading.md](docs/guides/upgrading.md).
+
 ## What's new in 3.3 — dependency DAGs for the Supervisor
 
 Plans stopped being flat lists. A step declares what it consumes, and
@@ -858,6 +884,35 @@ guarantees a crashed save can't corrupt an existing valid file.
 
 ---
 
+## Send images, PDFs and audio
+
+```python
+from agentx_dev import AgentRunner, AgentType, Claude, Media
+
+runner = AgentRunner(model=Claude(), agent=AgentType.ReAct, tools=[])
+
+result = runner.invoke(
+    "What does this chart show, and does the report agree?",
+    media=["q3_chart.png", "q3_report.pdf"],
+)
+```
+
+Swap in `GPT(model="gpt-4o")` and nothing else changes. You can also put
+media straight into a message for a bare model call:
+
+```python
+llm.invoke([{"role": "user", "content": ["What's in this photo?", Media.image("cat.jpg")]}])
+```
+
+| | GPT | Claude |
+|---|---|---|
+| image (file or URL) | yes | yes |
+| PDF | file | file or URL |
+| audio (wav / mp3) | audio models | no — `ValueError` |
+
+Paths are relative to where your program runs, not the agent's
+workspace. See [Media](docs/guides/media.md).
+
 ## Get a typed result back
 
 Force the agent's final answer to fit a Pydantic schema:
@@ -895,7 +950,13 @@ print(receipt.merchant)
 ## Stream output token-by-token
 
 ```python
-runner = AgentRunner(model=Claude(), agent=AgentType.ReAct, tools=[weather_tool])
+# use_function_calling=False is REQUIRED for text_delta: FC mode (the
+# auto-detected default since 3.1.7) emits structured tool calls, not
+# streaming text, so stream_tokens=True would yield zero text_delta.
+runner = AgentRunner(
+    model=Claude(), agent=AgentType.ReAct, tools=[weather_tool],
+    use_function_calling=False,
+)
 
 for event in runner.stream("What's the weather in NYC?", stream_tokens=True):
     if event["type"] == "text_delta":
@@ -1086,7 +1147,7 @@ print(f"Spent: ${llm.usage.estimate_cost(0.003, 0.015):.4f}")
     exercising the dynamic-spawn machinery and the persistent-state feature.
 - Project-scoped instruction sheet: [`AGENTX.md`](AGENTX.md) —
   read for the conventions this codebase expects.
-- The full framework docs: see [`agentx_dev/README.md`](agentx_dev/README.md)
+- The full framework docs: see [`docs/README.md`](docs/README.md)
   (every class, every method, every operational lever)
 
 ## Links

{agentx_dev-3.3.1 → agentx_dev-3.4.0}/agentx_dev/Agents/__init__.py

@@ -1,11 +1,11 @@
-from .Agent import AgentFormattor,AgentPrompt,AgentType,AgentCompletion,StandardParser,ToolCall
-
-
-__all__ =[
-    'AgentFormattor',
-    'AgentCompletion',
-    'AgentPrompt',
-    'AgentType',
-    'StandardParser',
-    'ToolCall'  
+from .Agent import AgentFormattor,AgentPrompt,AgentType,AgentCompletion,StandardParser,ToolCall
+
+
+__all__ =[
+    'AgentFormattor',
+    'AgentCompletion',
+    'AgentPrompt',
+    'AgentType',
+    'StandardParser',
+    'ToolCall'  
 ]

{agentx_dev-3.3.1 → agentx_dev-3.4.0}/agentx_dev/AsyncTools.py

@@ -1,160 +1,160 @@
-"""
-Async-enabled tools for concurrent execution in agent workflows.
-
-This module provides async versions of StandardTool and StructuredTool,
-enabling concurrent tool execution for improved performance in I/O-bound operations.
-"""
-
-from typing import Dict, Callable, List, Type, Coroutine, Any
-from pydantic import BaseModel, Field
-import asyncio
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class AsyncStandardTool:
-    """
-    Async version of StandardTool that supports concurrent execution.
-
-    This tool type allows async functions to be used as tools, enabling
-    concurrent I/O operations like API calls, database queries, etc.
-    """
-
-    def __init__(self, func: Callable[..., Coroutine], name: str | None = None, description: str | None = None):
-        """
-        Initializes an AsyncStandardTool.
-
-        Args:
-            func (Callable): Async function to execute when the tool is called.
-            name (str, optional): The name of the tool. Defaults to function name.
-            description (str, optional): Description of the tool. Defaults to function docstring.
-
-        Raises:
-            ValueError: If name or description cannot be determined.
-        """
-        self.func = func
-
-        if name:
-            self.name = name
-        elif getattr(func, "__name__", None) and func.__name__ != "<lambda>":
-            self.name = func.__name__
-        else:
-            raise ValueError("Tool name is required (the supplied function has no usable __name__)")
-
-        temp = description if description else self.func.__doc__
-        if temp:
-            self.description = temp
-        else:
-            raise ValueError("description needed cant be NONE")
-
-        self.__name__ = 'AsyncStandardTool'
-
-    async def execute(self, *args, **kwargs):
-        """Execute the async tool function."""
-        return await self.func(*args, **kwargs)
-
-    def __repr__(self) -> str:
-        return (
-            f"AsyncStandardTool(name={self.name!r}, description={self.description!r}, "
-            f"func={self.func!r})"
-        )
-
-
-class AsyncStructuredTool:
-    """
-    Async version of StructuredTool with Pydantic-based argument validation.
-
-    Combines the benefits of structured arguments with async execution capabilities.
-    """
-
-    def __init__(
-        self,
-        func: Callable[..., Coroutine],
-        args_schema: Type[BaseModel],
-        name: str | None = None,
-        description: str | None = None
-    ):
-        """
-        Initializes an AsyncStructuredTool.
-
-        Args:
-            func (Callable): Async function to execute.
-            args_schema (Type[BaseModel]): Pydantic model defining expected arguments.
-            name (str, optional): Tool name. Defaults to function name.
-            description (str, optional): Tool description. Defaults to function docstring.
-        """
-        self.func = func
-
-        if name:
-            self.name = name
-        elif getattr(func, "__name__", None) and func.__name__ != "<lambda>":
-            self.name = func.__name__
-        else:
-            raise ValueError("Tool name is required (the supplied function has no usable __name__)")
-
-        temp = description if description else self.func.__doc__
-        if temp:
-            self.description = temp
-        else:
-            raise ValueError("description needed cant be NONE")
-
-        self.args_schema = args_schema
-        self.__name__ = 'AsyncStructuredTool'
-
-    def to_openai_tool(self, description: str | None = None) -> Dict:
-        """OpenAI tools-API spec built from this tool's args_schema."""
-        from agentx_dev.Agents.Agent import to_openai_tool as _to
-        spec = _to(self.args_schema, description or self.description)
-        spec["function"]["name"] = self.name
-        return spec
-
-    def to_anthropic_tool(self, description: str | None = None) -> Dict:
-        """Anthropic tool spec built from this tool's args_schema."""
-        from agentx_dev.Agents.Agent import to_anthropic_tool as _to
-        spec = _to(self.args_schema, description or self.description)
-        spec["name"] = self.name
-        return spec
-
-    async def execute(self, **kwargs):
-        """Execute the async tool function with validated arguments."""
-        validated_args = self.args_schema(**kwargs)
-        return await self.func(**validated_args.model_dump())
-
-    def __repr__(self) -> str:
-        return (
-            f"AsyncStructuredTool(name={self.name!r}, description={self.description!r}, "
-            f"args_schema={self.args_schema.__name__}, func={self.func!r})"
-        )
-
-
-async def execute_tools_concurrently(tools_to_execute: List[Dict[str, Any]]) -> List[Any]:
-    """
-    Execute multiple async tools concurrently.
-
-    Args:
-        tools_to_execute: List of dicts with 'tool' (AsyncTool instance) and 'args' (dict).
-
-    Returns:
-        List of results from each tool execution in the same order.
-
-    Example:
-        >>> tools = [
-        ...     {'tool': weather_tool, 'args': {'location': 'NYC'}},
-        ...     {'tool': news_tool, 'args': {'topic': 'tech'}}
-        ... ]
-        >>> results = await execute_tools_concurrently(tools)
-    """
-    tasks = []
-    for item in tools_to_execute:
-        tool = item['tool']
-        args = item.get('args', {})
-
-        if isinstance(tool, AsyncStandardTool):
-            tasks.append(tool.execute(args.get('input', '')))
-        elif isinstance(tool, AsyncStructuredTool):
-            tasks.append(tool.execute(**args))
-        else:
-            logger.warning(f"Skipping non-async tool: {tool}")
-
-    return await asyncio.gather(*tasks, return_exceptions=True)
+"""
+Async-enabled tools for concurrent execution in agent workflows.
+
+This module provides async versions of StandardTool and StructuredTool,
+enabling concurrent tool execution for improved performance in I/O-bound operations.
+"""
+
+from typing import Dict, Callable, List, Type, Coroutine, Any
+from pydantic import BaseModel, Field
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncStandardTool:
+    """
+    Async version of StandardTool that supports concurrent execution.
+
+    This tool type allows async functions to be used as tools, enabling
+    concurrent I/O operations like API calls, database queries, etc.
+    """
+
+    def __init__(self, func: Callable[..., Coroutine], name: str | None = None, description: str | None = None):
+        """
+        Initializes an AsyncStandardTool.
+
+        Args:
+            func (Callable): Async function to execute when the tool is called.
+            name (str, optional): The name of the tool. Defaults to function name.
+            description (str, optional): Description of the tool. Defaults to function docstring.
+
+        Raises:
+            ValueError: If name or description cannot be determined.
+        """
+        self.func = func
+
+        if name:
+            self.name = name
+        elif getattr(func, "__name__", None) and func.__name__ != "<lambda>":
+            self.name = func.__name__
+        else:
+            raise ValueError("Tool name is required (the supplied function has no usable __name__)")
+
+        temp = description if description else self.func.__doc__
+        if temp:
+            self.description = temp
+        else:
+            raise ValueError("description needed cant be NONE")
+
+        self.__name__ = 'AsyncStandardTool'
+
+    async def execute(self, *args, **kwargs):
+        """Execute the async tool function."""
+        return await self.func(*args, **kwargs)
+
+    def __repr__(self) -> str:
+        return (
+            f"AsyncStandardTool(name={self.name!r}, description={self.description!r}, "
+            f"func={self.func!r})"
+        )
+
+
+class AsyncStructuredTool:
+    """
+    Async version of StructuredTool with Pydantic-based argument validation.
+
+    Combines the benefits of structured arguments with async execution capabilities.
+    """
+
+    def __init__(
+        self,
+        func: Callable[..., Coroutine],
+        args_schema: Type[BaseModel],
+        name: str | None = None,
+        description: str | None = None
+    ):
+        """
+        Initializes an AsyncStructuredTool.
+
+        Args:
+            func (Callable): Async function to execute.
+            args_schema (Type[BaseModel]): Pydantic model defining expected arguments.
+            name (str, optional): Tool name. Defaults to function name.
+            description (str, optional): Tool description. Defaults to function docstring.
+        """
+        self.func = func
+
+        if name:
+            self.name = name
+        elif getattr(func, "__name__", None) and func.__name__ != "<lambda>":
+            self.name = func.__name__
+        else:
+            raise ValueError("Tool name is required (the supplied function has no usable __name__)")
+
+        temp = description if description else self.func.__doc__
+        if temp:
+            self.description = temp
+        else:
+            raise ValueError("description needed cant be NONE")
+
+        self.args_schema = args_schema
+        self.__name__ = 'AsyncStructuredTool'
+
+    def to_openai_tool(self, description: str | None = None) -> Dict:
+        """OpenAI tools-API spec built from this tool's args_schema."""
+        from agentx_dev.Agents.Agent import to_openai_tool as _to
+        spec = _to(self.args_schema, description or self.description)
+        spec["function"]["name"] = self.name
+        return spec
+
+    def to_anthropic_tool(self, description: str | None = None) -> Dict:
+        """Anthropic tool spec built from this tool's args_schema."""
+        from agentx_dev.Agents.Agent import to_anthropic_tool as _to
+        spec = _to(self.args_schema, description or self.description)
+        spec["name"] = self.name
+        return spec
+
+    async def execute(self, **kwargs):
+        """Execute the async tool function with validated arguments."""
+        validated_args = self.args_schema(**kwargs)
+        return await self.func(**validated_args.model_dump())
+
+    def __repr__(self) -> str:
+        return (
+            f"AsyncStructuredTool(name={self.name!r}, description={self.description!r}, "
+            f"args_schema={self.args_schema.__name__}, func={self.func!r})"
+        )
+
+
+async def execute_tools_concurrently(tools_to_execute: List[Dict[str, Any]]) -> List[Any]:
+    """
+    Execute multiple async tools concurrently.
+
+    Args:
+        tools_to_execute: List of dicts with 'tool' (AsyncTool instance) and 'args' (dict).
+
+    Returns:
+        List of results from each tool execution in the same order.
+
+    Example:
+        >>> tools = [
+        ...     {'tool': weather_tool, 'args': {'location': 'NYC'}},
+        ...     {'tool': news_tool, 'args': {'topic': 'tech'}}
+        ... ]
+        >>> results = await execute_tools_concurrently(tools)
+    """
+    tasks = []
+    for item in tools_to_execute:
+        tool = item['tool']
+        args = item.get('args', {})
+
+        if isinstance(tool, AsyncStandardTool):
+            tasks.append(tool.execute(args.get('input', '')))
+        elif isinstance(tool, AsyncStructuredTool):
+            tasks.append(tool.execute(**args))
+        else:
+            logger.warning(f"Skipping non-async tool: {tool}")
+
+    return await asyncio.gather(*tasks, return_exceptions=True)