retab 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

{uiform → retab}/resources/consensus/completions.py

@@ -1,32 +1,23 @@
-import json
-from pathlib import Path
-from typing import Any, AsyncGenerator, Generator
-
 from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-from openai.types.chat.parsed_chat_completion import ParsedChatCompletionMessage
 from openai.types.shared_params.response_format_json_schema import ResponseFormatJSONSchema
-#from openai.lib._parsing import ResponseFormatT
-from pydantic import BaseModel as ResponseFormatT
 
+# from openai.lib._parsing import ResponseFormatT
+from pydantic import BaseModel as ResponseFormatT
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ..._utils.ai_models import assert_valid_model_extraction
-from ..._utils.json_schema import load_json_schema, unflatten_dict
-from ..._utils.stream_context_managers import as_async_context_manager, as_context_manager
-from ...types.chat import ChatCompletionUiformMessage
+from ...types.chat import ChatCompletionRetabMessage
 from ...types.completions import UiChatCompletionsRequest
-from ...types.documents.extractions import UiParsedChatCompletion, UiParsedChatCompletionChunk, UiParsedChoice
-from ...types.standards import PreparedRequest
+from ...types.documents.extractions import UiParsedChatCompletion
 from ...types.schemas.object import Schema
-
+from ...types.standards import PreparedRequest
 
 
 class BaseCompletionsMixin:
-
     def prepare_parse(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str,
         temperature: float,
         reasoning_effort: ChatCompletionReasoningEffort,
@@ -40,9 +31,10 @@ class BaseCompletionsMixin:
 
         schema_obj = Schema(json_schema=json_schema)
 
-        data = {
-            "messages": messages,
-            "response_format": {
+        request = UiChatCompletionsRequest(
+            model=model,
+            messages=messages,
+            response_format={
                 "type": "json_schema",
                 "json_schema": {
                     "name": schema_obj.id,
@@ -50,23 +42,17 @@ class BaseCompletionsMixin:
                     "strict": True,
                 },
             },
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-
-        # Validate DocumentAPIRequest data (raises exception if invalid)
-        ui_chat_completions_request = UiChatCompletionsRequest.model_validate(data)
-
-        return PreparedRequest(method="POST", url="/v1/completions", data=ui_chat_completions_request.model_dump(), idempotency_key=idempotency_key)
-
+            temperature=temperature,
+            stream=stream,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
+        return PreparedRequest(method="POST", url="/v1/completions", data=request.model_dump(), idempotency_key=idempotency_key)
 
     def prepare_create(
         self,
         response_format: ResponseFormatJSONSchema,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str,
         temperature: float,
         reasoning_effort: ChatCompletionReasoningEffort,
@@ -74,16 +60,16 @@ class BaseCompletionsMixin:
         n_consensus: int,
         idempotency_key: str | None = None,
     ) -> PreparedRequest:
-        
         json_schema = response_format["json_schema"].get("schema")
 
         assert isinstance(json_schema, dict), f"json_schema must be a dictionary, got {type(json_schema)}"
 
         schema_obj = Schema(json_schema=json_schema)
 
-        data = {
-            "messages": messages,
-            "response_format": {
+        request = UiChatCompletionsRequest(
+            model=model,
+            messages=messages,
+            response_format={
                 "type": "json_schema",
                 "json_schema": {
                     "name": schema_obj.id,
@@ -91,17 +77,12 @@ class BaseCompletionsMixin:
                     "strict": True,
                 },
             },
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-
-        # Validate DocumentAPIRequest data (raises exception if invalid)
-        ui_chat_completions_request = UiChatCompletionsRequest.model_validate(data)
-
-        return PreparedRequest(method="POST", url="/v1/completions", data=ui_chat_completions_request.model_dump(), idempotency_key=idempotency_key)
+            temperature=temperature,
+            stream=stream,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
+        return PreparedRequest(method="POST", url="/v1/completions", data=request.model_dump(), idempotency_key=idempotency_key)
 
 
 class Completions(SyncAPIResource, BaseCompletionsMixin):
@@ -110,7 +91,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
     def create(
         self,
         response_format: ResponseFormatJSONSchema,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -119,7 +100,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
         stream: bool = False,
     ) -> UiParsedChatCompletion:
         """
-        Create a completion using the UiForm API.
+        Create a completion using the Retab API.
         """
 
         request = self.prepare_create(
@@ -137,11 +118,10 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
 
         return UiParsedChatCompletion.model_validate(response)
 
-
     def parse(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -149,7 +129,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
         idempotency_key: str | None = None,
     ) -> UiParsedChatCompletion:
         """
-        Parse messages using the UiForm API to extract structured data according to the provided JSON schema.
+        Parse messages using the Retab API to extract structured data according to the provided JSON schema.
 
         Args:
             response_format: JSON schema defining the expected data structure
@@ -158,7 +138,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
             temperature: Model temperature setting (0-1)
             reasoning_effort: The effort level for the model to reason about the input data
             idempotency_key: Idempotency key for request
-            store: Whether to store the data in the UiForm database
+            store: Whether to store the data in the Retab database
 
         Returns:
             UiParsedChatCompletion: Parsed response from the API
@@ -184,7 +164,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
     async def create(
         self,
         response_format: ResponseFormatJSONSchema,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -193,7 +173,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
         stream: bool = False,
     ) -> UiParsedChatCompletion:
         """
-        Create a completion using the UiForm API.
+        Create a completion using the Retab API.
         """
 
         request = self.prepare_create(
@@ -210,13 +190,10 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
         response = await self._client._prepared_request(request)
         return UiParsedChatCompletion.model_validate(response)
 
-
-
-
     async def parse(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -224,7 +201,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
         idempotency_key: str | None = None,
     ) -> UiParsedChatCompletion:
         """
-        Parse messages using the UiForm API asynchronously.
+        Parse messages using the Retab API asynchronously.
 
         Args:
             json_schema: JSON schema defining the expected data structure

{uiform → retab}/resources/consensus/completions_stream.py

@@ -1,32 +1,29 @@
 import json
-from pathlib import Path
-from typing import Any, AsyncGenerator, Generator
+from typing import AsyncGenerator, Generator
 
 from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
 from openai.types.chat.parsed_chat_completion import ParsedChatCompletionMessage
 from openai.types.shared_params.response_format_json_schema import ResponseFormatJSONSchema
-#from openai.lib._parsing import ResponseFormatT
-from pydantic import BaseModel as ResponseFormatT
 
+# from openai.lib._parsing import ResponseFormatT
+from pydantic import BaseModel as ResponseFormatT
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ..._utils.ai_models import assert_valid_model_extraction
-from ..._utils.json_schema import load_json_schema, unflatten_dict
+from ..._utils.json_schema import unflatten_dict
 from ..._utils.stream_context_managers import as_async_context_manager, as_context_manager
-from ...types.chat import ChatCompletionUiformMessage
+from ...types.chat import ChatCompletionRetabMessage
 from ...types.completions import UiChatCompletionsRequest
 from ...types.documents.extractions import UiParsedChatCompletion, UiParsedChatCompletionChunk, UiParsedChoice
-from ...types.standards import PreparedRequest
 from ...types.schemas.object import Schema
-
+from ...types.standards import PreparedRequest
 
 
 class BaseCompletionsMixin:
-
     def prepare_parse(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str,
         temperature: float,
         reasoning_effort: ChatCompletionReasoningEffort,
@@ -37,12 +34,11 @@ class BaseCompletionsMixin:
         assert_valid_model_extraction(model)
 
         json_schema = response_format.model_json_schema()
-
         schema_obj = Schema(json_schema=json_schema)
 
-        data = {
-            "messages": messages,
-            "response_format": {
+        request = UiChatCompletionsRequest(
+            messages=messages,
+            response_format={
                 "type": "json_schema",
                 "json_schema": {
                     "name": schema_obj.id,
@@ -50,23 +46,19 @@ class BaseCompletionsMixin:
                     "strict": True,
                 },
             },
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-
-        # Validate DocumentAPIRequest data (raises exception if invalid)
-        ui_chat_completions_request = UiChatCompletionsRequest.model_validate(data)
-
-        return PreparedRequest(method="POST", url="/v1/completions", data=ui_chat_completions_request.model_dump(), idempotency_key=idempotency_key)
+            model=model,
+            temperature=temperature,
+            stream=stream,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
 
+        return PreparedRequest(method="POST", url="/v1/completions", data=request.model_dump(), idempotency_key=idempotency_key)
 
     def prepare_create(
         self,
         response_format: ResponseFormatJSONSchema,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str,
         temperature: float,
         reasoning_effort: ChatCompletionReasoningEffort,
@@ -74,16 +66,17 @@ class BaseCompletionsMixin:
         n_consensus: int,
         idempotency_key: str | None = None,
     ) -> PreparedRequest:
-        
         json_schema = response_format["json_schema"].get("schema")
 
         assert isinstance(json_schema, dict), f"json_schema must be a dictionary, got {type(json_schema)}"
 
         schema_obj = Schema(json_schema=json_schema)
 
-        data = {
-            "messages": messages,
-            "response_format": {
+        # Validate DocumentAPIRequest data (raises exception if invalid)
+        request = UiChatCompletionsRequest(
+            model=model,
+            messages=messages,
+            response_format={
                 "type": "json_schema",
                 "json_schema": {
                     "name": schema_obj.id,
@@ -91,17 +84,13 @@ class BaseCompletionsMixin:
                     "strict": True,
                 },
             },
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-
-        # Validate DocumentAPIRequest data (raises exception if invalid)
-        ui_chat_completions_request = UiChatCompletionsRequest.model_validate(data)
+            temperature=temperature,
+            stream=stream,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
 
-        return PreparedRequest(method="POST", url="/v1/completions", data=ui_chat_completions_request.model_dump(), idempotency_key=idempotency_key)
+        return PreparedRequest(method="POST", url="/v1/completions", data=request.model_dump(), idempotency_key=idempotency_key)
 
 
 class Completions(SyncAPIResource, BaseCompletionsMixin):
@@ -111,7 +100,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
     def stream(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -119,7 +108,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
         idempotency_key: str | None = None,
     ) -> Generator[UiParsedChatCompletion, None, None]:
         """
-        Process messages using the UiForm API with streaming enabled.
+        Process messages using the Retab API with streaming enabled.
 
         Args:
             response_format: JSON schema defining the expected data structure
@@ -134,7 +123,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
 
         Usage:
         ```python
-        with uiform.completions.stream(json_schema, messages, model, temperature, reasoning_effort) as stream:
+        with retab.devpletions.stream(json_schema, messages, model, temperature, reasoning_effort) as stream:
             for response in stream:
                 print(response)
         ```
@@ -193,12 +182,11 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
 class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
     """Multi-provider Completions API wrapper for asynchronous usage."""
 
-   
     @as_async_context_manager
     async def stream(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -206,7 +194,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
         idempotency_key: str | None = None,
     ) -> AsyncGenerator[UiParsedChatCompletion, None]:
         """
-        Parse messages using the UiForm API asynchronously with streaming.
+        Parse messages using the Retab API asynchronously with streaming.
 
         Args:
             json_schema: JSON schema defining the expected data structure
@@ -222,7 +210,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
 
         Usage:
         ```python
-        async with uiform.completions.stream(json_schema, messages, model, temperature, reasoning_effort, n_consensus) as stream:
+        async with retab.devpletions.stream(json_schema, messages, model, temperature, reasoning_effort, n_consensus) as stream:
             async for response in stream:
                 print(response)
         ```

{uiform → retab}/resources/consensus/responses.py

@@ -1,33 +1,20 @@
-import json
-from pathlib import Path
-from typing import Any, AsyncGenerator, Generator, TypeVar, Generic, Optional, Union, List, Sequence, cast
+from typing import Optional, TypeVar, Union
 
-from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-from openai.types.chat.parsed_chat_completion import ParsedChatCompletionMessage
 from openai.types.responses.response import Response
-from openai.types.responses.response_input_param import ResponseInputParam, ResponseInputItemParam
-from openai.types.responses.response_output_item import ResponseOutputItem
-from openai.types.shared_params.response_format_json_schema import ResponseFormatJSONSchema
+from openai.types.responses.response_input_param import ResponseInputParam
+from openai.types.responses.response_text_config_param import ResponseTextConfigParam
+from openai.types.shared_params.reasoning import Reasoning
 from pydantic import BaseModel
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ..._utils.ai_models import assert_valid_model_extraction
-from ..._utils.json_schema import load_json_schema, unflatten_dict
-from ..._utils.responses import convert_to_openai_format, convert_from_openai_format, parse_openai_responses_response
-from ..._utils.stream_context_managers import as_async_context_manager, as_context_manager
-from ...types.chat import ChatCompletionUiformMessage
-from ...types.completions import UiChatResponseCreateRequest, UiChatCompletionsRequest
-from ...types.documents.extractions import UiParsedChatCompletion, UiParsedChatCompletionChunk, UiParsedChoice, UiResponse
-from ...types.standards import PreparedRequest
+from ...types.completions import UiChatResponseCreateRequest
+from ...types.documents.extractions import UiResponse
 from ...types.schemas.object import Schema
+from ...types.standards import PreparedRequest
 
-from typing import Optional, Union
-from openai.types.shared_params.reasoning import Reasoning
-from openai.types.responses.response_input_param import ResponseInputParam
-from openai.types.responses.response_text_config_param import ResponseTextConfigParam
-from openai.types.shared_params.response_format_json_schema import ResponseFormatJSONSchema
+T = TypeVar("T", bound=BaseModel)
 
-T = TypeVar('T', bound=BaseModel)
 
 class BaseResponsesMixin:
     def prepare_create(
@@ -55,35 +42,20 @@ class BaseResponsesMixin:
 
         if instructions is None:
             instructions = schema_obj.developer_system_prompt
-        
+
         # Create the request object based on the UiChatResponseCreateRequest model
-        data = UiChatResponseCreateRequest(
+        request = UiChatResponseCreateRequest(
             model=model,
             input=input,
             temperature=temperature,
             stream=False,
-            reasoning=reasoning, 
+            reasoning=reasoning,
             n_consensus=n_consensus,
-            text={
-                "format": {
-                    "type": "json_schema", 
-                    "name": schema_obj.id, 
-                    "schema": schema_obj.inference_json_schema, 
-                    "strict": True
-                }
-            },
+            text={"format": {"type": "json_schema", "name": schema_obj.id, "schema": schema_obj.inference_json_schema, "strict": True}},
             instructions=instructions,
         )
 
-        # Validate the request data
-        ui_chat_response_create_request = UiChatResponseCreateRequest.model_validate(data)
-
-        return PreparedRequest(
-            method="POST", 
-            url="/v1/responses", 
-            data=ui_chat_response_create_request.model_dump(), 
-            idempotency_key=idempotency_key
-        )
+        return PreparedRequest(method="POST", url="/v1/responses", data=request.model_dump(), idempotency_key=idempotency_key)
 
     def prepare_parse(
         self,
@@ -106,47 +78,29 @@ class BaseResponsesMixin:
 
         if instructions is None:
             instructions = schema_obj.developer_system_prompt
-        
+
         # Create the request object based on the UiChatResponseCreateRequest model
-        data = UiChatResponseCreateRequest(
+        request = UiChatResponseCreateRequest(
             model=model,
             input=input,
             temperature=temperature,
             stream=False,
-            reasoning=reasoning, 
+            reasoning=reasoning,
             n_consensus=n_consensus,
-            text={
-                "format": {
-                    "type": "json_schema", 
-                    "name": schema_obj.id, 
-                    "schema": schema_obj.inference_json_schema, 
-                    "strict": True
-                }
-            },
+            text={"format": {"type": "json_schema", "name": schema_obj.id, "schema": schema_obj.inference_json_schema, "strict": True}},
             instructions=instructions,
         )
 
-        # Validate the request data
-        ui_chat_response_create_request = UiChatResponseCreateRequest.model_validate(data)
-
-        return PreparedRequest(
-            method="POST", 
-            url="/v1/responses", 
-            data=ui_chat_response_create_request.model_dump(), 
-            idempotency_key=idempotency_key
-        )
-        
-
         return PreparedRequest(
-            method="POST", 
-            url="/v1/completions", 
-            data=ui_chat_completions_request.model_dump(), 
-            idempotency_key=idempotency_key
+            method="POST",
+            url="/v1/responses",
+            data=request.model_dump(),
+            idempotency_key=idempotency_key,
         )
 
 
 class Responses(SyncAPIResource, BaseResponsesMixin):
-    """UiForm Responses API compatible with OpenAI Responses API"""
+    """Retab Responses API compatible with OpenAI Responses API"""
 
     def create(
         self,
@@ -160,8 +114,8 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> Response:
         """
-        Create a completion using the UiForm API with OpenAI Responses API compatible interface.
-        
+        Create a completion using the Retab API with OpenAI Responses API compatible interface.
+
         Args:
             model: The model to use
             input: The input text or message array
@@ -187,9 +141,9 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
 
         result = self._client._prepared_request(request)
         response = UiResponse.model_validate(result)
-        
+
         return response
-            
+
     def parse(
         self,
         model: str,
@@ -202,8 +156,8 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> Response:
         """
-        Parse content using the UiForm API with OpenAI Responses API compatible interface.
-        
+        Parse content using the Retab API with OpenAI Responses API compatible interface.
+
         Args:
             model: The model to use
             input: The input text or message array
@@ -213,7 +167,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
             n_consensus: Number of consensus models to use
             instructions: Optional system instructions
             idempotency_key: Idempotency key for request
-            
+
         Returns:
             Response: OpenAI Responses API compatible response with parsed content
         """
@@ -230,12 +184,12 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
 
         result = self._client._prepared_request(request)
         response = UiResponse.model_validate(result)
-        
+
         return response
 
 
 class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
-    """UiForm Responses API compatible with OpenAI Responses API for async usage"""
+    """Retab Responses API compatible with OpenAI Responses API for async usage"""
 
     async def create(
         self,
@@ -249,8 +203,8 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> UiResponse:
         """
-        Create a completion using the UiForm API asynchronously with OpenAI Responses API compatible interface.
-        
+        Create a completion using the Retab API asynchronously with OpenAI Responses API compatible interface.
+
         Args:
             model: The model to use
             input: The input text or message array
@@ -260,7 +214,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
             n_consensus: Number of consensus models to use
             instructions: Optional system instructions
             idempotency_key: Idempotency key for request
-            
+
         Returns:
             Response: OpenAI Responses API compatible response
         """
@@ -278,9 +232,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
         result = await self._client._prepared_request(request)
         response = UiResponse.model_validate(result)
         return response
-        
 
-            
     async def parse(
         self,
         model: str,
@@ -293,8 +245,8 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> UiResponse:
         """
-        Parse content using the UiForm API asynchronously with OpenAI Responses API compatible interface.
-        
+        Parse content using the Retab API asynchronously with OpenAI Responses API compatible interface.
+
         Args:
             model: The model to use
             input: The input text or message array
@@ -304,7 +256,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
             n_consensus: Number of consensus models to use
             instructions: Optional system instructions
             idempotency_key: Idempotency key for request
-            
+
         Returns:
             Response: OpenAI Responses API compatible response with parsed content
         """
@@ -322,4 +274,3 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
         result = await self._client._prepared_request(request)
         response = UiResponse.model_validate(result)
         return response
-