lionagi 0.17.4__py3-none-any.whl → 0.17.6__py3-none-any.whl

lionagi/ln/fuzzy/_to_dict.py

@@ -9,10 +9,6 @@ from typing import Any, Literal
 
 from ._fuzzy_json import fuzzy_json
 
-# ----------------------------
-# Helpers (small, tight, local)
-# ----------------------------
-
 
 def _is_na(obj: Any) -> bool:
     """None / Pydantic undefined sentinels -> treat as NA."""
@@ -67,7 +63,7 @@ def _parse_str(
 def _object_to_mapping_like(
     obj: Any,
     *,
-    use_model_dump: bool,
+    prioritize_model_dump: bool = True,
     **kwargs: Any,
 ) -> Mapping | dict | Any:
     """
@@ -80,11 +76,11 @@ def _object_to_mapping_like(
       5) dict(obj)
     """
     # 1) Pydantic v2
-    if use_model_dump and hasattr(obj, "model_dump"):
+    if prioritize_model_dump and hasattr(obj, "model_dump"):
         return obj.model_dump(**kwargs)
 
     # 2) Common methods
-    for name in ("to_dict", "dict", "to_json", "json"):
+    for name in ("to_dict", "dict", "to_json", "json", "model_dump"):
         if hasattr(obj, name):
             res = getattr(obj, name)(**kwargs)
             return json.loads(res) if isinstance(res, str) else res
@@ -118,7 +114,7 @@ def _preprocess_recursive(
     max_depth: int,
     recursive_custom_types: bool,
     str_parse_opts: dict[str, Any],
-    use_model_dump: bool,
+    prioritize_model_dump: bool,
 ) -> Any:
     """
     Recursively process nested structures:
@@ -145,7 +141,7 @@ def _preprocess_recursive(
             max_depth=max_depth,
             recursive_custom_types=recursive_custom_types,
             str_parse_opts=str_parse_opts,
-            use_model_dump=use_model_dump,
+            prioritize_model_dump=prioritize_model_dump,
         )
 
     # Dict-like
@@ -158,7 +154,7 @@ def _preprocess_recursive(
                 max_depth=max_depth,
                 recursive_custom_types=recursive_custom_types,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
             for k, v in obj.items()
         }
@@ -172,7 +168,7 @@ def _preprocess_recursive(
                 max_depth=max_depth,
                 recursive_custom_types=recursive_custom_types,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
             for v in obj
         ]
@@ -198,7 +194,7 @@ def _preprocess_recursive(
                 max_depth=max_depth,
                 recursive_custom_types=recursive_custom_types,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
         except Exception:
             return obj
@@ -207,7 +203,7 @@ def _preprocess_recursive(
     if recursive_custom_types:
         with contextlib.suppress(Exception):
             mapped = _object_to_mapping_like(
-                obj, use_model_dump=use_model_dump
+                obj, prioritize_model_dump=prioritize_model_dump
             )
             return _preprocess_recursive(
                 mapped,
@@ -215,7 +211,7 @@ def _preprocess_recursive(
                 max_depth=max_depth,
                 recursive_custom_types=recursive_custom_types,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
 
     return obj
@@ -232,7 +228,7 @@ def _convert_top_level_to_dict(
     fuzzy_parse: bool,
     str_type: Literal["json", "xml"] | None,
     parser: Callable[[str], Any] | None,
-    use_model_dump: bool,
+    prioritize_model_dump: bool,
     use_enum_values: bool,
     **kwargs: Any,
 ) -> dict[str, Any]:
@@ -273,7 +269,7 @@ def _convert_top_level_to_dict(
         # faithfully following your previous "non-Sequence -> model path" behavior.
         if not isinstance(obj, Sequence):
             converted = _object_to_mapping_like(
-                obj, use_model_dump=use_model_dump, **kwargs
+                obj, prioritize_model_dump=prioritize_model_dump, **kwargs
             )
             # If conversion returned a string, try to parse JSON to mapping; else pass-through
             if isinstance(converted, str):
@@ -321,7 +317,7 @@ def to_dict(
     input_: Any,
     /,
     *,
-    use_model_dump: bool = True,
+    prioritize_model_dump: bool = True,
     fuzzy_parse: bool = False,
     suppress: bool = False,
     str_type: Literal["json", "xml"] | None = "json",
@@ -330,12 +326,16 @@ def to_dict(
     max_recursive_depth: int | None = None,
     recursive_python_only: bool = True,
     use_enum_values: bool = False,
+    use_model_dump: bool | None = None,  # deprecated
     **kwargs: Any,
 ) -> dict[str, Any]:
     """
     Convert various input types to a dictionary, with optional recursive processing.
     Semantics preserved from original implementation.
     """
+    if use_model_dump is not None:
+        prioritize_model_dump = use_model_dump
+
     try:
         # Clamp recursion depth (match your constraints)
         if not isinstance(max_recursive_depth, int):
@@ -368,7 +368,7 @@ def to_dict(
                 max_depth=max_depth,
                 recursive_custom_types=not recursive_python_only,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
 
         # Final top-level conversion
@@ -377,7 +377,7 @@ def to_dict(
             fuzzy_parse=fuzzy_parse,
             str_type=str_type,
             parser=parser,
-            use_model_dump=use_model_dump,
+            prioritize_model_dump=prioritize_model_dump,
             use_enum_values=use_enum_values,
             **kwargs,
         )

lionagi/ln/types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from enum import Enum as _Enum
 from typing import Any, ClassVar, Final, Literal, TypeVar, Union
@@ -22,6 +23,7 @@ __all__ = (
     "not_sentinel",
     "Params",
     "DataClass",
+    "KeysLike",
 )
 
 T = TypeVar("T")
@@ -236,6 +238,16 @@ class Params:
                 data[k] = v
         return data
 
+    def __hash__(self) -> int:
+        from ._hash import hash_dict
+
+        return hash_dict(self.to_dict())
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Params):
+            return False
+        return hash(self) == hash(other)
+
 
 @dataclass(slots=True)
 class DataClass:
@@ -297,3 +309,6 @@ class DataClass:
         if value is None and cls._none_as_sentinel:
             return True
         return is_sentinel(value)
+
+
+KeysLike = Sequence[str] | KeysDict

lionagi/operations/operate/operate.py

@@ -12,6 +12,7 @@ from lionagi.models import FieldModel, ModelParams
 from lionagi.protocols.operatives.step import Operative, Step
 from lionagi.protocols.types import Instruction, Progression, SenderRecipient
 from lionagi.service.imodel import iModel
+from lionagi.session.branch import AlcallParams
 
 if TYPE_CHECKING:
     from lionagi.session.branch import Branch, ToolRef
@@ -64,10 +65,8 @@ async def operate(
     return_operative: bool = False,
     actions: bool = False,
     reason: bool = False,
-    action_kwargs: dict = None,
-    action_strategy: Literal[
-        "sequential", "concurrent", "batch"
-    ] = "concurrent",
+    call_params: AlcallParams = None,
+    action_strategy: Literal["sequential", "concurrent"] = "concurrent",
     verbose_action: bool = False,
     field_models: list[FieldModel] = None,
     exclude_fields: list | dict | None = None,
@@ -191,17 +190,14 @@ async def operate(
         getattr(response_model, "action_required", None) is True
         and getattr(response_model, "action_requests", None) is not None
     ):
-        action_kwargs = action_kwargs or {}
-        action_kwargs["strategy"] = (
-            instruct.action_strategy
-            if instruct.action_strategy
-            else action_kwargs.get("strategy", "concurrent")
+        action_strategy = (
+            action_strategy or instruct.action_strategy or "concurrent"
         )
-
         action_response_models = await branch.act(
             response_model.action_requests,
+            strategy=action_strategy,
             verbose_action=verbose_action,
-            **action_kwargs,
+            call_params=call_params,
         )
         # Possibly refine the operative with the tool outputs
         operative = Step.respond_operative(

lionagi/operations/parse/parse.py

@@ -6,9 +6,6 @@ from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import BaseModel
 
-from lionagi.ln.fuzzy._fuzzy_validate import fuzzy_validate_mapping
-from lionagi.utils import breakdown_pydantic_annotation
-
 if TYPE_CHECKING:
     from lionagi.session.branch import Branch
 
@@ -34,6 +31,11 @@ async def parse(
     suppress_conversion_errors: bool = False,
     response_format=None,
 ):
+    from lionagi.libs.schema.breakdown_pydantic_annotation import (
+        breakdown_pydantic_annotation,
+    )
+    from lionagi.ln.fuzzy._fuzzy_validate import fuzzy_validate_mapping
+
     if operative is not None:
         max_retries = operative.max_retries
         response_format = operative.request_type or response_format

lionagi/protocols/generic/element.py

@@ -21,8 +21,7 @@ from pydantic import (
 from lionagi import ln
 from lionagi._class_registry import get_class
 from lionagi._errors import IDError
-from lionagi.settings import Settings
-from lionagi.utils import import_module, time, to_dict
+from lionagi.utils import import_module, to_dict
 
 from .._concepts import Collective, Observable, Ordering
 
@@ -156,9 +155,7 @@ class Element(BaseModel, Observable):
         frozen=True,
     )
     created_at: float = Field(
-        default_factory=lambda: time(
-            tz=Settings.Config.TIMEZONE, type_="timestamp"
-        ),
+        default_factory=lambda: ln.now_utc().timestamp(),
         title="Creation Timestamp",
         description="Timestamp of element creation.",
         frozen=True,
@@ -205,7 +202,7 @@ class Element(BaseModel, Observable):
             ValueError: If `val` cannot be converted to a float timestamp.
         """
         if val is None:
-            return time(tz=Settings.Config.TIMEZONE, type_="timestamp")
+            return ln.now_utc().timestamp()
         if isinstance(val, float):
             return val
         if isinstance(val, dt.datetime):

lionagi/protocols/generic/event.py

@@ -138,7 +138,7 @@ class Event(Element):
     """
 
     execution: Execution = Field(default_factory=Execution)
-    streaming: bool = False
+    streaming: bool = Field(False, exclude=True)
 
     @field_serializer("execution")
     def _serialize_execution(self, val: Execution) -> dict:

lionagi/protocols/mail/package.py

@@ -5,8 +5,8 @@
 from enum import Enum
 from typing import Any
 
+from lionagi.ln import now_utc
 from lionagi.protocols.generic.element import ID, IDType
-from lionagi.utils import time
 
 from .._concepts import Communicatable, Observable
 
@@ -93,7 +93,7 @@ class Package(Observable):
     ):
         super().__init__()
         self.id = IDType.create()
-        self.created_at = time(type_="timestamp")
+        self.created_at = now_utc().timestamp()
         self.category = validate_category(category)
         self.item = item
         self.request_source = request_source

lionagi/protocols/messages/instruction.py

@@ -7,7 +7,7 @@ from typing import Any, Literal
 from pydantic import BaseModel, JsonValue, field_serializer
 from typing_extensions import override
 
-from lionagi.utils import UNDEFINED, breakdown_pydantic_annotation, copy
+from lionagi.utils import UNDEFINED, copy
 
 from .base import MessageRole
 from .message import RoledMessage, SenderRecipient
@@ -256,6 +256,10 @@ def prepare_instruction_content(
     Raises:
         ValueError: If request_fields and request_model are both given.
     """
+    from lionagi.libs.schema.breakdown_pydantic_annotation import (
+        breakdown_pydantic_annotation,
+    )
+
     if request_fields and request_model:
         raise ValueError(
             "only one of request_fields or request_model can be provided"
@@ -476,6 +480,10 @@ class Instruction(RoledMessage):
 
     @response_format.setter
     def response_format(self, model: type[BaseModel]) -> None:
+        from lionagi.libs.schema.breakdown_pydantic_annotation import (
+            breakdown_pydantic_annotation,
+        )
+
         if isinstance(model, BaseModel):
             self.content["request_model"] = type(model)
         else:

lionagi/protocols/operatives/operative.py

@@ -7,9 +7,10 @@ from typing import Any
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 
+from lionagi.ln import extract_json
 from lionagi.ln.fuzzy._fuzzy_match import fuzzy_match_keys
 from lionagi.models import FieldModel, ModelParams, OperableModel
-from lionagi.utils import UNDEFINED, to_json
+from lionagi.utils import UNDEFINED
 
 
 class Operative:
@@ -145,7 +146,7 @@ class Operative:
         Raises:
             Exception: If the validation fails.
         """
-        d_ = to_json(text, fuzzy_parse=True)
+        d_ = extract_json(text, fuzzy_parse=True)
         if isinstance(d_, list | tuple) and len(d_) == 1:
             d_ = d_[0]
         try:
@@ -167,7 +168,7 @@ class Operative:
         """
         d_ = text
         try:
-            d_ = to_json(text, fuzzy_parse=True)
+            d_ = extract_json(text, fuzzy_parse=True)
             if isinstance(d_, list | tuple) and len(d_) == 1:
                 d_ = d_[0]
             d_ = fuzzy_match_keys(

lionagi/service/broadcaster.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import Any, ClassVar
+
+from lionagi.ln.concurrency.utils import is_coro_func
+from lionagi.protocols.generic.event import Event
+
+logger = logging.getLogger(__name__)
+
+__all__ = ("Broadcaster",)
+
+
+class Broadcaster:
+    """Real-time event broadcasting system for hook events. Should subclass to implement specific event types."""
+
+    _instance: ClassVar[Broadcaster | None] = None
+    _subscribers: ClassVar[list[Callable[[Any], None]]] = []
+    _event_type: ClassVar[type[Event]]
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def subscribe(cls, callback: Callable[[Any], None]) -> None:
+        """Subscribe to hook events with sync callback."""
+        if callback not in cls._subscribers:
+            cls._subscribers.append(callback)
+
+    @classmethod
+    def unsubscribe(cls, callback: Callable[[Any], None]) -> None:
+        """Unsubscribe from hook events."""
+        if callback in cls._subscribers:
+            cls._subscribers.remove(callback)
+
+    @classmethod
+    async def broadcast(cls, event) -> None:
+        """Broadcast event to all subscribers."""
+        if not isinstance(event, cls._event_type):
+            raise ValueError(
+                f"Event must be of type {cls._event_type.__name__}"
+            )
+
+        for callback in cls._subscribers:
+            try:
+                if is_coro_func(callback):
+                    await callback(event)
+                else:
+                    callback(event)
+            except Exception as e:
+                logger.error(
+                    f"Error in subscriber callback: {e}", exc_info=True
+                )
+
+    @classmethod
+    def get_subscriber_count(cls) -> int:
+        """Get total number of subscribers."""
+        return len(cls._subscribers)

lionagi/service/connections/api_calling.py

@@ -2,31 +2,18 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import asyncio
 import logging
 
-from anyio import get_cancelled_exc_class
-from pydantic import Field, PrivateAttr, model_validator
+from pydantic import Field, model_validator
 from typing_extensions import Self
 
-from lionagi.protocols.generic.event import Event, EventStatus
-from lionagi.protocols.types import Log
-from lionagi.service.hooks import HookEvent, HookEventTypes, global_hook_logger
-
+from ..hooks.hooked_event import HookedEvent
 from .endpoint import Endpoint
 
-
-# Lazy import for TokenCalculator
-def _get_token_calculator():
-    from lionagi.service.token_calculator import TokenCalculator
-
-    return TokenCalculator
-
-
 logger = logging.getLogger(__name__)
 
 
-class APICalling(Event):
+class APICalling(HookedEvent):
     """Handles asynchronous API calls with automatic token usage tracking.
 
     This class manages API calls through endpoints, handling both regular
@@ -61,9 +48,6 @@ class APICalling(Event):
         exclude=True,
     )
 
-    _pre_invoke_hook_event: HookEvent = PrivateAttr(None)
-    _post_invoke_hook_event: HookEvent = PrivateAttr(None)
-
     @model_validator(mode="after")
     def _validate_streaming(self) -> Self:
         """Validate streaming configuration and add token usage if requested."""
@@ -85,20 +69,16 @@ class APICalling(Event):
                 TOKEN_LIMITS = {
                     # OpenAI models
                     "gpt-4": 128_000,
-                    "gpt-4-turbo": 128_000,
-                    "o1-mini": 128_000,
-                    "o1-preview": 128_000,
                     "o1": 200_000,
                     "o3": 200_000,
                     "gpt-4.1": 1_000_000,
+                    "gpt-5": 1_000_000,
                     # Anthropic models
                     "sonnet": 200_000,
                     "haiku": 200_000,
                     "opus": 200_000,
                     # Google models
                     "gemini": 1_000_000,
-                    # Alibaba models
-                    "qwen-turbo": 1_000_000,
                 }
 
                 token_msg = (
@@ -131,12 +111,14 @@ class APICalling(Event):
     @property
     def required_tokens(self) -> int | None:
         """Calculate the number of tokens required for this request."""
+        from lionagi.service.token_calculator import TokenCalculator
+
         if not self.endpoint.config.requires_tokens:
             return None
 
         # Handle chat completions format
         if "messages" in self.payload:
-            return _get_token_calculator().calculate_message_tokens(
+            return TokenCalculator.calculate_message_tokens(
                 self.payload["messages"], **self.payload
             )
         # Handle responses API format
@@ -157,95 +139,29 @@ class APICalling(Event):
                             messages.append(item)
             else:
                 return None
-            return _get_token_calculator().calculate_message_tokens(
+            return TokenCalculator.calculate_message_tokens(
                 messages, **self.payload
             )
         # Handle embeddings endpoint
         elif "embed" in self.endpoint.config.endpoint:
-            return _get_token_calculator().calculate_embed_token(
-                **self.payload
-            )
+            return TokenCalculator.calculate_embed_token(**self.payload)
 
         return None
 
-    async def invoke(self) -> None:
-        """Execute the API call through the endpoint.
-
-        Updates execution status and stores the response or error.
-        """
-        start = asyncio.get_event_loop().time()
-
-        try:
-            self.execution.status = EventStatus.PROCESSING
-            if h_ev := self._pre_invoke_hook_event:
-                await h_ev.invoke()
-                if h_ev._should_exit:
-                    raise h_ev._exit_cause or RuntimeError(
-                        "Pre-invocation hook requested exit without a cause"
-                    )
-                await global_hook_logger.alog(Log.create(h_ev))
-
-            # Make the API call with skip_payload_creation=True since payload is already prepared
-            response = await self.endpoint.call(
-                request=self.payload,
-                cache_control=self.cache_control,
-                skip_payload_creation=True,
-                extra_headers=self.headers if self.headers else None,
-            )
-
-            if h_ev := self._post_invoke_hook_event:
-                await h_ev.invoke()
-                if h_ev._should_exit:
-                    raise h_ev._exit_cause or RuntimeError(
-                        "Post-invocation hook requested exit without a cause"
-                    )
-                await global_hook_logger.alog(Log.create(h_ev))
-
-            self.execution.response = response
-            self.execution.status = EventStatus.COMPLETED
-
-        except get_cancelled_exc_class():
-            self.execution.error = "API call cancelled"
-            self.execution.status = EventStatus.CANCELLED
-            raise
-
-        except Exception as e:
-            self.execution.error = str(e)
-            self.execution.status = EventStatus.FAILED
-            logger.error(f"API call failed: {e}")
-
-        finally:
-            self.execution.duration = asyncio.get_event_loop().time() - start
-
-    async def stream(self):
-        """Stream the API response through the endpoint.
-
-        Yields:
-            Streaming chunks from the API.
-        """
-        start = asyncio.get_event_loop().time()
-        response = []
-
-        try:
-            self.execution.status = EventStatus.PROCESSING
-
-            async for chunk in self.endpoint.stream(
-                request=self.payload,
-                extra_headers=self.headers if self.headers else None,
-            ):
-                response.append(chunk)
-                yield chunk
-
-            self.execution.response = response
-            self.execution.status = EventStatus.COMPLETED
-
-        except Exception as e:
-            self.execution.error = str(e)
-            self.execution.status = EventStatus.FAILED
-            logger.error(f"Streaming failed: {e}")
+    async def _invoke(self):
+        return await self.endpoint.call(
+            request=self.payload,
+            cache_control=self.cache_control,
+            skip_payload_creation=True,
+            extra_headers=self.headers if self.headers else None,
+        )
 
-        finally:
-            self.execution.duration = asyncio.get_event_loop().time() - start
+    async def _stream(self):
+        async for i in self.endpoint.stream(
+            request=self.payload,
+            extra_headers=self.headers if self.headers else None,
+        ):
+            yield i
 
     @property
     def request(self) -> dict:
@@ -253,42 +169,3 @@ class APICalling(Event):
         return {
             "required_tokens": self.required_tokens,
         }
-
-    @property
-    def response(self):
-        """Get the response from the execution."""
-        return self.execution.response if self.execution else None
-
-    def create_pre_invoke_hook(
-        self,
-        hook_registry,
-        exit_hook: bool = None,
-        hook_timeout: float = 30.0,
-        hook_params: dict = None,
-    ):
-        h_ev = HookEvent(
-            hook_type=HookEventTypes.PreInvokation,
-            event_like=self,
-            registry=hook_registry,
-            exit=exit_hook,
-            timeout=hook_timeout,
-            params=hook_params or {},
-        )
-        self._pre_invoke_hook_event = h_ev
-
-    def create_post_invoke_hook(
-        self,
-        hook_registry,
-        exit_hook: bool = None,
-        hook_timeout: float = 30.0,
-        hook_params: dict = None,
-    ):
-        h_ev = HookEvent(
-            hook_type=HookEventTypes.PostInvokation,
-            event_like=self,
-            registry=hook_registry,
-            exit=exit_hook,
-            timeout=hook_timeout,
-            params=hook_params or {},
-        )
-        self._post_invoke_hook_event = h_ev