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

gllm_inference/schema/activity.pyi

@@ -4,12 +4,13 @@ from pydantic import BaseModel
 from typing import Literal
 
 WEB_SEARCH_VISIBLE_FIELDS: Incomplete
+WebSearchActivityTypes: Incomplete
 
 class Activity(BaseModel):
     """Base schema for any activity.
 
     Attributes:
-        type (str): The type of activity being performed.
+        type (str): The type of activity being performed. Defaults to an empty string.
     """
     type: str
 
@@ -17,9 +18,10 @@ class MCPListToolsActivity(Activity):
     """Schema for listing tools in MCP.
 
     Attributes:
-        server_name (str): The name of the MCP server.
-        tools (list[dict[str, str]] | None): The tools in the MCP server.
-        type (str): The type of activity being performed.
+        type (Literal[ActivityType.MCP_LIST_TOOLS]): The type of activity being performed.
+            Defaults to ActivityType.MCP_LIST_TOOLS.
+        server_name (str): The name of the MCP server. Defaults to an empty string.
+        tools (list[dict[str, str]] | None): The tools in the MCP server. Defaults to None.
     """
     type: Literal[ActivityType.MCP_LIST_TOOLS]
     server_name: str
@@ -29,10 +31,10 @@ class MCPCallActivity(Activity):
     """Schema for MCP tool call.
 
     Attributes:
+        type (Literal[ActivityType.MCP_CALL]): The type of activity being performed. Defaults to ActivityType.MCP_CALL.
         server_name (str): The name of the MCP server.
         tool_name (str): The name of the tool.
         args (dict[str, str]): The arguments of the tool.
-        type (str): The type of activity being performed.
     """
     type: Literal[ActivityType.MCP_CALL]
     server_name: str
@@ -43,16 +45,16 @@ class WebSearchActivity(Activity):
     """Schema for web search tool call.
 
     Attributes:
-        type (str): The type of activity being performed.
-        pattern (str): The pattern of the web search.
-        url (str): The URL of the page.
-        query (str): The query of the web search.
+        type (WebSearchActivityTypes): The type of activity being performed. Defaults to ActivityType.SEARCH.
+        query (str | None): The query of the web search. Defaults to None.
+        url (str | None): The URL of the page. Defaults to None.
+        pattern (str | None): The pattern of the web search. Defaults to None.
         sources (list[dict[str, str]] | None): The sources of the web search.
     """
-    type: Literal[ActivityType.FIND_IN_PAGE, ActivityType.OPEN_PAGE, ActivityType.SEARCH]
+    type: WebSearchActivityTypes
+    query: str | None
     url: str | None
     pattern: str | None
-    query: str | None
     sources: list[dict[str, str]] | None
     def model_dump(self, *args, **kwargs) -> dict[str, str]:
         """Serialize the activity for display.

gllm_inference/schema/attachment.pyi

@@ -1,7 +1,9 @@
 from _typeshed import Incomplete
-from gllm_inference.constants import HEX_REPR_LENGTH as HEX_REPR_LENGTH
 from pydantic import BaseModel
+from typing import Any
 
+HEX_REPR_LENGTH: int
+METADATA_ITEM_REPR_LENGTH: int
 logger: Incomplete
 
 class Attachment(BaseModel):
@@ -13,68 +15,80 @@ class Attachment(BaseModel):
         mime_type (str): The mime type of the file attachment.
         extension (str): The extension of the file attachment.
         url (str | None): The URL of the file attachment. Defaults to None.
+        metadata (dict[str, Any]): The metadata of the file attachment. Defaults to an empty dictionary.
     """
     data: bytes
     filename: str
     mime_type: str
     extension: str
     url: str | None
+    metadata: dict[str, Any]
     @classmethod
-    def from_bytes(cls, bytes: bytes, filename: str | None = None) -> Attachment:
+    def from_bytes(cls, bytes: bytes, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
         """Creates an Attachment from bytes.
 
         Args:
             bytes (bytes): The bytes of the file.
             filename (str | None, optional): The filename of the file. Defaults to None,
                 in which case the filename will be derived from the extension.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
 
         Returns:
             Attachment: The instantiated Attachment.
         """
     @classmethod
-    def from_base64(cls, base64_data: str, filename: str | None = None) -> Attachment:
+    def from_base64(cls, base64_data: str, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
         """Creates an Attachment from a base64 string.
 
         Args:
             base64_data (str): The base64 string of the file.
             filename (str | None, optional): The filename of the file. Defaults to None,
                 in which case the filename will be derived from the mime type.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
 
         Returns:
             Attachment: The instantiated Attachment.
         """
     @classmethod
-    def from_data_url(cls, data_url: str, filename: str | None = None) -> Attachment:
+    def from_data_url(cls, data_url: str, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
         """Creates an Attachment from a data URL (data:[mime/type];base64,[bytes]).
 
         Args:
             data_url (str): The data URL of the file.
             filename (str | None, optional): The filename of the file. Defaults to None,
                 in which case the filename will be derived from the mime type.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
 
         Returns:
             Attachment: The instantiated Attachment.
         """
     @classmethod
-    def from_url(cls, url: str, filename: str | None = None) -> Attachment:
+    def from_url(cls, url: str, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
         """Creates an Attachment from a URL.
 
         Args:
             url (str): The URL of the file.
             filename (str | None, optional): The filename of the file. Defaults to None,
                 in which case the filename will be derived from the URL.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
 
         Returns:
             Attachment: The instantiated Attachment.
         """
     @classmethod
-    def from_path(cls, path: str, filename: str | None = None) -> Attachment:
+    def from_path(cls, path: str, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
         """Creates an Attachment from a path.
 
         Args:
             path (str): The path to the file.
             filename (str | None, optional): The filename of the file. Defaults to None,
                 in which case the filename will be derived from the path.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
 
         Returns:
             Attachment: The instantiated Attachment.

gllm_inference/schema/enums.pyi

@@ -9,11 +9,24 @@ class AttachmentType(StrEnum):
 
 class BatchStatus(StrEnum):
     """Defines the status of a batch job."""
-    CANCELING = 'canceling'
     IN_PROGRESS = 'in_progress'
     FINISHED = 'finished'
+    FAILED = 'failed'
+    CANCELING = 'canceling'
+    EXPIRED = 'expired'
     UNKNOWN = 'unknown'
 
+class LMEventType(StrEnum):
+    """Defines event types to be emitted by the LM invoker."""
+    ACTIVITY = 'activity'
+    CODE = 'code'
+    THINKING = 'thinking'
+
+class LMEventTypeSuffix(StrEnum):
+    """Defines suffixes for LM event types."""
+    START = '_start'
+    END = '_end'
+
 class EmitDataType(StrEnum):
     """Defines valid data types for emitting events."""
     ACTIVITY = 'activity'
@@ -24,6 +37,17 @@ class EmitDataType(StrEnum):
     THINKING_START = 'thinking_start'
     THINKING_END = 'thinking_end'
 
+class LMOutputType(StrEnum):
+    """Defines valid types for language model outputs."""
+    TEXT = 'text'
+    STRUCTURED = 'structured'
+    ATTACHMENT = 'attachment'
+    TOOL_CALL = 'tool_call'
+    THINKING = 'thinking'
+    CITATION = 'citation'
+    CODE_EXEC_RESULT = 'code_exec_result'
+    MCP_CALL = 'mcp_call'
+
 class ActivityType(StrEnum):
     """Defines valid activity types."""
     FIND_IN_PAGE = 'find_in_page'
@@ -44,6 +68,11 @@ class TruncateSide(StrEnum):
     RIGHT = 'RIGHT'
     LEFT = 'LEFT'
 
+class JinjaEnvType(StrEnum):
+    """Enumeration for Jinja environment types."""
+    JINJA_DEFAULT = 'jinja_default'
+    RESTRICTED = 'restricted'
+
 class WebSearchKey(StrEnum):
     """Defines valid web search keys."""
     PATTERN = 'pattern'

gllm_inference/schema/events.pyi

@@ -1,109 +1,105 @@
-from gllm_core.constants import EventLevel
+from _typeshed import Incomplete
+from gllm_core.constants import EventType
 from gllm_core.schema import Event
 from gllm_inference.schema.activity import Activity as Activity
-from gllm_inference.schema.enums import EmitDataType as EmitDataType
-from typing import Literal
+from typing import Any, Literal, Self
 
-class ActivityEvent(Event):
-    """Event schema for model-triggered activities (e.g. web search, MCP).
-
-    Attributes:
-        id (str): The unique identifier for the activity event. Defaults to an UUID string.
-        type (Literal): The type of event, always 'activity'.
-        value (Activity): The activity data containing message and type.
-        level (EventLevel): The severity level of the event. Defined through the EventLevel constants.
-    """
-    id: str
-    type: Literal[EmitDataType.ACTIVITY]
-    value: Activity
-    level: EventLevel
+CodeEventType: Incomplete
+ThinkingEventType: Incomplete
 
-class CodeEvent(Event):
-    """Event schema for model-triggered code execution.
+class ActivityEvent(Event):
+    """Event schema for model-triggered activities (e.g. web search, MCP call, etc.).
 
     Attributes:
-        id (str): The unique identifier for the code event. Defaults to an UUID string.
-        type (Literal): The type of event (code, code_start, or code_end).
-        value (str): The code content.
-        level (EventLevel): The severity level of the event. Defined through the EventLevel constants.
+        id (str): The ID of the activity event. Defaults to None.
+        value (dict[str, Any]): The value of the activity event.
+        level (EventLevel): The severity level of the activity event. Defaults to EventLevel.INFO.
+        type (Literal[EventType.ACTIVITY]): The type of the activity event. Defaults to EventType.ACTIVITY.
+        timestamp (datetime): The timestamp of the activity event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the activity event. Defaults to an empty dictionary.
     """
-    id: str
-    type: Literal[EmitDataType.CODE, EmitDataType.CODE_START, EmitDataType.CODE_END]
-    value: str
-    level: EventLevel
-    @classmethod
-    def start(cls, id: str | None = None) -> CodeEvent:
-        """Create a code start event.
-
-        Args:
-            id (str | None): The unique identifier for the code event. Defaults to an UUID string.
-
-        Returns:
-            CodeEvent: The code start event.
-        """
-    @classmethod
-    def content(cls, id: str | None = None, value: str = '') -> CodeEvent:
-        """Create a code content event.
-
-        Args:
-            id (str | None): The unique identifier for the code event. Defaults to an UUID string.
-            value (str): The code content.
-
-        Returns:
-            CodeEvent: The code value event.
-        """
+    value: dict[str, Any]
+    type: Literal[EventType.ACTIVITY]
     @classmethod
-    def end(cls, id: str | None = None) -> CodeEvent:
-        """Create a code end event.
+    def from_activity(cls, id_: str | None = None, activity: Activity | None = None) -> ActivityEvent:
+        """Create an activity event from an Activity object.
 
         Args:
-            id (str | None): The unique identifier for the code event. Defaults to an UUID string.
+            id_ (str | None, optional): The ID of the activity event. Defaults to None.
+            activity (Activity | None, optional): The activity object to create the event from.
+                Defaults to None, in which case the value will be an empty dictionary.
 
         Returns:
-            CodeEvent: The code end event.
+            ActivityEvent: The activity event.
         """
 
-class ThinkingEvent(Event):
-    """Event schema for model thinking.
+class BlockBasedEvent(Event):
+    """Event schema block-based events, which are limited by start and end events.
 
     Attributes:
-        id (str): The unique identifier for the thinking event. Defaults to an UUID string.
-        type (Literal): The type of thinking event (thinking, thinking_start, or thinking_end).
-        value (str): The thinking content or message.
-        level (EventLevel): The severity level of the event. Defined through the EventLevel constants.
+        id (str): The ID of the block-based event. Defaults to None.
+        value (str): The value of the block-based event. Defaults to an empty string.
+        level (EventLevel): The severity level of the block-based event. Defaults to EventLevel.INFO.
+        type (str): The type of the block-based event. Defaults to an empty string.
+        timestamp (datetime): The timestamp of the block-based event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the block-based event. Defaults to an empty dictionary.
     """
-    id: str
-    type: Literal[EmitDataType.THINKING, EmitDataType.THINKING_START, EmitDataType.THINKING_END]
     value: str
-    level: EventLevel
+    type: str
     @classmethod
-    def start(cls, id: str | None = None) -> ThinkingEvent:
-        """Create a thinking start event.
+    def start(cls, id_: str | None = None) -> Self:
+        """Create a block-based start event.
 
         Args:
-            id (str | None): The unique identifier for the thinking event. Defaults to an UUID string.
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
 
         Returns:
-            ThinkingEvent: The thinking start event.
+            Self: The block-based start event.
         """
     @classmethod
-    def content(cls, id: str | None = None, value: str = '') -> ThinkingEvent:
-        """Create a thinking value event.
+    def content(cls, id_: str | None = None, value: str = '') -> Self:
+        """Create a block-based content event.
 
         Args:
-            id (str | None): The unique identifier for the thinking event. Defaults to an UUID string.
-            value (str): The thinking content or message.
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
+            value (str, optional): The block-based content. Defaults to an empty string.
 
         Returns:
-            ThinkingEvent: The thinking value event.
+            Self: The block-based content event.
         """
     @classmethod
-    def end(cls, id: str | None = None) -> ThinkingEvent:
-        """Create a thinking end event.
+    def end(cls, id_: str | None = None) -> Self:
+        """Create a block-based end event.
 
         Args:
-            id (str | None): The unique identifier for the thinking event. Defaults to an UUID string.
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
 
         Returns:
-            ThinkingEvent: The thinking end event.
+            Self: The block-based end event.
         """
+
+class CodeEvent(BlockBasedEvent):
+    """Event schema for model-generated code to be executed.
+
+    Attributes:
+        id (str): The ID of the code event. Defaults to None.
+        value (str): The value of the code event. Defaults to an empty string.
+        level (EventLevel): The severity level of the code event. Defaults to EventLevel.INFO.
+        type (CodeEventType): The type of the code event. Defaults to EventType.CODE.
+        timestamp (datetime): The timestamp of the code event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the code event. Defaults to an empty dictionary.
+    """
+    type: CodeEventType
+
+class ThinkingEvent(BlockBasedEvent):
+    """Event schema for model-generated thinking.
+
+    Attributes:
+        id (str): The ID of the thinking event. Defaults to None.
+        value (str): The value of the thinking event. Defaults to an empty string.
+        level (EventLevel): The severity level of the thinking event. Defaults to EventLevel.INFO.
+        type (ThinkingEventType): The type of the thinking event. Defaults to EventType.THINKING.
+        timestamp (datetime): The timestamp of the thinking event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the thinking event. Defaults to an empty dictionary.
+    """
+    type: ThinkingEventType

gllm_inference/schema/formatter.pyi

@@ -0,0 +1,31 @@
+from gllm_inference.schema.enums import MessageRole as MessageRole
+from gllm_inference.schema.message import Message as Message
+from gllm_inference.schema.type_alias import MessageContent as MessageContent
+from pydantic import BaseModel
+
+class HistoryFormatter(BaseModel):
+    """Configuration for history formatting.
+
+    Attributes:
+        prefix_user_message (str): Prefix for user messages.
+        suffix_user_message (str): Suffix for user messages.
+        prefix_assistant_message (str): Prefix for assistant messages.
+        suffix_assistant_message (str): Suffix for assistant messages.
+    """
+    prefix_user_message: str
+    suffix_user_message: str
+    prefix_assistant_message: str
+    suffix_assistant_message: str
+    def format_history(self, history: list[Message]) -> list[Message]:
+        """Formats a list of messages based on their roles.
+
+        This method formats each message in the history list by applying the appropriate
+        formatting based on the message role (user or assistant). Other message types
+        are added to the result without modification.
+
+        Args:
+            history (list[Message]): The list of messages to format.
+
+        Returns:
+            list[Message]: A new list containing the formatted messages.
+        """