gllm-inference-binary 0.5.53__cp313-cp313-win_amd64.whl → 0.5.55__cp313-cp313-win_amd64.whl

gllm_inference/constants.pyi

@@ -5,7 +5,6 @@ DOCUMENT_MIME_TYPES: Incomplete
 EMBEDDING_ENDPOINT: str
 GOOGLE_SCOPES: Incomplete
 GRPC_ENABLE_RETRIES_KEY: str
-HEX_REPR_LENGTH: int
 INVOKER_DEFAULT_TIMEOUT: float
 INVOKER_PROPAGATED_MAX_RETRIES: int
 JINA_DEFAULT_URL: str

gllm_inference/lm_invoker/anthropic_lm_invoker.pyi

@@ -49,84 +49,123 @@ class AnthropicLMInvoker(BaseLMInvoker):
         result = await lm_invoker.invoke([text, image])
         ```
 
-    Tool calling:
-        Tool calling is a feature that allows the language model to call tools to perform tasks.
-        Tools can be passed to the via the `tools` parameter as a list of `Tool` objects.
-        When tools are provided and the model decides to call a tool, the tool calls are stored in the
-        `tool_calls` attribute in the output.
+    Text output:
+        The `AnthropicLMInvoker` generates text outputs by default.
+        Text outputs are stored in the `outputs` attribute of the `LMOutput` object and can be accessed
+        via the `texts` (all text outputs) or `text` (first text output) properties.
+
+        Output example:
+        ```python
+        LMOutput(outputs=[LMOutputItem(type="text", output="Hello, there!")])
+        ```
+
+    Structured output:
+        The `AnthropicLMInvoker` can be configured to generate structured outputs.
+        This feature can be enabled by providing a schema to the `response_schema` parameter.
+
+        Structured outputs are stored in the `outputs` attribute of the `LMOutput` object and can be accessed
+        via the `structureds` (all structured outputs) or `structured` (first structured output) properties.
+
+        The schema must either be one of the following:
+        1. A Pydantic BaseModel class
+            The structured output will be a Pydantic model.
+        2. A JSON schema dictionary
+            JSON dictionary schema must be compatible with Pydantic\'s JSON schema, especially for complex schemas.
+            Thus, it is recommended to create the JSON schema using Pydantic\'s `model_json_schema` method.
+            The structured output will be a dictionary.
 
         Usage example:
         ```python
-        lm_invoker = AnthropicLMInvoker(..., tools=[tool_1, tool_2])
+        class Animal(BaseModel):
+            name: str
+            color: str
+
+        json_schema = Animal.model_json_schema()
+
+        lm_invoker = AnthropicLMInvoker(..., response_schema=Animal)  # Using Pydantic BaseModel class
+        lm_invoker = AnthropicLMInvoker(..., response_schema=json_schema)  # Using JSON schema dictionary
         ```
 
         Output example:
         ```python
-        LMOutput(
-            response="Let me call the tools...",
-            tool_calls=[
-                ToolCall(id="123", name="tool_1", args={"key": "value"}),
-                ToolCall(id="456", name="tool_2", args={"key": "value"}),
-            ]
-        )
-        ```
+        # Using Pydantic BaseModel class outputs a Pydantic model
+        LMOutput(outputs=[LMOutputItem(type="structured", output=Animal(name="dog", color="white"))])
 
-    Structured output:
-        Structured output is a feature that allows the language model to output a structured response.
-        This feature can be enabled by providing a schema to the `response_schema` parameter.
+        # Using JSON schema dictionary outputs a dictionary
+        LMOutput(outputs=[LMOutputItem(type="structured", output={"name": "dog", "color": "white"})])
+        ```
 
-        The schema must be either a JSON schema dictionary or a Pydantic BaseModel class.
-        If JSON schema is used, it must be compatible with Pydantic\'s JSON schema, especially for complex schemas.
-        For this reason, it is recommended to create the JSON schema using Pydantic\'s `model_json_schema` method.
+        Structured output is not compatible with tool calling or thinking.
+        When structured output is enabled, streaming is disabled.
 
-        Structured output is achieved by providing the schema name in the `tool_choice` parameter. This forces
-        the model to call the provided schema as a tool. Thus, structured output is not compatible with:
-        1. Tool calling, since the tool calling is reserved to force the model to call the provided schema as a tool.
-        2. Thinking, since thinking is not allowed when a tool use is forced through the `tool_choice` parameter.
-        The language model also doesn\'t need to stream anything when structured output is enabled. Thus, standard
-        invocation will be performed regardless of whether the `event_emitter` parameter is provided or not.
+    Tool calling:
+        The `AnthropicLMInvoker` can be configured to call tools to perform certain tasks.
+        This feature can be enabled by providing a list of `Tool` objects to the `tools` parameter.
 
-        When enabled, the structured output is stored in the `structured_output` attribute in the output.
-        1. If the schema is a JSON schema dictionary, the structured output is a dictionary.
-        2. If the schema is a Pydantic BaseModel class, the structured output is a Pydantic model.
+        Tool calls outputs are stored in the `outputs` attribute of the `LMOutput` object and
+        can be accessed via the `tool_calls` property.
 
-        # Example 1: Using a JSON schema dictionary
         Usage example:
         ```python
-        schema = {
-            "title": "Animal",
-            "description": "A description of an animal.",
-            "properties": {
-                "color": {"title": "Color", "type": "string"},
-                "name": {"title": "Name", "type": "string"},
-            },
-            "required": ["name", "color"],
-            "type": "object",
-        }
-        lm_invoker = AnthropicLMInvoker(..., response_schema=schema)
+        lm_invoker = AnthropicLMInvoker(..., tools=[tool_1, tool_2])
         ```
+
         Output example:
         ```python
-        LMOutput(structured_output={"name": "Golden retriever", "color": "Golden"})
+        LMOutput(
+            outputs=[
+                LMOutputItem(type="text", output="I\'m using tools..."),
+                LMOutputItem(type="tool_call", output=ToolCall(id="123", name="tool_1", args={"key": "value"})),
+                LMOutputItem(type="tool_call", output=ToolCall(id="456", name="tool_2", args={"key": "value"})),
+            ]
+        )
         ```
 
-        # Example 2: Using a Pydantic BaseModel class
+    Thinking:
+        The `AnthropicLMInvoker` can be configured to perform step-by-step thinking process before answering.
+        This feature can be enabled by setting the `thinking` parameter to `True`.
+
+        Thinking outputs are stored in the `outputs` attribute of the `LMOutput` object
+        and can be accessed via the `thinkings` property.
+
         Usage example:
         ```python
-        class Animal(BaseModel):
-            name: str
-            color: str
-
-        lm_invoker = AnthropicLMInvoker(..., response_schema=Animal)
+        lm_invoker = AnthropicLMInvoker(..., thinking=True, thinking_budget=1024)
         ```
+
         Output example:
         ```python
-        LMOutput(structured_output=Animal(name="Golden retriever", color="Golden"))
+        LMOutput(
+            outputs=[
+                LMOutputItem(type="thinking", output=Reasoning(type="thinking", reasoning="I\'m thinking...", ...)),
+                LMOutputItem(type="text", output="Golden retriever is a good dog breed."),
+            ]
+        )
+        ```
+
+        Streaming output example:
+        ```python
+        {"type": "thinking_start", "value": "", ...}
+        {"type": "thinking", "value": "I\'m ", ...}
+        {"type": "thinking", "value": "thinking...", ...}
+        {"type": "thinking_end", "value": "", ...}
+        {"type": "response", "value": "Golden retriever ", ...}
+        {"type": "response", "value": "is a good dog breed.", ...}
         ```
+        Note: By default, the thinking token will be streamed with the legacy `EventType.DATA` event type.
+        To use the new simplified streamed event format, set the `simplify_events` parameter to `True` during
+        LM invoker initialization. The legacy event format support will be removed in v0.6.
+
+        The amount of tokens allocated for the thinking process can be set via the `thinking_budget` parameter.
+        For more information, please refer to the following documentation:
+        https://docs.claude.com/en/docs/build-with-claude/extended-thinking#working-with-thinking-budgets.
+
+        Thinking is only available for certain models, starting from Claude Sonnet 3.7.
 
     Analytics tracking:
-        Analytics tracking is a feature that allows the module to output additional information about the invocation.
+        The `AnthropicLMInvoker` can be configured to output additional information about the invocation.
         This feature can be enabled by setting the `output_analytics` parameter to `True`.
+
         When enabled, the following attributes will be stored in the output:
         1. `token_usage`: The token usage.
         2. `duration`: The duration in seconds.
@@ -135,7 +174,7 @@ class AnthropicLMInvoker(BaseLMInvoker):
         Output example:
         ```python
         LMOutput(
-            response="Golden retriever is a good dog breed.",
+            outputs=[...],
             token_usage=TokenUsage(input_tokens=100, output_tokens=50),
             duration=0.729,
             finish_details={"stop_reason": "end_turn"},
@@ -150,8 +189,6 @@ class AnthropicLMInvoker(BaseLMInvoker):
         Retry config examples:
         ```python
         retry_config = RetryConfig(max_retries=0, timeout=None)  # No retry, no timeout
-        retry_config = RetryConfig(max_retries=0, timeout=10.0)  # No retry, 10.0 seconds timeout
-        retry_config = RetryConfig(max_retries=5, timeout=None)  # 5 max retries, no timeout
         retry_config = RetryConfig(max_retries=5, timeout=10.0)  # 5 max retries, 10.0 seconds timeout
         ```
 
@@ -160,47 +197,6 @@ class AnthropicLMInvoker(BaseLMInvoker):
         lm_invoker = AnthropicLMInvoker(..., retry_config=retry_config)
         ```
 
-    Thinking:
-        Thinking is a feature that allows the language model to have enhanced reasoning capabilities for complex tasks,
-        while also providing transparency into its step-by-step thought process before it delivers its final answer.
-        This feature is only available for certain models, starting from Claude 3.7 Sonnet.
-        It can be enabled by setting the `thinking` parameter to `True`.
-
-        When thinking is enabled, the amount of tokens allocated for the thinking process can be set via the
-        `thinking_budget` parameter. The `thinking_budget`:
-        1. Must be greater than or equal to 1024.
-        2. Must be less than the `max_tokens` hyperparameter, as the `thinking_budget` is allocated from the
-           `max_tokens`. For example, if `max_tokens=2048` and `thinking_budget=1024`, the language model will
-           allocate at most 1024 tokens for thinking and the remaining 1024 tokens for generating the response.
-
-        When enabled, the reasoning is stored in the `reasoning` attribute in the output.
-
-        Usage example:
-        ```python
-        lm_invoker = AnthropicLMInvoker(..., thinking=True, thinking_budget=1024)
-        ```
-
-        Output example:
-        ```python
-        LMOutput(
-            response="Golden retriever is a good dog breed.",
-            reasoning=[Reasoning(type="thinking", reasoning="Let me think about it...", signature="x")],
-        )
-        ```
-
-        Streaming output example:
-        ```python
-        {"type": "thinking_start", "value": "", ...}
-        {"type": "thinking", "value": "Let me think "\', ...}
-        {"type": "thinking", "value": "about it..."}\', ...}
-        {"type": "thinking_end", "value": ""}\', ...}
-        {"type": "response", "value": "Golden retriever ", ...}
-        {"type": "response", "value": "is a good dog breed.", ...}
-        ```
-        Note: By default, the thinking token will be streamed with the legacy `EventType.DATA` event type.
-        To use the new simplified streamed event format, set the `simplify_events` parameter to `True` during
-        LM invoker initialization. The legacy event format support will be removed in v0.6.
-
     Batch processing:
         The `AnthropicLMInvoker` supports batch processing, which allows the language model to process multiple
         requests in a single call. Batch processing is supported through the `batch` attribute.
@@ -214,7 +210,7 @@ class AnthropicLMInvoker(BaseLMInvoker):
         Output example:
         ```python
         {
-            "request_1": LMOutput(response="The sky is blue."),
+            "request_1": LMOutput(outputs=[LMOutputItem(type="text", output="The sky is blue.")]),
             "request_2": LMOutput(finish_details={"type": "error", "error": {"message": "...", ...}, ...}),
         }
         ```
@@ -240,7 +236,7 @@ class AnthropicLMInvoker(BaseLMInvoker):
             Output example:
             ```python
             {
-                "request_1": LMOutput(response="The sky is blue."),
+                "request_1": LMOutput(outputs=[LMOutputItem(type="text", output="The sky is blue.")]),
                 "request_2": LMOutput(finish_details={"type": "error", "error": {"message": "...", ...}, ...}),
             }
             ```
@@ -263,18 +259,6 @@ class AnthropicLMInvoker(BaseLMInvoker):
             ```python
             await lm_invoker.batch.cancel(batch_id)
             ```
-
-    Output types:
-        The output of the `AnthropicLMInvoker` can either be:
-        1. `str`: A text response.
-        2. `LMOutput`: A Pydantic model that may contain the following attributes:
-            2.1. response (str)
-            2.2. tool_calls (list[ToolCall])
-            2.3. structured_output (dict[str, Any] | BaseModel | None)
-            2.4. token_usage (TokenUsage | None)
-            2.5. duration (float | None)
-            2.6. finish_details (dict[str, Any])
-            2.7. reasoning (list[Reasoning])
     '''
     client: Incomplete
     thinking: Incomplete

gllm_inference/lm_invoker/azure_openai_lm_invoker.pyi

@@ -51,11 +51,60 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
         result = await lm_invoker.invoke([text, image])
         ```
 
+    Text output:
+        The `AzureOpenAILMInvoker` generates text outputs by default.
+        Text outputs are stored in the `outputs` attribute of the `LMOutput` object and can be accessed
+        via the `texts` (all text outputs) or `text` (first text output) properties.
+
+        Output example:
+        ```python
+        LMOutput(outputs=[LMOutputItem(type="text", output="Hello, there!")])
+        ```
+
+    Structured output:
+        The `AzureOpenAILMInvoker` can be configured to generate structured outputs.
+        This feature can be enabled by providing a schema to the `response_schema` parameter.
+
+        Structured outputs are stored in the `outputs` attribute of the `LMOutput` object and can be accessed
+        via the `structureds` (all structured outputs) or `structured` (first structured output) properties.
+
+        The schema must either be one of the following:
+        1. A Pydantic BaseModel class
+            The structured output will be a Pydantic model.
+        2. A JSON schema dictionary
+            JSON dictionary schema must be compatible with Pydantic\'s JSON schema, especially for complex schemas.
+            Thus, it is recommended to create the JSON schema using Pydantic\'s `model_json_schema` method.
+            The structured output will be a dictionary.
+
+        Usage example:
+        ```python
+        class Animal(BaseModel):
+            name: str
+            color: str
+
+        json_schema = Animal.model_json_schema()
+
+        lm_invoker = AzureOpenAILMInvoker(..., response_schema=Animal)  # Using Pydantic BaseModel class
+        lm_invoker = AzureOpenAILMInvoker(..., response_schema=json_schema)  # Using JSON schema dictionary
+        ```
+
+        Output example:
+        ```python
+        # Using Pydantic BaseModel class outputs a Pydantic model
+        LMOutput(outputs=[LMOutputItem(type="structured", output=Animal(name="dog", color="white"))])
+
+        # Using JSON schema dictionary outputs a dictionary
+        LMOutput(outputs=[LMOutputItem(type="structured", output={"name": "dog", "color": "white"})])
+        ```
+
+        When structured output is enabled, streaming is disabled.
+
     Tool calling:
-        Tool calling is a feature that allows the language model to call tools to perform tasks.
-        Tools can be passed to the via the `tools` parameter as a list of `Tool` objects.
-        When tools are provided and the model decides to call a tool, the tool calls are stored in the
-        `tool_calls` attribute in the output.
+        The `AzureOpenAILMInvoker` can be configured to call tools to perform certain tasks.
+        This feature can be enabled by providing a list of `Tool` objects to the `tools` parameter.
+
+        Tool calls outputs are stored in the `outputs` attribute of the `LMOutput` object and
+        can be accessed via the `tool_calls` property.
 
         Usage example:
         ```python
@@ -65,66 +114,62 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
         Output example:
         ```python
         LMOutput(
-            response="Let me call the tools...",
-            tool_calls=[
-                ToolCall(id="123", name="tool_1", args={"key": "value"}),
-                ToolCall(id="456", name="tool_2", args={"key": "value"}),
+            outputs=[
+                LMOutputItem(type="text", output="I\'m using tools..."),
+                LMOutputItem(type="tool_call", output=ToolCall(id="123", name="tool_1", args={"key": "value"})),
+                LMOutputItem(type="tool_call", output=ToolCall(id="456", name="tool_2", args={"key": "value"})),
             ]
         )
         ```
 
-    Structured output:
-        Structured output is a feature that allows the language model to output a structured response.
-        This feature can be enabled by providing a schema to the `response_schema` parameter.
+    Reasoning:
+        The `AzureOpenAILMInvoker` performs step-by-step reasoning before generating a response when reasoning
+        models are used, such as GPT-5 models and o-series models.
 
-        The schema must be either a JSON schema dictionary or a Pydantic BaseModel class.
-        If JSON schema is used, it must be compatible with Pydantic\'s JSON schema, especially for complex schemas.
-        For this reason, it is recommended to create the JSON schema using Pydantic\'s `model_json_schema` method.
+        The reasoning effort can be set via the `reasoning_effort` parameter, which guides the models on the amount
+        of reasoning tokens to generate. Available options include `minimal`, `low`, `medium`, and `high`.
 
-        The language model also doesn\'t need to stream anything when structured output is enabled. Thus, standard
-        invocation will be performed regardless of whether the `event_emitter` parameter is provided or not.
+        While the raw reasoning tokens are not available, the summary of the reasoning tokens can still be generated.
+        This can be done by passing the desired summary level via the `reasoning_summary` parameter.
+        Available options include `auto` and `detailed`.
 
-        When enabled, the structured output is stored in the `structured_output` attribute in the output.
-        1. If the schema is a JSON schema dictionary, the structured output is a dictionary.
-        2. If the schema is a Pydantic BaseModel class, the structured output is a Pydantic model.
+        Reasoning summaries are stored in the `outputs` attribute of the `LMOutput` object
+        and can be accessed via the `thinkings` property.
 
-        # Example 1: Using a JSON schema dictionary
         Usage example:
         ```python
-        schema = {
-            "title": "Animal",
-            "description": "A description of an animal.",
-            "properties": {
-                "color": {"title": "Color", "type": "string"},
-                "name": {"title": "Name", "type": "string"},
-            },
-            "required": ["name", "color"],
-            "type": "object",
-        }
-        lm_invoker = AzureOpenAILMInvoker(..., response_schema=schema)
+        lm_invoker = AzureOpenAILMInvoker(..., reasoning_effort="high", reasoning_summary="detailed")
         ```
+
         Output example:
         ```python
-        LMOutput(structured_output={"name": "Golden retriever", "color": "Golden"})
+        LMOutput(
+            outputs=[
+                LMOutputItem(type="thinking", output=Reasoning(type="thinking", reasoning="I\'m thinking...", ...)),
+                LMOutputItem(type="text", output="Golden retriever is a good dog breed."),
+            ]
+        )
         ```
 
-        # Example 2: Using a Pydantic BaseModel class
-        Usage example:
-        ```python
-        class Animal(BaseModel):
-            name: str
-            color: str
-
-        lm_invoker = AzureOpenAILMInvoker(..., response_schema=Animal)
-        ```
-        Output example:
+        Streaming output example:
         ```python
-        LMOutput(structured_output=Animal(name="Golden retriever", color="Golden"))
+        {"type": "thinking_start", "value": "", ...}
+        {"type": "thinking", "value": "I\'m ", ...}
+        {"type": "thinking", "value": "thinking...", ...}
+        {"type": "thinking_end", "value": "", ...}
+        {"type": "response", "value": "Golden retriever ", ...}
+        {"type": "response", "value": "is a good dog breed.", ...}
         ```
+        Note: By default, the thinking token will be streamed with the legacy `EventType.DATA` event type.
+        To use the new simplified streamed event format, set the `simplify_events` parameter to `True` during
+        LM invoker initialization. The legacy event format support will be removed in v0.6.
+
+        Reasoning summary is not compatible with tool calling.
 
     Analytics tracking:
-        Analytics tracking is a feature that allows the module to output additional information about the invocation.
+        The `AzureOpenAILMInvoker` can be configured to output additional information about the invocation.
         This feature can be enabled by setting the `output_analytics` parameter to `True`.
+
         When enabled, the following attributes will be stored in the output:
         1. `token_usage`: The token usage.
         2. `duration`: The duration in seconds.
@@ -133,15 +178,10 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
         Output example:
         ```python
         LMOutput(
-            response="Golden retriever is a good dog breed.",
-            token_usage=TokenUsage(
-                input_tokens=1500,
-                output_tokens=200,
-                input_token_details=InputTokenDetails(cached_tokens=1200, uncached_tokens=300),
-                output_token_details=OutputTokenDetails(reasoning_tokens=180, response_tokens=20),
-            ),
+            outputs=[...],
+            token_usage=TokenUsage(input_tokens=100, output_tokens=50),
             duration=0.729,
-            finish_details={"status": "completed", "incomplete_details": {"reason": None}},
+            finish_details={"stop_reason": "end_turn"},
         )
         ```
 
@@ -153,8 +193,6 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
         Retry config examples:
         ```python
         retry_config = RetryConfig(max_retries=0, timeout=None)  # No retry, no timeout
-        retry_config = RetryConfig(max_retries=0, timeout=10.0)  # No retry, 10.0 seconds timeout
-        retry_config = RetryConfig(max_retries=5, timeout=None)  # 5 max retries, no timeout
         retry_config = RetryConfig(max_retries=5, timeout=10.0)  # 5 max retries, 10.0 seconds timeout
         ```
 
@@ -162,61 +200,6 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
         ```python
         lm_invoker = AzureOpenAILMInvoker(..., retry_config=retry_config)
         ```
-
-    Reasoning:
-        Azure OpenAI\'s GPT-5 models and o-series models are classified as reasoning models. Reasoning models think
-        before they answer, producing a long internal chain of thought before responding to the user. Reasoning models
-        excel in complex problem solving, coding, scientific reasoning, and multi-step planning for agentic workflows.
-
-        The reasoning effort of reasoning models can be set via the `reasoning_effort` parameter. This parameter
-        will guide the models on how many reasoning tokens it should generate before creating a response.
-        Available options include:
-        1. "minimal": Favors the least amount of reasoning, only supported for GPT-5 models onwards.
-        2. "low": Favors speed and economical token usage.
-        3. "medium": Favors a balance between speed and reasoning accuracy.
-        4. "high": Favors more complete reasoning at the cost of more tokens generated and slower responses.
-
-        Azure OpenAI doesn\'t expose the raw reasoning tokens. However, the summary of the reasoning tokens can still be
-        generated. The summary level can be set via the `reasoning_summary` parameter. Available options include:
-        1. "auto": The model decides the summary level automatically.
-        2. "detailed": The model will generate a detailed summary of the reasoning tokens.
-        Reasoning summary is not compatible with tool calling.
-        When enabled, the reasoning summary will be stored in the `reasoning` attribute in the output.
-
-        Output example:
-        ```python
-        LMOutput(
-            response="Golden retriever is a good dog breed.",
-            reasoning=[Reasoning(id="x", reasoning="Let me think about it...")],
-        )
-        ```
-
-        Streaming output example:
-        ```python
-        {"type": "thinking_start", "value": ""}\', ...}
-        {"type": "thinking", "value": "Let me think "}\', ...}
-        {"type": "thinking", "value": "about it..."}\', ...}
-        {"type": "thinking_end", "value": ""}\', ...}
-        {"type": "response", "value": "Golden retriever ", ...}
-        {"type": "response", "value": "is a good dog breed.", ...}
-        ```
-        Note: By default, the thinking token will be streamed with the legacy `EventType.DATA` event type.
-        To use the new simplified streamed event format, set the `simplify_events` parameter to `True` during
-        LM invoker initialization. The legacy event format support will be removed in v0.6.
-
-        Setting reasoning-related parameters for non-reasoning models will raise an error.
-
-    Output types:
-        The output of the `AzureOpenAILMInvoker` can either be:
-        1. `str`: A text response.
-        2. `LMOutput`: A Pydantic model that may contain the following attributes:
-            2.1. response (str)
-            2.2. tool_calls (list[ToolCall])
-            2.3. structured_output (dict[str, Any] | BaseModel | None)
-            2.4. token_usage (TokenUsage | None)
-            2.5. duration (float | None)
-            2.6. finish_details (dict[str, Any] | None)
-            2.7. reasoning (list[Reasoning])
     '''
     client_kwargs: Incomplete
     def __init__(self, azure_endpoint: str, azure_deployment: str, api_key: str | None = None, api_version: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool | LangChainTool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, reasoning_effort: ReasoningEffort | None = None, reasoning_summary: ReasoningSummary | None = None, simplify_events: bool = False) -> None: