use and update schema

# Conflicts:
#	packages/toolbox-core/src/toolbox_core/tool.py

Author: twishabansal

packages/toolbox-core/src/toolbox_core/client.py

@@ -79,16 +79,13 @@ def __parse_tool(
         authn_params = identify_required_authn_params(
             authn_params, auth_token_getters.keys()
         )
+        schema.parameters = params
 
         tool = ToolboxTool(
             session=self.__session,
             base_url=self.__base_url,
             name=name,
-            desc=schema.description,
-            params=[p.to_param() for p in params],
-            params_metadata=types.MappingProxyType(
-                {p.name: (p.type, p.description) for p in schema.parameters}
-            ),
+            schema=schema,
             # create a read-only values for the maps to prevent mutation
             required_authn_params=types.MappingProxyType(authn_params),
             auth_service_token_getters=types.MappingProxyType(auth_token_getters),

packages/toolbox-core/src/toolbox_core/tool.py

@@ -14,18 +14,18 @@
 
 
 import asyncio
+import copy
 import types
-from inspect import Parameter, Signature
+from inspect import Signature
 from typing import (
     Any,
     Callable,
     Iterable,
     Mapping,
     Optional,
-    Sequence,
     Union,
 )
-
+from toolbox_core.protocol import ToolSchema
 from aiohttp import ClientSession
 
 
@@ -47,9 +47,7 @@ def __init__(
         session: ClientSession,
         base_url: str,
         name: str,
-        desc: str,
-        params: Sequence[Parameter],
-        params_metadata: Mapping[str, tuple[str, str]],
+        schema: ToolSchema,
         required_authn_params: Mapping[str, list[str]],
         auth_service_token_getters: Mapping[str, Callable[[], str]],
         bound_params: Mapping[str, Union[Callable[[], Any], Any]],
@@ -62,10 +60,7 @@ def __init__(
             session: The `aiohttp.ClientSession` used for making API requests.
             base_url: The base URL of the Toolbox server API.
             name: The name of the remote tool.
-            desc: The description of the remote tool (used as its docstring).
-            params: A list of `inspect.Parameter` objects defining the tool's
-                arguments and their types/defaults.
-            params_metadata: A mapping of param names to their types and descriptions.
+            schema: The schema of the tool.
             required_authn_params: A dict of required authenticated parameters to a list
                 of services that provide values for them.
             auth_service_token_getters: A dict of authService -> token (or callables that
@@ -80,15 +75,14 @@ def __init__(
         self.__base_url: str = base_url
         self.__url = f"{base_url}/api/tool/{name}/invoke"
 
-        self.__desc = desc
-        self.__params = params
-        self.__params_metadata = params_metadata
+        self.__params = [param.to_param() for param in schema.parameters]
+        self.__schema = schema
 
         # the following properties are set to help anyone that might inspect it determine usage
         self.__name__ = name
-        self.__doc__ = self._schema_to_docstring(desc, params, params_metadata)
-        self.__signature__ = Signature(parameters=params, return_annotation=str)
-        self.__annotations__ = {p.name: p.annotation for p in params}
+        self.__doc__ = self._schema_to_docstring(self.__schema)
+        self.__signature__ = Signature(parameters=self.__params, return_annotation=str)
+        self.__annotations__ = {p.name: p.annotation for p in self.__params}
         # TODO: self.__qualname__ ??
 
         # map of parameter name to auth service required by it
@@ -100,27 +94,23 @@ def __init__(
 
     @staticmethod
     def _schema_to_docstring(
-        tool_description: str,
-        params: Sequence[Parameter],
-        params_metadata: Mapping[str, tuple[str, str]],
+        schema: ToolSchema
     ) -> str:
-        """Creates a python function docstring from a tool and it's params."""
-        docstring = tool_description
-        if not params:
+        """Convert a tool schema into its function docstring"""
+        docstring = schema.description
+        if not schema.parameters:
             return docstring
         docstring += "\n\nArgs:"
-        for p in params:
-            param_metadata = params_metadata[p.name]
-            docstring += f"\n    {p.name} ({param_metadata[0]}): {param_metadata[1]}"
+        for p in schema.parameters:
+            docstring += f"\n    {p.name} ({p.type}): {p.description}"
         return docstring
 
     def __copy(
         self,
         session: Optional[ClientSession] = None,
         base_url: Optional[str] = None,
         name: Optional[str] = None,
-        desc: Optional[str] = None,
-        params: Optional[list[Parameter]] = None,
+        schema: ToolSchema = None,
         required_authn_params: Optional[Mapping[str, list[str]]] = None,
         auth_service_token_getters: Optional[Mapping[str, Callable[[], str]]] = None,
         bound_params: Optional[Mapping[str, Union[Callable[[], Any], Any]]] = None,
@@ -132,9 +122,7 @@ def __copy(
             session: The `aiohttp.ClientSession` used for making API requests.
             base_url: The base URL of the Toolbox server API.
             name: The name of the remote tool.
-            desc: The description of the remote tool (used as its docstring).
-            params: A list of `inspect.Parameter` objects defining the tool's
-                arguments and their types/defaults.
+            schema: The schema of the tool.
             required_authn_params: A dict of required authenticated parameters that need
                 a auth_service_token_getter set for them yet.
             auth_service_token_getters: A dict of authService -> token (or callables
@@ -148,9 +136,7 @@ def __copy(
             session=check(session, self.__session),
             base_url=check(base_url, self.__base_url),
             name=check(name, self.__name__),
-            desc=check(desc, self.__desc),
-            params=check(params, self.__params),
-            params_metadata=self.__params_metadata,
+            schema=check(schema, self.__schema),
             required_authn_params=check(
                 required_authn_params, self.__required_authn_params
             ),
@@ -251,7 +237,14 @@ def add_auth_token_getters(
             )
         )
 
+        # Update tool params in schema
+        new_schema = copy.deepcopy(self.__schema)
+        for param in new_schema.parameters:
+            if param.name in auth_token_getters.keys():
+                new_schema.parameters.remove(param)
+
         return self.__copy(
+            schema=new_schema,
             auth_service_token_getters=new_getters,
             required_authn_params=new_req_authn_params,
         )
@@ -269,19 +262,20 @@ def bind_parameters(
          Returns:
              A new ToolboxTool instance with the specified parameters bound.
         """
-        param_names = set(p.name for p in self.__params)
+        param_names = set(p.name for p in self.__schema.parameters)
         for name in bound_params.keys():
             if name not in param_names:
                 raise Exception(f"unable to bind parameters: no parameter named {name}")
 
-        new_params = []
-        for p in self.__params:
-            if p.name not in bound_params:
-                new_params.append(p)
+        # Update tool params in schema
+        new_schema = copy.deepcopy(self.__schema)
+        for param in new_schema.parameters:
+            if param.name in bound_params:
+                new_schema.parameters.remove(param)
 
         return self.__copy(
-            params=new_params,
-            bound_params=bound_params,
+            schema=new_schema,
+            bound_params=types.MappingProxyType(dict(self.__bound_parameters, **bound_params))
         )
 
 
@@ -309,4 +303,4 @@ def identify_required_authn_params(
         required = not any(s in services for s in auth_service_names)
         if required:
             required_params[param] = services
-    return required_params
+    return required_params