lionagi 0.12.3__tar.gz → 0.12.5__tar.gz

{lionagi-0.12.3 → lionagi-0.12.5}/.github/workflows/ci.yml

@@ -35,7 +35,7 @@ jobs:
       if: steps.cached-uv-dependencies.outputs.cache-hit != 'true'
       run: |
         uv venv
-        uv build
+        uv sync --extra all
     
     - name: Run tests
       run: |

{lionagi-0.12.3 → lionagi-0.12.5}/.github/workflows/release.yml

@@ -28,7 +28,7 @@ jobs:
     - name: Install dependencies
       run: |
         uv venv
-        uv build
+        uv sync --extra all
     
     - name: Run tests
       run: |

{lionagi-0.12.3 → lionagi-0.12.5}/.gitignore

@@ -3,6 +3,9 @@ __pycache__/
 *.py[cod]
 *$py.class
 
+# Development notes
+CLAUDE.md
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -170,4 +173,4 @@ cython_debug/
 .roomodes
 .khive/
 .roo/
-data/logs/
+*logs/

{lionagi-0.12.3 → lionagi-0.12.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.12.3
+Version: 0.12.5
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -220,19 +220,18 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: aiocache>=0.12.0
-Requires-Dist: aiohttp>=3.10.0
-Requires-Dist: jinja2>=3.0.0
-Requires-Dist: pandas>=2.0.0
-Requires-Dist: pillow>=10.0.0
-Requires-Dist: pydantic>2.0.0
+Requires-Dist: aiohttp>=3.12.0
+Requires-Dist: backoff>=2.2.1
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pillow>=11.0.0
+Requires-Dist: pydantic-settings>=2.8.0
+Requires-Dist: pydapter[pandas]>=0.3.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.9.0
 Provides-Extra: all
 Requires-Dist: docling>=2.15.1; extra == 'all'
-Requires-Dist: litellm>=1.59.5; extra == 'all'
-Requires-Dist: ollama>=0.4.7; extra == 'all'
-Requires-Dist: openai>=1.60.0; extra == 'all'
+Requires-Dist: ollama>=0.5.0; extra == 'all'
 Provides-Extra: docs
 Requires-Dist: furo>=2024.8.6; extra == 'docs'
 Requires-Dist: sphinx-autobuild>=2024.10.3; extra == 'docs'
@@ -241,13 +240,12 @@ Provides-Extra: lint
 Requires-Dist: black[jupyter]>=24.10.0; extra == 'lint'
 Requires-Dist: isort>=5.13.2; extra == 'lint'
 Requires-Dist: pre-commit>=4.0.1; extra == 'lint'
-Provides-Extra: llms
-Requires-Dist: litellm>=1.59.5; extra == 'llms'
 Provides-Extra: ollama
-Requires-Dist: ollama>=0.4.7; extra == 'ollama'
-Requires-Dist: openai>=1.60.0; extra == 'ollama'
+Requires-Dist: ollama>=0.5.0; extra == 'ollama'
+Provides-Extra: reader
+Requires-Dist: docling>=2.15.1; extra == 'reader'
 Provides-Extra: test
-Requires-Dist: pytest-asyncio>=0.25.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.0.0; extra == 'test'
 Requires-Dist: pytest>=8.3.4; extra == 'test'
 Provides-Extra: tools
 Requires-Dist: docling>=2.15.1; extra == 'tools'
@@ -285,9 +283,6 @@ integrations, and custom validations in a single coherent pipeline.
 pip install lionagi
 ```
 
-Dependencies: •	aiocahce •	aiohttp •	jinja2 •	pandas •	pillow •	pydantic
-•	python-dotenv •	tiktoken
-
 ## Quick Start
 
 ```python
@@ -339,6 +334,10 @@ With fiery claws, dragons hide their laughter flaws!
 LionAGI supports advanced multi-step reasoning with ReAct. Tools let the LLM
 invoke external actions:
 
+```
+pip install "lionagi[reader]"
+```
+
 ```python
 from lionagi.tools.types import ReaderTool
 
@@ -393,8 +392,7 @@ Seamlessly route to different models in the same workflow.
 ### optional dependencies
 
 ```
-pip install "lionagi[tools]"
-pip install "lionagi[llms]"
+pip install "lionagi[reader]"
 pip install "lionagi[ollama]"
 ```
 

{lionagi-0.12.3 → lionagi-0.12.5}/README.md

@@ -30,9 +30,6 @@ integrations, and custom validations in a single coherent pipeline.
 pip install lionagi
 ```
 
-Dependencies: •	aiocahce •	aiohttp •	jinja2 •	pandas •	pillow •	pydantic
-•	python-dotenv •	tiktoken
-
 ## Quick Start
 
 ```python
@@ -84,6 +81,10 @@ With fiery claws, dragons hide their laughter flaws!
 LionAGI supports advanced multi-step reasoning with ReAct. Tools let the LLM
 invoke external actions:
 
+```
+pip install "lionagi[reader]"
+```
+
 ```python
 from lionagi.tools.types import ReaderTool
 
@@ -138,8 +139,7 @@ Seamlessly route to different models in the same workflow.
 ### optional dependencies
 
 ```
-pip install "lionagi[tools]"
-pip install "lionagi[llms]"
+pip install "lionagi[reader]"
 pip install "lionagi[ollama]"
 ```
 

lionagi-0.12.5/lionagi/config.py

@@ -0,0 +1,123 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, Field, SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class CacheConfig(BaseModel):
+    """Configuration for aiocache."""
+
+    ttl: int = 300
+    key: str | None = None
+    namespace: str | None = None
+    key_builder: Any = None
+    skip_cache_func: Any = lambda _: False
+    serializer: dict[str, Any] | None = None
+    plugins: Any = None
+    alias: str | None = None
+    noself: Any = lambda _: False
+
+    def as_kwargs(self) -> dict[str, Any]:
+        """Convert config to kwargs dict for @cached decorator.
+
+        Removes unserialisable callables that aiocache can't pickle.
+        """
+        raw = self.model_dump(exclude_none=True)
+        # Remove all unserialisable callables
+        unserialisable_keys = (
+            "key_builder",
+            "skip_cache_func",
+            "noself",
+            "serializer",
+            "plugins",
+        )
+        for key in unserialisable_keys:
+            raw.pop(key, None)
+        return raw
+
+
+class AppSettings(BaseSettings, frozen=True):
+    """Application settings with environment variable support."""
+
+    model_config = SettingsConfigDict(
+        env_file=(".env", ".env.local", ".secrets.env"),
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    aiocache_config: CacheConfig = Field(
+        default_factory=CacheConfig, description="Cache settings for aiocache"
+    )
+
+    # secrets
+    OPENAI_API_KEY: SecretStr | None = None
+    OPENROUTER_API_KEY: SecretStr | None = None
+    OLLAMA_API_KEY: SecretStr | None = None
+    EXA_API_KEY: SecretStr | None = None
+    PERPLEXITY_API_KEY: SecretStr | None = None
+    GROQ_API_KEY: SecretStr | None = None
+    ANTHROPIC_API_KEY: SecretStr | None = None
+
+    # 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-4o"
+
+    # default storage
+    LIONAGI_AUTO_STORE_EVENT: bool = False
+    LIONAGI_STORAGE_PROVIDER: str = "async_qdrant"
+
+    LIONAGI_AUTO_EMBED_LOG: bool = False
+
+    # specific storage
+    LIONAGI_QDRANT_URL: str = "http://localhost:6333"
+    LIONAGI_DEFAULT_QDRANT_COLLECTION: str = "event_logs"
+
+    # Class variable to store the singleton instance
+    _instance: ClassVar[Any] = None
+
+    def get_secret(self, key_name: str) -> str:
+        """
+        Get the secret value for a given key name.
+
+        Args:
+            key_name: The name of the secret key (e.g., "OPENAI_API_KEY")
+
+        Returns:
+            The secret value as a string
+
+        Raises:
+            AttributeError: If the key doesn't exist
+            ValueError: If the key exists but is None
+        """
+        if not hasattr(self, key_name):
+            if "ollama" in key_name.lower():
+                return "ollama"
+            raise AttributeError(
+                f"Secret key '{key_name}' not found in settings"
+            )
+
+        secret = getattr(self, key_name)
+        if secret is None:
+            # Special case for Ollama - return "ollama" even if key exists but is None
+            if "ollama" in key_name.lower():
+                return "ollama"
+            raise ValueError(f"Secret key '{key_name}' is not set")
+
+        if isinstance(secret, SecretStr):
+            return secret.get_secret_value()
+
+        return str(secret)
+
+
+# Create a singleton instance
+settings = AppSettings()
+# Store the instance in the class variable for singleton pattern
+AppSettings._instance = settings

lionagi-0.12.5/lionagi/libs/schema/load_pydantic_model_from_schema.py

@@ -0,0 +1,259 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import importlib.util
+import json
+import string
+import tempfile
+from pathlib import Path
+from typing import Any, TypeVar
+
+from pydantic import BaseModel, PydanticUserError
+
+from lionagi.utils import is_import_installed
+
+_HAS_DATAMODEL_CODE_GENERATOR = is_import_installed("datamodel-code-generator")
+
+# Import at module level for easier mocking in tests
+if _HAS_DATAMODEL_CODE_GENERATOR:
+    from datamodel_code_generator import (
+        DataModelType,
+        InputFileType,
+        PythonVersion,
+        generate,
+    )
+else:
+    # Create dummy objects for when package is not installed
+    DataModelType = None
+    InputFileType = None
+    PythonVersion = None
+    generate = None
+
+
+B = TypeVar("B", bound=BaseModel)
+
+
+def load_pydantic_model_from_schema(
+    schema: str | dict[str, Any],
+    model_name: str = "DynamicModel",
+    /,
+    pydantic_version=None,
+    python_version=None,
+) -> type[BaseModel]:
+    """
+    Generates a Pydantic model class dynamically from a JSON schema string or dict,
+    and ensures it's fully resolved using model_rebuild() with the correct namespace.
+
+    Args:
+        schema: The JSON schema as a string or a Python dictionary.
+        model_name: The desired base name for the generated Pydantic model.
+            If the schema has a 'title', that will likely be used.
+        pydantic_version: The Pydantic model type to generate.
+        python_version: The target Python version for generated code syntax.
+
+    Returns:
+        The dynamically created and resolved Pydantic BaseModel class.
+
+    Raises:
+        ValueError: If the schema is invalid.
+        FileNotFoundError: If the generated model file is not found.
+        AttributeError: If the expected model class cannot be found.
+        RuntimeError: For errors during generation, loading, or rebuilding.
+        Exception: For other potential errors.
+    """
+    if not _HAS_DATAMODEL_CODE_GENERATOR:
+        error_msg = "`datamodel-code-generator` is not installed. Please install with `pip install datamodel-code-generator`."
+        raise ImportError(error_msg)
+
+    if DataModelType is not None:
+        pydantic_version = (
+            pydantic_version or DataModelType.PydanticV2BaseModel
+        )
+        python_version = python_version or PythonVersion.PY_312
+    else:
+        # These won't be used since we'll raise ImportError above
+        pydantic_version = None
+        python_version = None
+
+    schema_input_data: str
+    schema_dict: dict[str, Any]
+    resolved_model_name = (
+        model_name  # Keep track of the potentially updated name
+    )
+
+    # --- 1. Prepare Schema Input ---
+    if isinstance(schema, dict):
+        try:
+            model_name_from_title = schema.get("title")
+            if model_name_from_title and isinstance(
+                model_name_from_title, str
+            ):
+                valid_chars = string.ascii_letters + string.digits + "_"
+                sanitized_title = "".join(
+                    c
+                    for c in model_name_from_title.replace(" ", "")
+                    if c in valid_chars
+                )
+                if sanitized_title and sanitized_title[0].isalpha():
+                    resolved_model_name = (
+                        sanitized_title  # Update the name to use
+                    )
+            schema_dict = schema
+            schema_input_data = json.dumps(schema)
+        except TypeError as e:
+            error_msg = "Invalid dictionary provided for schema"
+            raise ValueError(error_msg) from e
+    elif isinstance(schema, str):
+        try:
+            schema_dict = json.loads(schema)
+            model_name_from_title = schema_dict.get("title")
+            if model_name_from_title and isinstance(
+                model_name_from_title, str
+            ):
+                valid_chars = string.ascii_letters + string.digits + "_"
+                sanitized_title = "".join(
+                    c
+                    for c in model_name_from_title.replace(" ", "")
+                    if c in valid_chars
+                )
+                if sanitized_title and sanitized_title[0].isalpha():
+                    resolved_model_name = (
+                        sanitized_title  # Update the name to use
+                    )
+            schema_input_data = schema
+        except json.JSONDecodeError as e:
+            error_msg = "Invalid JSON schema string provided"
+            raise ValueError(error_msg) from e
+    else:
+        error_msg = "Schema must be a JSON string or a dictionary."
+        raise TypeError(error_msg)
+
+    # --- 2. Generate Code to Temporary File ---
+    with tempfile.TemporaryDirectory() as temporary_directory_name:
+        temporary_directory = Path(temporary_directory_name)
+        # Use a predictable but unique-ish filename
+        output_file = (
+            temporary_directory
+            / f"{resolved_model_name.lower()}_model_{hash(schema_input_data)}.py"
+        )
+        module_name = output_file.stem  # e.g., "userprofile_model_12345"
+
+        try:
+            generate(
+                schema_input_data,
+                input_file_type=InputFileType.JsonSchema,
+                input_filename="schema.json",
+                output=output_file,
+                output_model_type=pydantic_version,
+                target_python_version=python_version,
+                # Ensure necessary base models are imported in the generated code
+                base_class="pydantic.BaseModel",
+            )
+        except Exception as e:
+            # Optional: Print generated code on failure for debugging
+            # if output_file.exists():
+            #     print(f"--- Generated Code (Error) ---\n{output_file.read_text()}\n--------------------------")
+            error_msg = "Failed to generate model code"
+            raise RuntimeError(error_msg) from e
+
+        if not output_file.exists():
+            error_msg = f"Generated model file was not created: {output_file}"
+            raise FileNotFoundError(error_msg)
+
+        def get_modules():
+            spec = importlib.util.spec_from_file_location(
+                module_name, str(output_file)
+            )
+
+            if spec is None or spec.loader is None:
+                error_msg = f"Could not create module spec for {output_file}"
+                raise ImportError(error_msg)
+
+            return spec, importlib.util.module_from_spec(spec)
+
+        # --- 3. Import the Generated Module Dynamically ---
+        try:
+            spec, generated_module = get_modules()
+            # Important: Make pydantic available within the executed module's globals
+            # if it's not explicitly imported by the generated code for some reason.
+            # Usually, datamodel-code-generator handles imports well.
+            # generated_module.__dict__['BaseModel'] = BaseModel
+            spec.loader.exec_module(generated_module)
+
+        except Exception as e:
+            # Optional: Print generated code on failure for debugging
+            # print(f"--- Generated Code (Import Error) ---\n{output_file.read_text()}\n--------------------------")
+            error_msg = f"Failed to load generated module ({output_file})"
+            raise RuntimeError(error_msg) from e
+
+        def validate_base_model_class(m):
+            if not isinstance(m, type) or not issubclass(m, BaseModel):
+                error_msg = f"Found attribute '{resolved_model_name}' is not a Pydantic BaseModel class."
+                raise TypeError(error_msg)
+
+        # --- 4. Find the Model Class ---
+        model_class: type[BaseModel]
+        try:
+            # Use the name potentially derived from the schema title
+            model_class = getattr(generated_module, resolved_model_name)
+            validate_base_model_class(model_class)
+
+        except AttributeError:
+            # Fallback attempt (less likely now with title extraction)
+            try:
+                model_class = generated_module.Model  # Default fallback name
+                validate_base_model_class(model_class)
+                print(
+                    f"Warning: Model name '{resolved_model_name}' not found, falling back to 'Model'."
+                )
+            except AttributeError as e:
+                # List available Pydantic models found in the module for debugging
+                available_attrs = [
+                    attr
+                    for attr in dir(generated_module)
+                    if isinstance(getattr(generated_module, attr, None), type)
+                    and issubclass(
+                        getattr(generated_module, attr, object), BaseModel
+                    )  # Check inheritance safely
+                    and getattr(generated_module, attr, None)
+                    is not BaseModel  # Exclude BaseModel itself
+                ]
+                # Optional: Print generated code on failure for debugging
+                # print(f"--- Generated Code (AttributeError) ---\n{output_file.read_text()}\n--------------------------")
+                error_msg = (
+                    f"Could not find expected model class '{resolved_model_name}' or fallback 'Model' "
+                    f"in the generated module {output_file}. "
+                    f"Found Pydantic models: {available_attrs}"
+                )
+                raise AttributeError(error_msg) from e
+        except TypeError as e:
+            error_msg = (
+                f"Error validating found model class '{resolved_model_name}'"
+            )
+            raise TypeError(error_msg) from e
+
+        # --- 5. Rebuild the Model (Providing Namespace) ---
+        try:
+            # Pass the generated module's dictionary as the namespace
+            # for resolving type hints like 'Status', 'ProfileDetails', etc.
+            model_class.model_rebuild(
+                _types_namespace=generated_module.__dict__,
+                force=True,  # Force rebuild even if Pydantic thinks it's okay
+            )
+        except (
+            PydanticUserError,
+            NameError,
+        ) as e:  # Catch NameError explicitly here
+            # Optional: Print generated code on failure for debugging
+            # print(f"--- Generated Code (Rebuild Error) ---\n{output_file.read_text()}\n--------------------------")
+            error_msg = f"Error during model_rebuild for {resolved_model_name}"
+            raise RuntimeError(error_msg) from e
+        except Exception as e:
+            # Optional: Print generated code on failure for debugging
+            # print(f"--- Generated Code (Rebuild Error) ---\n{output_file.read_text()}\n--------------------------")
+            error_msg = f"Unexpected error during model_rebuild for {resolved_model_name}"
+            raise RuntimeError(error_msg) from e
+
+        # --- 6. Return the Resolved Model Class ---
+        return model_class

{lionagi-0.12.3 → lionagi-0.12.5}/lionagi/libs/token_transform/perplexity.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel
 
 from lionagi.protocols.generic.event import EventStatus
 from lionagi.protocols.generic.log import Log
-from lionagi.service.endpoints.base import APICalling
+from lionagi.service.connections.api_calling import APICalling
 from lionagi.service.imodel import iModel
 from lionagi.utils import alcall, lcall, to_dict, to_list
 
@@ -208,9 +208,7 @@ class LLMCompressor:
         Tokenize text. If no custom tokenizer, use the default from lionagi.
         """
         if not self.tokenizer:
-            from lionagi.service.endpoints.token_calculator import (
-                TokenCalculator,
-            )
+            from lionagi.service.token_calculator import TokenCalculator
 
             return TokenCalculator.tokenize(
                 text,

{lionagi-0.12.3 → lionagi-0.12.5}/lionagi/libs/token_transform/synthlang_/translate_to_synthlang.py

@@ -93,7 +93,7 @@ async def translate_to_synthlang(
     else:
         branch = Branch(system=final_prompt, chat_model=chat_model)
 
-    from lionagi.service.endpoints.token_calculator import TokenCalculator
+    from lionagi.service.token_calculator import TokenCalculator
 
     calculator = TokenCalculator()
 

{lionagi-0.12.3 → lionagi-0.12.5}/lionagi/operations/chat/chat.py

@@ -122,8 +122,8 @@ async def chat(
                     _msgs.append(i)
         messages = _msgs
 
-    imodel = imodel or branch.chat_model
-    if branch.msgs.system and imodel.sequential_exchange:
+    # All endpoints now assume sequential exchange (system message embedded in first user message)
+    if branch.msgs.system:
         messages = [msg for msg in messages if msg.role != "system"]
         first_instruction = None
 

{lionagi-0.12.3 → lionagi-0.12.5}/lionagi/operations/communicate/communicate.py

@@ -91,12 +91,27 @@ async def communicate(
         return res.response
 
     if response_format is not None:
-        return await branch.parse(
-            text=res.response,
-            request_type=response_format,
-            max_retries=num_parse_retries,
+        # Default to raising errors unless explicitly set in fuzzy_match_kwargs
+        parse_kwargs = {
+            "handle_validation": "raise",  # Default to raising errors
             **(fuzzy_match_kwargs or {}),
-        )
+        }
+
+        try:
+            return await branch.parse(
+                text=res.response,
+                request_type=response_format,
+                max_retries=num_parse_retries,
+                **parse_kwargs,
+            )
+        except ValueError as e:
+            # Re-raise with more context
+            logging.error(
+                f"Failed to parse response '{res.response}' into {response_format}: {e}"
+            )
+            raise ValueError(
+                f"Failed to parse model response into {response_format.__name__}: {e}"
+            ) from e
 
     if request_fields is not None:
         _d = fuzzy_validate_mapping(