gllm-inference-binary 0.5.52__cp311-cp311-win_amd64.whl → 0.5.54__cp311-cp311-win_amd64.whl

gllm_inference/lm_invoker/portkey_lm_invoker.pyi

@@ -102,49 +102,138 @@ class PortkeyLMInvoker(OpenAIChatCompletionsLMInvoker):
         result = await lm_invoker.invoke([text, image])
         ```
 
+    Text output:
+        The `PortkeyLMInvoker` 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 `PortkeyLMInvoker` 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 = PortkeyLMInvoker(..., response_schema=Animal)  # Using Pydantic BaseModel class
+        lm_invoker = PortkeyLMInvoker(..., 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:
-        Tools can be provided via the `tools` parameter to enable tool invocation.
+        The `PortkeyLMInvoker` 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
         lm_invoker = PortkeyLMInvoker(..., tools=[tool_1, tool_2])
         ```
+
         Output example:
         ```python
         LMOutput(
-            response="Let me call the tools...",
-            tool_calls=[
-                ToolCall(id="123", name="tool_1", 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:
-        The `response_schema` parameter enables structured responses (Pydantic BaseModel or JSON schema).
+    Thinking:
+        The `PortkeyLMInvoker` 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 = PortkeyLMInvoker(..., response_schema=Animal)
+        lm_invoker = PortkeyLMInvoker(..., 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://portkey.ai/docs/product/ai-gateway/multimodal-capabilities/thinking-mode.
+
+        Thinking is only available for certain models depending on capabilities
+
     Analytics tracking:
-        When `output_analytics=True`, the invoker includes token usage, duration, and finish details.
+        The `PortkeyLMInvoker` 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.
+        3. `finish_details`: The details about how the generation finished.
 
+        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={"finish_reason": "stop"},
+            finish_details={"stop_reason": "end_turn"},
         )
         ```
 
-        **Note:** When streaming is enabled, token usage analytics are not supported and will be `None`.
+        When streaming is enabled, token usage is not supported.
 
     Retry and timeout:
         The `PortkeyLMInvoker` supports retry and timeout configuration.
@@ -154,8 +243,6 @@ class PortkeyLMInvoker(OpenAIChatCompletionsLMInvoker):
         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
         ```
 
@@ -163,57 +250,6 @@ class PortkeyLMInvoker(OpenAIChatCompletionsLMInvoker):
         ```python
         lm_invoker = PortkeyLMInvoker(..., retry_config=retry_config)
         ```
-
-    Thinking:
-        The `thinking` parameter enables enhanced reasoning capability for supported models.
-        Thinking mode allocates additional “reasoning tokens” up to `thinking_budget` (minimum 1024).
-        When enabled, the model’s reasoning trace is stored in the `reasoning` attribute.
-
-        ```python
-        lm_invoker = PortkeyLMInvoker(..., thinking=True, thinking_budget=1024)
-        ```
-        Output example:
-        ```python
-        LMOutput(
-            response="Golden retriever is a good dog breed.",
-            reasoning=[Reasoning(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.
-
-        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 a positive integer.
-        2. Must be at least 1024.
-        3. Must be less than or equal to the model\'s maximum context length.
-        For more information, please refer to https://portkey.ai/docs/product/ai-gateway/multimodal-capabilities/thinking-mode
-
-        Setting reasoning-related parameters for non-reasoning models will raise an error.
-
-    Output types:
-        The output of the `PortkeyLMInvoker` can either be:
-        1. `str`: A simple text response.
-        2. `LMOutput`: A structured response model that may contain:
-            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])
     '''
     model_kwargs: Incomplete
     thinking: Incomplete

gllm_inference/lm_invoker/xai_lm_invoker.pyi

@@ -50,115 +50,108 @@ class XAILMInvoker(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.
-
-        Usage example:
-        ```python
-        lm_invoker = XAILMInvoker(..., tools=[tool_1, tool_2])
-        ```
+    Text output:
+        The `XAILMInvoker` 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(
-            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"}),
-            ]
-        )
+        LMOutput(outputs=[LMOutputItem(type="text", output="Hello, there!")])
         ```
 
     Structured output:
-        Structured output is a feature that allows the language model to output a structured response.
+        The `XAILMInvoker` can be configured to generate structured outputs.
         This feature can be enabled by providing a schema to the `response_schema` parameter.
 
-        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 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 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.
+        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.
 
-        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.
-
-        # 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 = XAILMInvoker(..., response_schema=schema)
+        class Animal(BaseModel):
+            name: str
+            color: str
+
+        json_schema = Animal.model_json_schema()
+
+        lm_invoker = XAILMInvoker(..., response_schema=Animal)  # Using Pydantic BaseModel class
+        lm_invoker = XAILMInvoker(..., response_schema=json_schema)  # Using JSON schema dictionary
         ```
+
         Output example:
         ```python
-        LMOutput(structured_output={"name": "Golden retriever", "color": "Golden"})
+        # 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"})])
         ```
 
-        # Example 2: Using a Pydantic BaseModel class
+        When structured output is enabled, streaming is disabled.
+
+    Tool calling:
+        The `XAILMInvoker` 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
-        class Animal(BaseModel):
-            name: str
-            color: str
-
-        lm_invoker = XAILMInvoker(..., response_schema=Animal)
+        lm_invoker = XAILMInvoker(..., tools=[tool_1, tool_2])
         ```
+
         Output example:
         ```python
-        LMOutput(structured_output=Animal(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"})),
+            ]
+        )
         ```
 
     Reasoning:
-        Reasoning effort is a feature specific to xAI\'s reasoning models that allows you to control the level
-        of reasoning performed by the model. This feature can be enabled by setting the `reasoning_effort` parameter.
-        Valid values are "low" and "high".
+        The `XAILMInvoker` performs step-by-step reasoning before generating a response when reasoning
+        models are used, such as `grok-3-mini`.
+
+        For some models, 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 `low` and `high`.
 
-        Please note that Grok 4 does not have a `reasoning_effort` parameter. If a `reasoning_effort` is provided,
-        the request will return error.
+        Some models may also output the reasoning tokens. In this case, the reasoning tokens are stored in
+        the `outputs` attribute of the `LMOutput` object and can be accessed via the `thinkings` property.
 
         Usage example:
         ```python
-        lm_invoker = XAILMInvoker(
-            model_name="grok-3",
-            reasoning_effort="high"  # Enable high reasoning effort
-        )
+        lm_invoker = XAILMInvoker(model_name="grok-3-mini", reasoning_effort="low")
         ```
 
-        When reasoning effort is enabled, the model\'s internal reasoning process is captured and stored in the
-        `reasoning` attribute in the output.
-
         Output example:
         ```python
         LMOutput(
-            response="The answer is 42",
-            reasoning=[
-                Reasoning(
-                    id="reasoning_1",
-                    reasoning="First, I need to understand the question. The user is asking about..."
-                )
+            outputs=[
+                LMOutputItem(type="thinking", output=Reasoning(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": "Let me think "}\', ...}
-        {"type": "thinking", "value": "about it..."}\', ...}
-        {"type": "thinking_end", "value": ""}\', ...}
+         ```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.", ...}
         ```
@@ -166,26 +159,48 @@ class XAILMInvoker(BaseLMInvoker):
         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.
+    Web Search:
+        The `XAILMInvoker` can be configured to search the web for relevant information.
+        This feature can be enabled by setting the `web_search` parameter to `True`.
+
+        Web search citations are stored in the `outputs` attribute of the `LMOutput` object and
+        can be accessed via the `citations` property.
+
+        Usage example:
+        ```python
+        lm_invoker = XAILMInvoker(..., web_search=True)
+        ```
+
+        Output example:
+        ```python
+        LMOutput(
+            outputs=[
+                LMOutputItem(type="citation", output=Chunk(id="123", content="...", metadata={...}, score=None)),
+                LMOutputItem(type="text", output="According to recent reports... ([Source](https://example.com))."),
+            ],
+        )
+        ```
 
     Analytics tracking:
-        Analytics tracking is a feature that allows the module to output additional information about the invocation.
+        The `XAILMInvoker` 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. `finish_details`: The details about how the generation finished.
+        2. `duration`: The duration in seconds.
+        3. `finish_details`: The details about how the generation finished.
 
         Output example:
         ```python
         LMOutput(
-            response="Golden retriever is a good dog breed.",
+            outputs=[...],
             token_usage=TokenUsage(input_tokens=100, output_tokens=50),
-            finish_details={"finish_reason": "stop"},
+            duration=0.729,
+            finish_details={"stop_reason": "end_turn"},
         )
         ```
 
-        When streaming is enabled, token usage is not supported. Therefore, the `token_usage` attribute will be `None`
-        regardless of the value of the `output_analytics` parameter.
+        When streaming is enabled, token usage is not supported.
 
     Retry and timeout:
         The `XAILMInvoker` supports retry and timeout configuration.
@@ -195,8 +210,6 @@ class XAILMInvoker(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
         ```
 
@@ -204,55 +217,6 @@ class XAILMInvoker(BaseLMInvoker):
         ```python
         lm_invoker = XAILMInvoker(..., retry_config=retry_config)
         ```
-
-    Web Search:
-        The web search is a feature that allows the language model to search the web for relevant information.
-        This feature can be enabled by setting the `web_search` parameter to `True`.
-
-        Usage example:
-        ```python
-        lm_invoker = XAILMInvoker(
-            model_name="grok-3",
-            web_search=True
-        )
-        ```
-
-        When web search is enabled, the language model will search for relevant information and may cite the
-        relevant sources (including from X platform). The citations will be stored as `Chunk` objects in the
-        `citations` attribute in the output.
-
-        Output example:
-        ```python
-        LMOutput(
-            response="According to recent reports, the latest AI developments... ([Source](https://example.com)).",
-            citations=[
-                Chunk(
-                    id="search_result_1",
-                    content="Latest AI developments report",
-                    metadata={
-                        "start_index": 164,
-                        "end_index": 275,
-                        "title": "Example title",
-                        "url": "https://www.example.com",
-                        "type": "url_citation",
-                    },
-                ),
-            ],
-        )
-        ```
-
-    Output types:
-        The output of the `XAILMInvoker` 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])
-            2.8. citations (list[Chunk])
     '''
     reasoning_effort: Incomplete
     web_search: Incomplete

gllm_inference/schema/__init__.pyi

@@ -2,10 +2,10 @@ from gllm_inference.schema.activity import Activity as Activity, MCPCallActivity
 from gllm_inference.schema.attachment import Attachment as Attachment
 from gllm_inference.schema.code_exec_result import CodeExecResult as CodeExecResult
 from gllm_inference.schema.config import TruncationConfig as TruncationConfig
-from gllm_inference.schema.enums import AttachmentType as AttachmentType, BatchStatus as BatchStatus, EmitDataType as EmitDataType, JinjaEnvType as JinjaEnvType, LMEventType as LMEventType, LMEventTypeSuffix as LMEventTypeSuffix, MessageRole as MessageRole, TruncateSide as TruncateSide
+from gllm_inference.schema.enums import AttachmentType as AttachmentType, BatchStatus as BatchStatus, EmitDataType as EmitDataType, JinjaEnvType as JinjaEnvType, LMEventType as LMEventType, LMEventTypeSuffix as LMEventTypeSuffix, LMOutputType as LMOutputType, MessageRole as MessageRole, TruncateSide as TruncateSide
 from gllm_inference.schema.events import ActivityEvent as ActivityEvent, CodeEvent as CodeEvent, ThinkingEvent as ThinkingEvent
 from gllm_inference.schema.lm_input import LMInput as LMInput
-from gllm_inference.schema.lm_output import LMOutput as LMOutput
+from gllm_inference.schema.lm_output import LMOutput as LMOutput, LMOutputData as LMOutputData, LMOutputItem as LMOutputItem
 from gllm_inference.schema.mcp import MCPCall as MCPCall, MCPServer as MCPServer
 from gllm_inference.schema.message import Message as Message
 from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
@@ -15,4 +15,4 @@ from gllm_inference.schema.tool_call import ToolCall as ToolCall
 from gllm_inference.schema.tool_result import ToolResult as ToolResult
 from gllm_inference.schema.type_alias import EMContent as EMContent, MessageContent as MessageContent, ResponseSchema as ResponseSchema, Vector as Vector
 
-__all__ = ['Activity', 'ActivityEvent', 'Attachment', 'AttachmentType', 'BatchStatus', 'CodeEvent', 'CodeExecResult', 'EMContent', 'EmitDataType', 'LMEventType', 'LMEventTypeSuffix', 'InputTokenDetails', 'JinjaEnvType', 'LMInput', 'LMOutput', 'MCPCall', 'MCPCallActivity', 'MCPListToolsActivity', 'MCPServer', 'Message', 'MessageContent', 'MessageRole', 'ModelId', 'ModelProvider', 'OutputTokenDetails', 'Reasoning', 'ThinkingEvent', 'ResponseSchema', 'TokenUsage', 'ToolCall', 'ToolResult', 'TruncateSide', 'TruncationConfig', 'Vector', 'WebSearchActivity']
+__all__ = ['Activity', 'ActivityEvent', 'Attachment', 'AttachmentType', 'BatchStatus', 'CodeEvent', 'CodeExecResult', 'EMContent', 'EmitDataType', 'InputTokenDetails', 'JinjaEnvType', 'LMEventType', 'LMEventTypeSuffix', 'LMInput', 'LMOutput', 'LMOutputItem', 'LMOutputData', 'LMOutputType', 'MCPCall', 'MCPCallActivity', 'MCPListToolsActivity', 'MCPServer', 'Message', 'MessageContent', 'MessageRole', 'ModelId', 'ModelProvider', 'OutputTokenDetails', 'Reasoning', 'ResponseSchema', 'ThinkingEvent', 'TokenUsage', 'ToolCall', 'ToolResult', 'TruncateSide', 'TruncationConfig', 'Vector', 'WebSearchActivity']

gllm_inference/schema/attachment.pyi

@@ -1,7 +1,7 @@
 from _typeshed import Incomplete
-from gllm_inference.constants import HEX_REPR_LENGTH as HEX_REPR_LENGTH
 from pydantic import BaseModel
 
+HEX_REPR_LENGTH: int
 logger: Incomplete
 
 class Attachment(BaseModel):

gllm_inference/schema/enums.pyi

@@ -35,6 +35,17 @@ class EmitDataType(StrEnum):
     THINKING_START = 'thinking_start'
     THINKING_END = 'thinking_end'
 
+class LMOutputType(StrEnum):
+    """Defines valid types for language model outputs."""
+    TEXT = 'text'
+    STRUCTURED = 'structured'
+    ATTACHMENT = 'attachment'
+    TOOL_CALL = 'tool_call'
+    THINKING = 'thinking'
+    CITATION = 'citation'
+    CODE_EXEC_RESULT = 'code_exec_result'
+    MCP_CALL = 'mcp_call'
+
 class ActivityType(StrEnum):
     """Defines valid activity types."""
     FIND_IN_PAGE = 'find_in_page'