[Utilities] Model Schema Function Tools

[umar-anzar]

from pydantic import BaseModel
from typing import Optional, Literal, Union

# Define the base structure for properties
class ToolParameterProperty(BaseModel):
    type: Literal["boolean", "integer", "float", "string", "array", "object"]  # Specifies the allowed types
    description: str  # A description of the property
    enum: Optional[list[Union[str, int, float]]] = None  # Optional enumeration of allowed values for the property
    items: Optional["ToolParameterProperty"] = None  # Recursive definition for arrays, specifying the type of their items
    properties: Optional[dict[str, "ToolParameterProperty"]] = None  # For objects, defines nested properties
    required: Optional[list[str]] = None  # Specifies the list of required fields for objects
    additionalProperties: Optional[bool] = True  # Indicates whether additional fields are allowed

# Update forward references for nested properties
ToolParameterProperty.model_rebuild()  # Ensures recursive references like `items` and `properties` work correctly

# Define the structure for the tool's parameters
class ToolParameters(BaseModel):
    type: Literal["object"]  # The type is always "object" for parameters
    properties: dict[str, ToolParameterProperty]  # A dictionary where keys are property names and values are their definitions
    required: list[str]  # A list of required property keys
    additionalProperties: bool = False  # Specifies whether additional properties are allowed

# Define the overall structure for a tool
class Tool(BaseModel):
    type: Literal["function"]  # The type is always "function" for tools
    name: str  # The name of the tool
    description: str  # A description of what the tool does
    parameters: ToolParameters  # The parameters associated with the tool


TOOLS = [
    {
        "type": "function",
        "name": "<function_name>",
        "description": "<description>",
        "parameters": {
            "additionalProperties": False,
            "type": "object",
            "properties": {
                "<parameter_name>": {
                    "type": "<data-type>",
                    "description": "<description>"
                },
            },
            "required": [
                "<parameter_name>",
            ]
        }
    },

]

type LiteralType = "boolean" | "integer" | "float" | "string" | "array" | "object";

interface ToolParameterProperty {
    type: LiteralType; // Defines the type of the property
    description: string; // Description of the property
    enum?: Array<string | number>; // Optional enumeration of allowed values
    items?: ToolParameterProperty; // Recursive definition for nested arrays
    properties?: { [key: string]: ToolParameterProperty }; // Object properties definition for nested structures
    required?: string[]; // List of required fields
    additionalProperties?: boolean; // Allows additional properties
}

interface ToolParameters {
    type: "object"; // Always an object for tool parameters
    properties: { [key: string]: ToolParameterProperty }; // Defines the structure of the properties
    required: string[]; // List of required property keys
    additionalProperties: boolean; // Specifies whether additional properties are allowed
}

interface Tool {
    type: "function"; // Always a function
    name: string; // Name of the tool
    description: string; // Description of the tool
    parameters: ToolParameters; // Parameters for the tool
}

[covteamai]

Added Validator

from typing import Optional, Literal, Union
from pydantic import BaseModel, model_validator


# Define the base structure for properties
class ToolParameterProperty(BaseModel):
    type: Literal["boolean", "integer", "number", "string", "array", "object"]  # Specifies the allowed types
    description: str  # A description of the property
    enum: Optional[list[Union[str, int, float]]] = None  # Optional enumeration of allowed values for the property
    items: Optional["ToolParameterProperty"] = None  # Recursive definition for arrays, specifying the type of their items
    properties: Optional[dict[str, "ToolParameterProperty"]] = None  # For objects, defines nested properties
    required: Optional[list[str]] = None  # Specifies the list of required fields for objects
    additionalProperties: bool = False  # Indicates whether additional fields are allowed

    @model_validator(mode="after")
    def validate(self):
        if self.type == "object":
            if self.items is not None:
                raise ValueError("Property of type 'object' cannot define 'items'; use 'properties' instead.")
            if self.properties is None:
                raise ValueError("Property of type 'object' must define 'properties'.")
            if self.required:
                for key in self.required:
                    if key not in self.properties:
                        raise ValueError(f"Required property '{key}' is not defined in 'properties'.")
        elif self.type == "array":
            if self.properties is not None:
                raise ValueError("Property of type 'array' cannot define 'properties'; use 'items' instead.")
            if self.items is None:
                raise ValueError("Property of type 'array' must define 'items'.")
        else:
            if self.items is not None or self.properties is not None:
                raise ValueError(f"Property of type '{self.type}' cannot define 'items' or 'properties'.")
        return self



# Update forward references for nested properties
ToolParameterProperty.model_rebuild()  # Ensures recursive references like `items` and `properties` work correctly

# Define the structure for the tool's parameters
class ToolParameters(BaseModel):
    type: Literal["object"]  # The type is always "object" for parameters
    properties: dict[str, ToolParameterProperty]  # A dictionary where keys are property names and values are their definitions
    required: Optional[list[str]] = None  # A list of required property keys
    additionalProperties: bool = False  # Specifies whether additional properties are allowed

    @model_validator(mode="after")
    def validate(self):
        if self.required:
            for key in self.required:
                if key not in self.properties:
                    raise ValueError(f"Required property '{key}' is not defined in 'properties'.")
        return self



# Define the overall structure for a tool
class Tool(BaseModel):
    type: Literal["function"]  # The type is always "function" for tools
    name: str  # The name of the tool
    description: str  # A description of what the tool does
    parameters: Optional[ToolParameters] = None  # The parameters associated with the tool
    strict: Optional[bool] = None  # Tool-level strict validation


    @model_validator(mode="after")
    def validate(self):
        if self.strict:
            if self.parameters.additionalProperties in {True, None}:
                raise ValueError("When strict is true, 'additionalProperties' must be false.")
            if not self.parameters.required:
                raise ValueError("When strict is true, 'required' must include all defined properties.")
            for key in self.parameters.properties:
                if key not in self.parameters.required:
                    raise ValueError(f"When strict is true, all defined properties must be in 'required'. Missing: '{key}'.")
        return self

TOOLS = [
    {
        "type": "function",
        "name": "<function_name>",
        "description": "<description>",
        "strict": True,
        "parameters": {
            "additionalProperties": False,
            "type": "object",
            "properties": {
                "<parameter_name>": {
                    "type": "<data-type>",
                    "description": "<description>",
                },
            },
            "required": [
                "<parameter_name>",
            ]
        }
    },
]

tool = {
    "type": "function",
    "name": "<function_name>",
    "description": "<description>",
    "strict": True,
    "parameters": {
        "additionalProperties": False,
        "type": "object",
        "properties": {
            "<parameter_name>": {
                "type": "string",
                "description": "<description>"
            },
            "<parameter_name2>": {
                "type": "object",
                "description": "<description>",
                "properties": {
                    "<parameter_name3>": {
                        "type": "string",
                        "description": "<description>"
                    }
                },
                "required": [
                    "<parameter_name3>"
                ]
            }
        },
        "required": [
            "<parameter_name>", 
            "<parameter_name2>"
        ]
    }
}