lionagi 0.17.11__py3-none-any.whl → 0.18.0__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

@@ -25,7 +25,6 @@ from .mail.manager import MailManager
 from .messages.base import (
     MESSAGE_FIELDS,
     MessageField,
-    MessageFlag,
     MessageRole,
     validate_sender_recipient,
 )
@@ -82,7 +81,6 @@ __all__ = (
     "PackageCategory",
     "MESSAGE_FIELDS",
     "MessageField",
-    "MessageFlag",
     "MessageRole",
     "validate_sender_recipient",
     "ActionRequest",

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/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/hooked_event.py

@@ -47,7 +47,7 @@ class HookedEvent(Event):
                     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()
 
@@ -57,7 +57,7 @@ class HookedEvent(Event):
                     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

lionagi/service/third_party/claude_code.py

@@ -18,12 +18,11 @@ 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
+from lionagi.utils import is_coro_func
 
 HAS_CLAUDE_CODE_CLI = False
 CLAUDE_CLI = None
@@ -415,6 +414,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)