gllm-inference-binary 0.5.40__cp311-cp311-win_amd64.whl → 0.5.66__cp311-cp311-win_amd64.whl

gllm_inference/lm_invoker/anthropic_lm_invoker.pyi

@@ -1,12 +1,14 @@
 from _typeshed import Incomplete
+from anthropic.types import ContentBlockStopEvent as ContentBlockStopEvent, Message as Message, RawContentBlockDeltaEvent as RawContentBlockDeltaEvent, RawContentBlockStartEvent as RawContentBlockStartEvent
 from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.schema.tool import Tool as Tool
 from gllm_core.utils.retry import RetryConfig as RetryConfig
 from gllm_inference.constants import INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.anthropic import InputType as InputType, Key as Key, OutputType as OutputType
-from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, BatchStatus as BatchStatus, LMInput as LMInput, LMOutput as LMOutput, Message as Message, ModelId as ModelId, ModelProvider as ModelProvider, Reasoning as Reasoning, ResponseSchema as ResponseSchema, ThinkingEvent as ThinkingEvent, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, BatchStatus as BatchStatus, LMInput as LMInput, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, Reasoning as Reasoning, ResponseSchema as ResponseSchema, ThinkingEvent as ThinkingEvent, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
 from langchain_core.tools import Tool as LangChainTool
+from pydantic import BaseModel as BaseModel
 from typing import Any
 
 SUPPORTED_ATTACHMENTS: Incomplete
@@ -49,84 +51,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 +176,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 +191,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 +199,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 +212,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 +238,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 +261,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:

gllm_inference/lm_invoker/batch/batch_operations.pyi

@@ -104,11 +104,12 @@ class BatchOperations:
         Returns:
             BatchStatus: The status of the batch job.
         """
-    async def retrieve(self, batch_id: str) -> dict[str, LMOutput]:
+    async def retrieve(self, batch_id: str, **kwargs: Any) -> dict[str, LMOutput]:
         """Retrieves the results of a batch job.
 
         Args:
             batch_id (str): The ID of the batch job to get the results of.
+            **kwargs (Any): Additional keyword arguments.
 
         Returns:
             dict[str, LMOutput]: The results of the batch job.