lionagi 0.17.11__py3-none-any.whl → 0.18.1__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,21 +43,44 @@ 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"
                     )
-                await global_hook_logger.alog(Log.create(h_ev))
+                await global_hook_logger.alog(h_ev)
 
             response = await self._invoke()
 
             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"
                     )
-                await global_hook_logger.alog(Log.create(h_ev))
+                await global_hook_logger.alog(h_ev)
 
             self.execution.response = response
             self.execution.status = EventStatus.COMPLETED
@@ -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

@@ -18,12 +18,10 @@ from pathlib import Path
 from textwrap import shorten
 from typing import Any, Literal
 
-from json_repair import repair_json
 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, is_import_installed
 
 HAS_CLAUDE_CODE_CLI = False
 CLAUDE_CLI = None
@@ -415,6 +413,8 @@ async def _ndjson_from_cli(request: ClaudeCodeRequest):
     • Robust against braces inside strings (uses json.JSONDecoder.raw_decode)
     • Falls back to `json_repair.repair_json` when necessary.
     """
+    from json_repair import repair_json
+
     workspace = request.cwd()
     workspace.mkdir(parents=True, exist_ok=True)
 
@@ -555,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

@@ -0,0 +1,435 @@
+"""
+OpenAI Model Names extracted from generated models.
+
+This module provides lists of allowed model names for different OpenAI services,
+extracted from the auto-generated openai_models.py file.
+"""
+
+from __future__ import annotations
+
+import warnings
+from enum import Enum
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field, model_validator
+
+warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
+
+
+# Manually define the chat models from the ChatModel class in openai_models.py
+# These are extracted from the Literal type definition
+CHAT_MODELS = (
+    "gpt-5",
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-5-2025-08-07",
+    "gpt-5-mini-2025-08-07",
+    "gpt-5-nano-2025-08-07",
+    "gpt-5-chat-latest",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-4.1-2025-04-14",
+    "gpt-4.1-mini-2025-04-14",
+    "gpt-4.1-nano-2025-04-14",
+    "o4-mini",
+    "o4-mini-2025-04-16",
+    "o3",
+    "o3-2025-04-16",
+    "o3-mini",
+    "o3-mini-2025-01-31",
+    "o1",
+    "o1-2024-12-17",
+    "o1-preview",
+    "o1-preview-2024-09-12",
+    "o1-mini",
+    "o1-mini-2024-09-12",
+    "gpt-4o",
+    "gpt-4o-2024-11-20",
+    "gpt-4o-2024-08-06",
+    "gpt-4o-2024-05-13",
+    "gpt-4o-audio-preview",
+    "gpt-4o-audio-preview-2024-10-01",
+    "gpt-4o-audio-preview-2024-12-17",
+    "gpt-4o-audio-preview-2025-06-03",
+    "gpt-4o-mini-audio-preview",
+    "gpt-4o-mini-audio-preview-2024-12-17",
+    "gpt-4o-search-preview",
+    "gpt-4o-mini-search-preview",
+    "gpt-4o-search-preview-2025-03-11",
+    "gpt-4o-mini-search-preview-2025-03-11",
+    "chatgpt-4o-latest",
+    "codex-mini-latest",
+    "gpt-4o-mini",
+    "gpt-4o-mini-2024-07-18",
+    "gpt-4-turbo",
+    "gpt-4-turbo-2024-04-09",
+    "gpt-4-0125-preview",
+    "gpt-4-turbo-preview",
+    "gpt-4-1106-preview",
+    "gpt-4-vision-preview",
+    "gpt-4",
+    "gpt-4-0314",
+    "gpt-4-0613",
+    "gpt-4-32k",
+    "gpt-4-32k-0314",
+    "gpt-4-32k-0613",
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-16k",
+    "gpt-3.5-turbo-0301",
+    "gpt-3.5-turbo-0613",
+    "gpt-3.5-turbo-1106",
+    "gpt-3.5-turbo-0125",
+    "gpt-3.5-turbo-16k-0613",
+    "o1-pro",
+    "o1-pro-2025-03-19",
+    "o3-pro",
+    "o3-pro-2025-06-10",
+)
+
+REASONING_MODELS = (
+    model
+    for model in CHAT_MODELS
+    if model.startswith(("o1", "o1-", "o3", "o3-", "o4", "o4-", "gpt-5"))
+)
+
+# Embedding models
+EMBEDDING_MODELS = (
+    "text-embedding-ada-002",
+    "text-embedding-3-small",
+    "text-embedding-3-large",
+)
+
+IMAGE_MODELS = ("dall-e-2", "dall-e-3", "gpt-image-1")
+
+MODERATION_MODELS = ("text-moderation-latest", "text-moderation-stable")
+
+
+ChatModels = Literal[CHAT_MODELS]
+ReasoningModels = Literal[REASONING_MODELS]
+EmbeddingModels = Literal[EMBEDDING_MODELS]
+ImageModels = Literal[IMAGE_MODELS]
+ModerationModels = Literal[MODERATION_MODELS]
+
+
+# Audio models
+AUDIO_MODELS = {
+    "tts": ["tts-1", "tts-1-hd", "gpt-4o-mini-tts"],
+    "transcription": [
+        "whisper-1",
+        "gpt-4o-transcribe",
+        "gpt-4o-mini-transcribe",
+    ],
+}
+
+
+# ---------- Roles & content parts ----------
+
+
+class ChatRole(str, Enum):
+    system = "system"
+    developer = "developer"  # modern system-like role
+    user = "user"
+    assistant = "assistant"
+    tool = "tool"  # for tool results sent back to the model
+
+
+class TextPart(BaseModel):
+    """Text content part for multimodal messages."""
+
+    type: Literal["text"] = "text"
+    text: str
+
+
+class ImageURLObject(BaseModel):
+    """Image URL object; 'detail' is optional and model-dependent."""
+
+    url: str
+    detail: Literal["auto", "low", "high"] | None = Field(
+        default=None,
+        description="Optional detail control for vision models (auto/low/high).",
+    )
+
+
+class ImageURLPart(BaseModel):
+    """Image content part for multimodal messages."""
+
+    type: Literal["image_url"] = "image_url"
+    image_url: ImageURLObject
+
+
+ContentPart = TextPart | ImageURLPart
+
+
+# ---------- Tool-calling structures ----------
+
+
+class FunctionDef(BaseModel):
+    """JSON Schema function definition for tool-calling."""
+
+    name: str
+    description: str | None = None
+    parameters: dict[str, Any] = Field(
+        default_factory=dict,
+        description="JSON Schema describing function parameters.",
+    )
+
+
+class FunctionTool(BaseModel):
+    type: Literal["function"] = "function"
+    function: FunctionDef
+
+
+class FunctionCall(BaseModel):
+    """Legacy function_call field on assistant messages."""
+
+    name: str
+    arguments: str
+
+
+class ToolCallFunction(BaseModel):
+    name: str
+    arguments: str
+
+
+class ToolCall(BaseModel):
+    """Assistant's tool call (modern)."""
+
+    id: str
+    type: Literal["function"] = "function"
+    function: ToolCallFunction
+
+
+class ToolChoiceFunction(BaseModel):
+    """Explicit tool selection."""
+
+    type: Literal["function"] = "function"
+    function: dict[str, str]  # {"name": "<function_name>"}
+
+
+ToolChoice = Union[Literal["auto", "none"], ToolChoiceFunction]
+
+
+# ---------- Response format (structured outputs) ----------
+
+
+class ResponseFormatText(BaseModel):
+    type: Literal["text"] = "text"
+
+
+class ResponseFormatJSONObject(BaseModel):
+    type: Literal["json_object"] = "json_object"
+
+
+class JSONSchemaFormat(BaseModel):
+    name: str
+    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"
+    json_schema: JSONSchemaFormat
+
+
+ResponseFormat = Union[
+    ResponseFormatText,
+    ResponseFormatJSONObject,
+    ResponseFormatJSONSchema,
+]
+
+
+# ---------- Messages (discriminated by role) ----------
+
+
+class SystemMessage(BaseModel):
+    role: Literal[ChatRole.system] = ChatRole.system
+    content: str | list[ContentPart]
+    name: str | None = None  # optional per API
+
+
+class DeveloperMessage(BaseModel):
+    role: Literal[ChatRole.developer] = ChatRole.developer
+    content: str | list[ContentPart]
+    name: str | None = None
+
+
+class UserMessage(BaseModel):
+    role: Literal[ChatRole.user] = ChatRole.user
+    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: 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):
+    role: Literal[ChatRole.tool] = ChatRole.tool
+    content: str  # tool output returned to the model
+    tool_call_id: str  # must reference the assistant's tool_calls[i].id
+
+
+ChatMessage = (
+    SystemMessage
+    | DeveloperMessage
+    | UserMessage
+    | AssistantMessage
+    | ToolMessage
+)
+
+# ---------- Stream options ----------
+
+
+class StreamOptions(BaseModel):
+    include_usage: bool | None = Field(
+        default=None,
+        description="If true, a final streamed chunk includes token usage.",
+    )
+
+
+# ---------- Main request model ----------
+
+
+class OpenAIChatCompletionsRequest(BaseModel):
+    """
+    Request body for OpenAI Chat Completions.
+    Endpoint: POST https://api.openai.com/v1/chat/completions
+    """
+
+    # Required
+    model: str = Field(..., description="Model name, e.g., 'gpt-4o', 'gpt-4o-mini'.")  # type: ignore
+    messages: list[ChatMessage] = Field(
+        ...,
+        description="Conversation so far, including system/developer context.",
+    )
+
+    # Sampling & penalties
+    temperature: float | None = Field(
+        default=None, ge=0.0, le=2.0, description="Higher is more random."
+    )
+    top_p: float | None = Field(
+        default=None, ge=0.0, le=1.0, description="Nucleus sampling."
+    )
+    presence_penalty: float | None = Field(
+        default=None,
+        ge=-2.0,
+        le=2.0,
+        description="Encourages new topics; -2..2.",
+    )
+    frequency_penalty: float | None = Field(
+        default=None,
+        ge=-2.0,
+        le=2.0,
+        description="Penalizes repetition; -2..2.",
+    )
+
+    # Token limits
+    max_completion_tokens: int | None = Field(
+        default=None,
+        description="Preferred cap on generated tokens (newer models).",
+    )
+    max_tokens: int | None = Field(
+        default=None,
+        description="Legacy completion cap (still accepted by many models).",
+    )
+
+    # Count, stop, logits
+    n: int | None = Field(
+        default=None, ge=1, description="# of choices to generate."
+    )
+    stop: str | list[str] | None = Field(
+        default=None, description="Stop sequence(s)."
+    )
+    logit_bias: dict[str, float] | None = Field(
+        default=None,
+        description="Map of token-id -> bias (-100..100).",
+    )
+    seed: int | None = Field(
+        default=None,
+        description="Optional reproducibility seed (model-dependent).",
+    )
+    logprobs: bool | None = None
+    top_logprobs: int | None = Field(
+        default=None,
+        ge=0,
+        description="When logprobs is true, how many top tokens to include.",
+    )
+
+    # Tool calling (modern)
+    tools: list[FunctionTool] | None = None
+    tool_choice: ToolChoice | None = Field(
+        default=None,
+        description="'auto' (default), 'none', or a function selection.",
+    )
+    parallel_tool_calls: bool | None = Field(
+        default=None,
+        description="Allow multiple tool calls in a single assistant turn.",
+    )
+
+    # Legacy function-calling (still supported)
+    functions: list[FunctionDef] | None = None
+    function_call: Literal["none", "auto"] | FunctionCall | None = None
+
+    # Structured outputs
+    response_format: ResponseFormat | None = None
+
+    # Streaming
+    stream: bool | None = None
+    stream_options: StreamOptions | None = None
+
+    # Routing / tiering
+    service_tier: (
+        Literal["auto", "default", "flex", "scale", "priority"] | None
+    ) = Field(
+        default=None,
+        description="Processing tier; requires account eligibility.",
+    )
+
+    # Misc
+    user: str | None = Field(
+        default=None,
+        description="End-user identifier for abuse monitoring & analytics.",
+    )
+    store: bool | None = Field(
+        default=None,
+        description="Whether to store the response server-side (model-dependent).",
+    )
+    metadata: dict[str, Any] | None = None
+    reasoning_effort: Literal["low", "medium", "high"] | None = Field(
+        default=None,
+        description="For reasoning models: trade-off between speed and accuracy.",
+    )
+
+    @model_validator(mode="after")
+    def _validate_reasoning_model_params(self):
+        if self.is_openai_model:
+            if self.is_reasoning_model:
+                self.temperature = None
+                self.top_p = None
+                self.logprobs = None
+                self.top_logprobs = None
+                self.logit_bias = None
+            else:
+                self.reasoning_effort = None
+        return self
+
+    @property
+    def is_reasoning_model(self) -> bool:
+        return self.model in REASONING_MODELS
+
+    @property
+    def is_openai_model(self) -> bool:
+        return self.model in CHAT_MODELS