feat(toolbox-core): Add support for optional parameters

Author: anubhav756

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

@@ -25,31 +25,43 @@ class ParameterSchema(BaseModel):
 
     name: str
     type: str
+    required: bool = True
     description: str
     authSources: Optional[list[str]] = None
     items: Optional["ParameterSchema"] = None
 
     def __get_type(self) -> Type:
+        base_type: Type
         if self.type == "string":
-            return str
+            base_type = str
         elif self.type == "integer":
-            return int
+            base_type = int
         elif self.type == "float":
-            return float
+            base_type = float
         elif self.type == "boolean":
-            return bool
+            base_type = bool
         elif self.type == "array":
             if self.items is None:
                 raise Exception("Unexpected value: type is 'list' but items is None")
-            return list[self.items.__get_type()]  # type: ignore
+            base_type = list[self.items.__get_type()]
+        else:
+            raise ValueError(f"Unsupported schema type: {self.type}")
 
-        raise ValueError(f"Unsupported schema type: {self.type}")
+        if not self.required:
+            return Optional[base_type]
+
+        return base_type
 
     def to_param(self) -> Parameter:
+        default = Parameter.empty
+        if not self.required:
+            default = None
+            
         return Parameter(
             self.name,
             Parameter.POSITIONAL_OR_KEYWORD,
             annotation=self.__get_type(),
+            default=default,
         )
 
 

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

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import copy
-from inspect import Signature
+from inspect import Signature, Parameter
 from types import MappingProxyType
 from typing import Any, Awaitable, Callable, Mapping, Optional, Sequence, Union
 from warnings import warn
@@ -89,7 +89,11 @@ def __init__(
         self.__params = params
         self.__pydantic_model = params_to_pydantic_model(name, self.__params)
 
-        inspect_type_params = [param.to_param() for param in self.__params]
+        # Sort parameters to ensure required ones (required=True) come before
+        # optional ones (required=False). This prevents the "non-default argument
+        # follows default argument" error when creating the signature.
+        sorted_params = sorted(self.__params, key=lambda p: p.required, reverse=True)
+        inspect_type_params = [param.to_param() for param in sorted_params]
 
         # the following properties are set to help anyone that might inspect it determine usage
         self.__name__ = name
@@ -268,7 +272,9 @@ async def __call__(self, *args: Any, **kwargs: Any) -> str:
 
         # validate inputs to this call using the signature
         all_args = self.__signature__.bind(*args, **kwargs)
-        all_args.apply_defaults()  # Include default values if not provided
+
+        # The payload will only contain arguments explicitly provided by the user.
+        # Optional arguments not provided by the user will not be in the payload.
         payload = all_args.arguments
 
         # Perform argument type validations using pydantic

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

@@ -111,11 +111,20 @@ def params_to_pydantic_model(
     """Converts the given parameters to a Pydantic BaseModel class."""
     field_definitions = {}
     for field in params:
+
+        # Determine the default value based on the 'required' flag.
+        # '...' (Ellipsis) signifies a required field in Pydantic.
+        # 'None' makes the field optional with a default value of None.
+        default_value = ... if field.required else None
+
         field_definitions[field.name] = cast(
             Any,
             (
                 field.to_param().annotation,
-                Field(description=field.description),
+                Field(
+                    description=field.description,
+                    default=default_value,
+                ),
             ),
         )
     return create_model(tool_name, **field_definitions)