lionagi 0.17.11__py3-none-any.whl → 0.18.1__py3-none-any.whl

lionagi/protocols/messages/system.py

@@ -1,144 +1,73 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
+from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, NoReturn
+from typing import Any
 
-from pydantic import JsonValue
-from typing_extensions import Self, override
+from pydantic import Field, field_validator
 
 from .base import SenderRecipient
-from .message import MessageRole, RoledMessage, Template, jinja_env
+from .message import MessageContent, MessageRole, RoledMessage
 
-__all__ = ("System",)
 
+@dataclass(slots=True)
+class SystemContent(MessageContent):
+    """Content for system messages.
 
-def format_system_content(
-    system_datetime: bool | str | None,
-    system_message: str,
-) -> dict:
+    Fields:
+        system_message: Main system instruction text
+        system_datetime: Optional datetime string
     """
-    Insert optional datetime string into the system message content.
 
-    Args:
-        system_datetime (bool|str|None):
-            If True, embed current time. If str, use as time. If None, omit.
-        system_message (str):
-            The main system message text.
-
-    Returns:
-        dict: The combined system content.
-    """
-    content: dict = {"system_message": system_message}
-    if system_datetime:
-        if isinstance(system_datetime, str):
-            content["system_datetime"] = system_datetime
-        else:
-            content["system_datetime"] = datetime.now().isoformat(
-                timespec="minutes"
-            )
-    return content
-
-
-class System(RoledMessage):
-    """
-    A specialized message that sets a *system-level* context or policy.
-    Usually the first in a conversation, instructing the AI about general
-    constraints or identity.
-    """
-
-    template: str | Template | None = jinja_env.get_template(
-        "system_message.jinja2"
+    system_message: str = (
+        "You are a helpful AI assistant. Let's think step by step."
     )
+    system_datetime: str | None = None
 
-    @override
-    @classmethod
-    def create(
-        cls,
-        system_message="You are a helpful AI assistant. Let's think step by step.",
-        system_datetime=None,
-        sender: SenderRecipient = None,
-        recipient: SenderRecipient = None,
-        template=None,
-        system: Any = None,
-        **kwargs,
-    ) -> Self:
-        """
-        Construct a system message with optional datetime annotation.
-
-        Args:
-            system_message (str):
-                The main text instructing the AI about behavior/identity.
-            system_datetime (bool|str, optional):
-                If True or str, embed a time reference. If str, it is used directly.
-            sender (SenderRecipient, optional):
-                Typically `MessageRole.SYSTEM`.
-            recipient (SenderRecipient, optional):
-                Typically `MessageRole.ASSISTANT`.
-            template (Template|str|None):
-                An optional custom template for rendering.
-            system (Any):
-                Alias for `system_message` (deprecated).
-            **kwargs:
-                Additional content merged into the final dict.
+    @property
+    def rendered(self) -> str:
+        """Render system message with optional datetime."""
+        parts = []
+        if self.system_datetime:
+            parts.append(f"System Time: {self.system_datetime}")
+        parts.append(self.system_message)
+        return "\n\n".join(parts)
 
-        Returns:
-            System: A newly created system-level message.
-        """
-        if system and system_message:
-            raise ValueError(
-                "Cannot provide both system and system_message arguments."
-                "as they are alias, and `system` is deprecated"
-            )
-        system_message = system_message or system
-
-        content = format_system_content(
-            system_datetime=system_datetime, system_message=system_message
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "SystemContent":
+        """Construct SystemContent from dictionary."""
+        system_message = data.get(
+            "system_message",
+            cls.__dataclass_fields__["system_message"].default,
         )
-        content.update(kwargs)
-        params = {
-            "role": MessageRole.SYSTEM,
-            "content": content,
-            "sender": sender or MessageRole.SYSTEM,
-            "recipient": recipient or MessageRole.ASSISTANT,
-        }
-        if template:
-            params["template"] = template
-        return cls(**params)
+        system_datetime = data.get("system_datetime")
 
-    def update(
-        self,
-        system_message: JsonValue = None,
-        sender: SenderRecipient = None,
-        recipient: SenderRecipient = None,
-        system_datetime: bool | str = None,
-        template: Template | str | None = None,
-        **kwargs,
-    ) -> NoReturn:
-        """
-        Adjust fields of this system message.
+        # Handle datetime generation
+        if system_datetime is True:
+            system_datetime = datetime.now().isoformat(timespec="minutes")
+        elif system_datetime is False or system_datetime is None:
+            system_datetime = None
 
-        Args:
-            system_message (JsonValue):
-                New system message text.
-            sender (SenderRecipient):
-                Updated sender or role.
-            recipient (SenderRecipient):
-                Updated recipient or role.
-            system_datetime (bool|str):
-                If set, embed new datetime info.
-            template (Template|str|None):
-                New template override.
-            **kwargs:
-                Additional fields for self.content.
-        """
-        if any([system_message, system_message]):
-            self.content = format_system_content(
-                system_datetime=system_datetime, system_message=system_message
-            )
-        super().update(
-            sender=sender, recipient=recipient, template=template, **kwargs
+        return cls(
+            system_message=system_message, system_datetime=system_datetime
         )
 
 
-# File: lionagi/protocols/messages/system.py
+class System(RoledMessage):
+    """System-level message setting context or policy for the conversation."""
+
+    role: MessageRole = MessageRole.SYSTEM
+    content: SystemContent = Field(default_factory=SystemContent)
+    sender: SenderRecipient | None = MessageRole.SYSTEM
+    recipient: SenderRecipient | None = MessageRole.ASSISTANT
+
+    @field_validator("content", mode="before")
+    def _validate_content(cls, v):
+        if v is None:
+            return SystemContent()
+        if isinstance(v, dict):
+            return SystemContent.from_dict(v)
+        if isinstance(v, SystemContent):
+            return v
+        raise TypeError("content must be dict or SystemContent instance")

lionagi/protocols/types.py

@@ -5,7 +5,7 @@ from ._concepts import Collective, Communicatable, Condition, Manager
 from ._concepts import Observable as LegacyObservable
 from ._concepts import Observer, Ordering, Relational, Sendable
 from .contracts import Observable, ObservableProto
-from .generic.element import ID, Element, IDError, IDType, validate_order
+from .generic.element import ID, Element, validate_order
 from .generic.event import Event, EventStatus, Execution
 from .generic.log import (
     DataLogger,
@@ -20,12 +20,9 @@ from .generic.progression import Progression, prog
 from .graph.edge import EdgeCondition
 from .graph.graph import Edge, Graph, Node
 from .ids import canonical_id, to_uuid
-from .mail.exchange import Exchange, Mail, Mailbox, Package, PackageCategory
-from .mail.manager import MailManager
 from .messages.base import (
     MESSAGE_FIELDS,
     MessageField,
-    MessageFlag,
     MessageRole,
     validate_sender_recipient,
 )
@@ -56,8 +53,6 @@ __all__ = (
     "to_uuid",  # ID conversion utility
     "ID",
     "Element",
-    "IDError",
-    "IDType",
     "validate_order",
     "Event",
     "EventStatus",
@@ -75,14 +70,8 @@ __all__ = (
     "Edge",
     "Graph",
     "Node",
-    "Exchange",
-    "Mail",
-    "Mailbox",
-    "Package",
-    "PackageCategory",
     "MESSAGE_FIELDS",
     "MessageField",
-    "MessageFlag",
     "MessageRole",
     "validate_sender_recipient",
     "ActionRequest",
@@ -93,7 +82,6 @@ __all__ = (
     "RoledMessage",
     "SenderRecipient",
     "System",
-    "MailManager",
     "DataLogger",
     "DataLoggerConfig",
 )

lionagi/service/connections/__init__.py

@@ -1,6 +1,7 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
+from .api_calling import APICalling
 from .endpoint import Endpoint
 from .endpoint_config import EndpointConfig
 from .header_factory import HeaderFactory
@@ -11,4 +12,6 @@ __all__ = (
     "EndpointConfig",
     "HeaderFactory",
     "match_endpoint",
+    "APICalling",
+    "match_endpoint",
 )

lionagi/service/connections/endpoint.py

@@ -122,10 +122,7 @@ class Endpoint:
             # Validate the filtered payload
             payload = self.config.validate_payload(filtered_payload)
         else:
-            # If no request_options, we still need to remove obvious non-API params
-            # These are parameters that are never part of any API payload
             non_api_params = {
-                "task",
                 "provider",
                 "base_url",
                 "endpoint",
@@ -133,13 +130,9 @@ class Endpoint:
                 "api_key",
                 "queue_capacity",
                 "capacity_refresh_time",
-                "interval",
-                "limit_requests",
-                "limit_tokens",
                 "invoke_with_endpoint",
                 "extra_headers",
                 "headers",
-                "cache_control",
                 "include_token_usage_to_model",
                 "chat_model",
                 "imodel",
@@ -148,7 +141,6 @@ class Endpoint:
                 "aggregation_count",
                 "action_strategy",
                 "parse_model",
-                "reason",
                 "actions",
                 "return_operative",
                 "operative_model",

lionagi/service/connections/providers/claude_code_cli.py

@@ -84,8 +84,9 @@ class ClaudeCodeCLIEndpoint(Endpoint):
     async def stream(
         self, request: dict | BaseModel, **kwargs
     ) -> AsyncIterator[ClaudeChunk | dict | ClaudeSession]:
-        payload, _ = self.create_payload(request, **kwargs)["request"]
-        async for chunk in stream_claude_code_cli(payload):
+        payload, _ = self.create_payload(request, **kwargs)
+        request_obj = payload["request"]
+        async for chunk in stream_claude_code_cli(request_obj):
             yield chunk
 
     async def _call(

lionagi/service/connections/providers/oai_.py

@@ -18,45 +18,21 @@ from pydantic import BaseModel
 from lionagi.config import settings
 from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
-from lionagi.service.third_party.openai_model_names import (
-    REASONING_MODELS,
-    is_reasoning_model,
-)
-
-__all__ = (
-    "OpenaiChatEndpoint",
-    "OpenaiResponseEndpoint",
-    "OpenaiEmbedEndpoint",
-    "OpenrouterChatEndpoint",
-    "GroqChatEndpoint",
-    "OPENAI_CHAT_ENDPOINT_CONFIG",
-    "OPENAI_RESPONSE_ENDPOINT_CONFIG",
-    "OPENAI_EMBEDDING_ENDPOINT_CONFIG",
-    "OPENROUTER_CHAT_ENDPOINT_CONFIG",
-    "OPENROUTER_GEMINI_ENDPOINT_CONFIG",
-    "GROQ_CHAT_ENDPOINT_CONFIG",
-    "REASONING_MODELS",
-    "REASONING_NOT_SUPPORT_PARAMS",
+from lionagi.service.third_party.openai_models import (
+    OpenAIChatCompletionsRequest,
 )
 
 
-def _get_openai_config(**kwargs):
-    """Create OpenAI endpoint configuration with defaults."""
-    config = dict(
-        name="openai_chat",
-        provider="openai",
-        base_url="https://api.openai.com/v1",
-        endpoint="chat/completions",
-        kwargs={"model": settings.OPENAI_DEFAULT_MODEL},
-        api_key=settings.OPENAI_API_KEY or "dummy-key-for-testing",
-        auth_type="bearer",
-        content_type="application/json",
-        method="POST",
-        requires_tokens=True,
-        # NOTE: OpenAI models have incorrect role literals, only use for param validation
-        # request_options=CreateChatCompletionRequest,
-    )
-    config.update(kwargs)
+def _get_oai_config(**kw):
+    config = {
+        "provider": "openai",
+        "base_url": "https://api.openai.com/v1",
+        "auth_type": "bearer",
+        "content_type": "application/json",
+        "method": "POST",
+        "api_key": settings.OPENAI_API_KEY or "dummy-key-for-testing",
+    }
+    config.update(kw)
     return EndpointConfig(**config)
 
 
@@ -72,8 +48,7 @@ def _get_openrouter_config(**kwargs):
         auth_type="bearer",
         content_type="application/json",
         method="POST",
-        # NOTE: OpenRouter uses OpenAI-compatible format
-        # request_options=CreateChatCompletionRequest,
+        request_options=OpenAIChatCompletionsRequest,
     )
     config.update(kwargs)
     return EndpointConfig(**config)
@@ -91,48 +66,21 @@ def _get_groq_config(**kwargs):
         auth_type="bearer",
         content_type="application/json",
         method="POST",
+        request_options=OpenAIChatCompletionsRequest,
     )
     config.update(kwargs)
     return EndpointConfig(**config)
 
 
-# OpenAI endpoints
-OPENAI_CHAT_ENDPOINT_CONFIG = _get_openai_config()
-
-OPENAI_RESPONSE_ENDPOINT_CONFIG = _get_openai_config(
-    name="openai_response",
-    endpoint="responses",
-)
-
-OPENAI_EMBEDDING_ENDPOINT_CONFIG = _get_openai_config(
-    name="openai_embed",
-    endpoint="embeddings",
-    kwargs={"model": "text-embedding-3-small"},
-)
-
-# OpenRouter endpoints
-OPENROUTER_CHAT_ENDPOINT_CONFIG = _get_openrouter_config()
-
-OPENROUTER_GEMINI_ENDPOINT_CONFIG = _get_openrouter_config(
-    name="openrouter_gemini",
-    kwargs={"model": "google/gemini-2.5-flash"},
-)
-
-# Groq endpoints
-GROQ_CHAT_ENDPOINT_CONFIG = _get_groq_config()
-
-REASONING_NOT_SUPPORT_PARAMS = (
-    "temperature",
-    "top_p",
-    "logit_bias",
-    "logprobs",
-    "top_logprobs",
-)
-
-
 class OpenaiChatEndpoint(Endpoint):
     def __init__(self, config=None, **kwargs):
-        config = config or _get_openai_config()
+        config = config or _get_oai_config(
+            name="oai_chat",
+            endpoint="chat/completions",
+            request_options=OpenAIChatCompletionsRequest,
+            kwargs={"model": settings.OPENAI_DEFAULT_MODEL},
+            requires_tokens=True,
+        )
         super().__init__(config, **kwargs)
 
     def create_payload(
@@ -145,34 +93,20 @@ class OpenaiChatEndpoint(Endpoint):
         payload, headers = super().create_payload(
             request, extra_headers, **kwargs
         )
-
-        # Handle reasoning models
-        model = payload.get("model")
-        if (
-            model
-            and is_reasoning_model(model)
-            and not model.startswith("gpt-5")
-        ):
-            # Remove unsupported parameters for reasoning models
-            for param in REASONING_NOT_SUPPORT_PARAMS:
-                payload.pop(param, None)
-
-            # Convert system role to developer role for reasoning models
-            if "messages" in payload and payload["messages"]:
-                if payload["messages"][0].get("role") == "system":
-                    payload["messages"][0]["role"] = "developer"
-        else:
-            # Remove reasoning_effort for non-reasoning models
-            payload.pop("reasoning_effort", None)
+        # Convert system role to developer role for reasoning models
+        if "messages" in payload and payload["messages"]:
+            if payload["messages"][0].get("role") == "system":
+                payload["messages"][0]["role"] = "developer"
 
         return (payload, headers)
 
 
 class OpenaiResponseEndpoint(Endpoint):
     def __init__(self, config=None, **kwargs):
-        config = config or _get_openai_config(
+        config = config or _get_oai_config(
             name="openai_response",
             endpoint="responses",
+            requires_tokens=True,
         )
         super().__init__(config, **kwargs)
 
@@ -191,9 +125,10 @@ class GroqChatEndpoint(Endpoint):
 
 class OpenaiEmbedEndpoint(Endpoint):
     def __init__(self, config=None, **kwargs):
-        config = config or _get_openai_config(
+        config = config or _get_oai_config(
             name="openai_embed",
             endpoint="embeddings",
             kwargs={"model": "text-embedding-3-small"},
+            requires_tokens=True,
         )
         super().__init__(config, **kwargs)

lionagi/service/connections/providers/ollama_.py

@@ -24,6 +24,8 @@ _HAS_OLLAMA = is_import_installed("ollama")
 
 def _get_ollama_config(**kwargs):
     """Create Ollama endpoint configuration with defaults."""
+    from ...third_party.openai_models import OpenAIChatCompletionsRequest
+
     config = dict(
         name="ollama_chat",
         provider="ollama",
@@ -36,8 +38,7 @@ def _get_ollama_config(**kwargs):
         content_type="application/json",
         auth_type="none",  # No authentication
         default_headers={},  # No auth headers needed
-        # NOTE: Not using request_options due to OpenAI model role literal issues
-        # request_options=CreateChatCompletionRequest,
+        request_options=OpenAIChatCompletionsRequest,
     )
     config.update(kwargs)
     return EndpointConfig(**config)

lionagi/service/hooks/_types.py

@@ -8,7 +8,7 @@ from typing import TypeVar
 
 from typing_extensions import TypedDict
 
-from lionagi.utils import Enum
+from lionagi.ln.types import Enum
 
 SC = TypeVar("SC")  # streaming chunk type
 

lionagi/service/hooks/_utils.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 from anyio import sleep
 
 from lionagi._errors import ValidationError
-from lionagi.utils import is_coro_func
+from lionagi.ln import is_coro_func
 
 from ._types import ALLOWED_HOOKS_TYPES, HookEventTypes
 

lionagi/service/hooks/hook_event.py

@@ -3,7 +3,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import anyio
 from pydantic import Field, PrivateAttr, field_validator
@@ -12,19 +12,14 @@ from lionagi.ln.concurrency import fail_after, get_cancelled_exc_class
 from lionagi.protocols.types import Event, EventStatus
 
 from ._types import AssosiatedEventInfo, HookEventTypes
-
-if TYPE_CHECKING:
-    from .hook_registry import HookRegistry
-else:
-    # Import at runtime for Pydantic
-    from .hook_registry import HookRegistry
+from .hook_registry import HookRegistry
 
 
 class HookEvent(Event):
     registry: HookRegistry = Field(..., exclude=True)
     hook_type: HookEventTypes
     exit: bool = Field(False, exclude=True)
-    timeout: int = Field(30, exclude=True)
+    timeout: int | float = Field(30, exclude=True)
     params: dict[str, Any] = Field(default_factory=dict, exclude=True)
     event_like: Event | type[Event] = Field(..., exclude=True)
     _should_exit: bool = PrivateAttr(False)

lionagi/service/hooks/hook_registry.py

@@ -6,8 +6,8 @@ from __future__ import annotations
 from typing import Any, TypeVar
 
 from lionagi.ln.concurrency import get_cancelled_exc_class
+from lionagi.ln.types import Undefined
 from lionagi.protocols.types import Event, EventStatus
-from lionagi.utils import UNDEFINED
 
 from ._types import HookDict, HookEventTypes, StreamHandlers
 from ._utils import get_handler, validate_hooks, validate_stream_handlers
@@ -99,7 +99,7 @@ class HookRegistry:
             )
             return (res, False, EventStatus.COMPLETED)
         except get_cancelled_exc_class() as e:
-            return ((UNDEFINED, e), True, EventStatus.CANCELLED)
+            return ((Undefined, e), True, EventStatus.CANCELLED)
         except Exception as e:
             return (e, exit, EventStatus.CANCELLED)
 
@@ -125,7 +125,7 @@ class HookRegistry:
             )
             return (res, False, EventStatus.COMPLETED)
         except get_cancelled_exc_class() as e:
-            return ((UNDEFINED, e), True, EventStatus.CANCELLED)
+            return ((Undefined, e), True, EventStatus.CANCELLED)
         except Exception as e:
             return (e, exit, EventStatus.CANCELLED)
 
@@ -147,7 +147,7 @@ class HookRegistry:
             )
             return (res, False, EventStatus.COMPLETED)
         except get_cancelled_exc_class() as e:
-            return ((UNDEFINED, e), True, EventStatus.CANCELLED)
+            return ((Undefined, e), True, EventStatus.CANCELLED)
         except Exception as e:
             return (e, exit, EventStatus.ABORTED)
 
@@ -171,7 +171,7 @@ class HookRegistry:
             )
             return (res, False, None)
         except get_cancelled_exc_class() as e:
-            return ((UNDEFINED, e), True, EventStatus.CANCELLED)
+            return ((Undefined, e), True, EventStatus.CANCELLED)
         except Exception as e:
             return (e, exit, EventStatus.ABORTED)