chore: regenerate SDK client core from Otari OpenAPI spec

Author: khaledosman

src/otari/_client/__init__.py

@@ -77,6 +77,7 @@
     "ChatCompletion",
     "ChatCompletionChunk",
     "ChatCompletionRequest",
+    "ChatCompletionRequestToolsInner",
     "ChatMessageInput",
     "Content",
     "Content1",
@@ -279,6 +280,7 @@
 from otari._client.models.chat_completion import ChatCompletion as ChatCompletion
 from otari._client.models.chat_completion_chunk import ChatCompletionChunk as ChatCompletionChunk
 from otari._client.models.chat_completion_request import ChatCompletionRequest as ChatCompletionRequest
+from otari._client.models.chat_completion_request_tools_inner import ChatCompletionRequestToolsInner as ChatCompletionRequestToolsInner
 from otari._client.models.chat_message_input import ChatMessageInput as ChatMessageInput
 from otari._client.models.content import Content as Content
 from otari._client.models.content1 import Content1 as Content1

src/otari/_client/api/messages_api.py

@@ -57,7 +57,7 @@ def count_message_tokens_v1_messages_count_tokens_post(
     ) -> CountTokensResponse:
         """Count Message Tokens
 
-        Anthropic ``/v1/messages/count_tokens``-compatible endpoint.  Returns ``{\"input_tokens\": N}`` without contacting an upstream provider: counting is local, so there is no budget reservation, pricing, or usage logging. Authentication mirrors :func:`create_message` — platform mode resolves the caller's token against the platform, standalone mode validates the API key — so the endpoint is not an open token-counting oracle.
+        Anthropic ``/v1/messages/count_tokens``-compatible endpoint.  Returns ``{\"input_tokens\": N}`` without contacting an upstream provider: counting is local, so there is no budget reservation, pricing, or usage logging. Authentication mirrors :func:`create_message` — hybrid mode resolves the caller's token against the platform, standalone mode validates the API key — so the endpoint is not an open token-counting oracle.
 
         :param count_tokens_request: (required)
         :type count_tokens_request: CountTokensRequest
@@ -125,7 +125,7 @@ def count_message_tokens_v1_messages_count_tokens_post_with_http_info(
     ) -> ApiResponse[CountTokensResponse]:
         """Count Message Tokens
 
-        Anthropic ``/v1/messages/count_tokens``-compatible endpoint.  Returns ``{\"input_tokens\": N}`` without contacting an upstream provider: counting is local, so there is no budget reservation, pricing, or usage logging. Authentication mirrors :func:`create_message` — platform mode resolves the caller's token against the platform, standalone mode validates the API key — so the endpoint is not an open token-counting oracle.
+        Anthropic ``/v1/messages/count_tokens``-compatible endpoint.  Returns ``{\"input_tokens\": N}`` without contacting an upstream provider: counting is local, so there is no budget reservation, pricing, or usage logging. Authentication mirrors :func:`create_message` — hybrid mode resolves the caller's token against the platform, standalone mode validates the API key — so the endpoint is not an open token-counting oracle.
 
         :param count_tokens_request: (required)
         :type count_tokens_request: CountTokensRequest
@@ -193,7 +193,7 @@ def count_message_tokens_v1_messages_count_tokens_post_without_preload_content(
     ) -> RESTResponseType:
         """Count Message Tokens
 
-        Anthropic ``/v1/messages/count_tokens``-compatible endpoint.  Returns ``{\"input_tokens\": N}`` without contacting an upstream provider: counting is local, so there is no budget reservation, pricing, or usage logging. Authentication mirrors :func:`create_message` — platform mode resolves the caller's token against the platform, standalone mode validates the API key — so the endpoint is not an open token-counting oracle.
+        Anthropic ``/v1/messages/count_tokens``-compatible endpoint.  Returns ``{\"input_tokens\": N}`` without contacting an upstream provider: counting is local, so there is no budget reservation, pricing, or usage logging. Authentication mirrors :func:`create_message` — hybrid mode resolves the caller's token against the platform, standalone mode validates the API key — so the endpoint is not an open token-counting oracle.
 
         :param count_tokens_request: (required)
         :type count_tokens_request: CountTokensRequest
@@ -333,7 +333,7 @@ def create_message_v1_messages_post(
     ) -> MessageResponse:
         """Create Message
 
-        Anthropic Messages API-compatible endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and platform mode. Platform-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
+        Anthropic Messages API-compatible endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and hybrid mode. Hybrid-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
 
         :param messages_request: (required)
         :type messages_request: MessagesRequest
@@ -401,7 +401,7 @@ def create_message_v1_messages_post_with_http_info(
     ) -> ApiResponse[MessageResponse]:
         """Create Message
 
-        Anthropic Messages API-compatible endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and platform mode. Platform-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
+        Anthropic Messages API-compatible endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and hybrid mode. Hybrid-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
 
         :param messages_request: (required)
         :type messages_request: MessagesRequest
@@ -469,7 +469,7 @@ def create_message_v1_messages_post_without_preload_content(
     ) -> RESTResponseType:
         """Create Message
 
-        Anthropic Messages API-compatible endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and platform mode. Platform-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
+        Anthropic Messages API-compatible endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and hybrid mode. Hybrid-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
 
         :param messages_request: (required)
         :type messages_request: MessagesRequest

src/otari/_client/api/responses_api.py

@@ -55,7 +55,7 @@ def create_response_v1_responses_post(
     ) -> object:
         """Create Response
 
-        OpenAI-compatible Responses endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and platform mode. Platform-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
+        OpenAI-compatible Responses endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and hybrid mode. Hybrid-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
 
         :param responses_request: (required)
         :type responses_request: ResponsesRequest
@@ -123,7 +123,7 @@ def create_response_v1_responses_post_with_http_info(
     ) -> ApiResponse[object]:
         """Create Response
 
-        OpenAI-compatible Responses endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and platform mode. Platform-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
+        OpenAI-compatible Responses endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and hybrid mode. Hybrid-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
 
         :param responses_request: (required)
         :type responses_request: ResponsesRequest
@@ -191,7 +191,7 @@ def create_response_v1_responses_post_without_preload_content(
     ) -> RESTResponseType:
         """Create Response
 
-        OpenAI-compatible Responses endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and platform mode. Platform-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
+        OpenAI-compatible Responses endpoint.  Supports MCP tool-use loops, sandboxed code execution, and SearXNG web_search in both standalone mode and hybrid mode. Hybrid-mode requests resolve credentials via the platform service and (for non-tool-loop requests) get multi-attempt fallback across the resolved route. Tool-loop requests collapse to a single attempt — once ``on_first_response`` lock-in plumbing lands across the codebase, a follow-up will enable pre-lock-in fallback for tool-loop requests too.
 
         :param responses_request: (required)
         :type responses_request: ResponsesRequest

src/otari/_client/models/__init__.py

@@ -46,6 +46,7 @@
 from otari._client.models.chat_completion import ChatCompletion
 from otari._client.models.chat_completion_chunk import ChatCompletionChunk
 from otari._client.models.chat_completion_request import ChatCompletionRequest
+from otari._client.models.chat_completion_request_tools_inner import ChatCompletionRequestToolsInner
 from otari._client.models.chat_message_input import ChatMessageInput
 from otari._client.models.content import Content
 from otari._client.models.content1 import Content1

src/otari/_client/models/chat_completion_request.py

@@ -21,6 +21,7 @@
 from typing import Any, ClassVar, Dict, List, Optional, Union
 from typing_extensions import Annotated
 from uuid import UUID
+from otari._client.models.chat_completion_request_tools_inner import ChatCompletionRequestToolsInner
 from otari._client.models.chat_message_input import ChatMessageInput
 from otari._client.models.guardrail_config import GuardrailConfig
 from otari._client.models.mcp_server_config import McpServerConfig
@@ -51,17 +52,18 @@ class ChatCompletionRequest(BaseModel):
     reasoning_effort: Optional[StrictStr] = None
     response_format: Optional[Dict[str, Any]] = None
     seed: Optional[StrictInt] = None
+    session_label: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="Optional caller-supplied label for cost attribution (per run, experiment, or conversation). In hybrid mode it is forwarded onto the platform usage report so spend can be sliced by session without standing up OpenTelemetry. Stripped before the request is forwarded upstream to the provider. Has no effect in standalone mode, where there is no platform to report it to.")
     stop: Optional[Stop] = None
     stream: Optional[StrictBool] = False
     stream_options: Optional[Dict[str, Any]] = None
     temperature: Optional[Union[StrictFloat, StrictInt]] = None
     tool_choice: Optional[ToolChoice] = None
-    tools: Optional[List[Optional[Dict[str, Any]]]] = None
+    tools: Optional[List[ChatCompletionRequestToolsInner]] = None
     tools_header: Optional[Annotated[str, Field(strict=True, max_length=4000)]] = Field(default=None, description="Optional override for the lead-in that the gateway prepends before the per-tool hint block in the system message. Useful for expressing global tool-selection policy (e.g. 'prefer MCP tools over code_execution'). Falls back to OTARI_TOOLS_HEADER env, then to the built-in default.")
     top_logprobs: Optional[StrictInt] = None
     top_p: Optional[Union[StrictFloat, StrictInt]] = None
     user: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["frequency_penalty", "guardrails", "logit_bias", "logprobs", "max_completion_tokens", "max_tokens", "max_tool_iterations", "mcp_server_ids", "mcp_servers", "messages", "model", "n", "parallel_tool_calls", "presence_penalty", "reasoning_effort", "response_format", "seed", "stop", "stream", "stream_options", "temperature", "tool_choice", "tools", "tools_header", "top_logprobs", "top_p", "user"]
+    __properties: ClassVar[List[str]] = ["frequency_penalty", "guardrails", "logit_bias", "logprobs", "max_completion_tokens", "max_tokens", "max_tool_iterations", "mcp_server_ids", "mcp_servers", "messages", "model", "n", "parallel_tool_calls", "presence_penalty", "reasoning_effort", "response_format", "seed", "session_label", "stop", "stream", "stream_options", "temperature", "tool_choice", "tools", "tools_header", "top_logprobs", "top_p", "user"]
 
     @field_validator('reasoning_effort')
     def reasoning_effort_validate_enum(cls, value):
@@ -139,6 +141,13 @@ def to_dict(self) -> Dict[str, Any]:
         # override the default output from pydantic by calling `to_dict()` of tool_choice
         if self.tool_choice:
             _dict['tool_choice'] = self.tool_choice.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in tools (list)
+        _items = []
+        if self.tools:
+            for _item_tools in self.tools:
+                if _item_tools:
+                    _items.append(_item_tools.to_dict())
+            _dict['tools'] = _items
         # set to None if frequency_penalty (nullable) is None
         # and model_fields_set contains the field
         if self.frequency_penalty is None and "frequency_penalty" in self.model_fields_set:
@@ -214,6 +223,11 @@ def to_dict(self) -> Dict[str, Any]:
         if self.seed is None and "seed" in self.model_fields_set:
             _dict['seed'] = None
 
+        # set to None if session_label (nullable) is None
+        # and model_fields_set contains the field
+        if self.session_label is None and "session_label" in self.model_fields_set:
+            _dict['session_label'] = None
+
         # set to None if stop (nullable) is None
         # and model_fields_set contains the field
         if self.stop is None and "stop" in self.model_fields_set:
@@ -288,12 +302,13 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
             "reasoning_effort": obj.get("reasoning_effort"),
             "response_format": obj.get("response_format"),
             "seed": obj.get("seed"),
+            "session_label": obj.get("session_label"),
             "stop": Stop.from_dict(obj["stop"]) if obj.get("stop") is not None else None,
             "stream": obj.get("stream") if obj.get("stream") is not None else False,
             "stream_options": obj.get("stream_options"),
             "temperature": obj.get("temperature"),
             "tool_choice": ToolChoice.from_dict(obj["tool_choice"]) if obj.get("tool_choice") is not None else None,
-            "tools": obj.get("tools"),
+            "tools": [ChatCompletionRequestToolsInner.from_dict(_item) for _item in obj["tools"]] if obj.get("tools") is not None else None,
             "tools_header": obj.get("tools_header"),
             "top_logprobs": obj.get("top_logprobs"),
             "top_p": obj.get("top_p"),