lionagi 0.14.8__py3-none-any.whl → 0.14.9__py3-none-any.whl

lionagi/_errors.py

@@ -2,28 +2,137 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+__all__ = (
+    "LionError",
+    "ValidationError",
+    "NotFoundError",
+    "ExistsError",
+    "ObservationError",
+    "ResourceError",
+    "RateLimitError",
+    "IDError",
+    "RelationError",
+    "OperationError",
+    "ExecutionError",
+    "ItemNotFoundError",
+    "ItemExistsError",
+)
+
 
 class LionError(Exception):
-    pass
+    default_message: ClassVar[str] = "LionAGI error"
+    default_status_code: ClassVar[int] = 500
+    __slots__ = ("message", "details", "status_code")
+
+    def __init__(
+        self,
+        message: str | None = None,
+        *,
+        details: dict[str, Any] | None = None,
+        status_code: int | None = None,
+        cause: Exception | None = None,
+    ):
+        super().__init__(message or self.default_message)
+        if cause:
+            self.__cause__ = cause  # preserves traceback
+        self.message = message or self.default_message
+        self.details = details or {}
+        self.status_code = status_code or type(self).default_status_code
+
+    def to_dict(self, *, include_cause: bool = False) -> dict[str, Any]:
+        data = {
+            "error": self.__class__.__name__,
+            "message": self.message,
+            "status_code": self.status_code,
+            **({"details": self.details} if self.details else {}),
+        }
+        if include_cause and (cause := self.get_cause()):
+            data["cause"] = repr(cause)
+        return data
+
+    def get_cause(self) -> Exception | None:
+        """Get the cause of this error, if any."""
+        return self.__cause__ if hasattr(self, "__cause__") else None
+
+    @classmethod
+    def from_value(
+        cls,
+        value: Any,
+        *,
+        expected: str | None = None,
+        message: str | None = None,
+        cause: Exception | None = None,
+        **extra: Any,
+    ):
+        """Create a ValidationError from a value with optional expected type and message."""
+        details = {
+            "value": value,
+            "type": type(value).__name__,
+            **({"expected": expected} if expected else {}),
+            **extra,
+        }
+        return cls(message=message, details=details, cause=cause)
 
 
-class ItemNotFoundError(LionError):
-    pass
+class ValidationError(LionError):
+    """Exception raised when validation fails."""
 
+    default_message = "Validation failed"
+    default_status_code = 422
+    __slots__ = ()
 
-class ItemExistsError(LionError):
-    pass
 
+class NotFoundError(LionError):
+    """Exception raised when an item is not found."""
 
-class IDError(LionError):
-    pass
+    default_message = "Item not found"
+    default_status_code = 404
+    __slots__ = ()
 
 
-class RelationError(LionError):
-    pass
+class ExistsError(LionError):
+    """Exception raised when an item already exists."""
+
+    default_message = "Item already exists"
+    default_status_code = 409
+    __slots__ = ()
+
+
+class ObservationError(LionError):
+    """Exception raised when an observation fails."""
+
+    default_message = "Observation failed"
+    default_status_code = 500
+    __slots__ = ()
+
+
+class ResourceError(LionError):
+    """Exception raised when resource access fails."""
+
+    default_message = "Resource error"
+    default_status_code = 429
+    __slots__ = ()
 
 
 class RateLimitError(LionError):
+    __slots__ = ("retry_after",)  # one extra attr
+    default_message = "Rate limit exceeded"
+    default_status_code = 429
+
+    def __init__(self, retry_after: float, **kw):
+        super().__init__(**kw)
+        object.__setattr__(self, "retry_after", retry_after)
+
+
+class IDError(LionError):
+    pass
+
+
+class RelationError(LionError):
     pass
 
 
@@ -35,5 +144,5 @@ class ExecutionError(LionError):
     pass
 
 
-class ValidationError(LionError):
-    pass
+ItemNotFoundError = NotFoundError
+ItemExistsError = ExistsError

lionagi/_types.py

@@ -1,9 +1,3 @@
 from .fields import *
 from .models import *
-from .operations import (
-    BrainstormOperation,
-    ExpansionStrategy,
-    Operation,
-    PlanOperation,
-)
 from .protocols.types import *

lionagi/config.py

@@ -63,12 +63,14 @@ class AppSettings(BaseSettings, frozen=True):
     GROQ_API_KEY: SecretStr | None = None
     ANTHROPIC_API_KEY: SecretStr | None = None
 
+    OPENAI_DEFAULT_MODEL: str = "gpt-4.1-mini"
+
     # defaults models
     LIONAGI_EMBEDDING_PROVIDER: str = "openai"
     LIONAGI_EMBEDDING_MODEL: str = "text-embedding-3-small"
 
     LIONAGI_CHAT_PROVIDER: str = "openai"
-    LIONAGI_CHAT_MODEL: str = "gpt-4.1-nano"
+    LIONAGI_CHAT_MODEL: str = "gpt-4.1-mini"
 
     # default storage
     LIONAGI_AUTO_STORE_EVENT: bool = False

lionagi/models/operable_model.py

@@ -263,7 +263,7 @@ class OperableModel(HashableModel):
             Dictionary mapping field names to FieldInfo objects,
             excluding the extra_fields field itself
         """
-        a = {**self.model_fields, **self.extra_fields}
+        a = {**type(self).model_fields, **self.extra_fields}
         a.pop("extra_fields", None)
         a.pop("extra_field_models", None)  # Exclude internal field tracking
         return a
@@ -358,7 +358,12 @@ class OperableModel(HashableModel):
                 for k, v in kwargs.items():
                     self.field_setattr(field_name, k, v)
             else:
-                self.extra_fields[field_name] = Field(**kwargs)
+                _kwargs = {
+                    k: v
+                    for k, v in kwargs.items()
+                    if k not in ("name", "annotation", "validator_kwargs")
+                }
+                self.extra_fields[field_name] = Field(**_kwargs)
 
         # Handle no explicit defined field
         if not field_obj and not kwargs:
@@ -478,7 +483,7 @@ class OperableModel(HashableModel):
             raise KeyError(f"Field {field_name} not found in object fields.")
 
         if str(attr).strip("s").lower() == "annotation":
-            return self.model_fields[field_name].annotation
+            return type(self).model_fields[field_name].annotation
 
         field_obj = all_fields[field_name]
 

lionagi/operations/flow.py

@@ -349,7 +349,6 @@ class DependencyAwareExecutor:
                 and branch.metadata
                 and branch.metadata.get("pending_context_inheritance")
             ):
-
                 primary_dep_id = branch.metadata.get("inherit_from_operation")
                 if primary_dep_id and primary_dep_id in self.results:
                     # Find the primary dependency's branch

lionagi/protocols/generic/event.py

@@ -30,6 +30,8 @@ class EventStatus(str, Enum):
     PROCESSING = "processing"
     COMPLETED = "completed"
     FAILED = "failed"
+    CANCELLED = "cancelled"
+    ABORTED = "aborted"
 
 
 class Execution:

lionagi/protocols/generic/log.py

@@ -13,18 +13,19 @@ from pydantic import BaseModel, Field, PrivateAttr, field_validator
 
 from lionagi.utils import create_path, to_dict
 
-from .._concepts import Manager
 from .element import Element
 from .pile import Pile
 
 __all__ = (
+    "DataLoggerConfig",
     "LogManagerConfig",
     "Log",
+    "DataLogger",
     "LogManager",
 )
 
 
-class LogManagerConfig(BaseModel):
+class DataLoggerConfig(BaseModel):
     persist_dir: str | Path = "./data/logs"
     subfolder: str | None = None
     file_prefix: str | None = None
@@ -101,7 +102,7 @@ class Log(Element):
         return cls(content=content)
 
 
-class LogManager(Manager):
+class DataLogger:
     """
     Manages a collection of logs, optionally auto-dumping them
     to CSV or JSON when capacity is reached or at program exit.
@@ -111,7 +112,7 @@ class LogManager(Manager):
         self,
         *,
         logs: Any = None,
-        _config: LogManagerConfig = None,
+        _config: DataLoggerConfig = None,
         **kwargs,
     ):
         """
@@ -128,7 +129,7 @@ class LogManager(Manager):
             clear_after_dump: Whether to clear logs after saving.
         """
         if _config is None:
-            _config = LogManagerConfig(**kwargs)
+            _config = DataLoggerConfig(**kwargs)
 
         if isinstance(logs, dict):
             self.logs = Pile.from_dict(logs)
@@ -188,8 +189,15 @@ class LogManager(Manager):
             if do_clear:
                 self.logs.clear()
         except Exception as e:
-            logging.error(f"Failed to dump logs: {e}")
-            raise
+            # Check if it's a JSON serialization error with complex objects
+            if "JSON serializable" in str(e):
+                logging.debug(f"Could not serialize logs to JSON: {e}")
+                # Don't raise for JSON serialization issues during dumps
+                if clear is not False:
+                    self.logs.clear()  # Still clear if requested
+            else:
+                logging.error(f"Failed to dump logs: {e}")
+                raise
 
     async def adump(
         self,
@@ -222,16 +230,24 @@ class LogManager(Manager):
             try:
                 self.dump(clear=self._config.clear_after_dump)
             except Exception as e:
-                logging.error(f"Failed to save logs on exit: {e}")
+                # Only log debug level for JSON serialization errors during exit
+                # These are non-critical and often occur with complex objects
+                if "JSON serializable" in str(e):
+                    logging.debug(f"Could not serialize logs to JSON: {e}")
+                else:
+                    logging.error(f"Failed to save logs on exit: {e}")
 
     @classmethod
     def from_config(
-        cls, config: LogManagerConfig, logs: Any = None
-    ) -> LogManager:
+        cls, config: DataLoggerConfig, logs: Any = None
+    ) -> DataLogger:
         """
         Construct a LogManager from a LogManagerConfig.
         """
         return cls(_config=config, logs=logs)
 
 
+LogManagerConfig = DataLoggerConfig
+LogManager = DataLogger
+
 # File: lionagi/protocols/generic/log.py

lionagi/protocols/operatives/step.py

@@ -168,7 +168,7 @@ class Step:
                     ACTION_REQUESTS_FIELD,
                 ]
             )
-        if "reason" in operative.response_model.model_fields:
+        if "reason" in type(operative.response_model).model_fields:
             field_models.extend([REASON_FIELD])
 
         operative = Step._create_response_type(

lionagi/protocols/types.py

@@ -18,7 +18,13 @@ from .forms.flow import FlowDefinition, FlowStep
 from .forms.report import BaseForm, Form, Report
 from .generic.element import ID, Element, IDError, IDType, validate_order
 from .generic.event import Event, EventStatus, Execution
-from .generic.log import Log, LogManager, LogManagerConfig
+from .generic.log import (
+    DataLogger,
+    DataLoggerConfig,
+    Log,
+    LogManager,
+    LogManagerConfig,
+)
 from .generic.pile import Pile, to_list_type
 from .generic.processor import Executor, Processor
 from .generic.progression import Progression, prog
@@ -107,4 +113,6 @@ __all__ = (
     "FunctionCalling",
     "ToolRef",
     "MailManager",
+    "DataLogger",
+    "DataLoggerConfig",
 )

lionagi/service/__init__.py

@@ -1 +1,22 @@
-from .types import *
+from .connections.api_calling import APICalling
+from .connections.endpoint import Endpoint, EndpointConfig
+from .hooks import *
+from .imodel import iModel
+from .manager import iModelManager
+from .rate_limited_processor import RateLimitedAPIExecutor
+from .token_calculator import TokenCalculator
+
+__all__ = (
+    "APICalling",
+    "Endpoint",
+    "EndpointConfig",
+    "RateLimitedAPIExecutor",
+    "TokenCalculator",
+    "iModel",
+    "iModelManager",
+    "HookEventTypes",
+    "HookDict",
+    "AssosiatedEventInfo",
+    "HookEvent",
+    "HookRegistry",
+)

lionagi/service/connections/api_calling.py

@@ -5,10 +5,13 @@
 import asyncio
 import logging
 
-from pydantic import Field, model_validator
+from anyio import get_cancelled_exc_class
+from pydantic import Field, PrivateAttr, 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 lionagi.service.token_calculator import TokenCalculator
 
 from .endpoint import Endpoint
@@ -51,6 +54,9 @@ 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."""
@@ -162,6 +168,13 @@ class APICalling(Event):
 
         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(
@@ -171,10 +184,18 @@ class APICalling(Event):
                 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 asyncio.CancelledError:
+        except get_cancelled_exc_class():
             self.execution.error = "API call cancelled"
             self.execution.status = EventStatus.FAILED
             raise
@@ -228,3 +249,37 @@ class APICalling(Event):
     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

lionagi/service/connections/endpoint_config.py

@@ -32,7 +32,7 @@ class EndpointConfig(BaseModel):
     endpoint_params: list[str] | None = None
     method: str = "POST"
     params: dict[str, str] = Field(default_factory=dict)
-    content_type: str = "application/json"
+    content_type: str | None = "application/json"
     auth_type: AUTH_TYPES = "bearer"
     default_headers: dict = {}
     request_options: B | None = None

lionagi/service/connections/header_factory.py

@@ -27,11 +27,13 @@ class HeaderFactory:
     @staticmethod
     def get_header(
         auth_type: AUTH_TYPES,
-        content_type: str = "application/json",
+        content_type: str | None = "application/json",
         api_key: str | SecretStr | None = None,
         default_headers: dict[str, str] | None = None,
     ) -> dict[str, str]:
-        dict_ = HeaderFactory.get_content_type_header(content_type)
+        dict_ = {}
+        if content_type is not None:
+            dict_ = HeaderFactory.get_content_type_header(content_type)
 
         if auth_type == "none":
             # No authentication needed

lionagi/service/connections/match_endpoint.py

@@ -16,49 +16,49 @@ def match_endpoint(
         if "chat" in endpoint:
             from .providers.oai_ import OpenaiChatEndpoint
 
-            return OpenaiChatEndpoint(**kwargs)
+            return OpenaiChatEndpoint(None, **kwargs)
         if "response" in endpoint:
             from .providers.oai_ import OpenaiResponseEndpoint
 
-            return OpenaiResponseEndpoint(**kwargs)
+            return OpenaiResponseEndpoint(None, **kwargs)
     if provider == "openrouter" and "chat" in endpoint:
         from .providers.oai_ import OpenrouterChatEndpoint
 
-        return OpenrouterChatEndpoint(**kwargs)
+        return OpenrouterChatEndpoint(None, **kwargs)
     if provider == "ollama" and "chat" in endpoint:
         from .providers.ollama_ import OllamaChatEndpoint
 
-        return OllamaChatEndpoint(**kwargs)
+        return OllamaChatEndpoint(None, **kwargs)
     if provider == "exa" and "search" in endpoint:
         from .providers.exa_ import ExaSearchEndpoint
 
-        return ExaSearchEndpoint(**kwargs)
+        return ExaSearchEndpoint(None, **kwargs)
     if provider == "anthropic" and (
         "messages" in endpoint or "chat" in endpoint
     ):
         from .providers.anthropic_ import AnthropicMessagesEndpoint
 
-        return AnthropicMessagesEndpoint(**kwargs)
+        return AnthropicMessagesEndpoint(None, **kwargs)
     if provider == "groq" and "chat" in endpoint:
         from .providers.oai_ import GroqChatEndpoint
 
-        return GroqChatEndpoint(**kwargs)
+        return GroqChatEndpoint(None, **kwargs)
     if provider == "perplexity" and "chat" in endpoint:
         from .providers.perplexity_ import PerplexityChatEndpoint
 
-        return PerplexityChatEndpoint(**kwargs)
+        return PerplexityChatEndpoint(None, **kwargs)
     if provider == "claude_code":
         if "cli" in endpoint:
             from .providers.claude_code_cli import ClaudeCodeCLIEndpoint
 
-            return ClaudeCodeCLIEndpoint(**kwargs)
+            return ClaudeCodeCLIEndpoint(None, **kwargs)
 
         if "query" in endpoint or "code" in endpoint:
             from lionagi.service.connections.providers.claude_code_ import (
                 ClaudeCodeEndpoint,
             )
 
-            return ClaudeCodeEndpoint(**kwargs)
+            return ClaudeCodeEndpoint(None, **kwargs)
 
     from .providers.oai_ import OpenaiChatEndpoint
 

lionagi/service/connections/providers/anthropic_.py

@@ -9,7 +9,7 @@ from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
 from lionagi.service.third_party.anthropic_models import CreateMessageRequest
 
-ANTHROPIC_MESSAGES_ENDPOINT_CONFIG = EndpointConfig(
+_get_config = lambda: EndpointConfig(
     name="anthropic_messages",
     provider="anthropic",
     base_url="https://api.anthropic.com/v1",
@@ -22,13 +22,16 @@ ANTHROPIC_MESSAGES_ENDPOINT_CONFIG = EndpointConfig(
     request_options=CreateMessageRequest,
 )
 
+ANTHROPIC_MESSAGES_ENDPOINT_CONFIG = _get_config()  # backward compatibility
+
 
 class AnthropicMessagesEndpoint(Endpoint):
     def __init__(
         self,
-        config: EndpointConfig = ANTHROPIC_MESSAGES_ENDPOINT_CONFIG,
+        config: EndpointConfig = None,
         **kwargs,
     ):
+        config = config or _get_config()
         super().__init__(config, **kwargs)
 
     def create_payload(

lionagi/service/connections/providers/claude_code_.py

@@ -12,12 +12,14 @@ from pydantic import BaseModel
 from lionagi.libs.schema.as_readable import as_readable
 from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
-from lionagi.utils import is_import_installed, to_dict, to_list
+from lionagi.utils import to_dict, to_list
 
-from ._claude_code.models import (
+from ...third_party.claude_code import (
     CLAUDE_CODE_OPTION_PARAMS,
+    HAS_CLAUDE_CODE_SDK,
     ClaudeCodeRequest,
     ClaudePermission,
+    stream_cc_sdk_events,
 )
 
 __all__ = (
@@ -27,24 +29,27 @@ __all__ = (
     "ClaudeCodeEndpoint",
 )
 
-HAS_CLAUDE_CODE_SDK = is_import_installed("claude_code_sdk")
 
 # --------------------------------------------------------------------------- SDK endpoint
-ENDPOINT_CONFIG = EndpointConfig(
+
+_get_config = lambda: EndpointConfig(
     name="claude_code",
     provider="claude_code",
     base_url="internal",
     endpoint="query",
-    api_key="dummy",
     request_options=ClaudeCodeRequest,
     timeout=3000,
+    api_key="dummy-key",
 )
 
 
+ENDPOINT_CONFIG = _get_config()  # backward compatibility
+
+
 class ClaudeCodeEndpoint(Endpoint):
     """Direct Python-SDK (non-CLI) endpoint - unchanged except for bug-fixes."""
 
-    def __init__(self, config: EndpointConfig = ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config: EndpointConfig = None, **kwargs):
         if not HAS_CLAUDE_CODE_SDK:
             raise ImportError(
                 "claude_code_sdk is not installed. "
@@ -56,6 +61,7 @@ class ClaudeCodeEndpoint(Endpoint):
             DeprecationWarning,
         )
 
+        config = config or _get_config()
         super().__init__(config=config, **kwargs)
 
     def create_payload(self, request: dict | BaseModel, **kwargs):
@@ -64,16 +70,9 @@ class ClaudeCodeEndpoint(Endpoint):
         req_obj = ClaudeCodeRequest.create(messages=messages, **req_dict)
         return {"request": req_obj}, {}
 
-    def _stream_claude_code(self, request: ClaudeCodeRequest):
-        from claude_code_sdk import query as sdk_query
-
-        return sdk_query(
-            prompt=request.prompt, options=request.as_claude_options()
-        )
-
     async def stream(self, request: dict | BaseModel, **kwargs):
         payload, _ = self.create_payload(request, **kwargs)
-        async for chunk in self._stream_claude_code(payload["request"]):
+        async for chunk in stream_cc_sdk_events(payload["request"]):
             yield chunk
 
     def _parse_claude_code_response(self, responses: list) -> dict:
@@ -204,9 +203,6 @@ class ClaudeCodeEndpoint(Endpoint):
 
                     responses.append(chunk)
 
-        # 3. Parse the responses into a clean format
-        return self._parse_claude_code_response(responses)
-
 
 def _display_message(chunk, theme):
     from claude_code_sdk import types as cc_types