lionagi 0.5.0__tar.gz → 0.5.2__tar.gz

{lionagi-0.5.0 → lionagi-0.5.2}/.env.example

@@ -2,6 +2,5 @@
 # model providers
 # OPENAI_API_KEY=
 # ANTHROPIC_API_KEY=
-
-# scrape youtube
-# RAPIDAPI_KEY=
+# PERPLEXITY_API_KEY=
+# GROK_API_KEY=

{lionagi-0.5.0 → lionagi-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.5.0
+Version: 0.5.2
 Summary: An AGentic Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -218,10 +218,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.11.10
 Requires-Dist: jinja2>=3.1.4
-Requires-Dist: litellm>=1.55.2
+Requires-Dist: litellm>=1.55.3
 Requires-Dist: pandas>=2.0.0
 Requires-Dist: pillow>=11.0.0
+Requires-Dist: pydantic>=2.10.3
 Requires-Dist: python-dotenv>=1.0.1
 Description-Content-Type: text/markdown
 
@@ -246,17 +248,35 @@ LION is designed to be:
 - 🔧 **Flexible**: Build any workflow you need
 - 🚀 **Efficient**: Minimal dependencies, maximum performance
 
+
+
+## Installation
+
+LION maintains minimal dependencies for maximum reliability:
+
+```bash
+uv pip install lionagi
+```
+
+Dependencies:
+- litellm
+- jinja2
+- pandas
+- pillow
+- python-dotenv
+
+
 ## Quick Start
 
 ```python
 from lionagi import iModel, Branch
 
 # Initialize model
-gpt4o = iModel(provider="openai", model="gpt-4o")
+gpt4o = iModel(provider="openai", task="chat", model="gpt-4o")
 
 hunter = Branch(
-    system="you are a hilarious dragon hunter who responds in 10 words rhymes",
-    imodel=gpt4o,
+  system="you are a hilarious dragon hunter who responds in 10 words rhymes",
+  imodel=gpt4o,
 )
 
 # Chat asynchronously
@@ -267,20 +287,199 @@ print(await hunter.communicate("I am a dragon"))
 You claim to be a dragon, oh what a braggin'!
 ```
 
-## Installation
+## 📦 Features
 
-LION maintains minimal dependencies for maximum reliability:
+### 1. Model Agnostic Structured Output
 
-```bash
-uv pip install lionagi
+LION provides a unified interface for interacting with any AI model, regardless of the underlying architecture. This allows you to easily switch between models without changing your code.
+
+```python
+from pydantic import BaseModel
+
+class Joke(BaseModel):
+  joke: str
+
+sonnet = iModel(
+  provider="anthropic",
+  model="claude-3-5-sonnet-20241022",
+  max_tokens=100,                    # max_tokens is required for anthropic models
+)
+
+response = await hunter.communicate(
+  instruction="I am a dragon",
+  response_format=Joke,           # structured output in given pydantic model
+  clear_messages=True,            # refresh the conversation
+  imodel=sonnet,                  # use sonnet model, which doesn't support structured output
+)
+
+print(type(response))
+print(response.joke)
 ```
 
-Dependencies:
-- litellm
-- jinja2
-- pandas
-- pillow
-- python-dotenv
+```
+<class '__main__.Joke'>
+Joke(joke='With fiery claws, dragons hide their laughter flaws!')
+```
+
+
+### 2. Complete Observability
+
+```python
+# using perplexity model
+pplx_small = iModel(
+    provider="perplexity",
+    task="chat/completions",
+    model="llama-3.1-sonar-small-128k-online",
+    max_tokens=1000,
+)
+
+b = await hunter.communicate(
+    instruction="What makes a well-behaved dragon?",
+    clear_messages=True,            # refresh the conversation
+    imodel=pplx_small,                  # use sonnet model
+)
+
+print(b)
+```
+
+```
+A well-behaved dragon is one that's calm and bright,
+No stress or fear, just a peaceful night.
+It's active, not lethargic, with a happy face,
+And behaviors like digging, not a frantic pace.
+It's social, friendly, and never a fright,
+Just a gentle soul, shining with delight
+```
+
+```python
+hunter.msgs.last_response.model_response
+```
+
+```
+{'id': '1be10f4c-0936-4050-ab48-91bd86ab11a5',
+ 'model': 'llama-3.1-sonar-small-128k-online',
+ 'object': 'chat.completion',
+ 'created': 1734369700,
+ 'choices': [{'index': 0,
+   'message': {'role': 'assistant',
+    'content': "A well-behaved dragon is one that's calm and bright,\nNo stress or fear, just a peaceful night.\nIt's active, not lethargic, with a happy face,\nAnd behaviors like digging, not a frantic pace.\nIt's social, friendly, and never a fright,\nJust a gentle soul, shining with delight"},
+   'finish_reason': 'stop',
+   'delta': {'role': 'assistant', 'content': ''}}],
+ 'usage': {'prompt_tokens': 40, 'completion_tokens': 69, 'total_tokens': 109},
+ 'citations': [{'url': 'https://dragonsdiet.com/blogs/dragon-care/15-bearded-dragon-behaviors-and-what-they-could-mean'},
+  {'url': 'https://masterbraeokk.tripod.com/dragons/behavior.html'},
+  {'url': 'https://files.eric.ed.gov/fulltext/ED247607.pdf'},
+  {'url': 'https://www.travelchinaguide.com/intro/social_customs/zodiac/dragon/five-elements.htm'},
+  {'url': 'https://www.travelchinaguide.com/intro/social_customs/zodiac/dragon/'}]}
+```
+
+
+### 3. Easy composition of complex workflows
+
+```python
+# chain of thoughts
+from pydantic import Field
+
+class Reason(BaseModel):
+  reason: str
+  confidence_score: float
+
+class Thought(BaseModel):
+  thought: str
+
+class Analysis(BaseModel):
+  thought: list[Thought] = Field(
+    default_factory=list, 
+    description="concise Chain of thoughts from you, 3 step, each in 8 words"
+  )
+  analysis: str = Field(
+    ...,
+    description="Final analysis of the dragon's psyche in 20 words",
+  )
+  reason: list[Reason] = Field(
+    default_factory=list,
+    description="Concise Reasoning behind the analysis, 3 support, each in 8 words"
+  )
+
+context1 = "I am a dragon, I think therefore I am, I suffer from shiny objects syndrome"
+context2 = "I like food and poetry, I use uv sometimes, it's cool but I am not familiar with pip"
+
+async def analyze(context) -> Analysis:
+  psychologist = Branch(
+    system="you are a renowned dragon psychologist",
+    imodel=gpt4o,
+  )
+  return await psychologist.communicate(
+    instruction="analyze the dragon's psyche using chain of thoughts",
+    guidance="think step by step, reason with logic",
+    context=context,
+    response_format=Analysis,
+  )
+
+```
+
+```python
+result1 = await analyze(context1)
+
+print("\nThoughts:")
+for i in result1.thought:
+    print(i.thought)
+
+print("\nAnalysis:")    
+print(result1.analysis)
+
+print("\nReasoning:")
+for i in result1.reason:
+    print(i.reason)
+```
+
+```
+
+Thoughts:
+Dragons are attracted to shiny objects naturally.
+This suggests a strong affinity for hoarding.
+Reflects the dragon's inherent desire for possession.
+
+Analysis:
+The dragon demonstrates a compulsive hoarding behavior linked to attraction for shiny objects.
+
+Reasoning:
+Shiny objects trigger instinctual hoarding behavior.
+Possession indicates a symbol of power and security.
+Hoarding is reinforced by evolutionary survival mechanisms.
+```
+
+```python
+result2 = await analyze(context2)
+
+print("\nThoughts:")
+for i in result2.thought:
+    print(i.thought)
+
+print("\nAnalysis:")    
+print(result2.analysis)
+
+print("\nReasoning:")
+for i in result2.reason:
+    print(i.reason)
+```
+
+```
+Thoughts:
+Dragon enjoys both food and poetry regularly.
+Dragon uses uv light with frequent interest.
+Dragon is unfamiliar and not comfortable with pip.
+
+Analysis:
+The dragon is curious and exploratory, yet selectively cautious about unfamiliar methodologies.
+
+Reasoning:
+Preference for food and poetry suggests curiosity.
+Frequent uv light use indicates exploratory nature.
+Discomfort with pip usage shows selective caution.
+```
+
+
 
 ## 🌟 Example Workflow
 

lionagi-0.5.2/README.md

@@ -0,0 +1,318 @@
+![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
+![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)
+
+[Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
+
+# LION Framework
+### Language InterOperable Network - The Future of Controlled AI Operations
+
+> Harness the power of next-generation AI while maintaining complete control and reliability.
+
+## Why LION?
+
+The AI revolution is transforming how we work - but with great power comes great responsibility. LION provides the control mechanisms and reliability features needed to safely integrate advanced AI capabilities into enterprise workflows.
+
+LION is designed to be:
+- 🔒 **Controlled**: Built-in safety mechanisms and verification
+- 🎯 **Precise**: Exact control over AI behaviors
+- 🔧 **Flexible**: Build any workflow you need
+- 🚀 **Efficient**: Minimal dependencies, maximum performance
+
+
+
+## Installation
+
+LION maintains minimal dependencies for maximum reliability:
+
+```bash
+uv pip install lionagi
+```
+
+Dependencies:
+- litellm
+- jinja2
+- pandas
+- pillow
+- python-dotenv
+
+
+## Quick Start
+
+```python
+from lionagi import iModel, Branch
+
+# Initialize model
+gpt4o = iModel(provider="openai", task="chat", model="gpt-4o")
+
+hunter = Branch(
+  system="you are a hilarious dragon hunter who responds in 10 words rhymes",
+  imodel=gpt4o,
+)
+
+# Chat asynchronously
+print(await hunter.communicate("I am a dragon"))
+```
+
+```
+You claim to be a dragon, oh what a braggin'!
+```
+
+## 📦 Features
+
+### 1. Model Agnostic Structured Output
+
+LION provides a unified interface for interacting with any AI model, regardless of the underlying architecture. This allows you to easily switch between models without changing your code.
+
+```python
+from pydantic import BaseModel
+
+class Joke(BaseModel):
+  joke: str
+
+sonnet = iModel(
+  provider="anthropic",
+  model="claude-3-5-sonnet-20241022",
+  max_tokens=100,                    # max_tokens is required for anthropic models
+)
+
+response = await hunter.communicate(
+  instruction="I am a dragon",
+  response_format=Joke,           # structured output in given pydantic model
+  clear_messages=True,            # refresh the conversation
+  imodel=sonnet,                  # use sonnet model, which doesn't support structured output
+)
+
+print(type(response))
+print(response.joke)
+```
+
+```
+<class '__main__.Joke'>
+Joke(joke='With fiery claws, dragons hide their laughter flaws!')
+```
+
+
+### 2. Complete Observability
+
+```python
+# using perplexity model
+pplx_small = iModel(
+    provider="perplexity",
+    task="chat/completions",
+    model="llama-3.1-sonar-small-128k-online",
+    max_tokens=1000,
+)
+
+b = await hunter.communicate(
+    instruction="What makes a well-behaved dragon?",
+    clear_messages=True,            # refresh the conversation
+    imodel=pplx_small,                  # use sonnet model
+)
+
+print(b)
+```
+
+```
+A well-behaved dragon is one that's calm and bright,
+No stress or fear, just a peaceful night.
+It's active, not lethargic, with a happy face,
+And behaviors like digging, not a frantic pace.
+It's social, friendly, and never a fright,
+Just a gentle soul, shining with delight
+```
+
+```python
+hunter.msgs.last_response.model_response
+```
+
+```
+{'id': '1be10f4c-0936-4050-ab48-91bd86ab11a5',
+ 'model': 'llama-3.1-sonar-small-128k-online',
+ 'object': 'chat.completion',
+ 'created': 1734369700,
+ 'choices': [{'index': 0,
+   'message': {'role': 'assistant',
+    'content': "A well-behaved dragon is one that's calm and bright,\nNo stress or fear, just a peaceful night.\nIt's active, not lethargic, with a happy face,\nAnd behaviors like digging, not a frantic pace.\nIt's social, friendly, and never a fright,\nJust a gentle soul, shining with delight"},
+   'finish_reason': 'stop',
+   'delta': {'role': 'assistant', 'content': ''}}],
+ 'usage': {'prompt_tokens': 40, 'completion_tokens': 69, 'total_tokens': 109},
+ 'citations': [{'url': 'https://dragonsdiet.com/blogs/dragon-care/15-bearded-dragon-behaviors-and-what-they-could-mean'},
+  {'url': 'https://masterbraeokk.tripod.com/dragons/behavior.html'},
+  {'url': 'https://files.eric.ed.gov/fulltext/ED247607.pdf'},
+  {'url': 'https://www.travelchinaguide.com/intro/social_customs/zodiac/dragon/five-elements.htm'},
+  {'url': 'https://www.travelchinaguide.com/intro/social_customs/zodiac/dragon/'}]}
+```
+
+
+### 3. Easy composition of complex workflows
+
+```python
+# chain of thoughts
+from pydantic import Field
+
+class Reason(BaseModel):
+  reason: str
+  confidence_score: float
+
+class Thought(BaseModel):
+  thought: str
+
+class Analysis(BaseModel):
+  thought: list[Thought] = Field(
+    default_factory=list, 
+    description="concise Chain of thoughts from you, 3 step, each in 8 words"
+  )
+  analysis: str = Field(
+    ...,
+    description="Final analysis of the dragon's psyche in 20 words",
+  )
+  reason: list[Reason] = Field(
+    default_factory=list,
+    description="Concise Reasoning behind the analysis, 3 support, each in 8 words"
+  )
+
+context1 = "I am a dragon, I think therefore I am, I suffer from shiny objects syndrome"
+context2 = "I like food and poetry, I use uv sometimes, it's cool but I am not familiar with pip"
+
+async def analyze(context) -> Analysis:
+  psychologist = Branch(
+    system="you are a renowned dragon psychologist",
+    imodel=gpt4o,
+  )
+  return await psychologist.communicate(
+    instruction="analyze the dragon's psyche using chain of thoughts",
+    guidance="think step by step, reason with logic",
+    context=context,
+    response_format=Analysis,
+  )
+
+```
+
+```python
+result1 = await analyze(context1)
+
+print("\nThoughts:")
+for i in result1.thought:
+    print(i.thought)
+
+print("\nAnalysis:")    
+print(result1.analysis)
+
+print("\nReasoning:")
+for i in result1.reason:
+    print(i.reason)
+```
+
+```
+
+Thoughts:
+Dragons are attracted to shiny objects naturally.
+This suggests a strong affinity for hoarding.
+Reflects the dragon's inherent desire for possession.
+
+Analysis:
+The dragon demonstrates a compulsive hoarding behavior linked to attraction for shiny objects.
+
+Reasoning:
+Shiny objects trigger instinctual hoarding behavior.
+Possession indicates a symbol of power and security.
+Hoarding is reinforced by evolutionary survival mechanisms.
+```
+
+```python
+result2 = await analyze(context2)
+
+print("\nThoughts:")
+for i in result2.thought:
+    print(i.thought)
+
+print("\nAnalysis:")    
+print(result2.analysis)
+
+print("\nReasoning:")
+for i in result2.reason:
+    print(i.reason)
+```
+
+```
+Thoughts:
+Dragon enjoys both food and poetry regularly.
+Dragon uses uv light with frequent interest.
+Dragon is unfamiliar and not comfortable with pip.
+
+Analysis:
+The dragon is curious and exploratory, yet selectively cautious about unfamiliar methodologies.
+
+Reasoning:
+Preference for food and poetry suggests curiosity.
+Frequent uv light use indicates exploratory nature.
+Discomfort with pip usage shows selective caution.
+```
+
+
+
+## 🌟 Example Workflow
+
+Below is an example of what you can build with LION. Note that these are sample implementations - LION provides the building blocks, you create the workflows that fit your needs.
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Orchestrator
+    participant ResearchAgent
+    participant AnalysisAgent
+    participant ValidationAgent
+    participant Tools
+
+    Client->>+Orchestrator: Submit Complex Task
+    Note over Orchestrator: Task Analysis & Planning
+
+    %% Research Phase
+    Orchestrator->>+ResearchAgent: Delegate Research
+    activate ResearchAgent
+    ResearchAgent->>Tools: Access Data Sources
+    Tools-->>ResearchAgent: Raw Data
+    ResearchAgent-->>-Orchestrator: Research Results
+    deactivate ResearchAgent
+
+    %% Analysis Phase
+    Orchestrator->>+AnalysisAgent: Process Data
+    activate AnalysisAgent
+    AnalysisAgent->>Tools: Apply Models
+    Tools-->>AnalysisAgent: Analysis Results
+    AnalysisAgent-->>-Orchestrator: Processed Insights
+    deactivate AnalysisAgent
+
+    %% Validation Phase
+    Orchestrator->>+ValidationAgent: Verify Results
+    activate ValidationAgent
+    ValidationAgent->>Tools: Apply Safety Checks
+    Tools-->>ValidationAgent: Validation Status
+    ValidationAgent-->>-Orchestrator: Verified Results
+    deactivate ValidationAgent
+
+    Orchestrator-->>-Client: Return Validated Output
+```
+
+
+## 🤝 Contributing
+
+Join our [Discord community](https://discord.gg/aqSJ2v46vu) to:
+- Share ideas
+- Report issues
+- Contribute code
+- Learn from others
+
+## 📚 Citation
+
+```bibtex
+@software{Li_LionAGI_2023,
+  author = {Haiyang Li},
+  month = {12},
+  year = {2023},
+  title = {LionAGI: Intelligent Integration Framework},
+  url = {https://github.com/lion-agi/lionagi},
+}
+```

{lionagi-0.5.0 → lionagi-0.5.2}/lionagi/__init__.py

@@ -5,7 +5,6 @@ import logging
 from dotenv import load_dotenv
 
 from .core.session.types import Branch
-from .integrations.litellm_.imodel import LiteiModel
 from .protocols.operatives.step import Step
 from .service import iModel
 from .settings import Settings

{lionagi-0.5.0 → lionagi-0.5.2}/lionagi/core/action/tool.py

@@ -138,12 +138,10 @@ class Tool(Element):
         Returns:
             str: A detailed string representation of the Tool.
         """
-        timestamp_str = datetime.fromtimestamp(self.timestamp).isoformat(
-            timespec="minutes"
-        )
+        timestamp_str = self.created_datetime.strftime("%Y-%m-%d %H:%M:%S")
         return (
-            f"{self.class_name()}(ln_id={self.ln_id[:6]}.., "
-            f"timestamp={timestamp_str}), "
+            f"{self.class_name()}(ln_id={str(self.ln_id)[:6]}.., "
+            f"created_timestamp={timestamp_str}), "
             f"schema_={json.dumps(self.schema_, indent=4)}"
         )
 

{lionagi-0.5.0 → lionagi-0.5.2}/lionagi/core/communication/action_request.py

@@ -4,7 +4,7 @@
 
 from typing_extensions import override
 
-from lionagi.core.typing import ID, Any, Callable, LnID, Note
+from lionagi.core.typing import ID, Any, Callable, IDType, Note
 from lionagi.libs.parse import to_dict
 from lionagi.libs.utils import copy
 
@@ -107,12 +107,12 @@ class ActionRequest(RoledMessage):
         )
 
     @property
-    def action_response_id(self) -> LnID | None:
+    def action_response_id(self) -> IDType | None:
         """
         Get the ID of the corresponding action response.
 
         Returns:
-            LnID | None: The ID of the action response, or None if not responded
+            IDType | None: The ID of the action response, or None if not responded
         """
         return self.content.get("action_response_id", None)
 

{lionagi-0.5.0 → lionagi-0.5.2}/lionagi/core/communication/message.py

@@ -58,7 +58,7 @@ class MessageField(str, Enum):
     - LION_CLASS: Class identifier for LION system
     - ROLE: Message role (system/user/assistant)
     - CONTENT: Message content
-    - ln_id: Unique message identifier
+    - id: Unique message identifier
     - SENDER: Message sender
     - RECIPIENT: Message recipient
     - METADATA: Additional message metadata
@@ -68,7 +68,7 @@ class MessageField(str, Enum):
     LION_CLASS = "lion_class"
     ROLE = "role"
     CONTENT = "content"
-    ln_id = "ln_id"
+    id = "id"
     SENDER = "sender"
     RECIPIENT = "recipient"
     METADATA = "metadata"
@@ -248,7 +248,7 @@ class RoledMessage(Component, BaseMail):
         if origin_obj and isinstance(origin_obj, Communicatable):
             info_dict = {
                 "clone_from_info": {
-                    "original_ln_id": origin_obj.ln_id,
+                    "original_id": origin_obj.id,
                     "original_timestamp": origin_obj.timestamp,
                     "original_sender": origin_obj.sender,
                     "original_recipient": origin_obj.recipient,

{lionagi-0.5.0 → lionagi-0.5.2}/lionagi/core/communication/utils.py

@@ -8,8 +8,8 @@ from lionagi.core.typing import (
     Any,
     BaseModel,
     IDError,
+    IDType,
     Literal,
-    LnID,
     Note,
 )
 from lionagi.integrations.pydantic_ import break_down_pydantic_annotation
@@ -229,7 +229,7 @@ def prepare_instruction_content(
 
 def validate_sender_recipient(
     value: Any, /
-) -> LnID | Literal["system", "user", "N/A", "assistant"]:
+) -> IDType | Literal["system", "user", "N/A", "assistant"]:
     """
     Validate sender and recipient fields for mail-like communication.
 
@@ -237,7 +237,7 @@ def validate_sender_recipient(
         value: The value to validate
 
     Returns:
-        Union[LnID, Literal]: Valid sender/recipient value
+        Union[IDType, Literal]: Valid sender/recipient value
 
     Raises:
         ValueError: If value is not a valid sender or recipient