gllm-inference-binary 0.5.9__cp312-cp312-win_amd64.whl → 0.5.9b1__cp312-cp312-win_amd64.whl

gllm_inference/exceptions/error_parser.pyi

@@ -1,48 +1,41 @@
-from enum import IntEnum
-from gllm_inference.constants import HTTP_STATUS_CODE_PATTERNS as HTTP_STATUS_CODE_PATTERNS
-from gllm_inference.exceptions.exceptions import BaseInvokerError as BaseInvokerError, InvokerRuntimeError as InvokerRuntimeError, ModelNotFoundError as ModelNotFoundError, ProviderAuthError as ProviderAuthError, ProviderInternalError as ProviderInternalError, ProviderInvalidArgsError as ProviderInvalidArgsError, ProviderOverloadedError as ProviderOverloadedError, ProviderRateLimitError as ProviderRateLimitError
-from gllm_inference.schema import ErrorResponse as ErrorResponse
+from gllm_inference.exceptions.exceptions import BaseInvokerError as BaseInvokerError, InvokerRuntimeError as InvokerRuntimeError
+from gllm_inference.exceptions.provider_error_map import ALL_PROVIDER_ERROR_MAPPINGS as ALL_PROVIDER_ERROR_MAPPINGS, HTTP_STATUS_TO_EXCEPTION_MAP as HTTP_STATUS_TO_EXCEPTION_MAP
 from typing import Any
 
-class ExtendedHTTPStatus(IntEnum):
-    """HTTP status codes outside of the standard HTTPStatus enum.
+def build_debug_info(error: Any, class_name: str) -> dict[str, Any]:
+    """Build debug information for an error.
 
-    Attributes:
-        SERVICE_OVERLOADED (int): HTTP status code for service overloaded.
-    """
-    SERVICE_OVERLOADED = 529
-
-HTTP_STATUS_TO_EXCEPTION_MAP: dict[int, type[BaseInvokerError]]
+    Args:
+        error (Any): The error to extract debug information from.
+        class_name (str): The name of the class that raised the error.
 
-def extract_http_status_code(response: ErrorResponse) -> int | None:
-    '''Extract HTTP status code from error message.
+    Returns:
+        dict[str, Any]: A dictionary containing debug information about the error.
+    """
+def convert_http_status_to_base_invoker_error(error: Exception, invoker: BaseEMInvoker | BaseLMInvoker, status_code_extractor: callable = None, provider_error_mapping: dict[str, type[BaseInvokerError]] = ...) -> BaseInvokerError:
+    """Extract provider error with HTTP status code fallback pattern.
 
-    This function extracts the HTTP status code from the error message. For example,
-    if the error message is "Error code: 401 - Invalid API key", "HTTP 429 Rate limit exceeded",
-    or "status: 500 Internal server error", the function will return "401", "429", or "500" respectively.
+    This function implements the common pattern used by Bedrock and Google invokers
+    where they first try to extract HTTP status codes, then fall back to provider-specific
+    error mappings based on exception keys.
 
     Args:
-        response (ErrorResponse): The response object or error message containing HTTP status code.
+        error (Exception): The error to convert.
+        invoker (BaseEMInvoker | BaseLMInvoker): The invoker instance that raised the error.
+        status_code_extractor (callable): Function to extract status code from error.
+        provider_error_mapping (dict): Provider-specific error mapping dictionary.
 
     Returns:
-        int | None: The extracted HTTP status code, or None if not found.
-    '''
-def parse_error_message(class_name: str, error: Any) -> BaseInvokerError:
-    """Parse error from different AI providers and return appropriate exception type.
-
-    This function analyzes the error message and HTTP status code to determine
-    the most appropriate exception type to return.
+        BaseInvokerError: The converted error.
+    """
+def convert_to_base_invoker_error(error: Exception, invoker: BaseEMInvoker | BaseLMInvoker) -> BaseInvokerError:
+    """Convert provider error into BaseInvokerError.
 
     Args:
-        class_name (str): Class name to include in the error message for clarity.
-        error (Any): The error object or message from the AI provider.
-            Can be an Exception object, Response object, ClientResponse object, string, or dict
-            that might contain HTTP status information.
+        error (Exception): The error to convert.
+        invoker (BaseEMInvoker | BaseLMInvoker): The invoker instance that raised the error.
 
     Returns:
-        BaseInvokerError: The appropriate exception instance based on error analysis.
+        BaseInvokerError: The converted error.
 
-    Raises:
-        CancelledError: If the original error is a CancelledError.
-        TimeoutError: If the original error is a TimeoutError.
     """

gllm_inference/exceptions/exceptions.pyi

@@ -22,10 +22,7 @@ class BaseInvokerError(Exception):
         """
 
 class ProviderInvalidArgsError(BaseInvokerError):
-    """Exception for bad or malformed requests, invalid parameters or structure.
-
-    Corresponds to HTTP 400 status code.
-    """
+    """Exception for bad or malformed requests, invalid parameters or structure."""
     def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
         """Initialize ProviderInvalidArgsError.
 
@@ -36,10 +33,7 @@ class ProviderInvalidArgsError(BaseInvokerError):
         """
 
 class ProviderAuthError(BaseInvokerError):
-    """Exception for authorization failures due to API key issues.
-
-    Corresponds to HTTP 401-403 status codes.
-    """
+    """Exception for authorization failures due to API key issues."""
     def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
         """Initialize ProviderAuthError.
 
@@ -50,10 +44,7 @@ class ProviderAuthError(BaseInvokerError):
         """
 
 class ProviderRateLimitError(BaseInvokerError):
-    """Exception for rate limit violations.
-
-    Corresponds to HTTP 429 status code.
-    """
+    """Exception for rate limit violations."""
     def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
         """Initialize ProviderRateLimitError.
 
@@ -64,10 +55,7 @@ class ProviderRateLimitError(BaseInvokerError):
         """
 
 class ProviderInternalError(BaseInvokerError):
-    """Exception for unexpected server-side errors.
-
-    Corresponds to HTTP 500 status code.
-    """
+    """Exception for unexpected server-side errors."""
     def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
         """Initialize ProviderInternalError.
 
@@ -78,10 +66,7 @@ class ProviderInternalError(BaseInvokerError):
         """
 
 class ProviderOverloadedError(BaseInvokerError):
-    """Exception for when the engine is currently overloaded.
-
-    Corresponds to HTTP 503, 529 status codes.
-    """
+    """Exception for when the engine is currently overloaded."""
     def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
         """Initialize ProviderOverloadedError.
 
@@ -92,10 +77,7 @@ class ProviderOverloadedError(BaseInvokerError):
         """
 
 class ModelNotFoundError(BaseInvokerError):
-    """Exception for model not found errors.
-
-    Corresponds to HTTP 404 status code.
-    """
+    """Exception for model not found errors."""
     def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
         """Initialize ModelNotFoundError.
 
@@ -105,11 +87,41 @@ class ModelNotFoundError(BaseInvokerError):
                 Defaults to None.
         """
 
-class InvokerRuntimeError(BaseInvokerError):
-    """Exception for runtime errors that occur during the invocation of the model.
+class APIConnectionError(BaseInvokerError):
+    """Exception for when the client fails to connect to the model provider."""
+    def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
+        """Initialize APIConnectionError.
+
+        Args:
+            class_name (str): The name of the class that raised the error.
+            debug_info (dict[str, Any] | None, optional): Additional debug information for developers.
+                Defaults to None.
+        """
+
+class APITimeoutError(BaseInvokerError):
+    """Exception for when the request to the model provider times out."""
+    def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
+        """Initialize APITimeoutError.
 
-    Corresponds to HTTP status codes other than the ones defined in HTTP_STATUS_TO_EXCEPTION_MAP.
-    """
+        Args:
+            class_name (str): The name of the class that raised the error.
+            debug_info (dict[str, Any] | None, optional): Additional debug information for developers.
+                Defaults to None.
+        """
+
+class ProviderConflictError(BaseInvokerError):
+    """Exception for when the request to the model provider conflicts."""
+    def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
+        """Initialize ProviderConflictError.
+
+        Args:
+            class_name (str): The name of the class that raised the error.
+            debug_info (dict[str, Any] | None, optional): Additional debug information for developers.
+                Defaults to None.
+        """
+
+class InvokerRuntimeError(BaseInvokerError):
+    """Exception for runtime errors that occur during the invocation of the model."""
     def __init__(self, class_name: str, debug_info: dict[str, Any] | None = None) -> None:
         """Initialize the InvokerRuntimeError.
 

gllm_inference/exceptions/provider_error_map.pyi

@@ -0,0 +1,23 @@
+from _typeshed import Incomplete
+from enum import IntEnum
+from gllm_inference.exceptions.exceptions import APIConnectionError as APIConnectionError, APITimeoutError as APITimeoutError, BaseInvokerError as BaseInvokerError, ModelNotFoundError as ModelNotFoundError, ProviderAuthError as ProviderAuthError, ProviderConflictError as ProviderConflictError, ProviderInternalError as ProviderInternalError, ProviderInvalidArgsError as ProviderInvalidArgsError, ProviderOverloadedError as ProviderOverloadedError, ProviderRateLimitError as ProviderRateLimitError
+
+class ExtendedHTTPStatus(IntEnum):
+    """HTTP status codes outside of the standard HTTPStatus enum.
+
+    Attributes:
+        SERVICE_OVERLOADED (int): HTTP status code for service overloaded.
+    """
+    SERVICE_OVERLOADED = 529
+
+HTTP_STATUS_TO_EXCEPTION_MAP: dict[int, type[BaseInvokerError]]
+ANTHROPIC_ERROR_MAPPING: Incomplete
+BEDROCK_ERROR_MAPPING: Incomplete
+GOOGLE_ERROR_MAPPING: Incomplete
+LANGCHAIN_ERROR_CODE_MAPPING: Incomplete
+LITELLM_ERROR_MAPPING: Incomplete
+OPENAI_ERROR_MAPPING: Incomplete
+TWELVELABS_ERROR_MAPPING: Incomplete
+VOYAGE_ERROR_MAPPING: Incomplete
+GRPC_STATUS_CODE_MAPPING: Incomplete
+ALL_PROVIDER_ERROR_MAPPINGS: Incomplete

gllm_inference/lm_invoker/__init__.pyi

@@ -7,5 +7,6 @@ from gllm_inference.lm_invoker.langchain_lm_invoker import LangChainLMInvoker as
 from gllm_inference.lm_invoker.litellm_lm_invoker import LiteLLMLMInvoker as LiteLLMLMInvoker
 from gllm_inference.lm_invoker.openai_compatible_lm_invoker import OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker
 from gllm_inference.lm_invoker.openai_lm_invoker import OpenAILMInvoker as OpenAILMInvoker
+from gllm_inference.lm_invoker.xai_lm_invoker import XAILMInvoker as XAILMInvoker
 
-__all__ = ['AnthropicLMInvoker', 'AzureOpenAILMInvoker', 'BedrockLMInvoker', 'DatasaurLMInvoker', 'GoogleLMInvoker', 'LangChainLMInvoker', 'LiteLLMLMInvoker', 'OpenAICompatibleLMInvoker', 'OpenAILMInvoker']
+__all__ = ['AnthropicLMInvoker', 'AzureOpenAILMInvoker', 'BedrockLMInvoker', 'DatasaurLMInvoker', 'GoogleLMInvoker', 'LangChainLMInvoker', 'LiteLLMLMInvoker', 'OpenAICompatibleLMInvoker', 'OpenAILMInvoker', 'XAILMInvoker']

gllm_inference/lm_invoker/azure_openai_lm_invoker.pyi

@@ -1,7 +1,7 @@
 from _typeshed import Incomplete
 from gllm_core.schema.tool import Tool as Tool
 from gllm_core.utils.retry import RetryConfig as RetryConfig
-from gllm_inference.constants import DEFAULT_AZURE_OPENAI_API_VERSION as DEFAULT_AZURE_OPENAI_API_VERSION, INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
+from gllm_inference.constants import AZURE_OPENAI_URL_SUFFIX as AZURE_OPENAI_URL_SUFFIX, INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
 from gllm_inference.lm_invoker.openai_lm_invoker import OpenAILMInvoker as OpenAILMInvoker, ReasoningEffort as ReasoningEffort, ReasoningSummary as ReasoningSummary
 from gllm_inference.lm_invoker.schema.openai import Key as Key
 from gllm_inference.schema import ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema
@@ -33,7 +33,7 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
         The `AzureOpenAILMInvoker` can be used as follows:
         ```python
         lm_invoker = AzureOpenAILMInvoker(
-            azure_endpoint="https://<your-azure-openai-endpoint>.openai.azure.com/",
+            azure_endpoint="https://<your-azure-openai-endpoint>.openai.azure.com/openai/v1",
             azure_deployment="<your-azure-openai-deployment>",
         )
         result = await lm_invoker.invoke("Hi there!")
@@ -158,17 +158,17 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
         ```
 
     Reasoning:
-        Azure OpenAI\'s 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.
+        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 to the prompt.
+        will guide the models on how many reasoning tokens it should generate before creating a response.
         Available options include:
-        1. "low": Favors speed and economical token usage.
-        2. "medium": Favors a balance between speed and reasoning accuracy.
-        3. "high": Favors more complete reasoning at the cost of more tokens generated and slower responses.
-        When not set, the reasoning effort will be equivalent to `medium` by default.
+        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:
@@ -220,7 +220,7 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
                 Defaults to an empty list.
     '''
     client: Incomplete
-    def __init__(self, azure_endpoint: str, azure_deployment: str, api_key: str | None = None, api_version: str = ..., 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) -> None:
+    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) -> None:
         """Initializes a new instance of the AzureOpenAILMInvoker class.
 
         Args:
@@ -228,8 +228,7 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
             azure_deployment (str): The deployment name of the Azure OpenAI service.
             api_key (str | None, optional): The API key for authenticating with Azure OpenAI. Defaults to None, in
                 which case the `AZURE_OPENAI_API_KEY` environment variable will be used.
-            api_version (str, optional): The API version of the Azure OpenAI service. Defaults to
-                `DEFAULT_AZURE_OPENAI_API_VERSION`.
+            api_version (str | None, optional): Deprecated parameter to be removed in v0.6. Defaults to None.
             model_kwargs (dict[str, Any] | None, optional): Additional model parameters. Defaults to None.
             default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the model.
                 Defaults to None.

gllm_inference/lm_invoker/bedrock_lm_invoker.pyi

@@ -2,6 +2,8 @@ from _typeshed import Incomplete
 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.exceptions import BaseInvokerError as BaseInvokerError, convert_http_status_to_base_invoker_error as convert_http_status_to_base_invoker_error
+from gllm_inference.exceptions.provider_error_map import BEDROCK_ERROR_MAPPING as BEDROCK_ERROR_MAPPING
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.bedrock import InputType as InputType, Key as Key, OutputType as OutputType
 from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, LMOutput as LMOutput, Message as Message, ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult

gllm_inference/lm_invoker/google_lm_invoker.pyi

@@ -3,6 +3,8 @@ from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.schema.tool import Tool
 from gllm_core.utils.retry import RetryConfig as RetryConfig
 from gllm_inference.constants import GOOGLE_SCOPES as GOOGLE_SCOPES, SECONDS_TO_MILLISECONDS as SECONDS_TO_MILLISECONDS
+from gllm_inference.exceptions import BaseInvokerError as BaseInvokerError, convert_http_status_to_base_invoker_error as convert_http_status_to_base_invoker_error
+from gllm_inference.exceptions.provider_error_map import GOOGLE_ERROR_MAPPING as GOOGLE_ERROR_MAPPING
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.google import InputType as InputType, Key as Key
 from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EmitDataType as EmitDataType, LMOutput as LMOutput, Message as Message, MessageRole as MessageRole, ModelId as ModelId, ModelProvider as ModelProvider, Reasoning as Reasoning, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
@@ -162,7 +164,12 @@ class GoogleLMInvoker(BaseLMInvoker):
         ```python
         LMOutput(
             response="Golden retriever is a good dog breed.",
-            token_usage=TokenUsage(input_tokens=100, output_tokens=50),
+            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),
+            ),
             duration=0.729,
             finish_details={"finish_reason": "STOP", "finish_message": None},
         )

gllm_inference/lm_invoker/langchain_lm_invoker.pyi

@@ -3,6 +3,8 @@ from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.schema.tool import Tool as Tool
 from gllm_core.utils.retry import RetryConfig
 from gllm_inference.constants import INVOKER_DEFAULT_TIMEOUT as INVOKER_DEFAULT_TIMEOUT, INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
+from gllm_inference.exceptions import BaseInvokerError as BaseInvokerError, InvokerRuntimeError as InvokerRuntimeError, build_debug_info as build_debug_info
+from gllm_inference.exceptions.provider_error_map import ALL_PROVIDER_ERROR_MAPPINGS as ALL_PROVIDER_ERROR_MAPPINGS, LANGCHAIN_ERROR_CODE_MAPPING as LANGCHAIN_ERROR_CODE_MAPPING
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.langchain import InputType as InputType, Key as Key
 from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, LMOutput as LMOutput, Message as Message, MessageRole as MessageRole, ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult

gllm_inference/lm_invoker/lm_invoker.pyi

@@ -5,29 +5,30 @@ from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.schema.tool import Tool
 from gllm_core.utils import RetryConfig
 from gllm_inference.constants import DOCUMENT_MIME_TYPES as DOCUMENT_MIME_TYPES, INVOKER_DEFAULT_TIMEOUT as INVOKER_DEFAULT_TIMEOUT
-from gllm_inference.exceptions import parse_error_message as parse_error_message
+from gllm_inference.exceptions import BaseInvokerError as BaseInvokerError, convert_to_base_invoker_error as convert_to_base_invoker_error
 from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EmitDataType as EmitDataType, LMOutput as LMOutput, Message as Message, MessageContent as MessageContent, MessageRole as MessageRole, ModelId as ModelId, Reasoning as Reasoning, ResponseSchema as ResponseSchema, ToolCall as ToolCall, ToolResult as ToolResult
 from langchain_core.tools import Tool as LangChainTool
 from typing import Any
 
-class _Key:
+class Key:
     """Defines valid keys in LM invokers JSON schema."""
     ADDITIONAL_PROPERTIES: str
     ANY_OF: str
+    ARGS_SCHEMA: str
+    ARUN: str
+    COROUTINE: str
     DATA_TYPE: str
     DATA_VALUE: str
     DEFAULT: str
     DESCRIPTION: str
-    FUNCTION: str
-    META: str
+    FUNC: str
     NAME: str
-    PARAMETERS: str
     PROPERTIES: str
     REQUIRED: str
     TITLE: str
     TYPE: str
 
-class _InputType:
+class InputType:
     """Defines valid input types in LM invokers JSON schema."""
     NULL: str
 

gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi

@@ -52,7 +52,7 @@ class OpenAICompatibleLMInvoker(BaseLMInvoker):
         ```
 
     Input types:
-        The `OpenAICompatibleLMInvoker` supports the following input types: text, audio, and image.
+        The `OpenAICompatibleLMInvoker` supports the following input types: text, audio, document, and image.
         Non-text inputs can be passed as an `Attachment` object with the `user` role.
 
         Usage example:

gllm_inference/lm_invoker/openai_lm_invoker.pyi

@@ -159,16 +159,17 @@ class OpenAILMInvoker(BaseLMInvoker):
         ```
 
     Reasoning:
-        OpenAI\'s 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.
+        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. "low": Favors speed and economical token usage.
-        2. "medium": Favors a balance between speed and reasoning accuracy.
-        3. "high": Favors more complete reasoning at the cost of more tokens generated and slower responses.
+        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.
         When not set, the reasoning effort will be equivalent to `medium` by default.
 
         OpenAI doesn\'t expose the raw reasoning tokens. However, the summary of the reasoning tokens can still be

gllm_inference/lm_invoker/schema/bedrock.pyi

@@ -5,8 +5,11 @@ class Key:
     CONTENT_BLOCK_INDEX: str
     DELTA: str
     DESCRIPTION: str
+    ERROR: str
+    CODE: str
     FORMAT: str
     FUNCTION: str
+    HTTP_STATUS_CODE: str
     INFERENCE_CONFIG: str
     INPUT: str
     INPUT_SCHEMA: str
@@ -14,9 +17,11 @@ class Key:
     JSON: str
     MESSAGE: str
     NAME: str
+    RESPONSE: str
     OUTPUT: str
     OUTPUT_TOKENS: str
     PARAMETERS: str
+    RESPONSE_METADATA: str
     ROLE: str
     SOURCE: str
     START: str

gllm_inference/lm_invoker/schema/langchain.pyi

@@ -1,6 +1,7 @@
 class Key:
     """Defines valid keys in LangChain."""
     ARGS: str
+    ERROR_CODE: str
     FINISH_REASON: str
     ID: str
     IMAGE_URL: str

gllm_inference/lm_invoker/schema/openai.pyi

@@ -83,6 +83,7 @@ class ReasoningEffort(StrEnum):
     HIGH = 'high'
     MEDIUM = 'medium'
     LOW = 'low'
+    MINIMAL = 'minimal'
 
 class ReasoningSummary(StrEnum):
     """Defines the reasoning summary for reasoning models."""

gllm_inference/lm_invoker/schema/openai_compatible.pyi

@@ -9,6 +9,9 @@ class Key:
     DEFS: str
     DESCRIPTION: str
     EFFORT: str
+    FILE: str
+    FILE_DATA: str
+    FILENAME: str
     FINISH_REASON: str
     FORMAT: str
     FUNCTION: str
@@ -40,6 +43,7 @@ class Key:
 
 class InputType:
     """Defines valid input types in OpenAI compatible models."""
+    FILE: str
     FUNCTION: str
     IMAGE_URL: str
     INPUT_AUDIO: str

gllm_inference/lm_invoker/schema/xai.pyi

@@ -0,0 +1,31 @@
+from enum import StrEnum
+
+class Key:
+    """Defines valid keys in xAI."""
+    ARGUMENTS: str
+    CHANNEL_OPTIONS: str
+    CITATIONS: str
+    COMPLETION_TOKENS: str
+    CONTENT: str
+    FINISH_REASON: str
+    FUNCTION: str
+    ID: str
+    NAME: str
+    ON: str
+    PROMPT_TOKENS: str
+    REASONING_CONTENT: str
+    REASONING_EFFORT: str
+    RESPONSE_FORMAT: str
+    SEARCH_PARAMETERS: str
+    TIMEOUT: str
+    TOOL_CALLS: str
+    TOOLS: str
+    TYPE: str
+    URL: str
+    URL_CITATION: str
+    USAGE: str
+
+class ReasoningEffort(StrEnum):
+    """Defines the reasoning effort for reasoning models."""
+    HIGH = 'high'
+    LOW = 'low'