gllm-core-binary 0.3.34__cp312-cp312-win_amd64.whl → 0.4.1__cp312-cp312-win_amd64.whl

gllm_core/adapters/tool/langchain.pyi

@@ -1,25 +1,9 @@
-from _typeshed import Incomplete
 from gllm_core.schema.tool import Tool as Tool
 from typing import Any
 
-class LangChainToolKeys:
-    """Constants for LangChain tool attribute keys."""
-    FUNC: str
-    COROUTINE: str
-    RUN: str
-    ARUN: str
-    NAME: str
-    DESCRIPTION: str
-    ARGS_SCHEMA: str
-
-LANGCHAIN_FUNCTION_ATTRS: Incomplete
-
 def from_langchain_tool(langchain_tool: Any) -> Tool:
     """Convert a LangChain tool into the SDK Tool representation.
 
-    This function handles both traditional LangChain tools created with the @tool decorator
-    and tools created by subclassing the LangChain Tool class.
-
     Args:
         langchain_tool (Any): The LangChain tool to convert.
 

gllm_core/constants.pyi

@@ -13,7 +13,6 @@ class EventType(StrEnum):
     """Defines event types for the event emitter module."""
     ACTIVITY = 'activity'
     CODE = 'code'
-    DATA = 'data'
     REFERENCE = 'reference'
     RESPONSE = 'response'
     STATUS = 'status'

gllm_core/event/event_emitter.pyi

@@ -1,11 +1,11 @@
 from _typeshed import Incomplete
-from gllm_core.constants import EventLevel as EventLevel, EventType as EventType
+from gllm_core.constants import EventLevel as EventLevel
 from gllm_core.event.handler import ConsoleEventHandler as ConsoleEventHandler, PrintEventHandler as PrintEventHandler, StreamEventHandler as StreamEventHandler
 from gllm_core.event.handler.event_handler import BaseEventHandler as BaseEventHandler
 from gllm_core.event.hook.event_hook import BaseEventHook as BaseEventHook
 from gllm_core.schema import Event as Event
 from gllm_core.utils import validate_string_enum as validate_string_enum
-from typing import Any, AsyncGenerator
+from typing import AsyncGenerator
 
 class EventEmitter:
     '''Handles events emitting using event handlers with various levels and types.
@@ -123,31 +123,19 @@ class EventEmitter:
         Returns:
             EventEmitter: A new instance of the EventEmitter class with a single StreamEventHandler.
         """
-    async def emit(self, value: str | dict[str, Any] | Event, event_level: EventLevel = ..., event_type: str = ..., metadata: dict[str, Any] | None = None, event_id: str | None = None, disabled_handlers: list[str] | None = None) -> None:
-        '''Emits an event using the configured event handlers.
+    async def emit(self, event: Event, disabled_handlers: list[str] | None = None) -> None:
+        """Emits an event using the configured event handlers.
 
-        If the value is an Event object, it is used directly and other parameters are ignored.
-        Otherwise, a new Event object is created with the provided parameters. The event is
-        then passed to all handlers except those listed in disabled_handlers. Events are only
-        processed if their severity level meets or exceeds the EventEmitter\'s configured level.
+        Events are emitted by passing them to all handlers except those listed in disabled_handlers.
+        Events are only processed if their severity level meets or exceeds the EventEmitter's configured level.
 
         Args:
-            value (str | dict[str, Any] | Event): The event value or Event object to emit. If an Event object
-                is provided, other parameters are ignored and the Event is used as-is.
-            event_level (EventLevel, optional): The severity level of the event.
-                Defaults to EventLevel.DEBUG.
-            event_type (str, optional): The type of event (e.g., "status", "response").
-                Defaults to EventType.STATUS.value.
-            metadata (dict[str, Any] | None, optional): Additional metadata for the event.
-                Defaults to None, which creates an empty dictionary.
-            event_id (str | None, optional): Unique identifier for the event.
-                Defaults to None, which creates an empty string.
-            disabled_handlers (list[str] | None, optional): Names of handlers to skip for
-                this event. Defaults to None.
+            event (Event): The event to emit.
+            disabled_handlers (list[str] | None, optional): Names of handlers to skip for this event. Defaults to None.
 
         Raises:
             ValueError: If the provided event_level is not a valid EventLevel.
-        '''
+        """
     async def close(self) -> None:
         """Closes all handlers in the handler list.
 

gllm_core/event/handler/console_event_handler.pyi

@@ -1,5 +1,4 @@
 from _typeshed import Incomplete
-from gllm_core.constants import EventType as EventType
 from gllm_core.event.handler.event_handler import BaseEventHandler as BaseEventHandler
 from gllm_core.schema import Event as Event
 

gllm_core/event/handler/print_event_handler.pyi

@@ -15,7 +15,7 @@ class PrintEventHandler(BaseEventHandler):
     """
     padding_char: Incomplete
     console: Incomplete
-    def __init__(self, name: str | None = None, color_map: dict[str, str] | None = None, padding_char: str = '=', separator_length: int | None = None) -> None:
+    def __init__(self, name: str | None = None, color_map: dict[str, str] | None = None, padding_char: str = '=') -> None:
         '''Initializes a new instance of the PrintEventHandler class.
 
         Args:
@@ -24,7 +24,6 @@ class PrintEventHandler(BaseEventHandler):
             color_map (dict[str, str], optional): The dictionary that maps certain event types to their corresponding
                 colors in Rich format. Defaults to None, in which case the default color map will be used.
             padding_char (str, optional): The character to use for padding. Defaults to "=".
-            separator_length (int | None, optional): Deprecated parameter. Defaults to None.
         '''
     async def emit(self, event: Event) -> None:
         """Emits the given event.

gllm_core/schema/component.pyi

@@ -1,43 +1,70 @@
-import abc
-from abc import ABC
 from gllm_core.event.event_emitter import EventEmitter as EventEmitter
+from gllm_core.schema.schema_generator import generate_params_model as generate_params_model
 from gllm_core.utils import BinaryHandlingStrategy as BinaryHandlingStrategy, binary_handler_factory as binary_handler_factory
-from gllm_core.utils.analyzer import MethodSignature as MethodSignature, ParameterInfo as ParameterInfo, ParameterKind as ParameterKind, RunAnalyzer as RunAnalyzer, RunProfile as RunProfile
+from gllm_core.utils.analyzer import MethodSignature as MethodSignature, ParameterInfo as ParameterInfo, ParameterKind as ParameterKind, RunProfile as RunProfile, analyze_method as analyze_method
 from gllm_core.utils.logger_manager import LoggerManager as LoggerManager
+from gllm_core.utils.main_method_resolver import MainMethodResolver as MainMethodResolver
+from pydantic import BaseModel as BaseModel
 from typing import Any, Callable
 
 def main(method: Callable) -> Callable:
     """Decorate a Component method as the async main entrypoint.
 
-    Note:
-        In v0.3, this decorator marks the method for forward compatibility
-        with v0.4+. The actual main method resolution still uses `_run()`.
+    Usage:
+        Declare the coroutine that should act as the primary execution path
+        for a `Component` subclass. The decorated coroutine will be resolved by
+        `Component.run()` unless another subclass overrides the decoration.
 
     Args:
         method (Callable): Coroutine to mark as the main entrypoint.
 
     Returns:
-        Callable: The same coroutine, unchanged except for an `__is_main__` marker.
+        Callable: The same coroutine that is passed to the decorator. The decorator only marks the method as the main
+            entrypoint. It does not wrap or change its behavior or signature.
 
-    Warns:
-        UserWarning: If the decorated callable is not asynchronous.
+    Raises:
+        TypeError: If the decorated callable is not asynchronous.
     """
 
-class Component(ABC, metaclass=abc.ABCMeta):
+class Component:
     '''An abstract base class for all components used throughout the Gen AI applications.
 
     Every instance of Component has access to class-level `_default_log_level` and `_logger`, as detailed below.
     For components that require high observability, it is recommended to set `_default_log_level` to `logging.INFO`
     or higher.
 
-    Example:
-    ```python
-    class MyComponent(Component):
-        _default_log_level = logging.INFO
+    Defining Custom Components:
+        There are two ways to define the main execution logic for a component:
 
-        def _run(self, **kwargs: Any) -> Any:
-            return "Hello, World!"
-    ```
+        1. **Using the @main decorator (Recommended)**:
+           Decorate an async method with `@main` to mark it as the primary entrypoint.
+           This is the preferred approach as it provides explicit control over the main method.
+
+           ```python
+           class MyComponent(Component):
+               _default_log_level = logging.INFO
+
+               @main
+               async def execute(self, **kwargs: Any) -> Any:
+                   return "Hello from @main!"
+           ```
+
+        2. **Implementing _run method (Deprecated)**:
+           Override the abstract `_run` method. This is the traditional approach and still supported.
+
+           ```python
+           class MyComponent(Component):
+               _default_log_level = logging.INFO
+
+               async def _run(self, **kwargs: Any) -> Any:
+                   return "Hello, World!"
+           ```
+
+        The `run()` method resolves the main entrypoint using the following precedence:
+        1. Method decorated with @main in the current class.
+        2. Method decorated with @main in the nearest ancestor class.
+        3. Method named in __main_method__ property.
+        4. The _run method (with deprecation warning).
 
     Attributes:
         run_profile (RunProfile): The profile of the `_run` method.
@@ -48,21 +75,93 @@ class Component(ABC, metaclass=abc.ABCMeta):
             **Do not override this property in your subclass.**
 
             You also do not need to write this attribute in your component\'s docstring.
-        _default_log_level (int): The default log level for the component. Defaults to DEBUG.
-        _logger (logging.Logger): The logger instance for the component.
     '''
+    def __init_subclass__(cls, **kwargs) -> None:
+        """Hook called when a subclass is created.
+
+        This validates the __main_method__ property and checks for multiple @main decorators
+        within the current class definition. Uses MainMethodResolver for consistent validation logic.
+
+        Note: Multiple inheritance conflicts are intentionally deferred to runtime (get_main())
+        to allow class definition to succeed.
+
+        Raises:
+            AttributeError: If __main_method__ refers to a non-existent method.
+            TypeError: If multiple methods are decorated with @main in the same class.
+        """
+    @classmethod
+    def get_main(cls) -> Callable | None:
+        """Return the resolved main coroutine for this Component class.
+
+        This method resolves the main method for the Component class following
+        the precedence rules:
+        1. Most derived coroutine decorated with `@main`.
+        2. Method named by `__main_method__`.
+        3. `_run` coroutine as a deprecated fallback.
+
+        Results are cached for performance.
+
+        Returns:
+            Callable | None: The coroutine that will be executed by `run()` or
+                `None` when no entrypoint can be determined.
+
+        Raises:
+            TypeError: If conflicting main methods are inherited from multiple ancestors.
+        """
+    @property
+    def input_params(self) -> type[BaseModel] | None:
+        '''Return the Pydantic model describing this component\'s main method input parameters.
+
+        Returns:
+            type[BaseModel] | None: The cached model that mirrors the signature of
+                the resolved main method, or `None` if no main method can be
+                determined.
+
+        Example:
+            ```python
+            from pydantic import ValidationError
+
+            component = SomeComponent()
+            ParamsModel = component.input_params
+            assert ParamsModel.__name__ == "SomeComponentParams"
+            fields = list(ParamsModel.model_fields)
+
+            # Validation with valid params
+            params = ParamsModel(text="hello")
+
+            # Validation catches missing required fields
+            try:
+                invalid_params = ParamsModel()  # Missing required \'text\' field
+            except ValidationError as e:
+                print(f"Validation failed: {e.error_count()} errors")
+
+            # Argument construction
+            payload = params.model_dump()
+            result = await component.run(**payload)
+            ```
+        '''
     async def run(self, **kwargs: Any) -> Any:
         """Runs the operations defined for the component.
 
-        This method emits the provided input arguments using an EventEmitter instance if available, executes a process
-        defined in the `_run` method, and emits the resulting output if the EventEmitter is provided.
+        This method emits the provided input arguments using an EventEmitter instance if available, executes the
+        resolved main method, and emits the resulting output if the EventEmitter is provided.
+
+        The main method is resolved using the following precedence:
+        1. Method decorated with @main in the current class.
+        2. Method decorated with @main in the nearest ancestor class.
+        3. Method named in __main_method__ property.
+        4. The _run method (with deprecation warning).
 
         Args:
             **kwargs (Any): A dictionary of arguments to be processed. May include an `event_emitter`
                 key with an EventEmitter instance.
 
         Returns:
-            Any: The result of the `_run` method.
+            Any: The result of the resolved main method.
+
+        Raises:
+            TypeError: If conflicting main methods are inherited from multiple ancestors.
+            AttributeError: If __main_method__ refers to a non-existent method.
         """
     @property
     def run_profile(self) -> RunProfile:

gllm_core/schema/schema_generator.pyi

@@ -0,0 +1,35 @@
+from gllm_core.utils.analyzer import analyze_method as analyze_method
+from pydantic import BaseModel as BaseModel
+from typing import Callable
+
+def generate_params_model(method: Callable, class_name: str) -> type[BaseModel]:
+    '''Generate a Pydantic model representing a component method signature.
+
+    The generated class is named `{class_name}Params` and contains one field for
+    every parameter in `method`. The first `self` parameter is ignored, `*args` are
+    skipped entirely, and `**kwargs` trigger `extra="allow"` to permit arbitrary
+    keyword arguments at runtime.
+
+    For legacy `_run` methods with only `**kwargs`, this function will use
+    RunAnalyzer to infer parameters from the method body usage patterns.
+
+    Args:
+        method (Callable): Method whose signature should be represented.
+        class_name (str): Component class name used to derive the generated model name.
+
+    Returns:
+        type[BaseModel]: A Pydantic `BaseModel` subclass describing the method\'s
+            parameters.
+
+    Example:
+        ```python
+        class_name = "TextProcessor"
+
+        def process(self, text: str, count: int = 5) -> str:
+            return text * count
+
+        Model = generate_params_model(process, class_name)
+        assert Model.__name__ == "TextProcessorParams"
+        assert Model(text="hello", count=2).model_dump() == {"text": "hello", "count": 2}
+        ```
+    '''

gllm_core/utils/__init__.pyi

@@ -5,8 +5,9 @@ from gllm_core.utils.concurrency import asyncify as asyncify, get_default_portal
 from gllm_core.utils.event_formatter import format_chunk_message as format_chunk_message, get_placeholder_keys as get_placeholder_keys
 from gllm_core.utils.google_sheets import load_gsheets as load_gsheets
 from gllm_core.utils.logger_manager import LoggerManager as LoggerManager
+from gllm_core.utils.main_method_resolver import MainMethodResolver as MainMethodResolver
 from gllm_core.utils.merger_method import MergerMethod as MergerMethod
 from gllm_core.utils.retry import RetryConfig as RetryConfig, retry as retry
 from gllm_core.utils.validation import validate_string_enum as validate_string_enum
 
-__all__ = ['BinaryHandlingStrategy', 'ChunkMetadataMerger', 'LoggerManager', 'MergerMethod', 'RunAnalyzer', 'RetryConfig', 'asyncify', 'get_default_portal', 'binary_handler_factory', 'format_chunk_message', 'get_placeholder_keys', 'load_gsheets', 'syncify', 'retry', 'validate_string_enum']
+__all__ = ['BinaryHandlingStrategy', 'ChunkMetadataMerger', 'LoggerManager', 'MainMethodResolver', 'MergerMethod', 'RunAnalyzer', 'RetryConfig', 'asyncify', 'get_default_portal', 'binary_handler_factory', 'format_chunk_message', 'get_placeholder_keys', 'load_gsheets', 'syncify', 'retry', 'validate_string_enum']

gllm_core/utils/analyzer.pyi

@@ -2,7 +2,7 @@ import ast
 from _typeshed import Incomplete
 from enum import StrEnum
 from pydantic import BaseModel
-from typing import Any
+from typing import Any, Callable
 
 class ParameterKind(StrEnum):
     """Enum representing the different kinds of parameters a method can have."""
@@ -107,3 +107,17 @@ class RunAnalyzer(ast.NodeVisitor):
         Args:
             node (ast.Subscript): The Subscript node to visit.
         '''
+
+def analyze_method(cls, method: Callable) -> RunProfile:
+    """Analyze a method using RunAnalyzer.
+
+    This function encapsulates the common analysis logic used by both
+    Component._analyze_run_method() and schema_generator._generate_from_analyzer().
+
+    Args:
+        cls (type): The class containing the method (for analyzer context).
+        method (Callable): The method to analyze.
+
+    Returns:
+        RunProfile: The analysis results.
+    """

gllm_core/utils/logger_manager.pyi

@@ -9,6 +9,7 @@ DEFAULT_DATE_FORMAT: str
 TEXT_COLOR_MAP: Incomplete
 LOG_FORMAT_KEY: str
 RICH_CLOSE_TAG: str
+JSON_LOG_FIELDS: Incomplete
 JSON_ERROR_FIELDS_MAP: Incomplete
 
 class TextRichHandler(RichHandler):

gllm_core/utils/main_method_resolver.pyi

@@ -0,0 +1,54 @@
+from _typeshed import Incomplete
+from gllm_core.utils.logger_manager import LoggerManager as LoggerManager
+from typing import Callable
+
+class MainMethodResolver:
+    """Resolves the main entrypoint method for Component classes.
+
+    This resolver implements the precedence rules for determining which method
+    should be used as the main entrypoint:
+    1. Method decorated with @main in the most derived class.
+    2. Method named by __main_method__ property.
+    3. _run method (with deprecation warning).
+
+    Attributes:
+        cls (type): The Component class to resolve the main method for.
+    """
+    cls: Incomplete
+    def __init__(self, component_class: type) -> None:
+        """Initialize the resolver with a Component class.
+
+        Args:
+            component_class (type): The Component class to resolve the main method for.
+        """
+    @staticmethod
+    def validate_class(component_class: type) -> None:
+        """Validate main method configuration at class definition time.
+
+        This performs early validation that can be done when a Component subclass
+        is defined, before any instances are created or methods are called.
+
+        Validations performed:
+        1. Check that __main_method__ property points to an existing method
+        2. Check that only one @main decorator is used within the same class
+
+        Note: Multiple inheritance conflicts are intentionally NOT checked here,
+        as they are deferred to runtime (get_main()) to allow class definition
+        to succeed.
+
+        Args:
+            component_class (type): The Component class to validate.
+
+        Raises:
+            AttributeError: If __main_method__ refers to a non-existent method.
+            TypeError: If multiple methods are decorated with @main in the same class.
+        """
+    def resolve(self) -> Callable | None:
+        """Resolve the main method following precedence rules.
+
+        Returns:
+            Callable | None: The resolved main method, or None if not found.
+
+        Raises:
+            TypeError: If conflicting main methods are inherited from multiple ancestors.
+        """

gllm_core/utils/retry.pyi

@@ -15,7 +15,6 @@ class RetryConfig(BaseModel):
         max_retries (int): Maximum number of retry attempts.
         base_delay (float): Base delay in seconds between retries.
         max_delay (float): Maximum delay in seconds between retries.
-        exponential_base (float): Base for exponential backoff. Deprecated and will be removed in v0.4.
         jitter (bool): Whether to add random jitter to delays.
         timeout (float | None): Overall timeout in seconds for the entire operation. If None, timeout is disabled.
         retry_on_exceptions (tuple[type[Exception], ...]): Tuple of exception types to retry on.
@@ -23,7 +22,6 @@ class RetryConfig(BaseModel):
     max_retries: int
     base_delay: float
     max_delay: float
-    exponential_base: float
     jitter: bool
     timeout: float | None
     retry_on_exceptions: tuple[type[Exception], ...]

gllm_core.pyi

@@ -14,33 +14,33 @@ import gllm_core.adapters.tool.from_langchain_tool
 import asyncio
 import typing
 import enum
-import datetime
 import gllm_core.event.handler.ConsoleEventHandler
 import gllm_core.event.handler.PrintEventHandler
 import gllm_core.event.handler.StreamEventHandler
 import gllm_core.schema.Event
 import gllm_core.utils.validate_string_enum
-import json
 import rich
 import rich.console
 import abc
 import gllm_core.utils.LoggerManager
 import rich.panel
 import rich.style
+import json
 import gllm_core.event.EventEmitter
 import gllm_core.schema.Component
 import gllm_core.utils.get_placeholder_keys
 import uuid
 import pydantic
 import __future__
-import ast
 import inspect
 import logging
-import textwrap
 import warnings
 import functools
 import traceback
 import gllm_core.utils.BinaryHandlingStrategy
+import datetime
+import ast
+import textwrap
 import base64
 import atexit
 import threading

{gllm_core_binary-0.3.34.dist-info → gllm_core_binary-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gllm-core-binary
-Version: 0.3.34
+Version: 0.4.1
 Summary: A library containing core components for Gen AI applications.
 Author-email: Dimitrij Ray <dimitrij.ray@gdplabs.id>, Henry Wicaksono <henry.wicaksono@gdplabs.id>, Resti Febriana <resti.febriana@gdplabs.id>
 Requires-Python: <3.14,>=3.11
@@ -18,7 +18,7 @@ Requires-Dist: pydantic<3.0.0,>=2.11.4
 Requires-Dist: python-json-logger<4.0.0,>=3.3.0
 Requires-Dist: rich<15.0.0,>=14.1.0
 Requires-Dist: scipy<2.0.0,>=1.15.1
-Requires-Dist: virtualenv>=20.36.1
+Requires-Dist: virtualenv==20.30.0
 Provides-Extra: dev
 Requires-Dist: coverage<8.0.0,>=7.4.4; extra == "dev"
 Requires-Dist: mypy<2.0.0,>=1.15.0; extra == "dev"

{gllm_core_binary-0.3.34.dist-info → gllm_core_binary-0.4.1.dist-info}/RECORD

@@ -1,42 +1,44 @@
-gllm_core.cp312-win_amd64.pyd,sha256=V3LNHA3LKULnhf7c7Pb9bI5BUQhEkx2pxuWIwbu4P4Y,1151488
-gllm_core.pyi,sha256=zffCuoWXO09wVDCEg8PZX9O3_14ECViuz1efa2KVvTo,1446
+gllm_core.cp312-win_amd64.pyd,sha256=49gLN9araoPnOBg4B0kgVbUT9u6oeMou8essgb3_2_0,1204224
+gllm_core.pyi,sha256=n1D4ZCjhQUKv7qxTYLWh-afK6ECPZCddwckzt6afO2w,1446
 gllm_core/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gllm_core/constants.pyi,sha256=p7-Sr-sNmjv6mboGJmALDd3UtTZ4y0m_gmUXIBbAzBk,923
+gllm_core/constants.pyi,sha256=9M5UxEkdttu4fSJTLxhjt7q1xTRYbjTFheM5EjQ5Bs4,904
 gllm_core/adapters/__init__.pyi,sha256=N8JBGr2mPUMAGaMd__7XxGr2NAzfaFMuNH15QkSfbrA,187
 gllm_core/adapters/tool/__init__.pyi,sha256=zRmMo1ilDaYF-cErfkQqy8zGnArHebdWmox-P34_7fI,244
 gllm_core/adapters/tool/google_adk.pyi,sha256=0awaKRXmmK5NiAP9vNNYjMARDPWfWyQqy29k3WHoX2s,953
-gllm_core/adapters/tool/langchain.pyi,sha256=LBqox8xFm6jSxPfBEftJr_zUmXwPk_qHNwU3bZaphhE,855
+gllm_core/adapters/tool/langchain.pyi,sha256=J2vRizEVUORs-GI4uyIBNpm05Np65PmJ4gyd1DwaAcU,415
 gllm_core/event/__init__.pyi,sha256=HVs5C80lFzVEH7mO8KJTUqEPi_7KyPvNeMLuoG-hDeE,177
-gllm_core/event/event_emitter.pyi,sha256=7WcK-SV4xVwh48rsc-gt_41J8qksBTxbWSWfnr85dYk,8386
+gllm_core/event/event_emitter.pyi,sha256=dzhlOGnA2h5-OSRZHt-AJ-THul-rDUatfwr6dyYzYu8,7297
 gllm_core/event/messenger.pyi,sha256=8Nvra-a7RqnfX0PAtm-Of5M8CvsYr0L_1k3HgdNCR5I,3190
 gllm_core/event/handler/__init__.pyi,sha256=gZ21Fjjog3-e3-_Xv5sTpX9_Mx8X2LUzTrqp_tPisCg,377
-gllm_core/event/handler/console_event_handler.pyi,sha256=h3Dpj6-UeZnKUm7iFFOmRWk8k2Hw6YsvP28FUWYjU4U,1550
+gllm_core/event/handler/console_event_handler.pyi,sha256=eCv0SaZEpbu8W2jQPLnWwXNzhGOSM5KAtDVUYfvlvMs,1494
 gllm_core/event/handler/event_handler.pyi,sha256=chEYnw3Rp9Lk3Cz4dSn6EVlzje4BG-SlM82J-4UE5Hw,2153
-gllm_core/event/handler/print_event_handler.pyi,sha256=Z34M73brc4eaDLDt_nmdo638qsyUVuuMLyIJ0PdBt6c,1805
+gllm_core/event/handler/print_event_handler.pyi,sha256=D_xNtpcBsGl7NVSCvFKEGvaUqfMTxPaQV8zXECwmZ2Q,1674
 gllm_core/event/handler/stream_event_handler.pyi,sha256=5faGSFQLBN7XMqd4nIfGkdTBI_ALVaE-fmxVAjzca9w,2908
 gllm_core/event/hook/__init__.pyi,sha256=gSDHYl0yi00zHHMRvU_Eg8qLqsGHESTvoNE3MXig-g0,149
 gllm_core/event/hook/event_hook.pyi,sha256=rMatofdNAwHI65ya_7-q3NAfmTuKhc2WkXeiGPAvcKI,600
 gllm_core/event/hook/json_stringify_event_hook.pyi,sha256=I-QxbaLc4rEyqhW_f4INN5UxBg_ZofHHN1HQKfPJ7rs,585
 gllm_core/schema/__init__.pyi,sha256=X7Gv3xgtl4Ylzsg9iuGgjJPkQey7OdvvIC_X1e5_LAI,310
 gllm_core/schema/chunk.pyi,sha256=ZVYQitMtvMStiFssnTCgtSIcj30VSsK2dKscSysl3R4,2378
-gllm_core/schema/component.pyi,sha256=c3pL5FAW05WyL-BJ3dARYJEM58ZLZci8DkaOXnbi6gA,3403
+gllm_core/schema/component.pyi,sha256=ucGtxWq6Q41y_iqKtPSurn2vLCTFa1F00LpVKKlvOD8,7861
 gllm_core/schema/event.pyi,sha256=Yd74uSWhIO1lx0_p70rYt-LMz4FZHbbbqJP7xhVh_pY,1335
+gllm_core/schema/schema_generator.pyi,sha256=ToadC6UKEq35k32wUK1VaMKiICRtENXUYdAQOMlTg3U,1445
 gllm_core/schema/tool.pyi,sha256=T5TufJZPYUzYoSPZBX0FkqgZ9u03VAIsZdwvY1PS7nw,8848
-gllm_core/utils/__init__.pyi,sha256=U13s25K_edFp2WoCHfB0NyTROXvnP62P5A2YRukSIhs,1246
-gllm_core/utils/analyzer.pyi,sha256=M7_KYdBqz5S5fEPvnd49e6ij01dOvJD-k7amAlvRwNQ,3989
+gllm_core/utils/__init__.pyi,sha256=ZFilGPXXqc2JGwy8AV8N7pf6zmtd9clzuk310PIGkBs,1359
+gllm_core/utils/analyzer.pyi,sha256=M48PRor76L5eAQBpSqpv3EkZ4kU1t5Zm3CPFd34dxWM,4470
 gllm_core/utils/binary_handler_factory.pyi,sha256=imcuCL2oa-7uwTnC_vI-_KvE1hGu1-5U4ZiF5fShDmQ,1739
 gllm_core/utils/chunk_metadata_merger.pyi,sha256=J1lHTFV-0IiC6xKzzC7x1D1wBoki249muEU2HrF6C58,2317
 gllm_core/utils/concurrency.pyi,sha256=n_Mb9D_2hJAQ7VSwDBxhgmDv7hyFRKevDlhcHoAjvyA,3959
 gllm_core/utils/event_formatter.pyi,sha256=ocQ_Ev_XorRhLzj0c2szlclz8V3_Ysbg6qHmjhmur3k,1375
 gllm_core/utils/google_sheets.pyi,sha256=IjKdc7H3hBLAp8I8jxnwDfKP79D1EIBIRQKKFTUNqjM,939
 gllm_core/utils/imports.pyi,sha256=-KM0pyw7yFVCUZjHjoNBRFgEnI8hlr0pquKuhcA2X9M,2196
-gllm_core/utils/logger_manager.pyi,sha256=uix04SafH9aXQSPiGNwleCiBRlTJfqZB3H8zxsJocuI,7130
+gllm_core/utils/logger_manager.pyi,sha256=IDRgA-5jRDu4miO5Ru_tFJHql2JlHdr1GvZdmdS9Sg8,7159
+gllm_core/utils/main_method_resolver.pyi,sha256=dHozSqFMwCyVorQ0ZE9N-c2V4PkpF8FdU1VGGPvTjK4,2178
 gllm_core/utils/merger_method.pyi,sha256=JsgHnO47cqenqNxCrHqhAR-nnR_dEqE-7wprVrd8ZFg,1868
-gllm_core/utils/retry.pyi,sha256=UMrS9GsKi_HFsXNeYybSuZPrFkkX5yrLyovJvbNVb6s,1748
+gllm_core/utils/retry.pyi,sha256=KxlPzURzZfCSgKC44v98nR2bqamzHqtbRuXLDEuX29c,1614
 gllm_core/utils/similarity.pyi,sha256=HmSxE5VfPwYZYih_bSIz8QRDbkouO_jij-FX6TSCEdM,439
 gllm_core/utils/validation.pyi,sha256=-RdMmb8afH7F7q4Ao7x6FbwaDfxUHn3hA3WiOgzB-3s,397
 gllm_core.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
-gllm_core_binary-0.3.34.dist-info/METADATA,sha256=-hTLcqi0YiYIjR8j5BmUeOTUaDHTusFjp7KirAoTO48,4680
-gllm_core_binary-0.3.34.dist-info/WHEEL,sha256=x5rgv--I0NI0IT1Lh9tN1VG2cI637p3deednwYLKnxc,96
-gllm_core_binary-0.3.34.dist-info/top_level.txt,sha256=UYoTGvK_Yec95-_QUuVCKEr6PUXb5Lc7Dr-x8SeX9uM,10
-gllm_core_binary-0.3.34.dist-info/RECORD,,
+gllm_core_binary-0.4.1.dist-info/METADATA,sha256=u-7q92Ir814MskzOGNcOIUcGbZ5cSlX7mkssju-XHmQ,4679
+gllm_core_binary-0.4.1.dist-info/WHEEL,sha256=x5rgv--I0NI0IT1Lh9tN1VG2cI637p3deednwYLKnxc,96
+gllm_core_binary-0.4.1.dist-info/top_level.txt,sha256=UYoTGvK_Yec95-_QUuVCKEr6PUXb5Lc7Dr-x8SeX9uM,10
+gllm_core_binary-0.4.1.dist-info/RECORD,,