swarmauri_toolkit_runtime 0.1.1.dev2__py3-none-any.whl → 0.11.0.dev1__py3-none-any.whl

swarmauri_toolkit_runtime/InspectRuntimeTool.py

@@ -34,5 +34,5 @@ class InspectRuntimeTool(ToolBase):
         return {
             "tool_name": tool_name,
             "tool_type": tool.type,
-            "tool": tool.model_dump(exclude_none=True),
+            "tool": tool.model_dump(exclude_none=True, by_alias=True),
         }

swarmauri_toolkit_runtime/ListRuntimeTools.py

@@ -11,7 +11,9 @@ from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
 class ListRuntimeTools(ToolBase):
     version: str = "0.1.0"
     name: str = "ListRuntimeTools"
-    description: str = "List all tools currently available in the active toolkit."
+    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)
@@ -21,7 +23,7 @@ class ListRuntimeTools(ToolBase):
             raise ValueError("toolkit is not configured")
 
         tools = {
-            name: tool.model_dump(exclude_none=True)
+            name: tool.model_dump(exclude_none=True, by_alias=True)
             for name, tool in self.toolkit.tools.items()
         }
         return {

swarmauri_toolkit_runtime/RegisterRuntimeTool.py

@@ -15,7 +15,8 @@ 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."
+        "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)
@@ -27,27 +28,36 @@ class RegisterRuntimeTool(ToolBase):
             Parameter(
                 name="tool_spec",
                 input_type="object",
-                description="Serialized tool payload with at least a 'type' field.",
+                description=(
+                    "Serialized tool payload with 'type', 'parameters', and "
+                    "'__call__' fields."
+                ),
                 required=True,
             )
         ]
     )
 
-    def __call__(self, tool_spec: Mapping[str, Any] | ToolBase) -> Dict[str, Any]:
+    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")
+            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")
+            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),
+            "tool": tool.model_dump(exclude_none=True, by_alias=True),
             "tool_count": len(self.toolkit),
         }

swarmauri_toolkit_runtime/ReplaceRuntimeTool.py

@@ -14,7 +14,10 @@ from ._tool_factory import build_tool_from_spec
 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."
+    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(
@@ -31,7 +34,10 @@ class ReplaceRuntimeTool(ToolBase):
             Parameter(
                 name="tool_spec",
                 input_type="object",
-                description="Serialized replacement tool payload with at least a 'type' field.",
+                description=(
+                    "Serialized replacement tool payload with 'type', "
+                    "'parameters', and '__call__' fields."
+                ),
                 required=True,
             ),
         ]
@@ -43,7 +49,9 @@ class ReplaceRuntimeTool(ToolBase):
         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")
+            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")
 
@@ -52,9 +60,16 @@ class ReplaceRuntimeTool(ToolBase):
             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")
+            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)
@@ -63,6 +78,6 @@ class ReplaceRuntimeTool(ToolBase):
             "previous_tool_name": tool_name,
             "tool_name": replacement.name,
             "tool_type": replacement.type,
-            "tool": replacement.model_dump(exclude_none=True),
+            "tool": replacement.model_dump(exclude_none=True, by_alias=True),
             "tool_count": len(self.toolkit),
         }

swarmauri_toolkit_runtime/RuntimeToolkit.py

@@ -1,6 +1,6 @@
 from typing import Dict, Literal
 
-from swarmauri_base.ComponentBase import ComponentBase, SubclassUnion
+from swarmauri_base.ComponentBase import ComponentBase
 from swarmauri_base.tools.ToolBase import ToolBase
 from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
 
@@ -14,13 +14,13 @@ from .ReplaceRuntimeTool import ReplaceRuntimeTool
 @ComponentBase.register_type(ToolkitBase, "RuntimeToolkit")
 class RuntimeToolkit(ToolkitBase):
     type: Literal["RuntimeToolkit"] = "RuntimeToolkit"
-    tools: Dict[str, SubclassUnion[ToolBase]] = {}
+    tools: Dict[str, ToolBase] = {}
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.tools = self._build_management_tools()
 
-    def _build_management_tools(self) -> Dict[str, SubclassUnion[ToolBase]]:
+    def _build_management_tools(self) -> Dict[str, ToolBase]:
         protected_tool_names = {
             "RegisterRuntimeTool",
             "InspectRuntimeTool",

swarmauri_toolkit_runtime/UnregisterRuntimeTool.py

@@ -33,7 +33,9 @@ class UnregisterRuntimeTool(ToolBase):
         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")
+            raise ValueError(
+                f"Tool '{tool_name}' is reserved by RuntimeToolkit"
+            )
 
         self.toolkit.remove_tool(tool_name)
         return {

swarmauri_toolkit_runtime/_dynamic_runtime_tool.py

@@ -0,0 +1,176 @@
+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/_tool_factory.py

@@ -1,27 +1,21 @@
-from importlib import import_module
 from typing import Any, Mapping
 
 from swarmauri_base.tools.ToolBase import ToolBase
+from swarmauri_standard.tools.Parameter import Parameter
 
-
-def _resolve_tool_module(tool_type: str):
-    module_names = [
-        f"swarmauri.tools.{tool_type}",
-        f"swarmauri_standard.tools.{tool_type}",
-    ]
-    last_error: ModuleNotFoundError | None = None
-    for module_name in module_names:
-        try:
-            return import_module(module_name)
-        except ModuleNotFoundError as exc:
-            last_error = exc
-    raise ValueError(f"Unable to resolve tool type '{tool_type}'") from last_error
+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")
+            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")
@@ -29,21 +23,24 @@ def build_tool_from_spec(tool_spec: Mapping[str, Any] | ToolBase) -> ToolBase:
     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")
+        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"
         )
-
-    module = _resolve_tool_module(tool_type)
-
-    tool_cls = getattr(module, tool_type, None)
-    if tool_cls is None:
+    call_source = tool_data.get("__call__")
+    if not isinstance(call_source, str) or not call_source.strip():
         raise ValueError(
-            f"Module for tool type '{tool_type}' does not expose that class"
+            "Runtime tool registration requires a non-empty '__call__' string"
         )
-    if not issubclass(tool_cls, ToolBase):
-        raise TypeError(f"Resolved class '{tool_type}' is not a ToolBase subtype")
 
-    return tool_cls.model_validate(tool_data)
+    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()

{swarmauri_toolkit_runtime-0.1.1.dev2.dist-info → swarmauri_toolkit_runtime-0.11.0.dev1.dist-info}/METADATA

@@ -1,31 +1,33 @@
 Metadata-Version: 2.4
 Name: swarmauri_toolkit_runtime
-Version: 0.1.1.dev2
+Version: 0.11.0.dev1
 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
 Keywords: swarmauri,sdk,standards,toolkit,runtime,agent-runtime,tool-management,tool-registration,tool-inspection,tool-replacement,tool-removal,tool-schema,explicit-parameters,runtime-governance,agent,crud,runtime-tools
 Author: Jacob Stewart
 Author-email: jacob@swarmauri.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.10,<3.15
 Classifier: Development Status :: 1 - Planning
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+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
 Description-Content-Type: text/markdown
 
-![Swarmauri Logo](https://github.com/swarmauri/swarmauri-sdk/blob/3d4d1cfa949399d7019ae9d8f296afba773dfb7f/assets/swarmauri.brand.theme.svg)
+![Swarmauri Logo](https://raw.githubusercontent.com/swarmauri/swarmauri-sdk/master/assets/swarmauri_sdk_brand.png)
 
 <p align="center">
     <a href="https://pepy.tech/project/swarmauri_toolkit_runtime/">
@@ -33,22 +35,24 @@ Description-Content-Type: text/markdown
     <a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/standards/swarmauri_toolkit_runtime/">
         <img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/standards/swarmauri_toolkit_runtime.svg"/></a>
     <a href="https://pypi.org/project/swarmauri_toolkit_runtime/">
-        <img src="https://img.shields.io/pypi/pyversions/swarmauri_toolkit_runtime" alt="PyPI - Python Version"/></a>
+        <img src="https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue" alt="PyPI - Python Version"/></a>
     <a href="https://pypi.org/project/swarmauri_toolkit_runtime/">
         <img src="https://img.shields.io/pypi/l/swarmauri_toolkit_runtime" alt="PyPI - License"/></a>
     <a href="https://pypi.org/project/swarmauri_toolkit_runtime/">
         <img src="https://img.shields.io/pypi/v/swarmauri_toolkit_runtime?label=swarmauri_toolkit_runtime&color=green" alt="PyPI - swarmauri_toolkit_runtime"/></a>
-</p>
+    <a href="https://discord.gg/N4UpBuQv8T">
+        <img src="https://img.shields.io/badge/Discord-Join%20Chat-5865F2?logo=discord&logoColor=white" alt="Discord"/></a></p>
 
 # Swarmauri Toolkit RuntimeToolkit
 
-`RuntimeToolkit` is a Swarmauri runtime-management toolkit for agents that need to register, inspect, list, replace, and remove tools during execution. It keeps tool mutation inside the active toolkit instance and requires explicit parameter declarations when a new runtime tool is introduced.
+`RuntimeToolkit` is a Swarmauri runtime-management toolkit for agents that need to register, inspect, list, replace, and remove tools during execution. It keeps tool mutation inside the active toolkit instance and requires both explicit parameter declarations and an explicit `__call__` implementation when a new runtime tool is introduced.
 
 ## Features
 
 - Bundles agent-callable CRUD operations for toolkit members.
-- Accepts serialized tool specs with `type` fields and materializes installed Swarmauri tools at runtime.
-- Enforces a non-empty declared `parameters` list for runtime tool registration and replacement.
+- Accepts serialized runtime tool specs with `type`, `parameters`, and `__call__` fields.
+- Enforces a non-empty declared `parameters` list and a non-empty `__call__` body for runtime tool registration and replacement.
+- Evaluates runtime `__call__` bodies through a restricted expression rail rather than unrestricted Python execution.
 - Returns agent-friendly dictionaries for reads, lists, and mutation results.
 - Protects the toolkit's own management tools from accidental overwrite or removal.
 - Supports Python 3.10 through 3.12.
@@ -78,7 +82,7 @@ pip install swarmauri_toolkit_runtime
 Use `RuntimeToolkit` when an agent needs to mutate its own tool surface safely at runtime. The expected workflow is:
 
 1. Start with the management toolkit.
-2. Register a runtime tool using an explicit parameter contract.
+2. Register a runtime tool using an explicit parameter contract and explicit callable body.
 3. Inspect or list the available runtime tools.
 4. Execute the registered tool.
 5. Replace or unregister the tool when the runtime surface changes.
@@ -92,7 +96,7 @@ toolkit = RuntimeToolkit()
 
 toolkit.get_tool_by_name("RegisterRuntimeTool")(
     {
-        "type": "AdditionTool",
+        "type": "RuntimeAdditionTool",
         "name": "RuntimeAdditionTool",
         "description": "Adds two integers during the active agent session.",
         "parameters": [
@@ -109,6 +113,7 @@ toolkit.get_tool_by_name("RegisterRuntimeTool")(
                 "required": True,
             },
         ],
+        "__call__": '{"sum": str(x + y)}',
     }
 )
 
@@ -128,14 +133,15 @@ print(result)
 
 Mutation tools accept a serialized tool specification. At minimum, provide:
 
-- a `type` field that resolves to an installed Swarmauri tool import such as `swarmauri.tools.AdditionTool`
+- a non-empty `type` field that names the runtime tool surface
 - a non-empty `parameters` list that explicitly declares the runtime callable contract
+- a non-empty `__call__` string that evaluates as a safe Python expression over the declared parameters and approved builtins
 
-Resolution prefers the `swarmauri` facade when present and falls back to `swarmauri_standard.tools.<ToolName>` for isolated package installs.
+The runtime evaluator permits only a constrained expression subset and approved builtins such as `str`, `int`, `float`, `len`, `sum`, `min`, `max`, and `abs`. Imports, attribute traversal, and arbitrary function calls are rejected.
 
 ```python
 {
-    "type": "AdditionTool",
+    "type": "RuntimeAdditionTool",
     "name": "RuntimeAdditionTool",
     "description": "Adds two integers.",
     "parameters": [
@@ -152,15 +158,19 @@ Resolution prefers the `swarmauri` facade when present and falls back to `swarma
             "required": True,
         },
     ],
+    "__call__": '{"sum": str(x + y)}',
 }
 ```
 
-If the target tool defines extra fields, include them in the spec and the toolkit will validate them against the concrete tool class.
+The `__call__` value is evaluated against the declared parameter names. A body such as `{"sum": str(x + y)}` is valid. A body that tries to import modules, access attributes, or reference undeclared names is rejected.
 
 ## Failure Modes
 
 - Registration fails when the tool spec omits `parameters`.
+- Registration fails when the tool spec omits `__call__`.
+- Registration fails when the `__call__` body uses unsafe syntax or disallowed names.
 - Registration fails when the tool name collides with a protected management tool.
+- Execution failures inside an accepted runtime tool return a structured error payload instead of propagating a hard exception or terminating the host process.
 - Replacement fails when the target tool is missing, reserved, or renamed to an existing tool.
 - Unregistration fails when the target is reserved or absent.
 
@@ -169,3 +179,5 @@ If the target tool defines extra fields, include them in the spec and the toolki
 `swarmauri_toolkit_runtime` is released under the Apache 2.0 License. See `LICENSE` for details.
 
 
+
+

swarmauri_toolkit_runtime-0.11.0.dev1.dist-info/RECORD

@@ -0,0 +1,14 @@
+swarmauri_toolkit_runtime/InspectRuntimeTool.py,sha256=fuSWqjXl0X83467ATB6jZ-3bAFMFTgvmI3pPQuWZsM0,1356
+swarmauri_toolkit_runtime/ListRuntimeTools.py,sha256=AF6Vx_aZRTAqzAFXXKvFBjVFp6ThuKq-wqn75yHBT14,1137
+swarmauri_toolkit_runtime/RegisterRuntimeTool.py,sha256=yLAjo2CI9vbX7yTv2bVor3pr-2ANtgmFqpSzti2Floc,2136
+swarmauri_toolkit_runtime/ReplaceRuntimeTool.py,sha256=9biwfk7dvROMLkcbONCY4wHLllDqs5YiXKPq6IqixkM,2959
+swarmauri_toolkit_runtime/RuntimeToolkit.py,sha256=ke-1h0OvmyXtVBoBh7TSBfpZihuUFc18vRohyOx301k,1638
+swarmauri_toolkit_runtime/UnregisterRuntimeTool.py,sha256=xNJDeSY_piz2hAySBxIYnVE2cpvNlKUj3vMQ9wpBqeM,1603
+swarmauri_toolkit_runtime/__init__.py,sha256=Ing0vOmvJXTiLCe8RMLXkOMN8-3DAt0NDDCnfumZoNA,471
+swarmauri_toolkit_runtime/_dynamic_runtime_tool.py,sha256=-UuXXRhDgZQgybapAJGI3NlLcdNcX03Kef64dz4dqyI,5370
+swarmauri_toolkit_runtime/_tool_factory.py,sha256=XNs-U84cOMgsUZogfjmWigXvQU_eEZInctrSmeh17oM,1776
+swarmauri_toolkit_runtime-0.11.0.dev1.dist-info/METADATA,sha256=Zu2Y8TWOojxX2TqL4b6KQCSmR2BFGvmcis9-wX9O-sY,7858
+swarmauri_toolkit_runtime-0.11.0.dev1.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+swarmauri_toolkit_runtime-0.11.0.dev1.dist-info/entry_points.txt,sha256=pB0M21BP9R-2_M52C_i5JBCsU1TLQD5m7P50IJs_lXA,421
+swarmauri_toolkit_runtime-0.11.0.dev1.dist-info/licenses/LICENSE,sha256=djUXOlCxLVszShEpZXshZ7v33G-2qIC_j9KXpWKZSzQ,11359
+swarmauri_toolkit_runtime-0.11.0.dev1.dist-info/RECORD,,

{swarmauri_toolkit_runtime-0.1.1.dev2.dist-info → swarmauri_toolkit_runtime-0.11.0.dev1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.3.2
+Generator: poetry-core 2.4.1
 Root-Is-Purelib: true
 Tag: py3-none-any

swarmauri_toolkit_runtime-0.1.1.dev2.dist-info/RECORD

@@ -1,13 +0,0 @@
-swarmauri_toolkit_runtime/InspectRuntimeTool.py,sha256=vy4XllPb46TfUxGJVN_ggYm-TEIHpTpI8BAiQJBrBF0,1341
-swarmauri_toolkit_runtime/ListRuntimeTools.py,sha256=D6tiHi8d1O95fd81fgVDyUdhNT4Tjqp4RWO3Na8b2Sk,1106
-swarmauri_toolkit_runtime/RegisterRuntimeTool.py,sha256=z3Uhr7iKCrCAAgdaolLlP0x-XUBMae36LptkFCzxF5M,1953
-swarmauri_toolkit_runtime/ReplaceRuntimeTool.py,sha256=5uZutD2jrIgVKHYWAlxQ5IEKZiW8XxL3vIlvQq2Jx0g,2708
-swarmauri_toolkit_runtime/RuntimeToolkit.py,sha256=q_SKZ6BADVPP6Zt5JdMmfqG8ac_xeDmek19pGRHgBgg,1683
-swarmauri_toolkit_runtime/UnregisterRuntimeTool.py,sha256=6dWC6CEgZ2eHSlgohgRB6c-mxPCoPBDs4TLT_kWYjps,1573
-swarmauri_toolkit_runtime/__init__.py,sha256=Ing0vOmvJXTiLCe8RMLXkOMN8-3DAt0NDDCnfumZoNA,471
-swarmauri_toolkit_runtime/_tool_factory.py,sha256=ZUCyxu9BXPtg8aVKRs66rQxpAJjokhCLp07qPSABXLs,1832
-swarmauri_toolkit_runtime-0.1.1.dev2.dist-info/METADATA,sha256=lWjpAsmmkhAs3_28jOJ_c5a6fPO68Rx7bZwgKvmETQg,6715
-swarmauri_toolkit_runtime-0.1.1.dev2.dist-info/WHEEL,sha256=Vz2fHgx6HFtSwhs8KvkHLqH5Ea4w1_rner5uNVGCeIE,88
-swarmauri_toolkit_runtime-0.1.1.dev2.dist-info/entry_points.txt,sha256=pB0M21BP9R-2_M52C_i5JBCsU1TLQD5m7P50IJs_lXA,421
-swarmauri_toolkit_runtime-0.1.1.dev2.dist-info/licenses/LICENSE,sha256=djUXOlCxLVszShEpZXshZ7v33G-2qIC_j9KXpWKZSzQ,11359
-swarmauri_toolkit_runtime-0.1.1.dev2.dist-info/RECORD,,