swarmauri_toolkit_runtime 0.11.0.dev1__tar.gz → 0.11.0.dev4__tar.gz

{swarmauri_toolkit_runtime-0.11.0.dev1 → swarmauri_toolkit_runtime-0.11.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarmauri_toolkit_runtime
-Version: 0.11.0.dev1
+Version: 0.11.0.dev4
 Summary: Runtime toolkit for explicit-parameter registration, inspection, replacement, listing, and removal of Swarmauri tools during agent execution.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -22,9 +22,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: pydantic
-Requires-Dist: swarmauri_base
-Requires-Dist: swarmauri_core
-Requires-Dist: swarmauri_standard
+Requires-Dist: swarmauri_base (>=0.11.0.dev6,<0.12)
+Requires-Dist: swarmauri_core (>=0.11.0.dev6,<0.12)
+Requires-Dist: swarmauri_standard (>=0.11.0.dev8,<0.12)
+Requires-Dist: swarmauri_tool_inspectruntimetool (>=0.1.0,<0.2)
+Requires-Dist: swarmauri_tool_listruntimetools (>=0.1.0,<0.2)
+Requires-Dist: swarmauri_tool_registerruntimetool (>=0.1.0,<0.2)
+Requires-Dist: swarmauri_tool_replaceruntimetool (>=0.1.0,<0.2)
+Requires-Dist: swarmauri_tool_unregisterruntimetool (>=0.1.0,<0.2)
 Description-Content-Type: text/markdown
 
 ![Swarmauri Logo](https://raw.githubusercontent.com/swarmauri/swarmauri-sdk/master/assets/swarmauri_sdk_brand.png)

{swarmauri_toolkit_runtime-0.11.0.dev1 → swarmauri_toolkit_runtime-0.11.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "swarmauri_toolkit_runtime"
-version = "0.11.0.dev1"
+version = "0.11.0.dev4"
 description = "Runtime toolkit for explicit-parameter registration, inspection, replacement, listing, and removal of Swarmauri tools during agent execution."
 license = "Apache-2.0"
 readme = { file = "README.md", content-type = "text/markdown" }
@@ -23,10 +23,15 @@ classifiers = [
 ]
 authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
 dependencies = [
+    "swarmauri_tool_registerruntimetool>=0.1.0,<0.2",
+    "swarmauri_tool_inspectruntimetool>=0.1.0,<0.2",
+    "swarmauri_tool_listruntimetools>=0.1.0,<0.2",
+    "swarmauri_tool_replaceruntimetool>=0.1.0,<0.2",
+    "swarmauri_tool_unregisterruntimetool>=0.1.0,<0.2",
     "pydantic",
-    "swarmauri_core",
-    "swarmauri_base",
-    "swarmauri_standard",
+    "swarmauri_core>=0.11.0.dev6,<0.12",
+    "swarmauri_base>=0.11.0.dev6,<0.12",
+    "swarmauri_standard>=0.11.0.dev8,<0.12",
 ]
 keywords = [
     "swarmauri",
@@ -49,6 +54,11 @@ keywords = [
 ]
 
 [tool.uv.sources]
+swarmauri_tool_registerruntimetool = { workspace = true }
+swarmauri_tool_inspectruntimetool = { workspace = true }
+swarmauri_tool_listruntimetools = { workspace = true }
+swarmauri_tool_replaceruntimetool = { workspace = true }
+swarmauri_tool_unregisterruntimetool = { workspace = true }
 swarmauri_core = { workspace = true }
 swarmauri_base = { workspace = true }
 swarmauri_standard = { workspace = true }
@@ -76,13 +86,6 @@ asyncio_default_fixture_loop_scope = "function"
 [project.entry-points.'swarmauri.toolkits']
 RuntimeToolkit = "swarmauri_toolkit_runtime:RuntimeToolkit"
 
-[project.entry-points.'swarmauri.tools']
-RegisterRuntimeTool = "swarmauri_toolkit_runtime:RegisterRuntimeTool"
-InspectRuntimeTool = "swarmauri_toolkit_runtime:InspectRuntimeTool"
-ListRuntimeTools = "swarmauri_toolkit_runtime:ListRuntimeTools"
-UnregisterRuntimeTool = "swarmauri_toolkit_runtime:UnregisterRuntimeTool"
-ReplaceRuntimeTool = "swarmauri_toolkit_runtime:ReplaceRuntimeTool"
-
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"

swarmauri_toolkit_runtime-0.11.0.dev4/swarmauri_toolkit_runtime/InspectRuntimeTool.py

@@ -0,0 +1,3 @@
+from swarmauri_tool_inspectruntimetool import InspectRuntimeTool
+
+__all__ = ["InspectRuntimeTool"]

swarmauri_toolkit_runtime-0.11.0.dev4/swarmauri_toolkit_runtime/ListRuntimeTools.py

@@ -0,0 +1,3 @@
+from swarmauri_tool_listruntimetools import ListRuntimeTools
+
+__all__ = ["ListRuntimeTools"]

swarmauri_toolkit_runtime-0.11.0.dev4/swarmauri_toolkit_runtime/RecipeTool.py

@@ -0,0 +1,47 @@
+from collections.abc import Callable
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+from swarmauri_base.ComponentBase import ComponentBase
+from swarmauri_base.tools.ToolBase import ToolBase
+
+
+class RecipeStep(BaseModel):
+    """Call one installed tool with literals or input references."""
+
+    tool: str
+    arguments: dict[str, Any] = Field(default_factory=dict)
+
+
+@ComponentBase.register_type(ToolBase, "RecipeTool")
+class RecipeTool(ToolBase):
+    """Run a sequence of existing tool calls through a host dispatcher."""
+
+    type: Literal["RecipeTool"] = "RecipeTool"
+    steps: list[RecipeStep] = Field(min_length=1, max_length=32)
+    dispatch: Callable[[str, dict[str, Any]], dict[str, Any]] = Field(
+        exclude=True
+    )
+
+    def __call__(self, **inputs):
+        declared = {parameter.name for parameter in self.parameters}
+        required = {
+            parameter.name
+            for parameter in self.parameters
+            if parameter.required
+        }
+        if inputs.keys() - declared or required - inputs.keys():
+            raise ValueError("Recipe inputs do not match its parameters")
+        results = []
+        for step in self.steps:
+            arguments = {
+                key: inputs[value["input"]]
+                if isinstance(value, dict) and value.keys() == {"input"}
+                else value
+                for key, value in step.arguments.items()
+            }
+            result = self.dispatch(step.tool, arguments)
+            results.append(result)
+            if result.get("status") != "completed":
+                break
+        return {"steps": results}

swarmauri_toolkit_runtime-0.11.0.dev4/swarmauri_toolkit_runtime/RegisterRuntimeTool.py

@@ -0,0 +1,3 @@
+from swarmauri_tool_registerruntimetool import RegisterRuntimeTool
+
+__all__ = ["RegisterRuntimeTool"]

swarmauri_toolkit_runtime-0.11.0.dev4/swarmauri_toolkit_runtime/ReplaceRuntimeTool.py

@@ -0,0 +1,3 @@
+from swarmauri_tool_replaceruntimetool import ReplaceRuntimeTool
+
+__all__ = ["ReplaceRuntimeTool"]

{swarmauri_toolkit_runtime-0.11.0.dev1 → swarmauri_toolkit_runtime-0.11.0.dev4}/swarmauri_toolkit_runtime/RuntimeToolkit.py

@@ -1,5 +1,8 @@
+from collections.abc import Callable, Mapping
 from typing import Dict, Literal
 
+from pydantic import Field, PrivateAttr
+
 from swarmauri_base.ComponentBase import ComponentBase
 from swarmauri_base.tools.ToolBase import ToolBase
 from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
@@ -9,12 +12,16 @@ from .InspectRuntimeTool import InspectRuntimeTool
 from .ListRuntimeTools import ListRuntimeTools
 from .UnregisterRuntimeTool import UnregisterRuntimeTool
 from .ReplaceRuntimeTool import ReplaceRuntimeTool
+from .RecipeTool import RecipeTool
+from ._tool_factory import build_tool_from_spec
 
 
 @ComponentBase.register_type(ToolkitBase, "RuntimeToolkit")
 class RuntimeToolkit(ToolkitBase):
     type: Literal["RuntimeToolkit"] = "RuntimeToolkit"
     tools: Dict[str, ToolBase] = {}
+    revision: int = Field(default=0, ge=0)
+    _recipe_dispatch: Callable | None = PrivateAttr(default=None)
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -30,7 +37,9 @@ class RuntimeToolkit(ToolkitBase):
         }
         return {
             "RegisterRuntimeTool": RegisterRuntimeTool(
-                toolkit=self, protected_tool_names=protected_tool_names
+                toolkit=self,
+                protected_tool_names=protected_tool_names,
+                factory=self._build_tool,
             ),
             "InspectRuntimeTool": InspectRuntimeTool(toolkit=self),
             "ListRuntimeTools": ListRuntimeTools(toolkit=self),
@@ -38,6 +47,29 @@ class RuntimeToolkit(ToolkitBase):
                 toolkit=self, protected_tool_names=protected_tool_names
             ),
             "ReplaceRuntimeTool": ReplaceRuntimeTool(
-                toolkit=self, protected_tool_names=protected_tool_names
+                toolkit=self,
+                protected_tool_names=protected_tool_names,
+                factory=self._build_tool,
             ),
         }
+
+    def bind_recipe_dispatch(self, dispatch: Callable) -> None:
+        """Configure the application dispatcher for recipe steps."""
+        self._recipe_dispatch = dispatch
+
+    def _build_tool(self, spec):
+        if isinstance(spec, Mapping) and spec.get("type") == "RecipeTool":
+            if self._recipe_dispatch is None:
+                raise ValueError("Recipe dispatch is not configured")
+            return RecipeTool.model_validate(
+                {**spec, "dispatch": self._recipe_dispatch}
+            )
+        return build_tool_from_spec(spec)
+
+    def add_tool(self, tool):
+        super().add_tool(tool)
+        self.revision += 1
+
+    def remove_tool(self, tool_name):
+        super().remove_tool(tool_name)
+        self.revision += 1

swarmauri_toolkit_runtime-0.11.0.dev4/swarmauri_toolkit_runtime/UnregisterRuntimeTool.py

@@ -0,0 +1,3 @@
+from swarmauri_tool_unregisterruntimetool import UnregisterRuntimeTool
+
+__all__ = ["UnregisterRuntimeTool"]

swarmauri_toolkit_runtime-0.11.0.dev4/swarmauri_toolkit_runtime/_dynamic_runtime_tool.py

@@ -0,0 +1,3 @@
+from swarmauri_standard.tools._dynamic_runtime_tool import DynamicRuntimeTool
+
+__all__ = ["DynamicRuntimeTool"]

swarmauri_toolkit_runtime-0.11.0.dev4/swarmauri_toolkit_runtime/_tool_factory.py

@@ -0,0 +1,3 @@
+from swarmauri_standard.tools._tool_factory import build_tool_from_spec
+
+__all__ = ["build_tool_from_spec"]

swarmauri_toolkit_runtime-0.11.0.dev1/swarmauri_toolkit_runtime/InspectRuntimeTool.py

@@ -1,38 +0,0 @@
-from typing import Any, Dict, List, Literal
-
-from pydantic import Field
-
-from swarmauri_base.ComponentBase import ComponentBase
-from swarmauri_base.tools.ToolBase import ToolBase
-from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
-from swarmauri_standard.tools.Parameter import Parameter
-
-
-@ComponentBase.register_type(ToolBase, "InspectRuntimeTool")
-class InspectRuntimeTool(ToolBase):
-    version: str = "0.1.0"
-    name: str = "InspectRuntimeTool"
-    description: str = "Read one tool from the active toolkit by name."
-    type: Literal["InspectRuntimeTool"] = "InspectRuntimeTool"
-    toolkit: ToolkitBase | None = Field(default=None, exclude=True, repr=False)
-    parameters: List[Parameter] = Field(
-        default_factory=lambda: [
-            Parameter(
-                name="tool_name",
-                input_type="string",
-                description="Name of the tool to fetch from the toolkit.",
-                required=True,
-            )
-        ]
-    )
-
-    def __call__(self, tool_name: str) -> Dict[str, Any]:
-        if self.toolkit is None:
-            raise ValueError("toolkit is not configured")
-
-        tool = self.toolkit.get_tool_by_name(tool_name)
-        return {
-            "tool_name": tool_name,
-            "tool_type": tool.type,
-            "tool": tool.model_dump(exclude_none=True, by_alias=True),
-        }

swarmauri_toolkit_runtime-0.11.0.dev1/swarmauri_toolkit_runtime/ListRuntimeTools.py

@@ -1,33 +0,0 @@
-from typing import Any, Dict, List, Literal
-
-from pydantic import Field
-
-from swarmauri_base.ComponentBase import ComponentBase
-from swarmauri_base.tools.ToolBase import ToolBase
-from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
-
-
-@ComponentBase.register_type(ToolBase, "ListRuntimeTools")
-class ListRuntimeTools(ToolBase):
-    version: str = "0.1.0"
-    name: str = "ListRuntimeTools"
-    description: str = (
-        "List all tools currently available in the active toolkit."
-    )
-    type: Literal["ListRuntimeTools"] = "ListRuntimeTools"
-    toolkit: ToolkitBase | None = Field(default=None, exclude=True, repr=False)
-    parameters: List[Any] = Field(default_factory=list)
-
-    def __call__(self) -> Dict[str, Any]:
-        if self.toolkit is None:
-            raise ValueError("toolkit is not configured")
-
-        tools = {
-            name: tool.model_dump(exclude_none=True, by_alias=True)
-            for name, tool in self.toolkit.tools.items()
-        }
-        return {
-            "tool_count": len(self.toolkit),
-            "tool_names": list(self.toolkit.tools.keys()),
-            "tools": tools,
-        }

swarmauri_toolkit_runtime-0.11.0.dev1/swarmauri_toolkit_runtime/RegisterRuntimeTool.py

@@ -1,63 +0,0 @@
-from typing import Any, Dict, List, Literal, Mapping
-
-from pydantic import Field
-
-from swarmauri_base.ComponentBase import ComponentBase
-from swarmauri_base.tools.ToolBase import ToolBase
-from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
-from swarmauri_standard.tools.Parameter import Parameter
-
-from ._tool_factory import build_tool_from_spec
-
-
-@ComponentBase.register_type(ToolBase, "RegisterRuntimeTool")
-class RegisterRuntimeTool(ToolBase):
-    version: str = "0.1.0"
-    name: str = "RegisterRuntimeTool"
-    description: str = (
-        "Create a tool from a serialized tool spec and add it to the "
-        "active toolkit."
-    )
-    type: Literal["RegisterRuntimeTool"] = "RegisterRuntimeTool"
-    toolkit: ToolkitBase | None = Field(default=None, exclude=True, repr=False)
-    protected_tool_names: set[str] = Field(
-        default_factory=set, exclude=True, repr=False
-    )
-    parameters: List[Parameter] = Field(
-        default_factory=lambda: [
-            Parameter(
-                name="tool_spec",
-                input_type="object",
-                description=(
-                    "Serialized tool payload with 'type', 'parameters', and "
-                    "'__call__' fields."
-                ),
-                required=True,
-            )
-        ]
-    )
-
-    def __call__(
-        self, tool_spec: Mapping[str, Any] | ToolBase
-    ) -> Dict[str, Any]:
-        if self.toolkit is None:
-            raise ValueError("toolkit is not configured")
-
-        tool = build_tool_from_spec(tool_spec)
-        if tool.name in self.protected_tool_names:
-            raise ValueError(
-                f"Tool '{tool.name}' is reserved by RuntimeToolkit"
-            )
-        if tool.name in self.toolkit.tools:
-            raise ValueError(
-                f"Tool '{tool.name}' already exists in the toolkit"
-            )
-
-        self.toolkit.add_tool(tool)
-        return {
-            "status": "created",
-            "tool_name": tool.name,
-            "tool_type": tool.type,
-            "tool": tool.model_dump(exclude_none=True, by_alias=True),
-            "tool_count": len(self.toolkit),
-        }

swarmauri_toolkit_runtime-0.11.0.dev1/swarmauri_toolkit_runtime/ReplaceRuntimeTool.py

@@ -1,83 +0,0 @@
-from typing import Any, Dict, List, Literal, Mapping
-
-from pydantic import Field
-
-from swarmauri_base.ComponentBase import ComponentBase
-from swarmauri_base.tools.ToolBase import ToolBase
-from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
-from swarmauri_standard.tools.Parameter import Parameter
-
-from ._tool_factory import build_tool_from_spec
-
-
-@ComponentBase.register_type(ToolBase, "ReplaceRuntimeTool")
-class ReplaceRuntimeTool(ToolBase):
-    version: str = "0.1.0"
-    name: str = "ReplaceRuntimeTool"
-    description: str = (
-        "Replace an existing non-reserved tool in the active toolkit "
-        "with a new serialized tool spec."
-    )
-    type: Literal["ReplaceRuntimeTool"] = "ReplaceRuntimeTool"
-    toolkit: ToolkitBase | None = Field(default=None, exclude=True, repr=False)
-    protected_tool_names: set[str] = Field(
-        default_factory=set, exclude=True, repr=False
-    )
-    parameters: List[Parameter] = Field(
-        default_factory=lambda: [
-            Parameter(
-                name="tool_name",
-                input_type="string",
-                description="Existing tool name to replace.",
-                required=True,
-            ),
-            Parameter(
-                name="tool_spec",
-                input_type="object",
-                description=(
-                    "Serialized replacement tool payload with 'type', "
-                    "'parameters', and '__call__' fields."
-                ),
-                required=True,
-            ),
-        ]
-    )
-
-    def __call__(
-        self, tool_name: str, tool_spec: Mapping[str, Any] | ToolBase
-    ) -> Dict[str, Any]:
-        if self.toolkit is None:
-            raise ValueError("toolkit is not configured")
-        if tool_name in self.protected_tool_names:
-            raise ValueError(
-                f"Tool '{tool_name}' is reserved by RuntimeToolkit"
-            )
-        if tool_name not in self.toolkit.tools:
-            raise ValueError(f"Tool '{tool_name}' not found in the toolkit")
-
-        replacement = build_tool_from_spec(tool_spec)
-        if (
-            replacement.name in self.protected_tool_names
-            and replacement.name != tool_name
-        ):
-            raise ValueError(
-                f"Tool '{replacement.name}' is reserved by RuntimeToolkit"
-            )
-        if (
-            replacement.name != tool_name
-            and replacement.name in self.toolkit.tools
-        ):
-            raise ValueError(
-                f"Tool '{replacement.name}' already exists in the toolkit"
-            )
-
-        self.toolkit.remove_tool(tool_name)
-        self.toolkit.add_tool(replacement)
-        return {
-            "status": "updated",
-            "previous_tool_name": tool_name,
-            "tool_name": replacement.name,
-            "tool_type": replacement.type,
-            "tool": replacement.model_dump(exclude_none=True, by_alias=True),
-            "tool_count": len(self.toolkit),
-        }

swarmauri_toolkit_runtime-0.11.0.dev1/swarmauri_toolkit_runtime/UnregisterRuntimeTool.py

@@ -1,45 +0,0 @@
-from typing import Any, Dict, List, Literal
-
-from pydantic import Field
-
-from swarmauri_base.ComponentBase import ComponentBase
-from swarmauri_base.tools.ToolBase import ToolBase
-from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
-from swarmauri_standard.tools.Parameter import Parameter
-
-
-@ComponentBase.register_type(ToolBase, "UnregisterRuntimeTool")
-class UnregisterRuntimeTool(ToolBase):
-    version: str = "0.1.0"
-    name: str = "UnregisterRuntimeTool"
-    description: str = "Delete a non-reserved tool from the active toolkit."
-    type: Literal["UnregisterRuntimeTool"] = "UnregisterRuntimeTool"
-    toolkit: ToolkitBase | None = Field(default=None, exclude=True, repr=False)
-    protected_tool_names: set[str] = Field(
-        default_factory=set, exclude=True, repr=False
-    )
-    parameters: List[Parameter] = Field(
-        default_factory=lambda: [
-            Parameter(
-                name="tool_name",
-                input_type="string",
-                description="Name of the tool to remove from the toolkit.",
-                required=True,
-            )
-        ]
-    )
-
-    def __call__(self, tool_name: str) -> Dict[str, Any]:
-        if self.toolkit is None:
-            raise ValueError("toolkit is not configured")
-        if tool_name in self.protected_tool_names:
-            raise ValueError(
-                f"Tool '{tool_name}' is reserved by RuntimeToolkit"
-            )
-
-        self.toolkit.remove_tool(tool_name)
-        return {
-            "status": "deleted",
-            "tool_name": tool_name,
-            "tool_count": len(self.toolkit),
-        }

swarmauri_toolkit_runtime-0.11.0.dev1/swarmauri_toolkit_runtime/_dynamic_runtime_tool.py

@@ -1,176 +0,0 @@
-import ast
-from typing import Any, Dict, Literal
-
-from pydantic import ConfigDict, Field
-
-from swarmauri_base.tools.ToolBase import ToolBase
-
-
-SAFE_BUILTINS = {
-    "abs": abs,
-    "bool": bool,
-    "dict": dict,
-    "float": float,
-    "int": int,
-    "len": len,
-    "list": list,
-    "max": max,
-    "min": min,
-    "round": round,
-    "set": set,
-    "str": str,
-    "sum": sum,
-    "tuple": tuple,
-}
-
-ALLOWED_AST_NODES = (
-    ast.Add,
-    ast.And,
-    ast.BinOp,
-    ast.BoolOp,
-    ast.Compare,
-    ast.Constant,
-    ast.Dict,
-    ast.Div,
-    ast.Eq,
-    ast.Expression,
-    ast.FloorDiv,
-    ast.Gt,
-    ast.GtE,
-    ast.IfExp,
-    ast.List,
-    ast.Load,
-    ast.Lt,
-    ast.LtE,
-    ast.Mod,
-    ast.Mult,
-    ast.Name,
-    ast.Not,
-    ast.NotEq,
-    ast.Or,
-    ast.Pow,
-    ast.Set,
-    ast.Sub,
-    ast.Tuple,
-    ast.USub,
-    ast.UnaryOp,
-    ast.Call,
-)
-
-
-class SafeExpressionValidator(ast.NodeVisitor):
-    def __init__(self, allowed_names: set[str]):
-        self.allowed_names = allowed_names
-
-    def generic_visit(self, node):
-        if not isinstance(node, ALLOWED_AST_NODES):
-            raise ValueError(
-                f"Runtime tool '__call__' contains unsafe syntax: {type(node).__name__}"  # noqa: E501
-            )
-        super().generic_visit(node)
-
-    def visit_Name(self, node: ast.Name):
-        if node.id not in self.allowed_names:
-            raise ValueError(
-                f"Runtime tool '__call__' references disallowed name '{node.id}'"  # noqa: E501
-            )
-        self.generic_visit(node)
-
-    def visit_Call(self, node: ast.Call):
-        if not isinstance(node.func, ast.Name):
-            raise ValueError(
-                (
-                    "Runtime tool '__call__' only allows direct calls to approved "  # noqa: E501
-                    "builtins"
-                )
-            )
-        if node.func.id not in SAFE_BUILTINS:
-            raise ValueError(
-                f"Runtime tool '__call__' cannot call '{node.func.id}' safely"
-            )
-        self.generic_visit(node)
-
-
-class DynamicRuntimeTool(ToolBase):
-    model_config = ConfigDict(populate_by_name=True)
-
-    version: str = "0.1.0"
-    type: str
-    runtime_kind: Literal["dynamic"] = Field(default="dynamic", exclude=True)
-    call_source: str = Field(alias="__call__", serialization_alias="__call__")
-
-    def validate_call_source(self) -> "DynamicRuntimeTool":
-        self._compile_expression(self._normalized_expression())
-        return self
-
-    def __call__(self, *args, **kwargs) -> Any:
-        try:
-            expression = self._normalized_expression()
-            compiled = self._compile_expression(expression)
-            runtime_inputs = self._bind_inputs(args, kwargs)
-            runtime_globals = {"__builtins__": {}}
-            runtime_locals = {**SAFE_BUILTINS, **runtime_inputs}
-            return eval(compiled, runtime_globals, runtime_locals)
-        except BaseException as exc:
-            return self._safe_error_result(exc)
-
-    def _normalized_expression(self) -> str:
-        expression = self.call_source.strip()
-        if expression.startswith("return "):
-            expression = expression[7:].strip()
-        if not expression:
-            raise ValueError("Runtime tool '__call__' must not be empty")
-        return expression
-
-    def _compile_expression(self, expression: str):
-        try:
-            parsed = ast.parse(expression, mode="eval")
-        except SyntaxError as exc:
-            raise ValueError(
-                "Runtime tool '__call__' must be a safe Python expression"
-            ) from exc
-
-        allowed_names = {
-            parameter.name for parameter in self.parameters
-        } | set(SAFE_BUILTINS)
-        SafeExpressionValidator(allowed_names).visit(parsed)
-        return compile(
-            parsed, filename=f"<runtime-tool:{self.name}>", mode="eval"
-        )
-
-    def _bind_inputs(
-        self, args: tuple[Any, ...], kwargs: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        parameter_names = [parameter.name for parameter in self.parameters]
-        if len(args) > len(parameter_names):
-            raise ValueError(
-                f"Runtime tool '{self.name}' received too many positional arguments"  # noqa: E501
-            )
-
-        bound_inputs: Dict[str, Any] = dict(zip(parameter_names, args))
-        for key, value in kwargs.items():
-            if key not in parameter_names:
-                raise ValueError(
-                    f"Runtime tool '{self.name}' received unexpected argument '{key}'"  # noqa: E501
-                )
-            if key in bound_inputs:
-                raise ValueError(
-                    f"Runtime tool '{self.name}' received duplicate argument '{key}'"  # noqa: E501
-                )
-            bound_inputs[key] = value
-
-        for parameter in self.parameters:
-            if parameter.required and parameter.name not in bound_inputs:
-                raise ValueError(
-                    f"Runtime tool '{self.name}' is missing required argument '{parameter.name}'"  # noqa: E501
-                )
-        return bound_inputs
-
-    def _safe_error_result(self, exc: BaseException) -> Dict[str, Any]:
-        return {
-            "status": "error",
-            "tool_name": self.name,
-            "tool_type": self.type,
-            "error_type": type(exc).__name__,
-            "error": str(exc),
-        }

swarmauri_toolkit_runtime-0.11.0.dev1/swarmauri_toolkit_runtime/_tool_factory.py

@@ -1,46 +0,0 @@
-from typing import Any, Mapping
-
-from swarmauri_base.tools.ToolBase import ToolBase
-from swarmauri_standard.tools.Parameter import Parameter
-
-from ._dynamic_runtime_tool import DynamicRuntimeTool
-
-
-def build_tool_from_spec(tool_spec: Mapping[str, Any] | ToolBase) -> ToolBase:
-    if isinstance(tool_spec, ToolBase):
-        if not tool_spec.parameters:
-            raise ValueError(
-                "Runtime tool registration requires declared parameters"
-            )
-        if not callable(getattr(tool_spec, "__call__", None)):
-            raise ValueError(
-                "Runtime tool registration requires a callable '__call__'"
-            )
-        return tool_spec
-    if not isinstance(tool_spec, Mapping):
-        raise TypeError("tool_spec must be a mapping or ToolBase instance")
-
-    tool_data = dict(tool_spec)
-    tool_type = tool_data.get("type")
-    if not isinstance(tool_type, str) or not tool_type:
-        raise ValueError(
-            "tool_spec must include a non-empty string 'type' field"
-        )
-    declared_parameters = tool_data.get("parameters")
-    if not isinstance(declared_parameters, list) or not declared_parameters:
-        raise ValueError(
-            "Runtime tool registration requires a non-empty 'parameters' list"
-        )
-    call_source = tool_data.get("__call__")
-    if not isinstance(call_source, str) or not call_source.strip():
-        raise ValueError(
-            "Runtime tool registration requires a non-empty '__call__' string"
-        )
-
-    tool_data["parameters"] = [
-        parameter
-        if isinstance(parameter, Parameter)
-        else Parameter.model_validate(parameter)
-        for parameter in declared_parameters
-    ]
-    return DynamicRuntimeTool.model_validate(tool_data).validate_call_source()