lionagi 0.17.11__tar.gz → 0.18.0__tar.gz

lionagi-0.18.0/AGENTS.md

@@ -0,0 +1,31 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- Core runtime lives in `lionagi/` with subpackages for adapters, operations, session orchestration, protocol definitions, and tool integrations.
+- Reusable assets, demos, and reference notebooks sit under `assets/`, `cookbooks/`, and `notebooks/`; automation scripts are in `scripts/`.
+- Tests mirror the package layout in `tests/` (for example `tests/session/`, `tests/operations/`) with shared fixtures in `tests/fixtures/`.
+- Documentation sources are maintained in `docs/` (MkDocs) and long-form guides in `CLAUDE.md`; published artifacts land in `site/` after builds.
+
+## Build, Test, and Development Commands
+- Install or update the environment with `uv sync --dev`; this pulls project and tooling dependencies from `pyproject.toml` / `uv.lock`.
+- Run the full suite via `uv run pytest`; pass `-m "not slow"` or `-k session` to target subsets while retaining pytest defaults (parallel, strict markers).
+- Format and lint before committing: `uv run black .`, `uv run ruff check lionagi tests`, and `pre-commit run --all-files` for the configured hook chain.
+
+## Coding Style & Naming Conventions
+- Follow Black’s 79-character line length and isort’s Black profile; keep imports grouped standard/third-party/local.
+- Prefer explicit type hints and Pydantic models for structured data; name modules and directories in snake_case, classes in PascalCase, async coroutines with `_async` suffix when clarity helps.
+- Avoid introducing new global state; prefer dependency injection through service or session layers within `lionagi/`.
+
+## Testing Guidelines
+- Place unit tests adjacent to the relevant module subtree (`tests/operations/test_branch.py`, etc.) using filenames that start with `test_` and classes prefixed `Test`.
+- Leverage pytest markers declared in `pyproject.toml` (`unit`, `integration`, `slow`, `performance`); mark long-running or network-dependent flows to keep CI lean.
+- Maintain coverage by extending fixtures and factories in `tests/fixtures/`; include regression cases for bugs and concurrency edge scenarios.
+
+## Commit & Pull Request Guidelines
+- Match the existing history: concise, sentence-case summaries in the imperative voice (e.g., `Improve session retry logic`).
+- Each PR should describe scope, testing evidence (`uv run pytest` output, linting), linked GitHub issues, and screenshots or logs for UX-facing changes.
+- Keep changesets focused, update `docs/` or `mkdocs.yml` alongside API changes, and request reviews once CI is green.
+
+## Documentation & Configuration Notes
+- Keep `.env.example` aligned with new configuration keys; avoid committing real secrets or API tokens.
+- When altering public interfaces, update `docs/` and regenerate the MkDocs site with `uv run mkdocs build` to verify navigation.

{lionagi-0.17.11 → lionagi-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.17.11
+Version: 0.18.0
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -223,7 +223,6 @@ Requires-Dist: aiocache>=0.12.0
 Requires-Dist: aiohttp>=3.11.0
 Requires-Dist: anyio>=4.7.0
 Requires-Dist: backoff>=2.0.0
-Requires-Dist: jinja2>=3.0.0
 Requires-Dist: json-repair>=0.40.0
 Requires-Dist: msgspec>=0.18.0
 Requires-Dist: pydantic-settings>=2.8.0

{lionagi-0.17.11 → lionagi-0.18.0}/cookbooks/using_mcp/react_mcp_with_schema.py

@@ -69,7 +69,7 @@ async def test_react_with_mcp():
                 ),
                 "context": {},
             },
-            tools=["search_exa_search", "search_perplexity_search"],
+            tools=["exa_search", "perplexity_search"],
             max_extensions=3,
             verbose=True,
         )

lionagi-0.18.0/docs/quickstart/installation.md

@@ -0,0 +1,77 @@
+# Installation
+
+## Install LionAGI
+
+**Recommended**: Use `uv` for faster dependency resolution:
+```bash
+uv add lionagi
+```
+
+**Alternative**: Standard pip installation:
+```bash
+pip install lionagi
+```
+
+## Configure API Keys
+
+Create a `.env` file in your project root:
+
+```bash
+# At minimum, add one provider
+OPENAI_API_KEY=your_key_here
+
+# Optional: Additional providers
+ANTHROPIC_API_KEY=your_key_here
+OPENROUTER_API_KEY=your_key_here
+NVIDIA_NIM_API_KEY=your_key_here
+GROQ_API_KEY=your_key_here
+PERPLEXITY_API_KEY=your_key_here
+EXA_API_KEY=your_key_here
+```
+
+LionAGI automatically loads from `.env` - no manual configuration needed.
+
+## Verify Installation
+
+Run this test to confirm everything works:
+
+```python
+from lionagi import Branch, iModel
+
+async def test():
+    gpt4 = iModel(provider="openai", model="gpt-4o-mini")
+    branch = Branch(chat_model=gpt4)
+    reply = await branch.chat("Hello from LionAGI!")
+    print(f"LionAGI says: {reply}")
+
+if __name__ == "__main__":
+    import anyio
+    anyio.run(test)
+```
+
+Expected output: A conversational response from the model.
+
+## Supported Providers
+
+LionAGI comes pre-configured for these providers:
+
+- **`openai`** - GPT-5, GPT-4.1, o4-mini
+- **`anthropic`** - Claude 4.5 Sonnet, Claude 4.1 Opus
+- **`claude_code`** - Claude Code SDK integration
+- **`ollama`** - Local model hosting
+- **`openrouter`** - Access 200+ models via single API
+- **`nvidia_nim`** - NVIDIA inference microservices
+- **`groq`** - Fast inference on LPU hardware
+- **`perplexity`** - Search-augmented responses
+
+### Custom Providers
+
+**OpenAI-compatible endpoints**:
+```python
+custom = iModel(
+    provider="openai_compatible",
+    model="custom-model",
+    api_key="your_key",
+    base_url="https://custom-endpoint.com/v1"
+)
+```

lionagi-0.18.0/docs/quickstart/your-first-flow.md

@@ -0,0 +1,80 @@
+# Your First Flow
+
+This quickstart shows LionAGI's core pattern: **multiple specialized branches working together**.
+
+We'll build a self-critiquing joke generator - one branch writes jokes, another critiques them, then they iterate to improve.
+
+## Complete Example
+
+```python
+from lionagi import Branch, iModel
+
+chat_model = iModel(provider="openai", model="gpt-4.1-mini")
+
+async def generate_joke(joke_request):
+    # Create two specialized branches
+    comedian = Branch(
+        chat_model=chat_model,
+        system="You are a comedian who makes technical concepts funny."
+    )
+
+    editor = Branch(
+        chat_model=chat_model,
+        system="You are an editor who improves clarity and punch."
+    )
+
+    # Flow: Generate → Critique → Revise → Verify
+    joke = await comedian.communicate(
+        "Write a short joke",
+        context={"user_input": joke_request}
+    )
+
+    feedback = await editor.communicate(
+        "Give humorous critical feedback to improve this joke by addressing clarity and punch.",
+        context={"joke": joke}
+    )
+
+    revision = await comedian.communicate(
+        "Revise the joke based on this feedback.",
+        context={"feedback": feedback}
+    )
+
+    final_check = await editor.communicate(
+        "Is this version better than the original? If yes, reply the following token (including the square brackets) '[YES]' only, otherwise elaborate on why not without including the token.",
+        context={"revised_joke": revision}
+    )
+
+    # Return improved version if approved
+    if "[yes]" in final_check.lower():
+        return revision
+    return joke  # Fallback to original if not improved
+
+# Run it
+if __name__ == "__main__":
+    import anyio
+    result = anyio.run(generate_joke, "machine learning")
+    print(result)
+```
+
+## What Just Happened
+
+**Branch**: Independent conversation context with its own system prompt and memory
+- `comedian` = creative joke writing
+- `editor` = critical feedback
+
+**Flow**: Sequential operations across branches
+1. Comedian generates initial joke
+2. Editor provides feedback
+3. Comedian revises based on feedback
+4. Editor validates improvement
+
+**Context**: Each `communicate()` call can include context from previous steps
+
+## Try It
+
+Save the code above and run:
+```bash
+uv run your_script.py
+```
+
+Expected output: A refined joke about machine learning, improved through iteration.

lionagi-0.18.0/lionagi/libs/schema/minimal_yaml.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+import yaml
+
+# --- YAML Dumper with minimal, readable settings --------------------------------
+
+
+class MinimalDumper(yaml.SafeDumper):
+    # Disable anchors/aliases (&id001, *id001) for repeated objects.
+    def ignore_aliases(self, data: Any) -> bool:  # type: ignore[override]
+        return True
+
+
+def _represent_str(dumper: yaml.SafeDumper, data: str):
+    # Use block scalars for multiline text; plain style otherwise.
+    if "\n" in data:
+        return dumper.represent_scalar(
+            "tag:yaml.org,2002:str", data, style="|"
+        )
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data)
+
+
+MinimalDumper.add_representer(str, _represent_str)
+
+# --- Optional pruning of empty values -------------------------------------------
+
+
+def _is_empty(x: Any) -> bool:
+    """
+    Define 'empty' for pruning. Keeps 0 and False.
+    - None or '' (after strip) are empty
+    - Empty containers are empty
+    """
+    if x is None:
+        return True
+    if isinstance(x, str):
+        return x.strip() == ""
+    if isinstance(x, dict):
+        return len(x) == 0
+    if isinstance(x, (list, tuple, set)):
+        return len(x) == 0
+    # Keep numbers (including 0) and booleans (including False)
+    return False
+
+
+def _prune(x: Any) -> Any:
+    """Recursively remove empty leaves and empty containers produced thereby."""
+    if isinstance(x, dict):
+        pruned = {k: _prune(v) for k, v in x.items() if not _is_empty(v)}
+        # Remove keys that became empty after recursion
+        return {k: v for k, v in pruned.items() if not _is_empty(v)}
+    if isinstance(x, list):
+        pruned_list = [_prune(v) for v in x if not _is_empty(v)]
+        return [v for v in pruned_list if not _is_empty(v)]
+    if isinstance(x, tuple):
+        pruned_list = [_prune(v) for v in x if not _is_empty(v)]
+        return tuple(v for v in pruned_list if not _is_empty(v))
+    if isinstance(x, set):
+        pruned_set = {_prune(v) for v in x if not _is_empty(v)}
+        return {v for v in pruned_set if not _is_empty(v)}
+    return x
+
+
+# --- Public API ------------------------------------------------------------------
+
+
+def minimal_yaml(
+    value: Any,
+    *,
+    drop_empties: bool = True,
+    indent: int = 2,
+    line_width: int = 2**31 - 1,  # avoid PyYAML inserting line-wraps
+    sort_keys: bool = False,
+) -> str:
+    """
+    Convert any Python value (dict/list/scalars) to a minimal, readable YAML string.
+    - Lists -> YAML sequences with '- '
+    - Dicts -> 'key: value' mappings
+    - Multiline strings -> block scalars (|)
+    - Optional pruning of empty values (keeps 0 and False)
+    - No aliases/anchors
+    """
+    if isinstance(value, str):
+        value = orjson.loads(value)
+
+    data = _prune(value) if drop_empties else value
+    return yaml.dump(
+        data,
+        Dumper=MinimalDumper,
+        default_flow_style=False,  # block style
+        sort_keys=sort_keys,  # preserve insertion order
+        allow_unicode=True,
+        indent=indent,
+        width=line_width,
+    )

{lionagi-0.17.11 → lionagi-0.18.0}/lionagi/ln/types.py

@@ -232,10 +232,13 @@ class Params:
         dict_.update(kw_)
         return dict_
 
-    def to_dict(self) -> dict[str, str]:
+    def to_dict(self, exclude: set[str] = None) -> dict[str, str]:
         data = {}
+        exclude = exclude or set()
         for k in self.allowed():
-            if not self._is_sentinel(v := getattr(self, k, Undefined)):
+            if k not in exclude and not self._is_sentinel(
+                v := getattr(self, k, Undefined)
+            ):
                 data[k] = v
         return data
 
@@ -249,6 +252,12 @@ class Params:
             return False
         return hash(self) == hash(other)
 
+    def with_updates(self, **kwargs: Any) -> DataClass:
+        """Return a new instance with updated fields."""
+        dict_ = self.to_dict()
+        dict_.update(kwargs)
+        return type(self)(**dict_)
+
 
 @dataclass(slots=True)
 class DataClass:
@@ -296,11 +305,13 @@ class DataClass:
         for k in self.allowed():
             _validate_strict(k)
 
-    def to_dict(self) -> dict[str, str]:
+    def to_dict(self, exclude: set[str] = None) -> dict[str, str]:
         data = {}
-        print(self.allowed())
+        exclude = exclude or set()
         for k in type(self).allowed():
-            if not self._is_sentinel(v := getattr(self, k)):
+            if k not in exclude and not self._is_sentinel(
+                v := getattr(self, k)
+            ):
                 data[k] = v
         return data
 
@@ -311,6 +322,22 @@ class DataClass:
             return True
         return is_sentinel(value)
 
+    def with_updates(self, **kwargs: Any) -> DataClass:
+        """Return a new instance with updated fields."""
+        dict_ = self.to_dict()
+        dict_.update(kwargs)
+        return type(self)(**dict_)
+
+    def __hash__(self) -> int:
+        from ._hash import hash_dict
+
+        return hash_dict(self.to_dict())
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, DataClass):
+            return False
+        return hash(self) == hash(other)
+
 
 KeysLike = Sequence[str] | KeysDict
 

{lionagi-0.17.11 → lionagi-0.18.0}/lionagi/models/field_model.py

@@ -513,6 +513,15 @@ class FieldModel(Params):
                     # These are FieldTemplate markers, don't pass to FieldInfo
                     pass
                 else:
+                    # Filter out unserializable objects from json_schema_extra
+                    # to avoid Pydantic serialization errors when generating JSON schema
+                    from pydantic import BaseModel
+
+                    # Skip model classes and other unserializable types
+                    if isinstance(meta.value, type):
+                        # Skip type objects (including model classes) - they can't be serialized
+                        continue
+
                     # Any other metadata goes in json_schema_extra
                     if "json_schema_extra" not in field_kwargs:
                         field_kwargs["json_schema_extra"] = {}