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

gllm_inference/lm_invoker/xai_lm_invoker.pyi

@@ -1,14 +1,13 @@
 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_core.schema import Tool as Tool
+from gllm_core.utils import RetryConfig as RetryConfig
 from gllm_inference.constants import GRPC_ENABLE_RETRIES_KEY as GRPC_ENABLE_RETRIES_KEY, 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 GRPC_STATUS_CODE_MAPPING as GRPC_STATUS_CODE_MAPPING
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.xai import Key as Key, ReasoningEffort as ReasoningEffort
 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, Reasoning as Reasoning, ResponseSchema as ResponseSchema, ThinkingEvent as ThinkingEvent, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
-from gllm_inference.utils.validation import validate_string_enum as validate_string_enum
 from langchain_core.tools import Tool as LangChainTool
 from typing import Any
 
@@ -50,115 +49,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 +158,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 +209,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 +216,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/model/__init__.pyi

@@ -1,9 +1,13 @@
+from gllm_inference.model.em.cohere_em import CohereEM as CohereEM
 from gllm_inference.model.em.google_em import GoogleEM as GoogleEM
+from gllm_inference.model.em.jina_em import JinaEM as JinaEM
 from gllm_inference.model.em.openai_em import OpenAIEM as OpenAIEM
 from gllm_inference.model.em.twelvelabs_em import TwelveLabsEM as TwelveLabsEM
 from gllm_inference.model.em.voyage_em import VoyageEM as VoyageEM
 from gllm_inference.model.lm.anthropic_lm import AnthropicLM as AnthropicLM
 from gllm_inference.model.lm.google_lm import GoogleLM as GoogleLM
 from gllm_inference.model.lm.openai_lm import OpenAILM as OpenAILM
+from gllm_inference.model.lm.sea_lion_lm import SeaLionLM as SeaLionLM
+from gllm_inference.model.lm.xai_lm import XAILM as XAILM
 
-__all__ = ['AnthropicLM', 'GoogleEM', 'GoogleLM', 'OpenAIEM', 'OpenAILM', 'TwelveLabsEM', 'VoyageEM']
+__all__ = ['AnthropicLM', 'CohereEM', 'GoogleEM', 'GoogleLM', 'JinaEM', 'OpenAIEM', 'OpenAILM', 'SeaLionLM', 'TwelveLabsEM', 'VoyageEM', 'XAILM']

gllm_inference/model/em/cohere_em.pyi

@@ -0,0 +1,17 @@
+class CohereEM:
+    '''Defines Cohere embedding model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import CohereEM
+    from gllm_inference.em_invoker import CohereEMInvoker
+
+    em_invoker = CohereEMInvoker(CohereEM.EMBED_V4_0)
+    result = await em_invoker.invoke("Hello, world!")
+    ```
+    '''
+    EMBED_V4_0: str
+    EMBED_ENGLISH_V3_0: str
+    EMBED_ENGLISH_LIGHT_V3_0: str
+    EMBED_MULTILINGUAL_V3_0: str
+    EMBED_MULTILINGUAL_LIGHT_V3_0: str

gllm_inference/model/em/jina_em.pyi

@@ -0,0 +1,22 @@
+class JinaEM:
+    '''Defines Jina embedding model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import JinaEM
+    from gllm_inference.em_invoker import JinaEMInvoker
+
+    em_invoker = JinaEMInvoker(JinaEM.JINA_EMBEDDINGS_V4)
+    result = await em_invoker.invoke("Hello, world!")
+    ```
+    '''
+    JINA_EMBEDDINGS_V4: str
+    JINA_EMBEDDINGS_V3: str
+    JINA_EMBEDDINGS_V2_BASE_EN: str
+    JINA_EMBEDDINGS_V2_BASE_CODE: str
+    JINA_CLIP_V2: str
+    JINA_CLIP_V1: str
+    JINA_CODE_EMBEDDINGS_1_5B: str
+    JINA_CODE_EMBEDDINGS_0_5B: str
+    JINA_COLBERT_V2: str
+    JINA_COLBERT_V1_EN: str

gllm_inference/model/lm/anthropic_lm.pyi

@@ -12,9 +12,11 @@ class AnthropicLM:
     '''
     CLAUDE_OPUS_4_1: str
     CLAUDE_OPUS_4: str
+    CLAUDE_SONNET_4_5: str
     CLAUDE_SONNET_4: str
     CLAUDE_SONNET_3_7: str
     CLAUDE_SONNET_3_5: str
+    CLAUDE_HAIKU_4_5: str
     CLAUDE_HAIKU_3_5: str
     CLAUDE_OPUS_3: str
     CLAUDE_HAIKU_3: str

gllm_inference/model/lm/google_lm.pyi

@@ -12,6 +12,7 @@ class GoogleLM:
     '''
     GEMINI_2_5_PRO: str
     GEMINI_2_5_FLASH: str
+    GEMINI_2_5_FLASH_IMAGE: str
     GEMINI_2_5_FLASH_LITE: str
     GEMINI_2_0_FLASH: str
     GEMINI_2_0_FLASH_LITE: str

gllm_inference/model/lm/sea_lion_lm.pyi

@@ -0,0 +1,16 @@
+class SeaLionLM:
+    '''Defines SEA-LION language model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import SeaLionLM
+    from gllm_inference.lm_invoker import SeaLionLMInvoker
+
+    lm_invoker = SeaLionLMInvoker(SeaLionLM.GEMMA_SEA_LION_V4_27B_IT)
+    response = await lm_invoker.invoke("Hello, world!")
+    ```
+    '''
+    GEMMA_SEA_LION_V4_27B_IT: str
+    LLAMA_SEA_LION_V3_5_70B_R: str
+    LLAMA_SEA_LION_V3_70B_IT: str
+    QWEN_SEA_LION_V4_32B_IT: str

gllm_inference/model/lm/xai_lm.pyi

@@ -0,0 +1,19 @@
+class XAILM:
+    '''Defines XAI language model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import XAILM
+    from gllm_inference.lm_invoker import XAILMInvoker
+
+    lm_invoker = XAILMInvoker(XAILM.GROK_4_FAST_REASONING)
+    response = await lm_invoker.invoke("Hello, world!")
+    ```
+    '''
+    GROK_CODE_FAST_1: str
+    GROK_4_FAST_REASONING: str
+    GROK_4_FAST_NON_REASONING: str
+    GROK_4_0709: str
+    GROK_3_MINI: str
+    GROK_3: str
+    GROK_2_VISION_1212: str

gllm_inference/prompt_builder/format_strategy/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.prompt_builder.format_strategy.jinja_format_strategy import JinjaFormatStrategy as JinjaFormatStrategy
+from gllm_inference.prompt_builder.format_strategy.string_format_strategy import StringFormatStrategy as StringFormatStrategy
+
+__all__ = ['StringFormatStrategy', 'JinjaFormatStrategy']

gllm_inference/prompt_builder/format_strategy/format_strategy.pyi

@@ -0,0 +1,55 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC, abstractmethod
+from gllm_inference.schema.message import MessageContent as MessageContent
+
+class BasePromptFormattingStrategy(ABC, metaclass=abc.ABCMeta):
+    """Base class for prompt formatting strategies.
+
+    This class defines the interface for different prompt templating engines. Subclasses
+    implement specific formatting strategies to render templates with variable
+    substitution.
+
+    The strategy pattern allows the PromptBuilder to work with different templating engines
+    without changing its core logic.
+
+    Attributes:
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    key_defaults: Incomplete
+    def __init__(self, key_defaults: dict[str, str] | None = None) -> None:
+        """Initialize the BasePromptFormattingStrategy.
+
+        Args:
+            key_defaults (dict[str, str] | None, optional): The default values for the keys. Defaults to None,
+                in which case no default values are used.
+        """
+    def format(self, template: str, variables_map: dict[str, str] | None = None, extra_contents: list[MessageContent] | None = None) -> list[str]:
+        """Format template with variables using the template method pattern.
+
+        This is a template method that defines the algorithm for formatting:
+        1. Merge key_defaults and variables_map
+        2. Render the template (delegated to subclass via _render_template)
+        3. Append extra_contents to the result
+
+        Args:
+            template (str): Template string to format.
+            variables_map (dict[str, str] | None, optional): Variables for substitution. Defaults to None.
+            extra_contents (list[MessageContent] | None, optional): Extra contents to format. Defaults to None.
+
+        Returns:
+            str: Formatted template string.
+        """
+    @abstractmethod
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract variable keys from template.
+
+        Args:
+            template (str | None): Template string to extract keys from.
+
+        Returns:
+            set[str]: Set of variable keys found in template.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """

gllm_inference/prompt_builder/format_strategy/jinja_format_strategy.pyi

@@ -0,0 +1,45 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_builder.format_strategy.format_strategy import BasePromptFormattingStrategy as BasePromptFormattingStrategy
+from gllm_inference.schema import JinjaEnvType as JinjaEnvType
+from jinja2.sandbox import SandboxedEnvironment
+from typing import Any
+
+JINJA_DEFAULT_BLACKLISTED_FILTERS: list[str]
+JINJA_DEFAULT_SAFE_GLOBALS: dict[str, Any]
+JINJA_DANGEROUS_PATTERNS: list[str]
+PROMPT_BUILDER_VARIABLE_START_STRING: str
+PROMPT_BUILDER_VARIABLE_END_STRING: str
+
+class JinjaFormatStrategy(BasePromptFormattingStrategy):
+    """Jinja2 template engine for formatting prompts.
+
+    Attributes:
+        jinja_env (SandboxedEnvironment): The Jinja environment for rendering templates.
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    jinja_env: Incomplete
+    def __init__(self, environment: JinjaEnvType | SandboxedEnvironment = ..., key_defaults: dict[str, str] | None = None) -> None:
+        """Initialize the JinjaFormatStrategy.
+
+        Args:
+            environment (JinjaEnvType | SandboxedEnvironment, optional): The environment for Jinja rendering.
+                It can be one of the following:
+                1. `JinjaEnvType.RESTRICTED`: Uses a minimal, restricted Jinja environment.
+                        Safest for most cases.
+                2. `JinjaEnvType.JINJA_DEFAULT`: Uses the full Jinja environment. Allows more powerful templating,
+                        but with fewer safety restrictions.
+                3. `SandboxedEnvironment` instance: A custom Jinja `SandboxedEnvironment` object provided by the
+                        user. Offers fine-grained control over template execution.
+                Defaults to `JinjaEnvType.RESTRICTED`
+            key_defaults (dict[str, str], optional): The default values for the keys. Defaults to None, in which
+                case no default values are used.
+        """
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract keys from Jinja template using AST analysis.
+
+        Args:
+            template (str | None): The template to extract keys from.
+
+        Returns:
+            set[str]: The set of keys found in the template.
+        """

gllm_inference/prompt_builder/format_strategy/string_format_strategy.pyi

@@ -0,0 +1,20 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_builder.format_strategy.format_strategy import BasePromptFormattingStrategy as BasePromptFormattingStrategy
+
+KEY_EXTRACTOR_REGEX: Incomplete
+
+class StringFormatStrategy(BasePromptFormattingStrategy):
+    """String format strategy using str.format() method.
+
+    Attributes:
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract keys from a template.
+
+        Args:
+            template (str | None): The template to extract keys from.
+
+        Returns:
+            set[str]: The set of keys found in the template.
+        """

gllm_inference/prompt_builder/prompt_builder.pyi

@@ -1,9 +1,9 @@
 from _typeshed import Incomplete
-from gllm_inference.schema import Message as Message, MessageContent as MessageContent, MessageRole as MessageRole
+from gllm_inference.prompt_builder.format_strategy import JinjaFormatStrategy as JinjaFormatStrategy, StringFormatStrategy as StringFormatStrategy
+from gllm_inference.schema import HistoryFormatter as HistoryFormatter, JinjaEnvType as JinjaEnvType, Message as Message, MessageContent as MessageContent, MessageRole as MessageRole
+from jinja2.sandbox import SandboxedEnvironment as SandboxedEnvironment
 from typing import Any
 
-KEY_EXTRACTOR_REGEX: Incomplete
-
 class PromptBuilder:
     """A prompt builder class used in Gen AI applications.
 
@@ -12,12 +12,16 @@ class PromptBuilder:
         user_template (str): The user prompt template. May contain placeholders enclosed in curly braces `{}`.
         prompt_key_set (set[str]): A set of expected keys that must be present in the prompt templates.
         key_defaults (dict[str, str]): Default values for the keys in the prompt templates.
+        strategy (BasePromptFormattingStrategy): The format strategy to be used for formatting the prompt.
+        history_formatter (HistoryFormatter): The history formatter to be used for formatting the history.
     """
+    key_defaults: Incomplete
     system_template: Incomplete
     user_template: Incomplete
+    history_formatter: Incomplete
+    strategy: Incomplete
     prompt_key_set: Incomplete
-    key_defaults: Incomplete
-    def __init__(self, system_template: str = '', user_template: str = '', key_defaults: dict[str, str] | None = None, ignore_extra_keys: bool | None = None) -> None:
+    def __init__(self, system_template: str = '', user_template: str = '', key_defaults: dict[str, str] | None = None, ignore_extra_keys: bool | None = None, history_formatter: HistoryFormatter | None = None, use_jinja: bool | None = False, jinja_env: JinjaEnvType | SandboxedEnvironment | None = None) -> None:
         """Initializes a new instance of the PromptBuilder class.
 
         Args:
@@ -30,6 +34,19 @@ class PromptBuilder:
                 Defaults to None, in which case no default values will be assigned to the keys.
             ignore_extra_keys (bool | None, optional): Deprecated parameter. Will be removed in v0.6. Extra keys
                 will always raise a warning only instead of raising an error.
+            history_formatter (HistoryFormatter | None, optional): The history formatter to be used for formatting
+                the history. Defaults to None, in which case the history will be used as is.
+            use_jinja (bool, optional): Whether to use Jinja for rendering the prompt templates.
+                Defaults to False.
+            jinja_env (JinjaEnvType | SandboxedEnvironment, optional): The environment for Jinja rendering.
+                It can be one of the following:
+                1. `JinjaEnvType.RESTRICTED`: Uses a minimal, restricted Jinja environment.
+                        Safest for most cases.
+                2. `JinjaEnvType.JINJA_DEFAULT`: Uses the full Jinja environment. Allows more powerful templating,
+                        but with fewer safety restrictions.
+                3. `SandboxedEnvironment` instance: A custom Jinja `SandboxedEnvironment` object provided by the
+                        user. Offers fine-grained control over template execution.
+                Defaults to `JinjaEnvType.RESTRICTED`
 
         Raises:
             ValueError: If both `system_template` and `user_template` are empty.
@@ -49,7 +66,7 @@ class PromptBuilder:
                 Values must be either a string or an object that can be serialized to a string.
 
         Returns:
-            list[Message]: A formatted list of messages.
+            list[Message]: A list of formatted messages.
 
         Raises:
             ValueError: If a required key for the prompt template is missing from `kwargs`.

gllm_inference/schema/__init__.pyi

@@ -2,10 +2,11 @@ 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, 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.formatter import HistoryFormatter as HistoryFormatter
 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 +16,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', 'InputTokenDetails', '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', 'HistoryFormatter', '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']