gllm-inference-binary 0.5.38__cp313-cp313-win_amd64.whl → 0.5.39__cp313-cp313-win_amd64.whl

gllm_inference/lm_invoker/anthropic_lm_invoker.pyi

@@ -188,17 +188,18 @@ class AnthropicLMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled, the thinking token will be streamed with the `EventType.DATA` event type.
-
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "thinking_start", "data_value": ""}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "Let me think "}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "about it..."}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking_end", "data_value": ""}\', ...}
+        {"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
@@ -288,7 +289,7 @@ class AnthropicLMInvoker(BaseLMInvoker):
     client: Incomplete
     thinking: Incomplete
     thinking_budget: Incomplete
-    def __init__(self, model_name: str, api_key: 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, thinking: bool = False, thinking_budget: int = ...) -> None:
+    def __init__(self, model_name: str, api_key: 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, thinking: bool = False, thinking_budget: int = ..., simplify_events: bool = False) -> None:
         """Initializes the AnthropicLmInvoker instance.
 
         Args:
@@ -309,6 +310,9 @@ class AnthropicLMInvoker(BaseLMInvoker):
             thinking (bool, optional): Whether to enable thinking. Only allowed for thinking models. Defaults to False.
             thinking_budget (int, optional): The tokens allocated for the thinking process. Must be greater than or
                 equal to 1024. Only allowed for thinking models. Defaults to DEFAULT_THINKING_BUDGET.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
 
         Raises:
             ValueError:

gllm_inference/lm_invoker/azure_openai_lm_invoker.pyi

@@ -191,16 +191,18 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
         )
         ```
 
-        When streaming is enabled along with reasoning summary, the reasoning summary token will be streamed with the
-        `EventType.DATA` event type.
-
         Streaming output example:
         ```python
-        {"type": "data", "value": "Let me think ", ...}  # Reasoning summary token
-        {"type": "data", "value": "about it...", ...}  # Reasoning summary token
-        {"type": "response", "value": "Golden retriever ", ...}  # Response token
-        {"type": "response", "value": "is a good dog breed.", ...}  # Response token
+        {"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.
 
@@ -227,7 +229,7 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
             2.10. mcp_calls (list[MCPCall]): The MCP calls. Currently not supported. Defaults to an empty list.
     '''
     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) -> 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, simplify_events: bool = False) -> None:
         """Initializes a new instance of the AzureOpenAILMInvoker class.
 
         Args:
@@ -251,6 +253,9 @@ class AzureOpenAILMInvoker(OpenAILMInvoker):
                 for non-reasoning models. If None, the model will perform medium reasoning effort. Defaults to None.
             reasoning_summary (ReasoningSummary | None, optional): The reasoning summary level for reasoning models.
                 Not allowed for non-reasoning models. If None, no summary will be generated. Defaults to None.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
 
         Raises:
             ValueError:

gllm_inference/lm_invoker/datasaur_lm_invoker.pyi

@@ -3,7 +3,7 @@ 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 DOCUMENT_MIME_TYPES as DOCUMENT_MIME_TYPES, INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
-from gllm_inference.lm_invoker.openai_compatible_lm_invoker import OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker
+from gllm_inference.lm_invoker.openai_chat_completions_lm_invoker import OpenAIChatCompletionsLMInvoker as OpenAIChatCompletionsLMInvoker
 from gllm_inference.lm_invoker.schema.datasaur import InputType as InputType, Key as Key
 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, ToolCall as ToolCall, ToolResult as ToolResult
 from langchain_core.tools import Tool as LangChainTool
@@ -11,7 +11,7 @@ from typing import Any
 
 SUPPORTED_ATTACHMENTS: Incomplete
 
-class DatasaurLMInvoker(OpenAICompatibleLMInvoker):
+class DatasaurLMInvoker(OpenAIChatCompletionsLMInvoker):
     '''A language model invoker to interact with Datasaur LLM Projects Deployment API.
 
     Attributes:

gllm_inference/lm_invoker/google_lm_invoker.pyi

@@ -216,17 +216,18 @@ class GoogleLMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled, the thinking token will be streamed with the `EventType.DATA` event type.
-
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "thinking_start", "data_value": ""}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "Let me think "}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "about it..."}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking_end", "data_value": ""}\', ...}
+        {"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`:
@@ -259,7 +260,7 @@ class GoogleLMInvoker(BaseLMInvoker):
     client_params: Incomplete
     thinking: Incomplete
     thinking_budget: Incomplete
-    def __init__(self, model_name: str, api_key: str | None = None, credentials_path: str | None = None, project_id: str | None = None, location: str = 'us-central1', 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, thinking: bool | None = None, thinking_budget: int = ...) -> None:
+    def __init__(self, model_name: str, api_key: str | None = None, credentials_path: str | None = None, project_id: str | None = None, location: str = 'us-central1', 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, thinking: bool | None = None, thinking_budget: int = ..., simplify_events: bool = False) -> None:
         '''Initializes a new instance of the GoogleLMInvoker class.
 
         Args:
@@ -288,6 +289,9 @@ class GoogleLMInvoker(BaseLMInvoker):
                 Defaults to True for Gemini 2.5 Pro models and False for other models.
             thinking_budget (int, optional): The tokens allowed for thinking process. Only allowed for thinking models.
                 Defaults to -1, in which case the model will control the budget automatically.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
 
         Note:
             If neither `api_key` nor `credentials_path` is provided, Google Gen AI will be used by default.

gllm_inference/lm_invoker/litellm_lm_invoker.pyi

@@ -2,7 +2,7 @@ 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.lm_invoker.openai_compatible_lm_invoker import OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker
+from gllm_inference.lm_invoker.openai_chat_completions_lm_invoker import OpenAIChatCompletionsLMInvoker as OpenAIChatCompletionsLMInvoker
 from gllm_inference.lm_invoker.openai_lm_invoker import ReasoningEffort as ReasoningEffort
 from gllm_inference.schema import AttachmentType as AttachmentType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema
 from langchain_core.tools import Tool as LangChainTool
@@ -10,7 +10,7 @@ from typing import Any
 
 SUPPORTED_ATTACHMENTS: Incomplete
 
-class LiteLLMLMInvoker(OpenAICompatibleLMInvoker):
+class LiteLLMLMInvoker(OpenAIChatCompletionsLMInvoker):
     '''A language model invoker to interact with language models using LiteLLM.
 
     Attributes:
@@ -192,17 +192,18 @@ class LiteLLMLMInvoker(OpenAICompatibleLMInvoker):
         )
         ```
 
-        When streaming is enabled along with reasoning and the provider supports reasoning output, the reasoning token
-        will be streamed with the `EventType.DATA` event type.
-
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "thinking_start", "data_value": ""}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "Let me think "}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "about it..."}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking_end", "data_value": ""}\', ...}
+        {"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.
 
@@ -229,7 +230,7 @@ class LiteLLMLMInvoker(OpenAICompatibleLMInvoker):
             2.10. mcp_calls (list[MCPCall]): The MCP calls. Currently not supported. Defaults to an empty list.
     '''
     completion: Incomplete
-    def __init__(self, model_id: str, 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) -> None:
+    def __init__(self, model_id: str, 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, simplify_events: bool = False) -> None:
         """Initializes a new instance of the LiteLLMLMInvoker class.
 
         Args:
@@ -246,4 +247,7 @@ class LiteLLMLMInvoker(OpenAICompatibleLMInvoker):
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
             reasoning_effort (ReasoningEffort | None, optional): The reasoning effort for reasoning models.
                 Defaults to None.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
         """

gllm_inference/lm_invoker/lm_invoker.pyi

@@ -56,7 +56,7 @@ class BaseLMInvoker(ABC, metaclass=abc.ABCMeta):
     response_schema: Incomplete
     output_analytics: Incomplete
     retry_config: Incomplete
-    def __init__(self, model_id: ModelId, default_hyperparameters: dict[str, Any] | None = None, supported_attachments: set[str] | None = None, tools: list[Tool | LangChainTool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None) -> None:
+    def __init__(self, model_id: ModelId, default_hyperparameters: dict[str, Any] | None = None, supported_attachments: set[str] | None = None, tools: list[Tool | LangChainTool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, simplify_events: bool = False) -> None:
         """Initializes a new instance of the BaseLMInvoker class.
 
         Args:
@@ -73,6 +73,9 @@ class BaseLMInvoker(ABC, metaclass=abc.ABCMeta):
             output_analytics (bool, optional): Whether to output the invocation analytics. Defaults to False.
             retry_config (RetryConfig | None, optional): The retry configuration for the language model.
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
         """
     @property
     def model_id(self) -> str:

gllm_inference/lm_invoker/openai_chat_completions_lm_invoker.pyi

@@ -207,18 +207,18 @@ class OpenAIChatCompletionsLMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled along with reasoning and the provider supports reasoning output, the reasoning token
-        will be streamed with the `EventType.DATA` event type.
-
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "thinking_start", "data_value": ""}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "Let me think "}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "about it..."}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking_end", "data_value": ""}\', ...}
+        {"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.
 
@@ -244,7 +244,7 @@ class OpenAIChatCompletionsLMInvoker(BaseLMInvoker):
             2.10. mcp_calls (list[MCPCall]): The MCP calls. Currently not supported. Defaults to an empty list.
     '''
     client_kwargs: Incomplete
-    def __init__(self, model_name: str, api_key: str | None = None, base_url: 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) -> None:
+    def __init__(self, model_name: str, api_key: str | None = None, base_url: 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, simplify_events: bool = False) -> None:
         '''Initializes a new instance of the OpenAIChatCompletionsLMInvoker class.
 
         Args:
@@ -266,6 +266,9 @@ class OpenAIChatCompletionsLMInvoker(BaseLMInvoker):
             retry_config (RetryConfig | None, optional): The retry configuration for the language model.
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
             reasoning_effort (str | None, optional): The reasoning effort for the language model. Defaults to None.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
         '''
     def set_response_schema(self, response_schema: ResponseSchema | None) -> None:
         """Sets the response schema for the OpenAI language model.

gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi

@@ -25,7 +25,7 @@ class OpenAICompatibleLMInvoker(OpenAIChatCompletionsLMInvoker):
 
     This class is deprecated and will be removed in v0.6. Please use the `OpenAIChatCompletionsLMInvoker` class instead.
     """
-    def __init__(self, model_name: str, base_url: str, api_key: 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) -> None:
+    def __init__(self, model_name: str, base_url: str, api_key: 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, simplify_events: bool = False) -> None:
         '''Initializes a new instance of the OpenAICompatibleLMInvoker class.
 
         Args:
@@ -46,4 +46,7 @@ class OpenAICompatibleLMInvoker(OpenAIChatCompletionsLMInvoker):
             retry_config (RetryConfig | None, optional): The retry configuration for the language model.
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
             reasoning_effort (str | None, optional): The reasoning effort for the language model. Defaults to None.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
         '''

gllm_inference/lm_invoker/openai_lm_invoker.pyi

@@ -216,18 +216,18 @@ class OpenAILMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled along with reasoning summary, the reasoning summary token will be streamed with the
-        `EventType.DATA` event type.
-
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "thinking_start", "data_value": ""}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "Let me think "}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "about it..."}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking_end", "data_value": ""}\', ...}
+        {"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.
 
@@ -262,14 +262,16 @@ class OpenAILMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled, the MCP call activities will be streamed with the `EventType.DATA` event type.
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "activity", "data_value": "{\\"type\\": \\"mcp_list_tools\\"}", ...}\', ...}
-        {"type": "data", "value": \'{"data_type": "activity", "data_value": "{\\"type\\": \\"mcp_call\\"}", ...}\', ...}
+        {"type": "activity", "value": {"type": "mcp_list_tools", ...}, ...}
+        {"type": "activity", "value": {"type": "mcp_call", ...}, ...}
         {"type": "response", "value": "The result ", ...}
         {"type": "response", "value": "is 10.", ...}
         ```
+        Note: By default, the activity 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.
 
     Code interpreter:
         The code interpreter is a feature that allows the language model to write and run Python code in a
@@ -287,14 +289,8 @@ class OpenAILMInvoker(BaseLMInvoker):
         Messages example:
         ```python
         messages = [
-            Message(
-                role=MessageRole.SYSTEM,
-                contents=["You are a data analyst. Use the python tool to generate a file."],
-            ),
-            Message(
-                role=MessageRole.USER,
-                contents=["Show an histogram of the following data: [1, 2, 1, 4, 1, 2, 4, 2, 3, 1]"],
-            ),
+            Message.system("You are a data analyst. Use the python tool to generate a file."]),
+            Message.user("Show an histogram of the following data: [1, 2, 1, 4, 1, 2, 4, 2, 3, 1]"),
         ]
         ```
 
@@ -315,16 +311,18 @@ class OpenAILMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled, the executed code will be streamed with the `EventType.DATA` event type.
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "code_start", "data_value": ""}\', ...}
-        {"type": "data", "value": \'{"data_type": "code", "data_value": "import matplotlib"}\', ...}
-        {"type": "data", "value": \'{"data_type": "code", "data_value": ".pyplot as plt..."}\', ...}
-        {"type": "data", "value": \'{"data_type": "code_end", "data_value": ""}\', ...}
+        {"type": "code_start", "value": ""}\', ...}
+        {"type": "code", "value": "import matplotlib"}\', ...}
+        {"type": "code", "value": ".pyplot as plt..."}\', ...}
+        {"type": "code_end", "value": ""}\', ...}
         {"type": "response", "value": "The histogram ", ...}
         {"type": "response", "value": "is attached.", ...}
         ```
+        Note: By default, the code 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.
 
     Web search:
         The web search is a feature that allows the language model to search the web for relevant information.
@@ -359,13 +357,15 @@ class OpenAILMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled, the web search activities will be streamed with the `EventType.DATA` event type.
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "activity", "data_value": "{\\"query\\": \\"search query\\"}", ...}\', ...}
+        {"type": "activity", "value": {"query": "search query"}, ...}
         {"type": "response", "value": "The winner of the match ", ...}
         {"type": "response", "value": "is team A ([Example title](https://www.example.com)).", ...}
         ```
+        Note: By default, the activity 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.
 
     Output types:
         The output of the `OpenAILMInvoker` can either be:
@@ -392,7 +392,7 @@ class OpenAILMInvoker(BaseLMInvoker):
                 decides to invoke MCP tools. Defaults to an empty list.
     '''
     client_kwargs: Incomplete
-    def __init__(self, model_name: str, api_key: str | None = None, base_url: 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, mcp_servers: list[MCPServer] | None = None, code_interpreter: bool = False, web_search: bool = False) -> None:
+    def __init__(self, model_name: str, api_key: str | None = None, base_url: 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, mcp_servers: list[MCPServer] | None = None, code_interpreter: bool = False, web_search: bool = False, simplify_events: bool = False) -> None:
         '''Initializes a new instance of the OpenAILMInvoker class.
 
         Args:
@@ -421,6 +421,9 @@ class OpenAILMInvoker(BaseLMInvoker):
                 language model. Defaults to None.
             code_interpreter (bool, optional): Whether to enable the code interpreter. Defaults to False.
             web_search (bool, optional): Whether to enable the web search. Defaults to False.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
 
         Raises:
             ValueError:

gllm_inference/lm_invoker/xai_lm_invoker.pyi

@@ -153,18 +153,18 @@ class XAILMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled along with reasoning summary, the reasoning summary token will be streamed with the
-        `EventType.DATA` event type.
-
         Streaming output example:
         ```python
-        {"type": "data", "value": \'{"data_type": "thinking_start", "data_value": ""}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "Let me think "}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking", "data_value": "about it..."}\', ...}
-        {"type": "data", "value": \'{"data_type": "thinking_end", "data_value": ""}\', ...}
+        {"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.
 
@@ -218,13 +218,13 @@ class XAILMInvoker(BaseLMInvoker):
         ```
 
         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.
+        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 include... ([Source](https://example.com)).",
+            response="According to recent reports, the latest AI developments... ([Source](https://example.com)).",
             citations=[
                 Chunk(
                     id="search_result_1",
@@ -241,16 +241,6 @@ class XAILMInvoker(BaseLMInvoker):
         )
         ```
 
-        When streaming is enabled, the live search activities will be streamed with the `EventType.DATA` event type.
-        This allows you to track the search process in real-time.
-
-        Streaming output example:
-        ```python
-        {"type": "data", "value": \'{"data_type": "activity", "data_value": "{\\"query\\": \\"search query\\"}", ...}\', ...}
-        {"type": "response", "value": "According to recent reports, ", ...}
-        {"type": "response", "value": "the latest AI developments include...", ...}
-        ```
-
     Output types:
         The output of the `XAILMInvoker` can either be:
         1. `str`: The text response if no additional output is needed.
@@ -276,7 +266,7 @@ class XAILMInvoker(BaseLMInvoker):
     reasoning_effort: Incomplete
     web_search: Incomplete
     client_params: Incomplete
-    def __init__(self, model_name: str, api_key: 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, web_search: bool = False) -> None:
+    def __init__(self, model_name: str, api_key: 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, web_search: bool = False, simplify_events: bool = False) -> None:
         """Initializes a new instance of the XAILMInvoker class.
 
         Args:
@@ -298,6 +288,9 @@ class XAILMInvoker(BaseLMInvoker):
             reasoning_effort (ReasoningEffort | None, optional): The reasoning effort for reasoning models. Not allowed
                 for non-reasoning models. If None, the model will perform medium reasoning effort. Defaults to None.
             web_search (bool, optional): Whether to enable the web search. Defaults to False.
+            simplify_events (bool, optional): Temporary parameter to control the streamed events format.
+                When True, uses the simplified events format. When False, uses the legacy events format for
+                backward compatibility. Will be removed in v0.6. Defaults to False.
 
         Raises:
             ValueError:

{gllm_inference_binary-0.5.38.dist-info → gllm_inference_binary-0.5.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gllm-inference-binary
-Version: 0.5.38
+Version: 0.5.39
 Summary: A library containing components related to model inferences in Gen AI applications.
 Author-email: Henry Wicaksono <henry.wicaksono@gdplabs.id>, Resti Febrina <resti.febrina@gdplabs.id>
 Requires-Python: <3.14,>=3.11

{gllm_inference_binary-0.5.38.dist-info → gllm_inference_binary-0.5.39.dist-info}/RECORD

@@ -1,4 +1,4 @@
-gllm_inference.cp313-win_amd64.pyd,sha256=uP3RI8161EsIM2FizmuvQlGJygtK10n4htojUkuK9T8,3543040
+gllm_inference.cp313-win_amd64.pyd,sha256=nUkymTjVs8f2rSGYculJnhZrrTx4NpNav00YIOdUkU0,3560448
 gllm_inference.pyi,sha256=CM8fddhFC2U0VGu9_JWrokO5YDc3B-eXx8pSjLYRlGY,4750
 gllm_inference/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gllm_inference/constants.pyi,sha256=1OBoHfeWfW9bXH9kStNEH__MGnGp--jLfyheAeQnogY,302
@@ -36,18 +36,18 @@ gllm_inference/exceptions/error_parser.pyi,sha256=4aiJZhBzBOqlhdmpvaCvildGy7_Xxl
 gllm_inference/exceptions/exceptions.pyi,sha256=6y3ECgHAStqMGgQv8Dv-Ui-5PDD07mSj6qaRZeSWea4,5857
 gllm_inference/exceptions/provider_error_map.pyi,sha256=4AsAgbXAh91mxEW2YiomEuhBoeSNeAIo9WbT9WK8gQk,1233
 gllm_inference/lm_invoker/__init__.pyi,sha256=jG1xc5fTOeIgeKKVYSnsMzQThKk9kTW38yO_MYtv540,1387
-gllm_inference/lm_invoker/anthropic_lm_invoker.pyi,sha256=Cpt20CsCq-5CgFjQSA7zyS3NoRCBQxcIq-i-ZoOZU84,17577
-gllm_inference/lm_invoker/azure_openai_lm_invoker.pyi,sha256=xQO_lNI0hgeloGUJKResh1UbfodaGOo4UdkXz7sc0Qk,15315
+gllm_inference/lm_invoker/anthropic_lm_invoker.pyi,sha256=qc9zU0ZMT8RIAIqNSUTaQaDyNleNg-E6-0D5cPn2s_c,17952
+gllm_inference/lm_invoker/azure_openai_lm_invoker.pyi,sha256=nv9WZwgsMUKlct3CYAv2VM8vU423ZTu7pZ5l1yyPfbQ,15835
 gllm_inference/lm_invoker/bedrock_lm_invoker.pyi,sha256=ptyHTm1szPJEpQObdrsxHpbTkchCWE6K-YmVTmbdhvM,13037
-gllm_inference/lm_invoker/datasaur_lm_invoker.pyi,sha256=Gi1n6ySpXZH8BuXiQ3owTFwVt3T1xnhG18C4csbZUKU,9516
-gllm_inference/lm_invoker/google_lm_invoker.pyi,sha256=JsY1lTY4atVcvuXr8gmZLDBYnzA9DY3Ia7rljL-X87w,17484
+gllm_inference/lm_invoker/datasaur_lm_invoker.pyi,sha256=S50ULbQO_HW3rvyKPtIcS08gvEcXzjtKPSBzwk3q1i4,9537
+gllm_inference/lm_invoker/google_lm_invoker.pyi,sha256=CbWl2NGe0Hb-FV3fNzYyAoe1Tb4k1J0g9yGQyodLkXk,17856
 gllm_inference/lm_invoker/langchain_lm_invoker.pyi,sha256=dKN0flBxjiCUWW1QOz8HjoRfKpqXjNEz1pm5cS-40zA,13966
-gllm_inference/lm_invoker/litellm_lm_invoker.pyi,sha256=cnkg4Lk9sRqXylWQq5G3ujD_DzcVX88DCfEpA5hkTFA,13487
-gllm_inference/lm_invoker/lm_invoker.pyi,sha256=RVTE1aMsK9ksZRGI9UaUBgoW3SYqN0RSeIWyD_9agoQ,8328
-gllm_inference/lm_invoker/openai_chat_completions_lm_invoker.pyi,sha256=R8MMzhpKXN56WHzgS2w7UYkMSMF-oogfdythuy0t3Hs,16050
-gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi,sha256=Ad3RUYT1yGWGNSMRf8R8qw2pFEpdatnwsm6G0leh2kk,3913
-gllm_inference/lm_invoker/openai_lm_invoker.pyi,sha256=iG9Vakak5RENvN83K-L_kHBgRlSnikUlSBJg1-51edo,24279
-gllm_inference/lm_invoker/xai_lm_invoker.pyi,sha256=vEbWPniy8mnoHgbw0DUlBiLn91S0d4lIefxPEmIW97s,15994
+gllm_inference/lm_invoker/litellm_lm_invoker.pyi,sha256=FtrOu0h-M8jMToMPUzt7ngRtPBdRNmKYI4ewP-TplWc,13826
+gllm_inference/lm_invoker/lm_invoker.pyi,sha256=vUmMNEl7F__PavQJ42scoYGyWdEvZOw2Bwxhoqv_gKE,8659
+gllm_inference/lm_invoker/openai_chat_completions_lm_invoker.pyi,sha256=iwjwm9ZuxGZUVInNeknJUNqs56nnnQlw8ye_3cUkJ9M,16355
+gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi,sha256=T9sShA_9fgEuaaAuT2gJZq_EYNbEhf3IkWwMCwfszY8,4244
+gllm_inference/lm_invoker/openai_lm_invoker.pyi,sha256=ndXAsrnibKc9kk59t7enzteFrMfwinexCRVcDX6OgyA,24735
+gllm_inference/lm_invoker/xai_lm_invoker.pyi,sha256=4SnQdkomkIGZFswj2t-dx9yKRVAvs6PKc3MooBYkuxA,15773
 gllm_inference/lm_invoker/batch/__init__.pyi,sha256=vJOTHRJ83oq8Bq0UsMdID9_HW5JAxr06gUs4aPRZfEE,130
 gllm_inference/lm_invoker/batch/batch_operations.pyi,sha256=o2U17M41RKVFW6j_oxy-SxU1JqUtVt75pKRxrqXzorE,5499
 gllm_inference/lm_invoker/schema/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -117,7 +117,7 @@ gllm_inference/utils/io_utils.pyi,sha256=Eg7dvHWdXslTKdjh1j3dG50i7r35XG2zTmJ9XXv
 gllm_inference/utils/langchain.pyi,sha256=4AwFiVAO0ZpdgmqeC4Pb5NJwBt8vVr0MSUqLeCdTscc,1194
 gllm_inference/utils/validation.pyi,sha256=-RdMmb8afH7F7q4Ao7x6FbwaDfxUHn3hA3WiOgzB-3s,397
 gllm_inference.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
-gllm_inference_binary-0.5.38.dist-info/METADATA,sha256=Uysv4QWBKPE7Z5BebyI69N8fkhTvV4zDyr6DBOGaGVA,5770
-gllm_inference_binary-0.5.38.dist-info/WHEEL,sha256=O_u6PJIQ2pIcyIInxVQ9r-yArMuUZbBIaF1kpYVkYxA,96
-gllm_inference_binary-0.5.38.dist-info/top_level.txt,sha256=FpOjtN80F-qVNgbScXSEyqa0w09FYn6301iq6qt69IQ,15
-gllm_inference_binary-0.5.38.dist-info/RECORD,,
+gllm_inference_binary-0.5.39.dist-info/METADATA,sha256=fclPfv4h7mJziMKUfIgKXJJVXnT-OpvX8Aqnbg7m0go,5770
+gllm_inference_binary-0.5.39.dist-info/WHEEL,sha256=O_u6PJIQ2pIcyIInxVQ9r-yArMuUZbBIaF1kpYVkYxA,96
+gllm_inference_binary-0.5.39.dist-info/top_level.txt,sha256=FpOjtN80F-qVNgbScXSEyqa0w09FYn6301iq6qt69IQ,15
+gllm_inference_binary-0.5.39.dist-info/RECORD,,