orq-ai-sdk 4.2.0rc28__py3-none-any.whl → 4.2.6__py3-none-any.whl

orq_ai_sdk/models/updatetoolop.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 import httpx
 from orq_ai_sdk.models import OrqError
-from orq_ai_sdk.types import BaseModel
+from orq_ai_sdk.types import BaseModel, UNSET_SENTINEL
 from orq_ai_sdk.utils import (
     FieldMetadata,
     PathParamMetadata,
@@ -12,7 +12,7 @@ from orq_ai_sdk.utils import (
     get_discriminator,
 )
 import pydantic
-from pydantic import ConfigDict, Discriminator, Tag
+from pydantic import ConfigDict, Discriminator, Tag, model_serializer
 from typing import Any, Dict, List, Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
@@ -90,6 +90,22 @@ class UpdateToolRequestBodyCodeTool(BaseModel):
     parameters: Optional[UpdateToolRequestBodyToolsParameters] = None
     r"""The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["parameters"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateCodeExecutionToolTypedDict(TypedDict):
     r"""Updates an existing code execution tool configuration."""
@@ -140,6 +156,24 @@ class UpdateCodeExecutionTool(BaseModel):
 
     code_tool: Optional[UpdateToolRequestBodyCodeTool] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["path", "key", "display_name", "description", "status", "code_tool"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyToolsRequest4Status = Literal[
     "live",
@@ -163,6 +197,22 @@ class UpdateToolRequestBodyHeaders(BaseModel):
 
     encrypted: Optional[bool] = False
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["encrypted"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyToolsRequest4McpType = Literal["object",]
 
@@ -180,6 +230,22 @@ class UpdateToolRequestBodyToolsSchema(BaseModel):
 
     required: Optional[List[str]] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["properties", "required"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class RequestBodyToolsTypedDict(TypedDict):
     name: str
@@ -193,10 +259,26 @@ class RequestBodyTools(BaseModel):
 
     schema_: Annotated[UpdateToolRequestBodyToolsSchema, pydantic.Field(alias="schema")]
 
-    id: Optional[str] = "01KEXRJ83XG9Q69BQCH5GGK36C"
+    id: Optional[str] = "01KFTTTRDV9SJRNEYVHQ2V7GTG"
 
     description: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["id", "description"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyConnectionType = Literal[
     "http",
@@ -229,6 +311,22 @@ class UpdateToolRequestBodyMcp(BaseModel):
     connection_type: Optional[UpdateToolRequestBodyConnectionType] = None
     r"""The connection type used by the MCP server"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["server_url", "headers", "tools", "connection_type"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateMCPToolTypedDict(TypedDict):
     r"""Updates an existing MCP tool configuration."""
@@ -279,6 +377,24 @@ class UpdateMCPTool(BaseModel):
 
     mcp: Optional[UpdateToolRequestBodyMcp] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["path", "key", "display_name", "description", "status", "mcp"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyToolsRequestStatus = Literal[
     "live",
@@ -311,6 +427,22 @@ class UpdateToolHeaders2(BaseModel):
 
     encrypted: Optional[bool] = False
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["encrypted"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyToolsHeadersTypedDict = TypeAliasType(
     "UpdateToolRequestBodyToolsHeadersTypedDict",
@@ -351,6 +483,22 @@ class UpdateToolRequestBodyBlueprint(BaseModel):
     body: Optional[Dict[str, Any]] = None
     r"""The body to send with the request."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["headers", "body"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyToolsRequest3Type = Literal[
     "string",
@@ -396,6 +544,22 @@ class UpdateToolRequestBodyArguments(BaseModel):
     default_value: Optional[UpdateToolRequestBodyDefaultValue] = None
     r"""The default value of the argument."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["send_to_model", "default_value"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolRequestBodyHTTPTypedDict(TypedDict):
     blueprint: UpdateToolRequestBodyBlueprintTypedDict
@@ -411,6 +575,22 @@ class UpdateToolRequestBodyHTTP(BaseModel):
     arguments: Optional[Dict[str, UpdateToolRequestBodyArguments]] = None
     r"""The arguments to send with the request. The keys will be used to replace the placeholders in the `blueprint` field."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["arguments"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateHTTPToolTypedDict(TypedDict):
     r"""Updates an existing HTTP tool configuration."""
@@ -461,6 +641,24 @@ class UpdateHTTPTool(BaseModel):
 
     http: Optional[UpdateToolRequestBodyHTTP] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["path", "key", "display_name", "description", "status", "http"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyToolsStatus = Literal[
     "live",
@@ -535,6 +733,22 @@ class UpdateToolRequestBodyJSONSchema(BaseModel):
     strict: Optional[bool] = None
     r"""Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the `schema` field. Only a subset of JSON Schema is supported when `strict` is `true`. Only compatible with `OpenAI` models."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["strict"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateJSONSchemaToolTypedDict(TypedDict):
     r"""Updates an existing JSON Schema tool configuration."""
@@ -585,6 +799,24 @@ class UpdateJSONSchemaTool(BaseModel):
 
     json_schema: Optional[UpdateToolRequestBodyJSONSchema] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["path", "key", "display_name", "description", "status", "json_schema"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyStatus = Literal[
     "live",
@@ -663,6 +895,22 @@ class UpdateToolRequestBodyFunction(BaseModel):
     parameters: Optional[UpdateToolRequestBodyParameters] = None
     r"""The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "strict", "parameters"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateFunctionToolTypedDict(TypedDict):
     r"""Updates an existing function tool configuration."""
@@ -713,6 +961,24 @@ class UpdateFunctionTool(BaseModel):
 
     function: Optional[UpdateToolRequestBodyFunction] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["path", "key", "display_name", "description", "status", "function"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolRequestBodyTypedDict = TypeAliasType(
     "UpdateToolRequestBodyTypedDict",
@@ -757,6 +1023,22 @@ class UpdateToolRequest(BaseModel):
     ] = None
     r"""The tool to update"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["RequestBody"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolToolsResponseBodyData(BaseModel):
     error: str
@@ -853,6 +1135,22 @@ class UpdateToolResponseBodyCodeTool(BaseModel):
     parameters: Optional[UpdateToolResponseBodyToolsParameters] = None
     r"""The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["parameters"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolResponseBodyCodeExecutionToolTypedDict(TypedDict):
     r"""Executes code snippets in a sandboxed environment, currently supporting Python."""
@@ -916,7 +1214,7 @@ class UpdateToolResponseBodyCodeExecutionTool(BaseModel):
     code_tool: UpdateToolResponseBodyCodeTool
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KEXRJ83E15MNZEH36Y3EX9DR"
+        "tool_01KFTTTRDN3RSR1Q2T6RXFSPRH"
     )
 
     display_name: Optional[str] = None
@@ -935,6 +1233,31 @@ class UpdateToolResponseBodyCodeExecutionTool(BaseModel):
 
     version_hash: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "_id",
+                "display_name",
+                "created_by_id",
+                "updated_by_id",
+                "status",
+                "version_hash",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyToolsResponse200Status = Literal[
     "live",
@@ -958,6 +1281,22 @@ class UpdateToolResponseBodyHeaders(BaseModel):
 
     encrypted: Optional[bool] = False
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["encrypted"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyToolsResponse200ApplicationJSON4Type = Literal["object",]
 
@@ -975,6 +1314,22 @@ class UpdateToolResponseBodyToolsSchema(BaseModel):
 
     required: Optional[List[str]] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["properties", "required"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolResponseBodyToolsTypedDict(TypedDict):
     name: str
@@ -990,10 +1345,26 @@ class UpdateToolResponseBodyTools(BaseModel):
         UpdateToolResponseBodyToolsSchema, pydantic.Field(alias="schema")
     ]
 
-    id: Optional[str] = "01KEXRJ83CYXCJYZ8TJ1J9HFZ5"
+    id: Optional[str] = "01KFTTTRDM5N04EQ4NJZ2WDPDM"
 
     description: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["id", "description"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyConnectionType = Literal[
     "http",
@@ -1026,6 +1397,22 @@ class UpdateToolResponseBodyMcp(BaseModel):
     headers: Optional[Dict[str, UpdateToolResponseBodyHeaders]] = None
     r"""HTTP headers for MCP server requests with encryption support"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["headers"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolResponseBodyMCPToolTypedDict(TypedDict):
     r"""A tool from a Model Context Protocol (MCP) server that provides standardized access to external capabilities."""
@@ -1089,7 +1476,7 @@ class UpdateToolResponseBodyMCPTool(BaseModel):
     mcp: UpdateToolResponseBodyMcp
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KEXRJ83BVANM4AY058P120N0"
+        "tool_01KFTTTRDCVWJRQ2AQ9G5NYM9M"
     )
 
     display_name: Optional[str] = None
@@ -1106,6 +1493,31 @@ class UpdateToolResponseBodyMCPTool(BaseModel):
 
     version_hash: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "_id",
+                "display_name",
+                "created_by_id",
+                "updated_by_id",
+                "status",
+                "version_hash",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyToolsResponseStatus = Literal[
     "live",
@@ -1138,6 +1550,22 @@ class UpdateToolHeadersTools2(BaseModel):
 
     encrypted: Optional[bool] = False
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["encrypted"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyToolsHeadersTypedDict = TypeAliasType(
     "UpdateToolResponseBodyToolsHeadersTypedDict",
@@ -1178,6 +1606,22 @@ class UpdateToolResponseBodyBlueprint(BaseModel):
     body: Optional[Dict[str, Any]] = None
     r"""The body to send with the request."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["headers", "body"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyToolsResponse200ApplicationJSON3Type = Literal[
     "string",
@@ -1223,6 +1667,22 @@ class UpdateToolResponseBodyArguments(BaseModel):
     default_value: Optional[UpdateToolResponseBodyDefaultValue] = None
     r"""The default value of the argument."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["send_to_model", "default_value"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolResponseBodyHTTPTypedDict(TypedDict):
     blueprint: UpdateToolResponseBodyBlueprintTypedDict
@@ -1238,6 +1698,22 @@ class UpdateToolResponseBodyHTTP(BaseModel):
     arguments: Optional[Dict[str, UpdateToolResponseBodyArguments]] = None
     r"""The arguments to send with the request. The keys will be used to replace the placeholders in the `blueprint` field."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["arguments"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolResponseBodyHTTPToolTypedDict(TypedDict):
     r"""Executes HTTP requests to interact with external APIs and web services using customizable blueprints."""
@@ -1301,7 +1777,7 @@ class UpdateToolResponseBodyHTTPTool(BaseModel):
     http: UpdateToolResponseBodyHTTP
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KEXRJ838STY0FP67V9KPT6EW"
+        "tool_01KFTTTRDAB0NDF9NBND65DKAR"
     )
 
     display_name: Optional[str] = None
@@ -1318,6 +1794,31 @@ class UpdateToolResponseBodyHTTPTool(BaseModel):
 
     version_hash: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "_id",
+                "display_name",
+                "created_by_id",
+                "updated_by_id",
+                "status",
+                "version_hash",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyToolsStatus = Literal[
     "live",
@@ -1392,6 +1893,22 @@ class UpdateToolResponseBodyJSONSchema(BaseModel):
     strict: Optional[bool] = None
     r"""Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the `schema` field. Only a subset of JSON Schema is supported when `strict` is `true`. Only compatible with `OpenAI` models."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["strict"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolResponseBodyJSONSchemaToolTypedDict(TypedDict):
     r"""A tool that enforces structured output format using JSON Schema for consistent response formatting."""
@@ -1455,7 +1972,7 @@ class UpdateToolResponseBodyJSONSchemaTool(BaseModel):
     json_schema: UpdateToolResponseBodyJSONSchema
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KEXRJ836KE9DZCYTZZ06AF38"
+        "tool_01KFTTTRD9MXJG1S572RMKFT1K"
     )
 
     display_name: Optional[str] = None
@@ -1472,6 +1989,31 @@ class UpdateToolResponseBodyJSONSchemaTool(BaseModel):
 
     version_hash: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "_id",
+                "display_name",
+                "created_by_id",
+                "updated_by_id",
+                "status",
+                "version_hash",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyStatus = Literal[
     "live",
@@ -1550,6 +2092,22 @@ class UpdateToolResponseBodyFunction(BaseModel):
     parameters: Optional[UpdateToolResponseBodyParameters] = None
     r"""The parameters the functions accepts, described as a JSON Schema object. See the `OpenAI` [guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "strict", "parameters"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class UpdateToolResponseBodyFunctionToolTypedDict(TypedDict):
     r"""A custom function tool that allows the model to call predefined functions with structured parameters."""
@@ -1613,7 +2171,7 @@ class UpdateToolResponseBodyFunctionTool(BaseModel):
     function: UpdateToolResponseBodyFunction
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KEXRJ834N4QXQK4ECZQMVV2N"
+        "tool_01KFTTTRD888GYGB03M3MVC2JX"
     )
 
     display_name: Optional[str] = None
@@ -1630,6 +2188,31 @@ class UpdateToolResponseBodyFunctionTool(BaseModel):
 
     version_hash: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "_id",
+                "display_name",
+                "created_by_id",
+                "updated_by_id",
+                "status",
+                "version_hash",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 UpdateToolResponseBodyTypedDict = TypeAliasType(
     "UpdateToolResponseBodyTypedDict",