stackone-ai 2.5.1__tar.gz → 2.7.0__tar.gz

stackone_ai-2.7.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "2.7.0"
+}

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.7.0](https://github.com/StackOneHQ/stackone-ai-python/compare/stackone-ai-v2.6.0...stackone-ai-v2.7.0) (2026-04-14)
+
+
+### Features
+
+* **search-optimization:** cache tool catalog and parallelize per-account MCP fetches ([#173](https://github.com/StackOneHQ/stackone-ai-python/issues/173)) ([cd635e6](https://github.com/StackOneHQ/stackone-ai-python/commit/cd635e65621e4e84da270a57e4e1453a3734ad95))
+
+## [2.6.0](https://github.com/StackOneHQ/stackone-ai-python/compare/stackone-ai-v2.5.1...stackone-ai-v2.6.0) (2026-04-07)
+
+
+### Features
+
+* include available connectors in search/execute tool descriptions ([#165](https://github.com/StackOneHQ/stackone-ai-python/issues/165)) ([544f41e](https://github.com/StackOneHQ/stackone-ai-python/commit/544f41ef1340d11f58be1a34e627aa8e81f1102d))
+
 ## [2.5.1](https://github.com/StackOneHQ/stackone-ai-python/compare/stackone-ai-v2.5.0...stackone-ai-v2.5.1) (2026-03-26)
 
 

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackone-ai
-Version: 2.5.1
+Version: 2.7.0
 Summary: agents performing actions on your SaaS
 Author-email: StackOne <support@stackone.com>
 License-File: LICENSE

stackone_ai-2.7.0/examples/benchmark_search.py

@@ -0,0 +1,134 @@
+"""Benchmark: measure SDK search latency with caching.
+
+Runs fetch_tools, local (BM25+TF-IDF) search, and semantic search N times,
+reports cold vs warm average latency and the speedup from caching.
+
+Prerequisites:
+    - STACKONE_API_KEY environment variable
+    - STACKONE_ACCOUNT_ID environment variable
+
+Run with:
+    uv run python examples/benchmark_search.py              # default 100 iterations
+    uv run python examples/benchmark_search.py -n 50        # fewer for a quick check
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ModuleNotFoundError:
+    pass
+
+from stackone_ai import StackOneToolSet
+
+QUERIES = [
+    "list events",
+    "cancel a meeting",
+    "send a message",
+    "get current user",
+    "list employees",
+]
+
+
+def bench(fn, n: int) -> tuple[float, float, list[float]]:
+    """Run fn() n times. Return (cold, warm_avg, all_times)."""
+    times: list[float] = []
+    for _ in range(n):
+        t = time.perf_counter()
+        fn()
+        times.append(time.perf_counter() - t)
+
+    cold = times[0]
+    warm_times = times[1:]
+    warm_avg = sum(warm_times) / len(warm_times) if warm_times else cold
+    return cold, warm_avg, times
+
+
+def fmt_ms(seconds: float) -> str:
+    return f"{seconds * 1000:8.1f}ms"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Benchmark SDK search latency")
+    parser.add_argument(
+        "--iterations", "-n", type=int, default=100, help="iterations per benchmark (default 100)"
+    )
+    args = parser.parse_args()
+    n = args.iterations
+
+    api_key = os.getenv("STACKONE_API_KEY")
+    account_id = os.getenv("STACKONE_ACCOUNT_ID")
+
+    if not api_key:
+        print("Set STACKONE_API_KEY to run this benchmark.")
+        return 1
+    if not account_id:
+        print("Set STACKONE_ACCOUNT_ID to run this benchmark.")
+        return 1
+
+    print(f"Benchmarking with account {account_id[:8]}..., {n} iterations each\n")
+
+    ts = StackOneToolSet(
+        api_key=api_key,
+        account_id=account_id,
+        search={"method": "auto", "top_k": 5},
+    )
+
+    results: list[tuple[str, float, float, float]] = []
+    query_idx = 0
+
+    def next_query() -> str:
+        nonlocal query_idx
+        q = QUERIES[query_idx % len(QUERIES)]
+        query_idx += 1
+        return q
+
+    # --- 1. fetch_tools ---
+    print(f"[1/3] fetch_tools x{n} ...")
+    ts.clear_catalog_cache()
+    cold, warm_avg, _ = bench(lambda: ts.fetch_tools(), n)
+    speedup = cold / warm_avg if warm_avg > 0 else float("inf")
+    results.append(("fetch_tools", cold, warm_avg, speedup))
+    print(f"       cold={fmt_ms(cold)}  warm_avg={fmt_ms(warm_avg)}  speedup={speedup:.0f}x")
+
+    # --- 2. local search (BM25 + TF-IDF) ---
+    print(f"[2/3] search_tools (local) x{n} ...")
+    ts.clear_catalog_cache()
+    query_idx = 0
+    cold, warm_avg, _ = bench(lambda: ts.search_tools(next_query(), search="local"), n)
+    speedup = cold / warm_avg if warm_avg > 0 else float("inf")
+    results.append(("search (local/BM25)", cold, warm_avg, speedup))
+    print(f"       cold={fmt_ms(cold)}  warm_avg={fmt_ms(warm_avg)}  speedup={speedup:.0f}x")
+
+    # --- 3. semantic search (auto) ---
+    print(f"[3/3] search_tools (semantic/auto) x{n} ...")
+    ts.clear_catalog_cache()
+    query_idx = 0
+    cold, warm_avg, _ = bench(lambda: ts.search_tools(next_query(), search="auto"), n)
+    speedup = cold / warm_avg if warm_avg > 0 else float("inf")
+    results.append(("search (semantic)", cold, warm_avg, speedup))
+    print(f"       cold={fmt_ms(cold)}  warm_avg={fmt_ms(warm_avg)}  speedup={speedup:.0f}x")
+
+    # --- Summary ---
+    print("\n" + "=" * 65)
+    print(f"{'Benchmark':<22} {'Cold':>10} {'Warm (avg)':>10} {'Speedup':>10}")
+    print("-" * 65)
+    for name, c, w, s in results:
+        print(f"{name:<22} {fmt_ms(c):>10} {fmt_ms(w):>10} {s:>9.0f}x")
+    print("=" * 65)
+
+    print(f"\nWarm = average of {n - 1} calls after the first (cold) call.")
+    print("Speedup = cold / warm_avg — shows the benefit of caching.\n")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stackone_ai-2.7.0/examples/search_tool_example.py

@@ -0,0 +1,66 @@
+"""Search tool patterns: callable wrapper and config overrides.
+
+For semantic search basics, see semantic_search_example.py.
+For full agent execution, see agent_tool_search.py.
+
+Prerequisites:
+    - STACKONE_API_KEY environment variable
+    - STACKONE_ACCOUNT_ID environment variable
+
+Run with:
+    uv run python examples/search_tool_example.py
+"""
+
+from __future__ import annotations
+
+import os
+
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ModuleNotFoundError:
+    pass
+
+from stackone_ai import StackOneToolSet
+
+
+def main() -> None:
+    api_key = os.getenv("STACKONE_API_KEY")
+    account_id = os.getenv("STACKONE_ACCOUNT_ID")
+
+    if not api_key:
+        print("Set STACKONE_API_KEY to run this example.")
+        return
+    if not account_id:
+        print("Set STACKONE_ACCOUNT_ID to run this example.")
+        return
+
+    # --- Example 1: get_search_tool() callable ---
+    print("=== get_search_tool() callable ===\n")
+
+    toolset = StackOneToolSet(api_key=api_key, account_id=account_id, search={})
+    search_tool = toolset.get_search_tool()
+
+    queries = ["cancel an event", "list employees", "send a message"]
+    for query in queries:
+        tools = search_tool(query, top_k=3)
+        names = [t.name for t in tools]
+        print(f'  "{query}" -> {", ".join(names) or "(none)"}')
+
+    # --- Example 2: Constructor top_k vs per-call override ---
+    print("\n=== Constructor top_k vs per-call override ===\n")
+
+    toolset_3 = StackOneToolSet(api_key=api_key, account_id=account_id, search={"top_k": 3})
+
+    query = "manage employee records"
+
+    tools_3 = toolset_3.search_tools(query)
+    print(f"Constructor top_k=3: got {len(tools_3)} tools")
+
+    tools_override = toolset_3.search_tools(query, top_k=10)
+    print(f"Per-call top_k=10 (overrides constructor 3): got {len(tools_override)} tools")
+
+
+if __name__ == "__main__":
+    main()

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/examples/semantic_search_example.py

@@ -133,7 +133,6 @@ def example_search_action_names():
     print(f"Top {len(results_limited)} matches from the full catalog:")
     for r in results_limited:
         print(f"  [{r.similarity_score:.2f}] {r.id}")
-        print(f"         {r.description}")
     print()
 
     # Show filtering effect when account_ids are available

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/examples/test_examples.py

@@ -33,6 +33,8 @@ OPTIONAL_DEPENDENCIES = {
     "search_tool_example.py": ["mcp"],
     "semantic_search_example.py": ["mcp"],
     "mcp_server.py": ["mcp"],
+    "workday_integration.py": ["openai", "mcp"],
+    "benchmark_search.py": ["mcp"],
 }
 
 

stackone_ai-2.7.0/examples/workday_integration.py

@@ -0,0 +1,91 @@
+"""Workday integration: timeout and account scoping for slow providers.
+
+Workday can take 10-15s to respond. This example shows how to configure
+timeout and account_ids through the execute config.
+
+Prerequisites:
+    - STACKONE_API_KEY environment variable
+    - STACKONE_ACCOUNT_ID environment variable (a Workday-connected account)
+    - OPENAI_API_KEY environment variable
+
+Run with:
+    uv run python examples/workday_integration.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ModuleNotFoundError:
+    pass
+
+from openai import OpenAI
+
+from stackone_ai import StackOneToolSet
+
+
+def main() -> None:
+    api_key = os.getenv("STACKONE_API_KEY")
+    account_id = os.getenv("STACKONE_ACCOUNT_ID")
+
+    if not api_key:
+        print("Set STACKONE_API_KEY to run this example.")
+        return
+    if not account_id:
+        print("Set STACKONE_ACCOUNT_ID to run this example.")
+        return
+
+    # Timeout for slow providers, account_id for scoping
+    toolset = StackOneToolSet(
+        api_key=api_key,
+        account_id=account_id,
+        search={"method": "auto", "top_k": 5},
+        timeout=120,
+    )
+    client = OpenAI()
+
+    def run_agent(messages: list[dict], tools: list[dict], max_steps: int = 10) -> None:
+        """Simple agent loop: call LLM, execute tools, repeat."""
+        for _ in range(max_steps):
+            response = client.chat.completions.create(model="gpt-5.4", messages=messages, tools=tools)
+            choice = response.choices[0]
+
+            if not choice.message.tool_calls:
+                print(f"Answer: {choice.message.content}")
+                return
+
+            messages.append(choice.message.model_dump(exclude_none=True))
+            for tc in choice.message.tool_calls:
+                print(f"  -> {tc.function.name}({tc.function.arguments[:80]})")
+                result = toolset.execute(tc.function.name, tc.function.arguments)
+                messages.append({"role": "tool", "tool_call_id": tc.id, "content": json.dumps(result)})
+
+    # --- Example 1: Search and execute mode ---
+    print("=== Search and execute mode ===\n")
+    run_agent(
+        messages=[
+            {"role": "system", "content": "Use tool_search to find tools, then tool_execute to run them."},
+            {"role": "user", "content": "List the first 5 employees."},
+        ],
+        tools=toolset.openai(mode="search_and_execute"),
+    )
+
+    # --- Example 2: Normal mode ---
+    print("\n=== Normal mode ===\n")
+    tools = toolset.fetch_tools(actions=["workday_*_employee*"])
+    if len(tools) == 0:
+        print("No Workday tools found for this account.")
+    else:
+        run_agent(
+            messages=[{"role": "user", "content": "List the first 5 employees."}],
+            tools=tools.to_openai(),
+        )
+
+
+if __name__ == "__main__":
+    main()

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stackone-ai"
-version = "2.5.1"
+version = "2.7.0"
 description = "agents performing actions on your SaaS"
 readme = "README.md"
 requires-python = ">=3.10"

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/stackone_ai/__init__.py

@@ -23,4 +23,4 @@ __all__ = [
     "SemanticSearchResponse",
     "SemanticSearchError",
 ]
-__version__ = "2.5.1"
+__version__ = "2.7.0"

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/stackone_ai/models.py

@@ -65,6 +65,7 @@ class ExecuteConfig(BaseModel):
     parameter_locations: dict[str, ParameterLocation] = Field(
         default_factory=dict, description="Maps parameter names to their location in the request"
     )
+    timeout: float = Field(default=60.0, description="Request timeout in seconds")
 
 
 class ToolParameters(BaseModel):
@@ -249,7 +250,7 @@ class StackOneTool(BaseModel):
             if query_params:
                 request_kwargs["params"] = query_params
 
-            response = httpx.request(**request_kwargs)
+            response = httpx.request(**request_kwargs, timeout=self._execute_config.timeout)
             response_status = response.status_code
             response.raise_for_status()
 

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/stackone_ai/toolset.py

@@ -59,7 +59,7 @@ class SearchConfig(TypedDict, total=False):
 class ExecuteToolsConfig(TypedDict, total=False):
     """Execution configuration for the StackOneToolSet constructor.
 
-    Controls default account scoping for tool execution.
+    Controls default account scoping and timeout for tool execution.
 
     When set to ``None`` (default), no account scoping is applied.
     When provided, ``account_ids`` flow through to ``openai(mode="search_and_execute")``
@@ -69,6 +69,10 @@ class ExecuteToolsConfig(TypedDict, total=False):
     account_ids: list[str]
     """Account IDs to scope tool discovery and execution."""
 
+    timeout: float
+    """Request timeout in seconds. Default: 60. Can also be set as a top-level
+    constructor param which takes precedence."""
+
 
 _SEARCH_DEFAULT: SearchConfig = {"method": "auto"}
 
@@ -166,7 +170,6 @@ class _ExecuteTool(StackOneTool):
     """LLM-callable tool that executes a StackOne tool by name."""
 
     _toolset: Any = PrivateAttr(default=None)
-    _cached_tools: Any = PrivateAttr(default=None)
 
     def execute(
         self, arguments: str | JsonDict | None = None, *, options: JsonDict | None = None
@@ -181,10 +184,8 @@ class _ExecuteTool(StackOneTool):
             parsed = _ExecuteInput(**raw_params)
             tool_name = parsed.tool_name
 
-            if self._cached_tools is None:
-                self._cached_tools = self._toolset.fetch_tools(account_ids=self._toolset._account_ids)
-
-            target = self._cached_tools.get_tool(parsed.tool_name)
+            tools = self._toolset.fetch_tools(account_ids=self._toolset._account_ids)
+            target = tools.get_tool(parsed.tool_name)
 
             if target is None:
                 return {
@@ -205,13 +206,14 @@ class _ExecuteTool(StackOneTool):
             return {"error": f"Invalid input: {exc}", "tool_name": tool_name}
 
 
-def _create_search_tool(api_key: str) -> _SearchTool:
+def _create_search_tool(api_key: str, connectors: str = "") -> _SearchTool:
     name = "tool_search"
+    connector_line = f" Available connectors: {connectors}." if connectors else ""
     description = (
         "Search for available tools by describing what you need. "
         "Returns matching tool names, descriptions, and parameter schemas. "
         "Use the returned parameter schemas to know exactly what to pass "
-        "when calling tool_execute."
+        f"when calling tool_execute.{connector_line}"
     )
     parameters = ToolParameters(
         type="object",
@@ -259,14 +261,14 @@ def _create_search_tool(api_key: str) -> _SearchTool:
     return tool
 
 
-def _create_execute_tool(api_key: str) -> _ExecuteTool:
+def _create_execute_tool(api_key: str, connectors: str = "") -> _ExecuteTool:
     name = "tool_execute"
+    connector_line = f" Available connectors: {connectors}." if connectors else ""
     description = (
         "Execute a tool by name with the given parameters. "
         "Use tool_search first to find available tools. "
         "The parameters field must match the parameter schema returned "
-        "by tool_search. Pass parameters as a nested object matching "
-        "the schema structure."
+        f"by tool_search. Pass parameters as a nested object matching the schema structure.{connector_line}"
     )
     parameters = ToolParameters(
         type="object",
@@ -415,6 +417,7 @@ class _StackOneRpcTool(StackOneTool):
         api_key: str,
         base_url: str,
         account_id: str | None,
+        timeout: float = 60.0,
     ) -> None:
         execute_config = ExecuteConfig(
             method="POST",
@@ -423,6 +426,7 @@ class _StackOneRpcTool(StackOneTool):
             headers={},
             body_type="json",
             parameter_locations=dict(_RPC_PARAMETER_LOCATIONS),
+            timeout=timeout,
         )
         super().__init__(
             description=description,
@@ -555,6 +559,7 @@ class StackOneToolSet:
         base_url: str | None = None,
         search: SearchConfig | None = None,
         execute: ExecuteToolsConfig | None = None,
+        timeout: float | None = None,
     ) -> None:
         """Initialize StackOne tools with authentication
 
@@ -570,7 +575,10 @@ class StackOneToolSet:
                 Per-call options always override these defaults.
             execute: Execution configuration. Controls default account scoping
                 for tool execution. Pass ``{"account_ids": ["acc-1"]}`` to scope
-                meta tools to specific accounts.
+                tools to specific accounts.
+            timeout: Request timeout in seconds for tool execution HTTP calls.
+                Default: 60. Takes precedence over ``execute.timeout`` if set.
+                Increase for slow providers (e.g. Workday).
 
         Raises:
             ToolsetConfigError: If no API key is provided or found in environment
@@ -584,11 +592,15 @@ class StackOneToolSet:
         self.api_key: str = api_key_value
         self.account_id = account_id
         self.base_url = base_url or DEFAULT_BASE_URL
-        self._account_ids: list[str] = []
+        self._account_ids: list[str] = execute.get("account_ids", []) if execute else []
         self._semantic_client: SemanticSearchClient | None = None
         self._search_config: SearchConfig | None = search
         self._execute_config: ExecuteToolsConfig | None = execute
+        execute_timeout = execute.get("timeout") if execute else None
+        self._timeout: float = timeout if timeout is not None else (execute_timeout or 60.0)
         self._tools_cache: Tools | None = None
+        self._catalog_cache: dict[tuple[Any, ...], Tools] = {}
+        self._tool_index_cache: tuple[int, Any] | None = None
 
     def set_accounts(self, account_ids: list[str]) -> StackOneToolSet:
         """Set account IDs for filtering tools
@@ -600,8 +612,18 @@ class StackOneToolSet:
             This toolset instance for chaining
         """
         self._account_ids = account_ids
+        self.clear_catalog_cache()
         return self
 
+    def clear_catalog_cache(self) -> None:
+        """Invalidate cached tool catalog and local search index.
+
+        Call when linked accounts change outside of ``set_accounts`` or when
+        you need to force a fresh fetch from the StackOne MCP endpoint.
+        """
+        self._catalog_cache.clear()
+        self._tool_index_cache = None
+
     def get_search_tool(self, *, search: SearchMode | None = None) -> SearchTool:
         """Get a callable search tool that returns Tools collections.
 
@@ -645,10 +667,20 @@ class StackOneToolSet:
         if account_ids:
             self._account_ids = account_ids
 
-        search_tool = _create_search_tool(self.api_key)
+        # Discover available connectors for dynamic descriptions
+        connectors_str = ""
+        try:
+            all_tools = self.fetch_tools(account_ids=self._account_ids)
+            connectors = sorted(all_tools.get_connectors())
+            if connectors:
+                connectors_str = ", ".join(connectors)
+        except Exception:
+            logger.debug("Could not discover connectors for tool descriptions")
+
+        search_tool = _create_search_tool(self.api_key, connectors=connectors_str)
         search_tool._toolset = self
 
-        execute_tool = _create_execute_tool(self.api_key)
+        execute_tool = _create_execute_tool(self.api_key, connectors=connectors_str)
         execute_tool._toolset = self
 
         return Tools([search_tool, execute_tool])
@@ -779,7 +811,10 @@ class StackOneToolSet:
         if not available_connectors:
             return Tools([])
 
-        index = ToolIndex(list(all_tools))
+        cache_key = id(all_tools)
+        if self._tool_index_cache is None or self._tool_index_cache[0] != cache_key:
+            self._tool_index_cache = (cache_key, ToolIndex(list(all_tools)))
+        index = self._tool_index_cache[1]
         results = index.search(
             query,
             limit=top_k if top_k is not None else 5,
@@ -1148,14 +1183,31 @@ class StackOneToolSet:
             else:
                 account_scope = [None]
 
+            cache_key = (
+                tuple(sorted(account_scope, key=lambda a: (a is None, a))),
+                tuple(sorted(p.lower() for p in providers)) if providers else None,
+                tuple(sorted(actions)) if actions else None,
+            )
+            cached = self._catalog_cache.get(cache_key)
+            if cached is not None:
+                return cached
+
             endpoint = f"{self.base_url.rstrip('/')}/mcp"
-            all_tools: list[StackOneTool] = []
 
-            for account in account_scope:
+            def _fetch_for_account(account: str | None) -> list[StackOneTool]:
                 headers = self._build_mcp_headers(account)
                 catalog = _fetch_mcp_tools(endpoint, headers)
-                for tool_def in catalog:
-                    all_tools.append(self._create_rpc_tool(tool_def, account))
+                return [self._create_rpc_tool(tool_def, account) for tool_def in catalog]
+
+            all_tools: list[StackOneTool] = []
+            if len(account_scope) == 1:
+                all_tools.extend(_fetch_for_account(account_scope[0]))
+            else:
+                max_workers = min(len(account_scope), 10)
+                with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
+                    futures = [pool.submit(_fetch_for_account, acc) for acc in account_scope]
+                    for future in futures:
+                        all_tools.extend(future.result())
 
             if providers:
                 all_tools = [tool for tool in all_tools if self._filter_by_provider(tool.name, providers)]
@@ -1163,7 +1215,9 @@ class StackOneToolSet:
             if actions:
                 all_tools = [tool for tool in all_tools if self._filter_by_action(tool.name, actions)]
 
-            return Tools(all_tools)
+            result = Tools(all_tools)
+            self._catalog_cache[cache_key] = result
+            return result
 
         except ToolsetError:
             raise
@@ -1192,6 +1246,7 @@ class StackOneToolSet:
             api_key=self.api_key,
             base_url=self.base_url,
             account_id=account_id,
+            timeout=self._timeout,
         )
 
     def _normalize_schema_properties(self, schema: dict[str, Any]) -> dict[str, Any]:

{stackone_ai-2.5.1 → stackone_ai-2.7.0}/tests/test_agent_tools.py

@@ -268,7 +268,11 @@ class TestToolExecute:
 
         assert "error" in result
 
-    def test_caches_fetched_tools(self):
+    def test_delegates_catalog_lookup_to_toolset(self):
+        # _ExecuteTool no longer holds a local cache; the toolset's catalog
+        # cache (see StackOneToolSet._catalog_cache) is the single source of
+        # truth. Verify execute always defers to the toolset so it benefits
+        # from that shared cache.
         toolset = MagicMock()
         toolset.api_key = "test-key"
         toolset._account_ids = []
@@ -286,7 +290,8 @@ class TestToolExecute:
         execute.execute({"tool_name": "test_tool"})
         execute.execute({"tool_name": "test_tool"})
 
-        toolset.fetch_tools.assert_called_once()
+        assert toolset.fetch_tools.call_count == 2
+        toolset.fetch_tools.assert_called_with(account_ids=[])
 
     def test_passes_account_ids_from_toolset(self):
         toolset = MagicMock()