PR Suggestion from bots

Author: shashi-stackone

examples/meta_tools_example.py

@@ -53,7 +53,7 @@ def example_openai_meta_tools() -> None:
 
     if openai_key:
         client = OpenAI()
-        model = "gpt-5.1"
+        model = "gpt-4o"
         provider = "OpenAI"
     elif google_key:
         client = OpenAI(
@@ -85,8 +85,10 @@ def example_openai_meta_tools() -> None:
             "content": (
                 "You are a helpful scheduling assistant. "
                 "Use tool_search to find relevant tools, then tool_execute to run them. "
-                "If a tool execution fails, try different parameters or a different tool. "
-                "Do not repeat the same failed call."
+                "Always read the parameter schemas from tool_search results carefully. "
+                "If a tool needs a user URI, first search for and call a "
+                "'get current user' tool to obtain it. "
+                "If a tool execution fails, fix the parameters and retry."
             ),
         },
         {

stackone_ai/meta_tools.py

@@ -5,14 +5,13 @@
 import json
 from typing import TYPE_CHECKING, Any
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, PrivateAttr, ValidationError, field_validator
 
 from stackone_ai.models import (
     ExecuteConfig,
     JsonDict,
     ParameterLocation,
     StackOneAPIError,
-    StackOneError,
     StackOneTool,
     ToolParameters,
     Tools,
@@ -54,8 +53,8 @@ def validate_query(cls, v: str) -> str:
 class SearchMetaTool(StackOneTool):
     """LLM-callable tool that searches for available StackOne tools."""
 
-    _toolset: Any = None
-    _options: MetaToolsOptions = None  # type: ignore[assignment]
+    _toolset: Any = PrivateAttr(default=None)
+    _options: MetaToolsOptions = PrivateAttr(default=None)  # type: ignore[assignment]
 
     def execute(
         self, arguments: str | JsonDict | None = None, *, options: JsonDict | None = None
@@ -89,12 +88,8 @@ def execute(
                 "total": len(results),
                 "query": parsed.query,
             }
-        except json.JSONDecodeError as exc:
-            raise StackOneError(f"Invalid JSON in arguments: {exc}") from exc
-        except Exception as error:
-            if isinstance(error, StackOneError):
-                raise
-            raise StackOneError(f"Error searching tools: {error}") from error
+        except (json.JSONDecodeError, ValidationError) as exc:
+            return {"error": f"Invalid input: {exc}", "query": raw_params if "raw_params" in dir() else None}
 
 
 # --- tool_execute ---
@@ -118,42 +113,45 @@ def validate_tool_name(cls, v: str) -> str:
 class ExecuteMetaTool(StackOneTool):
     """LLM-callable tool that executes a StackOne tool by name."""
 
-    _toolset: Any = None
-    _options: MetaToolsOptions = None  # type: ignore[assignment]
+    _toolset: Any = PrivateAttr(default=None)
+    _options: MetaToolsOptions = PrivateAttr(default=None)  # type: ignore[assignment]
+    _cached_tools: Any = PrivateAttr(default=None)
 
     def execute(
         self, arguments: str | JsonDict | None = None, *, options: JsonDict | None = None
     ) -> JsonDict:
+        tool_name = "unknown"
         try:
             if isinstance(arguments, str):
                 raw_params = json.loads(arguments)
             else:
                 raw_params = arguments or {}
 
             parsed = ExecuteInput(**raw_params)
+            tool_name = parsed.tool_name
 
-            all_tools = self._toolset.fetch_tools(account_ids=self._options.account_ids)
-            target = all_tools.get_tool(parsed.tool_name)
+            if self._cached_tools is None:
+                self._cached_tools = self._toolset.fetch_tools(account_ids=self._options.account_ids)
+
+            target = self._cached_tools.get_tool(parsed.tool_name)
 
             if target is None:
                 return {
-                    "error": f'Tool "{parsed.tool_name}" not found. Use tool_search to find available tools.',
+                    "error": (
+                        f'Tool "{parsed.tool_name}" not found. Use tool_search to find available tools.'
+                    ),
                 }
 
             return target.execute(parsed.parameters, options=options)
         except StackOneAPIError as exc:
-            # Return API errors to the LLM so it can adjust parameters and retry
             return {
                 "error": str(exc),
                 "status_code": exc.status_code,
-                "tool_name": parsed.tool_name if "parsed" in dir() else "unknown",
+                "response_body": exc.response_body,
+                "tool_name": tool_name,
             }
-        except json.JSONDecodeError as exc:
-            raise StackOneError(f"Invalid JSON in arguments: {exc}") from exc
-        except Exception as error:
-            if isinstance(error, StackOneError):
-                raise
-            raise StackOneError(f"Error executing tool: {error}") from error
+        except (json.JSONDecodeError, ValidationError) as exc:
+            return {"error": f"Invalid input: {exc}", "tool_name": tool_name}
 
 
 # --- Factory ---
@@ -176,24 +174,25 @@ def create_meta_tools(
     api_key = toolset.api_key
 
     # tool_search
-    search_tool = _create_search_tool(api_key, opts)
+    search_tool = _create_search_tool(api_key)
     search_tool._toolset = toolset
     search_tool._options = opts
 
     # tool_execute
-    execute_tool = _create_execute_tool(api_key, opts)
+    execute_tool = _create_execute_tool(api_key)
     execute_tool._toolset = toolset
     execute_tool._options = opts
 
     return Tools([search_tool, execute_tool])
 
 
-def _create_search_tool(api_key: str, opts: MetaToolsOptions) -> SearchMetaTool:
+def _create_search_tool(api_key: str) -> SearchMetaTool:
     name = "tool_search"
     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."
+        "Use the returned parameter schemas to know exactly what to pass "
+        "when calling tool_execute."
     )
     parameters = ToolParameters(
         type="object",
@@ -207,13 +206,15 @@ def _create_search_tool(api_key: str, opts: MetaToolsOptions) -> SearchMetaTool:
             },
             "connector": {
                 "type": "string",
-                "description": 'Optional connector filter (e.g. "bamboohr", "hibob")',
+                "description": 'Optional connector filter (e.g. "bamboohr")',
+                "nullable": True,
             },
             "top_k": {
                 "type": "integer",
                 "description": "Max results to return (1-50, default 5)",
                 "minimum": 1,
                 "maximum": 50,
+                "nullable": True,
             },
         },
     )
@@ -239,13 +240,14 @@ def _create_search_tool(api_key: str, opts: MetaToolsOptions) -> SearchMetaTool:
     return tool
 
 
-def _create_execute_tool(api_key: str, opts: MetaToolsOptions) -> ExecuteMetaTool:
+def _create_execute_tool(api_key: str) -> ExecuteMetaTool:
     name = "tool_execute"
     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."
+        "The parameters field must match the parameter schema returned "
+        "by tool_search. Pass parameters as a nested object matching "
+        "the schema structure."
     )
     parameters = ToolParameters(
         type="object",
@@ -256,7 +258,8 @@ def _create_execute_tool(api_key: str, opts: MetaToolsOptions) -> ExecuteMetaToo
             },
             "parameters": {
                 "type": "object",
-                "description": "Parameters for the tool. Pass {} if none needed.",
+                "description": "Parameters for the tool, matching the schema from tool_search.",
+                "nullable": True,
             },
         },
     )

stackone_ai/models.py

@@ -422,6 +422,10 @@ def to_langchain(self) -> BaseTool:
                     python_type = int
                 elif type_str == "boolean":
                     python_type = bool
+                elif type_str == "object":
+                    python_type = dict
+                elif type_str == "array":
+                    python_type = list
 
                 field = Field(description=details.get("description", ""))
             else: