lionagi 0.14.7__tar.gz → 0.14.9__tar.gz

{lionagi-0.14.7 → lionagi-0.14.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.14.7
+Version: 0.14.9
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -272,7 +272,7 @@ Description-Content-Type: text/markdown
 
 [Documentation](https://lion-agi.github.io/lionagi/) |
 [Discord](https://discord.gg/JDj9ENhUE8) |
-[PyPI](https://pypi.org/project/lionagi/) |
+[PyPI](https://pypi.org/project/lionagi/)
 
 # LION - Language InterOperable Network
 
@@ -295,7 +295,9 @@ integrations, and custom validations in a single coherent pipeline.
 ## Installation
 
 ```
-pip install lionagi
+uv add lionagi  # recommended to use pyproject and uv for dependency management
+
+pip install lionagi # or install directly
 ```
 
 ## Quick Start
@@ -304,12 +306,12 @@ pip install lionagi
 from lionagi import Branch, iModel
 
 # Pick a model
-gpt4o = iModel(provider="openai", model="gpt-4o")
+gpt41 = iModel(provider="openai", model="gpt-4.1-mini")
 
 # Create a Branch (conversation context)
 hunter = Branch(
   system="you are a hilarious dragon hunter who responds in 10 words rhymes.",
-  chat_model=gpt4o,
+  chat_model=gpt41,
 )
 
 # Communicate asynchronously
@@ -390,41 +392,75 @@ print(df.tail())
 ```python
 from lionagi import Branch, iModel
 
-gpt4o = iModel(provider="openai", model="gpt-4o")
 sonnet = iModel(
   provider="anthropic",
   model="claude-3-5-sonnet-20241022",
   max_tokens=1000,                    # max_tokens is required for anthropic models
 )
 
-branch = Branch(chat_model=gpt4o)
-# Switch mid-flow
-analysis = await branch.communicate("Analyze these stats", imodel=sonnet)
+branch = Branch(chat_model=gpt41)
+analysis = await branch.communicate("Analyze these stats", chat_model=sonnet) # Switch mid-flow
 ```
 
 Seamlessly route to different models in the same workflow.
 
 ### Claude Code Integration
 
-LionAGI now supports Anthropic's [Claude Code Python SDK](https://github.com/anthropics/claude-code-sdk-python), enabling autonomous coding capabilities with persistent session management:
+LionAGI now supports Anthropic's Claude Code [Python SDK](https://github.com/anthropics/claude-code-sdk-python), and [CLI SDK](https://docs.anthropic.com/en/docs/claude-code/sdk) enabling autonomous coding capabilities with persistent session management. The CLI endpoint
+directly connects to claude code, and is recommended, you can either use it via a [proxy server](https://github.com/khive-ai/lionagi/tree/main/cookbooks/claude_proxy) or directly with `query_cli` endpoint, provided you have already logged onto claude code cli in your terminal.
 
 ```python
 from lionagi import iModel, Branch
 
-# Create a Claude Code model
-model = iModel(
-    provider="claude_code",
-    endpoint="query_cli",
-    model="sonnet",
-    allowed_tools=["Write", "Read", "Edit"],  # Control which tools Claude can use
-    permission_mode = "bypassPermissions", # Bypass tool permission checks (use with caution!),
-    verbose_output=True,  # Enable detailed output for debugging
-)
+def create_cc_model():
+  return iModel(
+      provider="claude_code",
+      endpoint="query_cli",
+      model="sonnet",
+      verbose_output=True,  # Enable detailed output for debugging
+  )
 
 # Start a coding session
-branch = Branch(chat_model=model)
-response = await branch.communicate("Explain the architecture of protocols, operations, and branch")
-response2 = await branch.communicate("how do these parts form lionagi system")
+orchestrator = Branch(chat_model=create_cc_model())
+response = await orchestrator.communicate("Explain the architecture of protocols, operations, and branch")
+
+# continue the session with more queries
+response2 = await orchestrator.communicate("how do these parts form lionagi system")
+```
+
+### Fan out fan in pattern orchestration with claude code
+
+```python
+# use structured outputs with claude code
+from lionagi.fields import LIST_INSTRUCT_FIELD_MODEL, Instruct
+
+response3 = await orchestrator.operate(
+  instruct=Instruct(
+    instruction="create 4 research questions for parallel discovery",
+    guidance="put into `instruct_models` field as part of your structured result message",
+    context="I'd like to create an orchestration system for AI agents using lionagi"
+  ),
+  field_models=[LIST_INSTRUCT_FIELD_MODEL],
+)
+
+len(response3.instruct_models)  # should be 4
+
+async def handle_instruct(instruct):
+  sub_branch = Branch(
+    system="You are an diligent research expert.",
+    chat_model=create_cc_model(),
+  )
+  return await sub_branch.operate(instruct=instruct)
+
+# run in parallel across all instruct models
+from lionagi.utils import alcall
+responses = await alcall(response3.instruct_models, handle_instruct)
+
+# now hand these reports back to the orchestrator
+final_response = await orchestrator.communicate(
+  "please synthesize these research findings into a final report",
+  context=responses,
+)
 ```
 
 Key features:
@@ -436,9 +472,14 @@ Key features:
 ### optional dependencies
 
 ```
-pip install "lionagi[reader]"
-pip install "lionagi[ollama]"
-pip install "lionagi[claude-code]"
+"lionagi[reader]" - Reader tool for any unstructured data and web pages
+"lionagi[ollama]" - Ollama model support for local inference
+"lionagi[claude-code]" - Claude code python SDK integration (cli endpoint does not require this)
+"lionagi[rich]" - Rich output formatting for better console display
+"lionagi[schema]" - Convert pydantic schema to make the Model class persistent
+"lionagi[postgres]" - Postgres database support for storing and retrieving structured data
+"lionagi[graph]" - Graph display for visualizing complex workflows
+"lionagi[sqlite]" - SQLite database support for lightweight data storage (also need `postgres` option)
 ```
 
 ## Community & Contributing

{lionagi-0.14.7 → lionagi-0.14.9}/README.md

@@ -4,7 +4,7 @@
 
 [Documentation](https://lion-agi.github.io/lionagi/) |
 [Discord](https://discord.gg/JDj9ENhUE8) |
-[PyPI](https://pypi.org/project/lionagi/) |
+[PyPI](https://pypi.org/project/lionagi/)
 
 # LION - Language InterOperable Network
 
@@ -27,7 +27,9 @@ integrations, and custom validations in a single coherent pipeline.
 ## Installation
 
 ```
-pip install lionagi
+uv add lionagi  # recommended to use pyproject and uv for dependency management
+
+pip install lionagi # or install directly
 ```
 
 ## Quick Start
@@ -36,12 +38,12 @@ pip install lionagi
 from lionagi import Branch, iModel
 
 # Pick a model
-gpt4o = iModel(provider="openai", model="gpt-4o")
+gpt41 = iModel(provider="openai", model="gpt-4.1-mini")
 
 # Create a Branch (conversation context)
 hunter = Branch(
   system="you are a hilarious dragon hunter who responds in 10 words rhymes.",
-  chat_model=gpt4o,
+  chat_model=gpt41,
 )
 
 # Communicate asynchronously
@@ -122,41 +124,75 @@ print(df.tail())
 ```python
 from lionagi import Branch, iModel
 
-gpt4o = iModel(provider="openai", model="gpt-4o")
 sonnet = iModel(
   provider="anthropic",
   model="claude-3-5-sonnet-20241022",
   max_tokens=1000,                    # max_tokens is required for anthropic models
 )
 
-branch = Branch(chat_model=gpt4o)
-# Switch mid-flow
-analysis = await branch.communicate("Analyze these stats", imodel=sonnet)
+branch = Branch(chat_model=gpt41)
+analysis = await branch.communicate("Analyze these stats", chat_model=sonnet) # Switch mid-flow
 ```
 
 Seamlessly route to different models in the same workflow.
 
 ### Claude Code Integration
 
-LionAGI now supports Anthropic's [Claude Code Python SDK](https://github.com/anthropics/claude-code-sdk-python), enabling autonomous coding capabilities with persistent session management:
+LionAGI now supports Anthropic's Claude Code [Python SDK](https://github.com/anthropics/claude-code-sdk-python), and [CLI SDK](https://docs.anthropic.com/en/docs/claude-code/sdk) enabling autonomous coding capabilities with persistent session management. The CLI endpoint
+directly connects to claude code, and is recommended, you can either use it via a [proxy server](https://github.com/khive-ai/lionagi/tree/main/cookbooks/claude_proxy) or directly with `query_cli` endpoint, provided you have already logged onto claude code cli in your terminal.
 
 ```python
 from lionagi import iModel, Branch
 
-# Create a Claude Code model
-model = iModel(
-    provider="claude_code",
-    endpoint="query_cli",
-    model="sonnet",
-    allowed_tools=["Write", "Read", "Edit"],  # Control which tools Claude can use
-    permission_mode = "bypassPermissions", # Bypass tool permission checks (use with caution!),
-    verbose_output=True,  # Enable detailed output for debugging
-)
+def create_cc_model():
+  return iModel(
+      provider="claude_code",
+      endpoint="query_cli",
+      model="sonnet",
+      verbose_output=True,  # Enable detailed output for debugging
+  )
 
 # Start a coding session
-branch = Branch(chat_model=model)
-response = await branch.communicate("Explain the architecture of protocols, operations, and branch")
-response2 = await branch.communicate("how do these parts form lionagi system")
+orchestrator = Branch(chat_model=create_cc_model())
+response = await orchestrator.communicate("Explain the architecture of protocols, operations, and branch")
+
+# continue the session with more queries
+response2 = await orchestrator.communicate("how do these parts form lionagi system")
+```
+
+### Fan out fan in pattern orchestration with claude code
+
+```python
+# use structured outputs with claude code
+from lionagi.fields import LIST_INSTRUCT_FIELD_MODEL, Instruct
+
+response3 = await orchestrator.operate(
+  instruct=Instruct(
+    instruction="create 4 research questions for parallel discovery",
+    guidance="put into `instruct_models` field as part of your structured result message",
+    context="I'd like to create an orchestration system for AI agents using lionagi"
+  ),
+  field_models=[LIST_INSTRUCT_FIELD_MODEL],
+)
+
+len(response3.instruct_models)  # should be 4
+
+async def handle_instruct(instruct):
+  sub_branch = Branch(
+    system="You are an diligent research expert.",
+    chat_model=create_cc_model(),
+  )
+  return await sub_branch.operate(instruct=instruct)
+
+# run in parallel across all instruct models
+from lionagi.utils import alcall
+responses = await alcall(response3.instruct_models, handle_instruct)
+
+# now hand these reports back to the orchestrator
+final_response = await orchestrator.communicate(
+  "please synthesize these research findings into a final report",
+  context=responses,
+)
 ```
 
 Key features:
@@ -168,9 +204,14 @@ Key features:
 ### optional dependencies
 
 ```
-pip install "lionagi[reader]"
-pip install "lionagi[ollama]"
-pip install "lionagi[claude-code]"
+"lionagi[reader]" - Reader tool for any unstructured data and web pages
+"lionagi[ollama]" - Ollama model support for local inference
+"lionagi[claude-code]" - Claude code python SDK integration (cli endpoint does not require this)
+"lionagi[rich]" - Rich output formatting for better console display
+"lionagi[schema]" - Convert pydantic schema to make the Model class persistent
+"lionagi[postgres]" - Postgres database support for storing and retrieving structured data
+"lionagi[graph]" - Graph display for visualizing complex workflows
+"lionagi[sqlite]" - SQLite database support for lightweight data storage (also need `postgres` option)
 ```
 
 ## Community & Contributing

{lionagi-0.14.7 → lionagi-0.14.9}/cookbooks/007_fan_out_in.py

@@ -1,5 +1,6 @@
-from lionagi import Branch, Builder, Session, iModel
+from lionagi import Branch, Builder, Operation, Session, iModel
 from lionagi.fields import LIST_INSTRUCT_FIELD_MODEL, Instruct
+from lionagi.protocols.types import AssistantResponse
 
 CC_WORKSPACE = ".khive/workspace"
 
@@ -15,7 +16,6 @@ def create_cc(
         provider="claude_code",
         endpoint="query_cli",
         model=model,
-        api_key="dummy_api_key",
         ws=f"{CC_WORKSPACE}/{subdir}",
         verbose_output=verbose_output,
         add_dir="../../../",
@@ -26,7 +26,7 @@ def create_cc(
 
 
 prompt = """
-Task: Investigate the codebase in the specified directory and provide a comprehensive overview.
+Task: Quickly Investigate the codebase in the specified directory and provide a comprehensive overview.
 
 ---START
 read into the specified dir, glance over the key components and pay attention to architecture, 
@@ -86,16 +86,44 @@ async def main():
             )
             research_nodes.append(node)
 
-        synthesis = builder.add_aggregation(
+        costs = 0
+
+        def get_context(node_id):
+            nonlocal costs
+            g = builder.get_graph()
+            node: Operation = g.internal_nodes[node_id]
+            branch = session.get_branch(node.branch_id, None)
+            if (
+                branch
+                and len(branch.messages) > 0
+                and isinstance(msg := branch.messages[-1], AssistantResponse)
+            ):
+                costs += msg.model_response.get("total_cost_usd") or 0
+                return f"""
+            Response: {msg.model_response.get("result") or "Not available"}
+            Summary: {msg.model_response.get("summary") or "Not available"}
+            """.strip()
+
+        await session.flow(builder.get_graph())
+        ctx = [get_context(i) for i in research_nodes]
+
+        synthesis = builder.add_operation(
             "communicate",
-            source_node_ids=research_nodes,
+            depends_on=research_nodes,
             branch=orc_branch,
             instruction="Synthesize the information from the researcher branches.",
+            context=[i for i in ctx if i is not None],
+        )
+
+        result3 = await session.flow(builder.get_graph())
+        result_synthesis = result3["operation_results"][synthesis]
+
+        builder.visualize(
+            "LionAGI codebase investigation: fan-out fan-in pattern with Claude Code"
         )
 
-        result2 = await session.flow(builder.get_graph())
-        result_synthesis = result2["operation_results"][synthesis]
         print(result_synthesis)
+        print(f"Flow total cost: ${costs:.4f}")
 
     except Exception as e:
         print(f"Error: {e}")

{lionagi-0.14.7 → lionagi-0.14.9}/cookbooks/claude_proxy/claude_code_proxy.py

@@ -47,12 +47,10 @@ app = FastAPI(
 def check_claude_code():
     """Verify Claude Code CLI is installed and accessible"""
     try:
-        from lionagi.service.connections.providers._claude_code.stream_cli import (
-            CLAUDE,
-        )
+        from lionagi.service.third_party.claude_code import CLAUDE_CLI
 
         result = subprocess.run(
-            [CLAUDE, "--version"], capture_output=True, text=True
+            [CLAUDE_CLI, "--version"], capture_output=True, text=True
         )
         if result.returncode != 0:
             raise RuntimeError(
@@ -75,7 +73,6 @@ async def health_check():
 
 @app.post("/v1/query")
 async def query(request: ClaudeCodeRequest):
-
     endpoint = ClaudeCodeCLIEndpoint()
     try:
         return await endpoint._call(payload={"request": request}, headers={})

lionagi-0.14.9/cookbooks/claude_proxy/run_w_claude_code_proxy.ipynb

@@ -0,0 +1,100 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d2ceb407",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from lionagi.service.connections.endpoint_config import EndpointConfig\n",
+    "from lionagi.service.imodel import Endpoint\n",
+    "from lionagi.service.connections.providers.claude_code_cli import (\n",
+    "    ClaudeCodeRequest,\n",
+    ")\n",
+    "\n",
+    "claude_code_config = EndpointConfig(\n",
+    "    name=\"claude_code_cli_proxy\",\n",
+    "    provider=\"claude_code\",\n",
+    "    base_url=\"http://localhost:8000/v1\",\n",
+    "    endpoint=\"query\",\n",
+    "    api_key=\"dummy_api_key\",\n",
+    "    kwargs={\"model\": \"sonnet\"},\n",
+    ")\n",
+    "claude_code = Endpoint(claude_code_config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5fc216f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# prompt = \"reply in text only, Write a Python function to calculate the factorial of a number.\"\n",
+    "\n",
+    "# await claude_code.call(request=ClaudeCodeRequest(prompt=prompt))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c173814",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from lionagi import iModel\n",
+    "\n",
+    "claude_code = iModel(endpoint=claude_code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe6dcca4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = await claude_code.invoke(\n",
+    "    messages=[\n",
+    "        {\n",
+    "            \"role\": \"user\",\n",
+    "            \"content\": \"reply in text only, Write a Python function to calculate the factorial of a number.\",\n",
+    "        }\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88db9e9a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result.response"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "lionagi",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

lionagi-0.14.9/lionagi/_errors.py

@@ -0,0 +1,148 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+__all__ = (
+    "LionError",
+    "ValidationError",
+    "NotFoundError",
+    "ExistsError",
+    "ObservationError",
+    "ResourceError",
+    "RateLimitError",
+    "IDError",
+    "RelationError",
+    "OperationError",
+    "ExecutionError",
+    "ItemNotFoundError",
+    "ItemExistsError",
+)
+
+
+class LionError(Exception):
+    default_message: ClassVar[str] = "LionAGI error"
+    default_status_code: ClassVar[int] = 500
+    __slots__ = ("message", "details", "status_code")
+
+    def __init__(
+        self,
+        message: str | None = None,
+        *,
+        details: dict[str, Any] | None = None,
+        status_code: int | None = None,
+        cause: Exception | None = None,
+    ):
+        super().__init__(message or self.default_message)
+        if cause:
+            self.__cause__ = cause  # preserves traceback
+        self.message = message or self.default_message
+        self.details = details or {}
+        self.status_code = status_code or type(self).default_status_code
+
+    def to_dict(self, *, include_cause: bool = False) -> dict[str, Any]:
+        data = {
+            "error": self.__class__.__name__,
+            "message": self.message,
+            "status_code": self.status_code,
+            **({"details": self.details} if self.details else {}),
+        }
+        if include_cause and (cause := self.get_cause()):
+            data["cause"] = repr(cause)
+        return data
+
+    def get_cause(self) -> Exception | None:
+        """Get the cause of this error, if any."""
+        return self.__cause__ if hasattr(self, "__cause__") else None
+
+    @classmethod
+    def from_value(
+        cls,
+        value: Any,
+        *,
+        expected: str | None = None,
+        message: str | None = None,
+        cause: Exception | None = None,
+        **extra: Any,
+    ):
+        """Create a ValidationError from a value with optional expected type and message."""
+        details = {
+            "value": value,
+            "type": type(value).__name__,
+            **({"expected": expected} if expected else {}),
+            **extra,
+        }
+        return cls(message=message, details=details, cause=cause)
+
+
+class ValidationError(LionError):
+    """Exception raised when validation fails."""
+
+    default_message = "Validation failed"
+    default_status_code = 422
+    __slots__ = ()
+
+
+class NotFoundError(LionError):
+    """Exception raised when an item is not found."""
+
+    default_message = "Item not found"
+    default_status_code = 404
+    __slots__ = ()
+
+
+class ExistsError(LionError):
+    """Exception raised when an item already exists."""
+
+    default_message = "Item already exists"
+    default_status_code = 409
+    __slots__ = ()
+
+
+class ObservationError(LionError):
+    """Exception raised when an observation fails."""
+
+    default_message = "Observation failed"
+    default_status_code = 500
+    __slots__ = ()
+
+
+class ResourceError(LionError):
+    """Exception raised when resource access fails."""
+
+    default_message = "Resource error"
+    default_status_code = 429
+    __slots__ = ()
+
+
+class RateLimitError(LionError):
+    __slots__ = ("retry_after",)  # one extra attr
+    default_message = "Rate limit exceeded"
+    default_status_code = 429
+
+    def __init__(self, retry_after: float, **kw):
+        super().__init__(**kw)
+        object.__setattr__(self, "retry_after", retry_after)
+
+
+class IDError(LionError):
+    pass
+
+
+class RelationError(LionError):
+    pass
+
+
+class OperationError(LionError):
+    pass
+
+
+class ExecutionError(LionError):
+    pass
+
+
+ItemNotFoundError = NotFoundError
+ItemExistsError = ExistsError

lionagi-0.14.9/lionagi/_types.py

@@ -0,0 +1,3 @@
+from .fields import *
+from .models import *
+from .protocols.types import *

{lionagi-0.14.7 → lionagi-0.14.9}/lionagi/config.py

@@ -63,12 +63,14 @@ class AppSettings(BaseSettings, frozen=True):
     GROQ_API_KEY: SecretStr | None = None
     ANTHROPIC_API_KEY: SecretStr | None = None
 
+    OPENAI_DEFAULT_MODEL: str = "gpt-4.1-mini"
+
     # 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-4.1-nano"
+    LIONAGI_CHAT_MODEL: str = "gpt-4.1-mini"
 
     # default storage
     LIONAGI_AUTO_STORE_EVENT: bool = False

{lionagi-0.14.7 → lionagi-0.14.9}/lionagi/fields/instruct.py

@@ -11,7 +11,6 @@ from lionagi.libs.validate.common_field_validators import (
     validate_nullable_jsonvalue_field,
 )
 from lionagi.models import FieldModel, HashableModel
-from lionagi.utils import to_num
 
 __all__ = (
     "Instruct",