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

lionagi/protocols/mail/manager.py

@@ -1,218 +0,0 @@
-# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0
-
-import asyncio
-from collections import deque
-from typing import Any
-
-from lionagi._errors import ItemNotFoundError
-
-from .._concepts import Manager, Observable
-from ..generic.element import ID, IDType
-from ..generic.pile import Pile, to_list_type
-from .exchange import Exchange
-from .mail import Mail, Package, PackageCategory
-
-
-class MailManager(Manager):
-    """
-    A manager for mail operations across various observable sources
-    within LionAGI. Unlike `Exchange`, this class can manage the state
-    of multiple sources in a more general or higher-level context,
-    storing mail queues in a dictionary rather than individual buffers.
-
-    Attributes
-    ----------
-    sources : Pile[Observable]
-        A concurrency-safe collection of known sources.
-    mails : dict[str, dict[str, deque]]
-        A nested mapping of recipient -> sender -> queue of mail.
-    execute_stop : bool
-        Controls the asynchronous execution loop; set to True to exit.
-    """
-
-    def __init__(self, sources: ID.Item | ID.ItemSeq = None) -> None:
-        """
-        Initialize a MailManager instance.
-
-        Parameters
-        ----------
-        sources : ID.Item | ID.ItemSeq, optional
-            Initial source(s) to manage. Each source must be an Observable.
-        """
-        self.sources: Pile[Observable] = Pile()
-        self.mails: dict[str, dict[str, deque]] = {}
-        self.execute_stop: bool = False
-
-        if sources:
-            self.add_sources(sources)
-
-    def add_sources(self, sources: ID.Item | ID.ItemSeq, /) -> None:
-        """
-        Register new sources in the MailManager.
-
-        Parameters
-        ----------
-        sources : ID.Item | ID.ItemSeq
-            A single source or multiple sources to be added.
-
-        Raises
-        ------
-        ValueError
-            If adding the sources fails for any reason.
-        """
-        try:
-            sources = to_list_type(sources)
-            self.sources.include(sources)
-            for item in sources:
-                self.mails[item.id] = {}
-        except Exception as e:
-            raise ValueError("Failed to add source.") from e
-
-    @staticmethod
-    def create_mail(
-        sender: ID.Ref,
-        recipient: ID.Ref,
-        category: PackageCategory | str,
-        package: Any,
-        request_source: Any = None,
-    ) -> Mail:
-        """
-        Factory method to generate a Mail object.
-
-        Parameters
-        ----------
-        sender : ID.Ref
-            Reference (ID or object) for the sender.
-        recipient : ID.Ref
-            Reference (ID or object) for the recipient.
-        category : PackageCategory | str
-            The category of this package.
-        package : Any
-            The payload or content in the mail.
-        request_source : Any, optional
-            Additional context about the request source.
-
-        Returns
-        -------
-        Mail
-            A new mail object with specified sender, recipient, and package.
-        """
-        pack = Package(
-            category=category, package=package, request_source=request_source
-        )
-        return Mail(sender=sender, recipient=recipient, package=pack)
-
-    def delete_source(self, source_id: IDType) -> None:
-        """
-        Remove a source from the manager, discarding any associated mail.
-
-        Parameters
-        ----------
-        source_id : IDType
-            The ID of the source to be removed.
-
-        Raises
-        ------
-        ItemNotFoundError
-            If the given source ID is not present.
-        """
-        if source_id not in self.sources:
-            raise ItemNotFoundError(f"Source {source_id} does not exist.")
-        self.sources.pop(source_id)
-        self.mails.pop(source_id)
-
-    def collect(self, sender: IDType) -> None:
-        """
-        Collect outbound mail from a single source.
-
-        Parameters
-        ----------
-        sender : IDType
-            The ID of the sender whose outbound mail is retrieved.
-
-        Raises
-        ------
-        ItemNotFoundError
-            If the sender is not recognized.
-        """
-        if sender not in self.sources:
-            raise ItemNotFoundError(f"Sender source {sender} does not exist.")
-        mailbox: Exchange = (
-            self.sources[sender]
-            if isinstance(self.sources[sender], Exchange)
-            else self.sources[sender].mailbox
-        )
-        while mailbox.pending_outs.size() > 0:
-            mail_id = mailbox.pending_outs.popleft()
-            mail: Mail = mailbox.pile_.pop(mail_id)
-            if mail.recipient not in self.sources:
-                rec_ = mail.recipient
-                raise ItemNotFoundError(
-                    f"Recipient source {rec_} does not exist"
-                )
-            if mail.sender not in self.mails[mail.recipient]:
-                self.mails[mail.recipient].update({mail.sender: deque()})
-            self.mails[mail.recipient][mail.sender].append(mail)
-
-    def send(self, recipient: IDType) -> None:
-        """
-        Send any pending mail to a specified recipient.
-
-        Parameters
-        ----------
-        recipient : IDType
-            The ID of the recipient to which mail should be delivered.
-
-        Raises
-        ------
-        ItemNotFoundError
-            If the recipient ID is not recognized.
-        """
-        if recipient not in self.sources:
-            raise ItemNotFoundError(
-                f"Recipient source {recipient} does not exist."
-            )
-        if not self.mails[recipient]:
-            return
-        for key in list(self.mails[recipient].keys()):
-            pending_mails = self.mails[recipient].pop(key)
-            mailbox: Exchange = (
-                self.sources[recipient]
-                if isinstance(self.sources[recipient], Exchange)
-                else self.sources[recipient].mailbox
-            )
-            while pending_mails:
-                mail = pending_mails.popleft()
-                mailbox.include(mail, direction="in")
-
-    def collect_all(self) -> None:
-        """
-        Collect outbound mail from all known sources.
-        """
-        for source in self.sources:
-            self.collect(sender=source.id)
-
-    def send_all(self) -> None:
-        """
-        Send mail to all known recipients who have pending items.
-        """
-        for source in self.sources:
-            self.send(recipient=source.id)
-
-    async def execute(self, refresh_time: int = 1) -> None:
-        """
-        Continuously collect and send mail in an asynchronous loop.
-
-        Parameters
-        ----------
-        refresh_time : int, optional
-            Delay (in seconds) between each collect/send cycle.
-        """
-        while not self.execute_stop:
-            self.collect_all()
-            self.send_all()
-            await asyncio.sleep(refresh_time)
-
-
-# File: lion_core/communication/manager.py

lionagi/protocols/mail/package.py

@@ -1,101 +0,0 @@
-# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0
-
-from enum import Enum
-from typing import Any
-
-from lionagi.ln import now_utc
-from lionagi.protocols.generic.element import ID, IDType
-
-from .._concepts import Communicatable, Observable
-
-
-class PackageCategory(str, Enum):
-    """
-    Enumeration of common package categories in LionAGI:
-
-    - MESSAGE: General message content
-    - TOOL: A tool or action to be invoked
-    - IMODEL: Some internal model reference
-    - NODE: A node in a graph
-    - NODE_LIST: A list of nodes
-    - NODE_ID: A node ID
-    - START: A 'start' signal
-    - END: An 'end' signal
-    - CONDITION: A condition or gating logic
-    - SIGNAL: A more generic signal or marker
-    """
-
-    MESSAGE = "message"
-    TOOL = "tool"
-    IMODEL = "imodel"
-    NODE = "node"
-    NODE_LIST = "node_list"
-    NODE_ID = "node_id"
-    START = "start"
-    END = "end"
-    CONDITION = "condition"
-    SIGNAL = "signal"
-
-
-def validate_category(value: Any) -> PackageCategory:
-    """
-    Validate and convert the input to a valid PackageCategory.
-
-    Parameters
-    ----------
-    value : Any
-        The input to interpret as a `PackageCategory`.
-
-    Returns
-    -------
-    PackageCategory
-        The validated category.
-
-    Raises
-    ------
-    ValueError
-        If the value cannot be converted into a valid package category.
-    """
-    if isinstance(value, PackageCategory):
-        return value
-    try:
-        return PackageCategory(str(value))
-    except ValueError as e:
-        raise ValueError("Invalid value for category.") from e
-
-
-class Package(Observable):
-    """
-    A self-contained package that can be attached to `Mail` items.
-    Includes a unique ID, creation timestamp, category, payload item,
-    and an optional request source for context.
-
-    Attributes
-    ----------
-    category : PackageCategory
-        The classification or type of package.
-    item : Any
-        The main payload or data of this package.
-    request_source : ID[Communicatable] | None
-        An optional reference indicating the origin or context
-        for this package.
-    """
-
-    __slots__ = ("id", "created_at", "category", "item", "request_source")
-
-    def __init__(
-        self,
-        category: PackageCategory,
-        item: Any,
-        request_source: ID[Communicatable] = None,
-    ):
-        super().__init__()
-        self.id = IDType.create()
-        self.created_at = now_utc().timestamp()
-        self.category = validate_category(category)
-        self.item = item
-        self.request_source = request_source
-
-
-# File: lionagi/protocols/mail/package.py

lionagi/protocols/messages/templates/README.md

@@ -1,28 +0,0 @@
-## Rendering Templates
-
-Once templates are defined, you can load and render them using Jinja2:
-
-```python
-from jinja2 import Environment, FileSystemLoader
-
-env = Environment(loader=FileSystemLoader('templates'))
-
-# Example: Rendering an instruction message
-template = env.get_template('instruction_message.jinja2')
-args = {
-    "guidance": "Please ensure accuracy.",
-    "instruction": "Summarize the document",
-    "context": ["Doc1: ...", "Doc2: ..."],
-    "request_fields": {"summary": "...", "key_points": "..."}
-}
-message_text = template.render(**args)
-print(message_text)
-```
-
-Benefits and Customization
-	•	You can easily rearrange sections within these templates without changing your code logic.
-	•	Each message type is clearly separated, making it simpler to maintain or adjust one message format without affecting the others.
-	•	If you find that you use some snippet (like rendering a schema) in multiple templates, you can factor it out into its own partial template (like tool_schemas.jinja2) and include it where needed.
-	•	Over time, you can add more templates or split existing ones if certain messages become too complex.
-
-By establishing this set of base templates and arguments, you have a starting point. You can expand or refine as your requirements evolve.

lionagi/protocols/messages/templates/action_request.jinja2

@@ -1,5 +0,0 @@
-Please perform the following action:
-- Function: {{ function }}
-- Arguments:
-```json
-{{ arguments | tojson(indent=2) }}

lionagi/protocols/messages/templates/action_response.jinja2

@@ -1,9 +0,0 @@
-The action has been performed. Results:
-
-Function: {{ function }}
-Arguments:
-```json
-{{ arguments | tojson(indent=2) }}
-
-Output:
-{{ output }}

lionagi/protocols/messages/templates/assistant_response.jinja2

@@ -1,6 +0,0 @@
-# Assistant Response
-{% if name is defined %}
-**Name** {{ name }}: 
-{% endif %}
-**Response**:
-{{ assistant_response }}

lionagi/protocols/messages/templates/instruction_message.jinja2

@@ -1,61 +0,0 @@
-{%- set content = [] -%}
-
-{# If plain_content is provided, we use it directly. Otherwise, we build a text block from guidance, instruction, context, etc. #}
-{% if plain_content %}
-{% set content = content + [{"type": "text", "text": plain_content}] %}
-{% else %}
-{# Build a text block from the available sections #}
-{% set text_block = "" %}
-
-{% if guidance %}
-## Guidance
-{{ guidance }}
-
-{% endif %}
-
-{% if instruction %}
-## Instruction
-{{ instruction }}
-
-{% endif %}
-
-{% if context %}
-## Context
-{% for item in context %}
-- {{ item }}
-{% endfor %}
-{% endif %}
-
-{% if tool_schemas %}
-## Tool Schemas
-{% include "tool_schemas.jinja2" %}
-{% endif %}
-
-{% if request_fields %}
-## Requested Fields
-Please return a JSON object with the following fields:
-```json
-{{ request_fields | tojson(indent=2) }}
-
-{% endif %}
-
-{% if request_response_format %}
-
-Response Format
-
-{{ request_response_format }}
-{% endif %}
-
-{# Append the built sections into text_block #}
-{% set text_block = text_block + self %}
-{% set content = content + [{"type": "text", "text": text_block.strip()}] %}
-{% endif %}
-
-{# If images are present, we append image_url items to content #}
-{% if images %}
-{% for img in images %}
-{% set content = content + [{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64," ~ img, "detail": image_detail}}] %}
-{% endfor %}
-{% endif %}
-
-{{ content | tojson(indent=2) }}

lionagi/protocols/messages/templates/system_message.jinja2

@@ -1,11 +0,0 @@
-{{ system_message }}
-{% if system_datetime %}
-System datetime: {{ system_datetime }}
-{% endif %}
-
-{% if additional_context %}
-Additional Context:
-{% for c in additional_context %}
-- {{ c }}
-{% endfor %}
-{% endif %}

lionagi/protocols/messages/templates/tool_schemas.jinja2

@@ -1,7 +0,0 @@
-{% for name, schema in tool_schemas.items() %}
-Tool: {{ name }}
-Schema:
-```json
-{{ schema | tojson(indent=2) }}
-
-{% endfor %}

lionagi/protocols/operatives/__init__.py

@@ -1,2 +0,0 @@
-# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0

lionagi/service/connections/providers/types.py

@@ -1,28 +0,0 @@
-from .anthropic_ import AnthropicMessagesEndpoint
-from .claude_code_cli import ClaudeCodeCLIEndpoint, ClaudeCodeRequest
-from .exa_ import ExaSearchEndpoint, ExaSearchRequest
-from .oai_ import (
-    GroqChatEndpoint,
-    OpenaiChatEndpoint,
-    OpenaiEmbedEndpoint,
-    OpenaiResponseEndpoint,
-    OpenrouterChatEndpoint,
-)
-from .ollama_ import OllamaChatEndpoint
-from .perplexity_ import PerplexityChatEndpoint, PerplexityChatRequest
-
-__all__ = (
-    "AnthropicMessagesEndpoint",
-    "ClaudeCodeRequest",
-    "ClaudeCodeCLIEndpoint",
-    "ExaSearchEndpoint",
-    "ExaSearchRequest",
-    "OpenaiChatEndpoint",
-    "OpenaiEmbedEndpoint",
-    "OpenaiResponseEndpoint",
-    "OpenrouterChatEndpoint",
-    "GroqChatEndpoint",
-    "OllamaChatEndpoint",
-    "PerplexityChatEndpoint",
-    "PerplexityChatRequest",
-)

lionagi/service/third_party/openai_model_names.py

@@ -1,198 +0,0 @@
-"""
-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 typing import Literal, get_args
-
-# 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",
-]
-
-# Reasoning models (o1, o3, o4 series)
-# Note: Add o1-pro models that may not be in the generated list yet
-ADDITIONAL_REASONING_MODELS = [
-    "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"))
-] + ADDITIONAL_REASONING_MODELS
-
-# GPT models (excluding reasoning models)
-GPT_MODELS = [
-    model
-    for model in CHAT_MODELS
-    if model.startswith("gpt")
-    or model.startswith("chatgpt")
-    or model.startswith("codex")
-]
-
-# Embedding models
-EMBEDDING_MODELS = [
-    "text-embedding-ada-002",
-    "text-embedding-3-small",
-    "text-embedding-3-large",
-]
-
-# Audio models
-AUDIO_MODELS = {
-    "tts": ["tts-1", "tts-1-hd", "gpt-4o-mini-tts"],
-    "transcription": [
-        "whisper-1",
-        "gpt-4o-transcribe",
-        "gpt-4o-mini-transcribe",
-    ],
-}
-
-# Image models
-IMAGE_MODELS = ["dall-e-2", "dall-e-3", "gpt-image-1"]
-
-# Moderation models
-MODERATION_MODELS = ["text-moderation-latest", "text-moderation-stable"]
-
-
-def is_reasoning_model(model: str) -> bool:
-    """Check if a model is a reasoning model (o1/o3/o4 series)."""
-    return model in REASONING_MODELS
-
-
-def is_valid_chat_model(model: str) -> bool:
-    """Check if a model is a valid chat model."""
-    return model in CHAT_MODELS
-
-
-def is_valid_embedding_model(model: str) -> bool:
-    """Check if a model is a valid embedding model."""
-    return model in EMBEDDING_MODELS
-
-
-def get_model_category(model: str) -> str:
-    """Get the category of a model."""
-    if model in REASONING_MODELS:
-        return "reasoning"
-    elif model in GPT_MODELS:
-        return "gpt"
-    elif model in EMBEDDING_MODELS:
-        return "embedding"
-    elif model in AUDIO_MODELS["tts"]:
-        return "tts"
-    elif model in AUDIO_MODELS["transcription"]:
-        return "transcription"
-    elif model in IMAGE_MODELS:
-        return "image"
-    elif model in MODERATION_MODELS:
-        return "moderation"
-    else:
-        return "unknown"
-
-
-def validate_model(model: str, category: str = None) -> bool:
-    """
-    Validate if a model is valid, optionally checking category.
-
-    Args:
-        model: The model name to validate
-        category: Optional category to check against ('chat', 'embedding', etc.)
-
-    Returns:
-        True if model is valid (and in the specified category if provided)
-    """
-    if category == "chat":
-        return model in CHAT_MODELS or model in ADDITIONAL_REASONING_MODELS
-    elif category == "reasoning":
-        return is_reasoning_model(model)
-    elif category == "embedding":
-        return is_valid_embedding_model(model)
-    elif category:
-        return get_model_category(model) == category
-    else:
-        # Check if model exists in any category
-        return get_model_category(model) != "unknown"
-
-
-# Export all model lists
-__all__ = [
-    "CHAT_MODELS",
-    "REASONING_MODELS",
-    "GPT_MODELS",
-    "EMBEDDING_MODELS",
-    "AUDIO_MODELS",
-    "IMAGE_MODELS",
-    "MODERATION_MODELS",
-    "is_reasoning_model",
-    "is_valid_chat_model",
-    "is_valid_embedding_model",
-    "get_model_category",
-    "validate_model",
-]