lionagi 0.18.0__py3-none-any.whl → 0.18.2__py3-none-any.whl

lionagi/service/hooks/hooked_event.py

@@ -5,7 +5,7 @@ import anyio
 from pydantic import PrivateAttr
 
 from lionagi.ln import get_cancelled_exc_class
-from lionagi.protocols.types import DataLogger, Event, EventStatus, Log
+from lionagi.protocols.types import DataLogger, Event, EventStatus
 from lionagi.service.hooks import HookEvent, HookEventTypes
 
 global_hook_logger = DataLogger(
@@ -43,6 +43,16 @@ class HookedEvent(Event):
             self.execution.status = EventStatus.PROCESSING
             if h_ev := self._pre_invoke_hook_event:
                 await h_ev.invoke()
+
+                # Check if hook failed or was cancelled - propagate to main event
+                if h_ev.execution.status in (
+                    EventStatus.FAILED,
+                    EventStatus.CANCELLED,
+                ):
+                    self.execution.status = h_ev.execution.status
+                    self.execution.error = f"Pre-invoke hook {h_ev.execution.status.value}: {h_ev.execution.error}"
+                    return
+
                 if h_ev._should_exit:
                     raise h_ev._exit_cause or RuntimeError(
                         "Pre-invocation hook requested exit without a cause"
@@ -53,6 +63,19 @@ class HookedEvent(Event):
 
             if h_ev := self._post_invoke_hook_event:
                 await h_ev.invoke()
+
+                # Check if hook failed or was cancelled - propagate to main event
+                if h_ev.execution.status in (
+                    EventStatus.FAILED,
+                    EventStatus.CANCELLED,
+                ):
+                    self.execution.status = h_ev.execution.status
+                    self.execution.error = f"Post-invoke hook {h_ev.execution.status.value}: {h_ev.execution.error}"
+                    self.execution.response = (
+                        response  # Keep response even if hook failed
+                    )
+                    return
+
                 if h_ev._should_exit:
                     raise h_ev._exit_cause or RuntimeError(
                         "Post-invocation hook requested exit without a cause"
@@ -87,10 +110,47 @@ class HookedEvent(Event):
         try:
             self.execution.status = EventStatus.PROCESSING
 
+            # Execute pre-invoke hook if present
+            if h_ev := self._pre_invoke_hook_event:
+                await h_ev.invoke()
+
+                # Check if hook failed or was cancelled - propagate to main event
+                if h_ev.execution.status in (
+                    EventStatus.FAILED,
+                    EventStatus.CANCELLED,
+                ):
+                    self.execution.status = h_ev.execution.status
+                    self.execution.error = f"Pre-invoke hook {h_ev.execution.status.value}: {h_ev.execution.error}"
+                    return
+
+                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(h_ev)
+
             async for chunk in self._stream():
                 response.append(chunk)
                 yield chunk
 
+            # Execute post-invoke hook if present
+            if h_ev := self._post_invoke_hook_event:
+                await h_ev.invoke()
+
+                # Check if hook failed or was cancelled - don't fail the stream since data was already sent
+                if h_ev.execution.status in (
+                    EventStatus.FAILED,
+                    EventStatus.CANCELLED,
+                ):
+                    # Log but don't fail the stream
+                    await global_hook_logger.alog(h_ev)
+                elif h_ev._should_exit:
+                    raise h_ev._exit_cause or RuntimeError(
+                        "Post-invocation hook requested exit without a cause"
+                    )
+                else:
+                    await global_hook_logger.alog(h_ev)
+
             self.execution.response = response
             self.execution.status = EventStatus.COMPLETED
 

lionagi/service/imodel.py

@@ -3,19 +3,22 @@
 
 import asyncio
 from collections.abc import AsyncGenerator, Callable
+from typing import Any
+from uuid import UUID, uuid4
 
 from pydantic import BaseModel
 
 from lionagi.ln import is_coro_func, now_utc
-from lionagi.protocols.generic.log import Log
-from lionagi.protocols.types import ID, Event, EventStatus, IDType
-from lionagi.service.hooks.hook_event import HookEventTypes
-from lionagi.service.hooks.hooked_event import HookedEvent
-
-from .connections.api_calling import APICalling
-from .connections.endpoint import Endpoint
-from .connections.match_endpoint import match_endpoint
-from .hooks import HookEvent, HookRegistry, global_hook_logger
+from lionagi.protocols.generic import ID, Event, EventStatus, Log
+
+from .connections import APICalling, Endpoint, match_endpoint
+from .hooks import (
+    HookedEvent,
+    HookEvent,
+    HookEventTypes,
+    HookRegistry,
+    global_hook_logger,
+)
 from .rate_limited_processor import RateLimitedAPIExecutor
 
 
@@ -52,7 +55,7 @@ class iModel:
         provider_metadata: dict | None = None,
         hook_registry: HookRegistry | dict | None = None,
         exit_hook: bool = False,
-        id: IDType | str = None,
+        id: UUID | str = None,
         created_at: float | None = None,
         **kwargs,
     ) -> None:
@@ -100,7 +103,7 @@ class iModel:
         if id is not None:
             self.id = ID.get_id(id)
         else:
-            self.id = IDType.create()
+            self.id = uuid4()
         if created_at is not None:
             if not isinstance(created_at, float):
                 raise ValueError("created_at must be a float timestamp.")
@@ -270,7 +273,7 @@ class iModel:
             include_token_usage_to_model=include_token_usage_to_model,
         )
 
-    async def process_chunk(self, chunk) -> None:
+    async def process_chunk(self, chunk) -> Any:
         """Processes a chunk of streaming data.
 
         Override this method in subclasses if you need custom handling
@@ -284,6 +287,7 @@ class iModel:
             if is_coro_func(self.streaming_process_func):
                 return await self.streaming_process_func(chunk)
             return self.streaming_process_func(chunk)
+        return None
 
     async def stream(self, api_call=None, **kw) -> AsyncGenerator:
         """Performs a streaming API call with the given arguments.
@@ -313,8 +317,8 @@ class iModel:
                 try:
                     async for i in api_call.stream():
                         result = await self.process_chunk(i)
-                        if result:
-                            yield result
+                        # Yield processed result if available, otherwise yield raw chunk
+                        yield result if result is not None else i
                 except Exception as e:
                     raise ValueError(f"Failed to stream API call: {e}")
                 finally:
@@ -323,8 +327,8 @@ class iModel:
             try:
                 async for i in api_call.stream():
                     result = await self.process_chunk(i)
-                    if result:
-                        yield result
+                    # Yield processed result if available, otherwise yield raw chunk
+                    yield result if result is not None else i
             except Exception as e:
                 raise ValueError(f"Failed to stream API call: {e}")
             finally:
@@ -360,10 +364,10 @@ class iModel:
             await self.executor.append(api_call)
             await self.executor.forward()
             ctr = 0
-            while api_call.status not in (
-                EventStatus.COMPLETED,
-                EventStatus.FAILED,
-            ):
+            while api_call.status in [
+                EventStatus.PROCESSING,
+                EventStatus.PENDING,
+            ]:
                 if ctr > 100:
                     break
                 await self.executor.forward()

lionagi/service/third_party/claude_code.py

@@ -22,7 +22,6 @@ from pydantic import BaseModel, Field, field_validator, model_validator
 
 from lionagi import ln
 from lionagi.libs.schema.as_readable import as_readable
-from lionagi.utils import is_coro_func
 
 HAS_CLAUDE_CODE_CLI = False
 CLAUDE_CLI = None
@@ -556,7 +555,7 @@ def _pp_final(sess: ClaudeSession, theme) -> None:
 async def _maybe_await(func, *args, **kw):
     """Call func which may be sync or async."""
     res = func(*args, **kw) if func else None
-    if is_coro_func(res):
+    if ln.is_coro_func(res):
         await res
 
 

lionagi/service/third_party/openai_models.py

@@ -145,7 +145,7 @@ class ImageURLObject(BaseModel):
     """Image URL object; 'detail' is optional and model-dependent."""
 
     url: str
-    detail: Optional[Literal["auto", "low", "high"]] = Field(
+    detail: Literal["auto", "low", "high"] | None = Field(
         default=None,
         description="Optional detail control for vision models (auto/low/high).",
     )
@@ -168,8 +168,8 @@ class FunctionDef(BaseModel):
     """JSON Schema function definition for tool-calling."""
 
     name: str
-    description: Optional[str] = None
-    parameters: Dict[str, Any] = Field(
+    description: str | None = None
+    parameters: dict[str, Any] = Field(
         default_factory=dict,
         description="JSON Schema describing function parameters.",
     )
@@ -204,7 +204,7 @@ class ToolChoiceFunction(BaseModel):
     """Explicit tool selection."""
 
     type: Literal["function"] = "function"
-    function: Dict[str, str]  # {"name": "<function_name>"}
+    function: dict[str, str]  # {"name": "<function_name>"}
 
 
 ToolChoice = Union[Literal["auto", "none"], ToolChoiceFunction]
@@ -223,12 +223,16 @@ class ResponseFormatJSONObject(BaseModel):
 
 class JSONSchemaFormat(BaseModel):
     name: str
-    schema: Dict[str, Any]
-    strict: Optional[bool] = Field(
+    schema_: dict[str, Any] = Field(
+        alias="schema", description="JSON Schema definition"
+    )
+    strict: bool | None = Field(
         default=None,
         description="If true, disallow unspecified properties (strict schema).",
     )
 
+    model_config = {"populate_by_name": True}
+
 
 class ResponseFormatJSONSchema(BaseModel):
     type: Literal["json_schema"] = "json_schema"
@@ -247,31 +251,29 @@ ResponseFormat = Union[
 
 class SystemMessage(BaseModel):
     role: Literal[ChatRole.system] = ChatRole.system
-    content: Union[str, List[ContentPart]]
-    name: Optional[str] = None  # optional per API
+    content: str | list[ContentPart]
+    name: str | None = None  # optional per API
 
 
 class DeveloperMessage(BaseModel):
     role: Literal[ChatRole.developer] = ChatRole.developer
-    content: Union[str, List[ContentPart]]
-    name: Optional[str] = None
+    content: str | list[ContentPart]
+    name: str | None = None
 
 
 class UserMessage(BaseModel):
     role: Literal[ChatRole.user] = ChatRole.user
-    content: Union[str, List[ContentPart]]
-    name: Optional[str] = None
+    content: str | list[ContentPart]
+    name: str | None = None
 
 
 class AssistantMessage(BaseModel):
     role: Literal[ChatRole.assistant] = ChatRole.assistant
     # Either textual content, or only tool_calls (when asking you to call tools)
-    content: Optional[Union[str, List[ContentPart]]] = None
-    name: Optional[str] = None
-    tool_calls: Optional[List[ToolCall]] = None  # modern tool-calling result
-    function_call: Optional[FunctionCall] = (
-        None  # legacy function-calling result
-    )
+    content: str | list[ContentPart] | None = None
+    name: str | None = None
+    tool_calls: list[ToolCall] | None = None  # modern tool-calling result
+    function_call: FunctionCall | None = None  # legacy function-calling result
 
 
 class ToolMessage(BaseModel):
@@ -292,7 +294,7 @@ ChatMessage = (
 
 
 class StreamOptions(BaseModel):
-    include_usage: Optional[bool] = Field(
+    include_usage: bool | None = Field(
         default=None,
         description="If true, a final streamed chunk includes token usage.",
     )
@@ -309,7 +311,7 @@ class OpenAIChatCompletionsRequest(BaseModel):
 
     # Required
     model: str = Field(..., description="Model name, e.g., 'gpt-4o', 'gpt-4o-mini'.")  # type: ignore
-    messages: List[ChatMessage] = Field(
+    messages: list[ChatMessage] = Field(
         ...,
         description="Conversation so far, including system/developer context.",
     )
@@ -348,7 +350,7 @@ class OpenAIChatCompletionsRequest(BaseModel):
     n: int | None = Field(
         default=None, ge=1, description="# of choices to generate."
     )
-    stop: str | List[str] | None = Field(
+    stop: str | list[str] | None = Field(
         default=None, description="Stop sequence(s)."
     )
     logit_bias: dict[str, float] | None = Field(
@@ -406,7 +408,7 @@ class OpenAIChatCompletionsRequest(BaseModel):
         description="Whether to store the response server-side (model-dependent).",
     )
     metadata: dict[str, Any] | None = None
-    reasoning_effort: Optional[Literal["low", "medium", "high"]] = Field(
+    reasoning_effort: Literal["low", "medium", "high"] | None = Field(
         default=None,
         description="For reasoning models: trade-off between speed and accuracy.",
     )

lionagi/service/token_calculator.py

@@ -1,83 +1,10 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
-import base64
 from collections.abc import Callable
-from io import BytesIO
 
 import tiktoken
 
-GPT4O_IMAGE_PRICING = {
-    "base_cost": 85,
-    "low_detail": 0,
-    "max_dimension": 2048,
-    "min_side": 768,
-    "tile_size": 512,
-    "tile_cost": 170,
-}
-
-GPT4O_MINI_IMAGE_PRICING = {
-    "base_cost": 2833,
-    "low_detail": 0,
-    "max_dimension": 2048,
-    "min_side": 768,
-    "tile_size": 512,
-    "tile_cost": 5667,
-}
-
-O1_IMAGE_PRICING = {
-    "base_cost": 75,
-    "low_detail": 0,
-    "max_dimension": 2048,
-    "min_side": 768,
-    "tile_size": 512,
-    "tile_cost": 150,
-}
-
-
-def calculate_image_token_usage_from_base64(
-    image_base64: str, detail, image_pricing
-):
-    from PIL import Image
-
-    # Decode the base64 string to get image data
-    if "data:image/jpeg;base64," in image_base64:
-        image_base64 = image_base64.split("data:image/jpeg;base64,")[1]
-        image_base64.strip("{}")
-
-    image_data = base64.b64decode(image_base64)
-    image = Image.open(BytesIO(image_data))
-
-    # Get image dimensions
-    width, height = image.size
-
-    if detail == "low":
-        return image_pricing["base_cost"] + image_pricing["low_detail"]
-
-    # Scale to fit within a 2048 x 2048 tile
-    max_dimension = image_pricing["max_dimension"]
-    if width > max_dimension or height > max_dimension:
-        scale_factor = max_dimension / max(width, height)
-        width = int(width * scale_factor)
-        height = int(height * scale_factor)
-
-    # Scale such that the shortest side is 768px
-    min_side = image_pricing["min_side"]
-    if min(width, height) > min_side:
-        scale_factor = min_side / min(width, height)
-        width = int(width * scale_factor)
-        height = int(height * scale_factor)
-
-    # Calculate the number of 512px tiles
-    num_tiles = (width // image_pricing["tile_size"]) * (
-        height // image_pricing["tile_size"]
-    )
-    token_cost = (
-        image_pricing["base_cost"] + image_pricing["tile_cost"] * num_tiles
-    )
-
-    return token_cost
-
 
 def get_encoding_name(value: str) -> str:
     try:
@@ -91,17 +18,6 @@ def get_encoding_name(value: str) -> str:
             return "o200k_base"
 
 
-def get_image_pricing(model: str) -> dict:
-    if "gpt-4o-mini" in model:
-        return GPT4O_MINI_IMAGE_PRICING
-    elif "gpt-4o" in model:
-        return GPT4O_IMAGE_PRICING
-    elif "o1" in model and "mini" not in model:
-        return O1_IMAGE_PRICING
-    else:
-        raise ValueError("Invalid model name")
-
-
 class TokenCalculator:
     @staticmethod
     def calculate_message_tokens(messages: list[dict], /, **kwargs) -> int:
@@ -177,16 +93,7 @@ class TokenCalculator:
                 if "text" in i_:
                     return TokenCalculator._calculate_chatitem(str(i_["text"]))
                 elif "image_url" in i_:
-                    a: str = i_["image_url"].get("url", "")
-                    if "data:image/jpeg;base64," in a:
-                        a = a.split("data:image/jpeg;base64,")[1].strip()
-                        pricing = get_image_pricing(model_name)
-                        return (
-                            calculate_image_token_usage_from_base64(
-                                a, i_.get("detail", "low"), pricing
-                            )
-                            + 15  # buffer for image
-                        )
+                    return 500  # fixed cost for image URL
 
             if isinstance(i_, list):
                 return sum(