lionagi 0.8.6__py3-none-any.whl → 0.8.8__py3-none-any.whl

lionagi/operations/ReAct/ReAct.py

@@ -28,8 +28,8 @@ async def ReAct(
     tools: Any = None,
     tool_schemas: Any = None,
     response_format: type[BaseModel] | BaseModel = None,
-    extension_allowed: bool = False,
-    max_extensions: int | None = None,
+    extension_allowed: bool = True,
+    max_extensions: int | None = 3,
     response_kwargs: dict | None = None,
     return_analysis: bool = False,
     analysis_model: iModel | None = None,
@@ -54,6 +54,8 @@ async def ReAct(
             sample_writing=interpret_sample,
             **(interpret_kwargs or {}),
         )
+        if verbose_analysis:
+            print(f"Interpreted instruction: {instruction_str}")
 
     # Convert Instruct to dict if necessary
     instruct_dict = (
@@ -92,9 +94,11 @@ async def ReAct(
         )
 
     # Validate and clamp max_extensions if needed
-    if max_extensions and max_extensions > 5:
-        logging.warning("max_extensions should not exceed 5; defaulting to 5.")
-        max_extensions = 5
+    if max_extensions and max_extensions > 100:
+        logging.warning(
+            "max_extensions should not exceed 100; defaulting to 100."
+        )
+        max_extensions = 100
 
     # Step 2: Possibly loop through expansions if extension_needed
     extensions = max_extensions

lionagi/protocols/generic/event.py

@@ -86,6 +86,7 @@ class Event(Element):
     """
 
     execution: Execution = Field(default_factory=Execution)
+    streaming: bool = False
 
     @field_serializer("execution")
     def _serialize_execution(self, val: Execution) -> dict:
@@ -160,6 +161,15 @@ class Event(Element):
         """
         raise NotImplementedError("Override in subclass.")
 
+    async def stream(self) -> None:
+        """Performs the event action asynchronously, streaming results.
+
+        Raises:
+            NotImplementedError: This base method must be overridden by
+            subclasses.
+        """
+        raise NotImplementedError("Override in subclass.")
+
     @classmethod
     def from_dict(cls, data: dict) -> "Event":
         """Not implemented. Events cannot be fully recreated once done.

lionagi/protocols/generic/processor.py

@@ -31,6 +31,7 @@ class Processor(Observer):
         self,
         queue_capacity: int,
         capacity_refresh_time: float,
+        concurrency_limit: int,
     ) -> None:
         """Initializes a Processor instance.
 
@@ -56,6 +57,10 @@ class Processor(Observer):
         self._available_capacity = queue_capacity
         self._execution_mode = False
         self._stop_event = asyncio.Event()
+        if concurrency_limit:
+            self._concurrency_sem = asyncio.Semaphore(concurrency_limit)
+        else:
+            self._concurrency_sem = None
 
     @property
     def available_capacity(self) -> int:
@@ -144,8 +149,11 @@ class Processor(Observer):
                 next_event = await self.dequeue()
 
             if await self.request_permission(**next_event.request):
-                next_event.status = EventStatus.PROCESSING
-                task = asyncio.create_task(next_event.invoke())
+
+                if next_event.streaming:
+                    task = asyncio.create_task(next_event.stream())
+                else:
+                    task = asyncio.create_task(next_event.invoke())
                 tasks.add(task)
 
             prev_event = next_event

lionagi/service/endpoints/base.py

@@ -3,13 +3,16 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import asyncio
+import json
 import logging
 from abc import ABC
+from collections.abc import AsyncGenerator
 from typing import Any, Literal
 
 import aiohttp
 from aiocache import cached
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing_extensions import Self
 
 from lionagi._errors import ExecutionError, RateLimitError
 from lionagi.protocols.generic.event import Event, EventStatus
@@ -347,6 +350,12 @@ class APICalling(Event):
     is_cached: bool = Field(default=False, exclude=True)
     should_invoke_endpoint: bool = Field(default=True, exclude=True)
 
+    @model_validator(mode="after")
+    def _validate_streaming(self) -> Self:
+        if self.payload.get("stream") is True:
+            self.streaming = True
+        return self
+
     @property
     def required_tokens(self) -> int | None:
         """int | None: The number of tokens required for this request."""
@@ -442,10 +451,91 @@ class APICalling(Event):
         """
         return await self._inner(**kwargs)
 
-    async def stream(self, **kwargs):
+    async def _stream(
+        self,
+        verbose: bool = True,
+        output_file: str = None,
+        with_response_header: bool = False,
+    ) -> AsyncGenerator:
+        async with aiohttp.ClientSession() as client:
+            async with client.request(
+                method=self.endpoint.method.upper(),
+                url=self.endpoint.full_url,
+                headers=self.headers,
+                json=self.payload,
+            ) as response:
+                if response.status != 200:
+                    try:
+                        error_text = await response.json()
+                    except Exception:
+                        error_text = await response.text()
+                    raise aiohttp.ClientResponseError(
+                        request_info=response.request_info,
+                        history=response.history,
+                        status=response.status,
+                        message=f"{error_text}",
+                        headers=response.headers,
+                    )
+
+                file_handle = None
+
+                if output_file:
+                    try:
+                        file_handle = open(output_file, "w")
+                    except Exception as e:
+                        raise ValueError(
+                            f"Invalid to output the response "
+                            f"to {output_file}. Error:{e}"
+                        )
+
+                try:
+                    async for chunk in response.content:
+                        chunk_str = chunk.decode("utf-8")
+                        chunk_list = chunk_str.split("data:")
+                        for c in chunk_list:
+                            c = c.strip()
+                            if c and c != "[DONE]":
+                                try:
+                                    if file_handle:
+                                        file_handle.write(c + "\n")
+                                    c_dict = json.loads(c)
+                                    if verbose:
+                                        if c_dict.get("choices"):
+                                            if content := c_dict["choices"][0][
+                                                "delta"
+                                            ].get("content"):
+                                                print(
+                                                    content, end="", flush=True
+                                                )
+                                    yield c_dict
+                                except json.JSONDecodeError:
+                                    yield c
+                                except asyncio.CancelledError as e:
+                                    raise e
+
+                    if with_response_header:
+                        yield response.headers
+
+                finally:
+                    if file_handle:
+                        file_handle.close()
+
+    async def stream(
+        self,
+        verbose: bool = True,
+        output_file: str = None,
+        with_response_header: bool = False,
+        **kwargs,
+    ) -> AsyncGenerator:
         """Performs a streaming request, if supported by the endpoint.
 
         Args:
+            verbose (bool):
+                If True, prints the response content to the console.
+            output_file (str):
+                If set, writes the response content to this file. (only applies to non-endpoint invoke)
+            with_response_header (bool):
+                If True, yields the response headers as well. (only applies to non-endpoint invoke)
             **kwargs: Additional parameters for the streaming call.
 
         Yields:
@@ -456,23 +546,39 @@ class APICalling(Event):
         """
         start = asyncio.get_event_loop().time()
         response = []
-        if not self.endpoint.is_streamable:
-            raise ValueError(
-                f"Endpoint {self.endpoint.endpoint} is not streamable."
-            )
-
-        async for i in self.endpoint._stream(
-            self.payload, self.headers, **kwargs
-        ):
-            content = i.choices[0].delta.content
-            if content is not None:
-                print(content, end="", flush=True)
-            response.append(i)
-            yield i
-
-        self.execution.duration = asyncio.get_event_loop().time() - start
-        self.execution.response = response
-        self.execution.status = EventStatus.COMPLETED
+        e1 = None
+        try:
+            if self.should_invoke_endpoint and self.endpoint.is_streamable:
+                async for i in self.endpoint._stream(
+                    self.payload, self.headers, **kwargs
+                ):
+                    content = i.choices[0].delta.content
+                    if verbose:
+                        if content is not None:
+                            print(content, end="", flush=True)
+                    response.append(i)
+                    yield i
+            else:
+                async for i in self._stream(
+                    verbose=verbose,
+                    output_file=output_file,
+                    with_response_header=with_response_header,
+                ):
+                    response.append(i)
+                    yield i
+        except Exception as e:
+            e1 = e
+        finally:
+            self.execution.duration = asyncio.get_event_loop().time() - start
+            if not response and e1:
+                self.execution.error = str(e1)
+                self.execution.status = EventStatus.FAILED
+                logging.error(
+                    f"API call to {self.endpoint.full_url} failed: {e1}"
+                )
+            else:
+                self.execution.response = response
+                self.execution.status = EventStatus.COMPLETED
 
     async def invoke(self) -> None:
         """Invokes the API call, updating the execution state with results.
@@ -483,9 +589,10 @@ class APICalling(Event):
         """
         start = asyncio.get_event_loop().time()
         kwargs = {"headers": self.headers, "json": self.payload}
+        response = None
+        e1 = None
 
         try:
-            response = None
             if self.should_invoke_endpoint and self.endpoint.is_invokeable:
                 response = await self.endpoint.invoke(
                     payload=self.payload,
@@ -498,14 +605,20 @@ class APICalling(Event):
                 else:
                     response = await self._inner(**kwargs)
 
-            self.execution.duration = asyncio.get_event_loop().time() - start
-            self.execution.response = response
-            self.execution.status = EventStatus.COMPLETED
         except Exception as e:
+            e1 = e
+
+        finally:
             self.execution.duration = asyncio.get_event_loop().time() - start
-            self.execution.error = str(e)
-            self.execution.status = EventStatus.FAILED
-            logging.error(f"API call to {self.endpoint.full_url} failed: {e}")
+            if not response and e1:
+                self.execution.error = str(e1)
+                self.execution.status = EventStatus.FAILED
+                logging.error(
+                    f"API call to {self.endpoint.full_url} failed: {e1}"
+                )
+            else:
+                self.execution.response = response
+                self.execution.status = EventStatus.COMPLETED
 
     def __str__(self) -> str:
         return (

lionagi/service/endpoints/chat_completion.py

@@ -27,10 +27,13 @@ class ChatCompletionEndPoint(EndPoint):
         headers: dict,
         **kwargs,
     ):
-        import litellm
+        from lionagi.libs.package.imports import check_import
+
+        check_import("litellm")
+        import litellm  # type: ignore
 
         litellm.drop_params = True
-        from litellm import acompletion
+        from litellm import acompletion  # type: ignore
 
         provider = self.config.provider
 
@@ -64,10 +67,13 @@ class ChatCompletionEndPoint(EndPoint):
         headers: dict,
         **kwargs,
     ) -> AsyncGenerator:
-        import litellm
+        from lionagi.libs.package.imports import check_import
+
+        check_import("litellm")
+        import litellm  # type: ignore
 
         litellm.drop_params = True
-        from litellm import acompletion
+        from litellm import acompletion  # type: ignore
 
         provider = self.config.provider
 

lionagi/service/endpoints/rate_limited_processor.py

@@ -28,8 +28,13 @@ class RateLimitedAPIProcessor(Processor):
         interval: float | None = None,
         limit_requests: int = None,
         limit_tokens: int = None,
+        concurrency_limit: int | None = None,
     ):
-        super().__init__(queue_capacity, capacity_refresh_time)
+        super().__init__(
+            queue_capacity=queue_capacity,
+            capacity_refresh_time=capacity_refresh_time,
+            concurrency_limit=concurrency_limit,
+        )
         self.limit_tokens = limit_tokens
         self.limit_requests = limit_requests
         self.interval = interval or self.capacity_refresh_time
@@ -37,6 +42,9 @@ class RateLimitedAPIProcessor(Processor):
         self.available_token = self.limit_tokens
         self._rate_limit_replenisher_task: asyncio.Task | None = None
         self._lock: asyncio.Lock = asyncio.Lock()
+        self._concurrency_sem = asyncio.Semaphore(
+            concurrency_limit or queue_capacity
+        )
 
     async def start_replenishing(self):
         """Start replenishing rate limit capacities at regular intervals."""
@@ -74,6 +82,7 @@ class RateLimitedAPIProcessor(Processor):
         interval: float | None = None,
         limit_requests: int = None,
         limit_tokens: int = None,
+        concurrency_limit: int | None = None,
     ) -> Self:
         self = cls(
             interval=interval,
@@ -81,6 +90,7 @@ class RateLimitedAPIProcessor(Processor):
             capacity_refresh_time=capacity_refresh_time,
             limit_requests=limit_requests,
             limit_tokens=limit_tokens,
+            concurrency_limit=concurrency_limit,
         )
         self._rate_limit_replenisher_task = asyncio.create_task(
             self.start_replenishing()
@@ -126,6 +136,7 @@ class RateLimitedAPIExecutor(Executor):
         limit_requests: int = None,
         limit_tokens: int = None,
         strict_event_type: bool = False,
+        concurrency_limit: int | None = None,
     ):
         config = {
             "queue_capacity": queue_capacity,
@@ -133,13 +144,13 @@ class RateLimitedAPIExecutor(Executor):
             "interval": interval,
             "limit_requests": limit_requests,
             "limit_tokens": limit_tokens,
+            "concurrency_limit": concurrency_limit,
         }
-
+        super().__init__(
+            processor_config=config, strict_event_type=strict_event_type
+        )
         self.config = config
         self.interval = interval
         self.limit_requests = limit_requests
         self.limit_tokens = limit_tokens
-
-        super().__init__(
-            processor_config=config, strict_event_type=strict_event_type
-        )
+        self.concurrency_limit = concurrency_limit or queue_capacity

lionagi/service/imodel.py

@@ -2,11 +2,16 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import asyncio
 import os
 import warnings
+from collections.abc import AsyncGenerator, Callable
 
 from pydantic import BaseModel
 
+from lionagi.protocols.generic.event import EventStatus
+from lionagi.utils import is_coro_func
+
 from .endpoints.base import APICalling, EndPoint
 from .endpoints.match_endpoint import match_endpoint
 from .endpoints.rate_limited_processor import RateLimitedAPIExecutor
@@ -54,7 +59,9 @@ class iModel:
         interval: float | None = None,
         limit_requests: int = None,
         limit_tokens: int = None,
-        invoke_with_endpoint: bool = True,
+        invoke_with_endpoint: bool = False,
+        concurrency_limit: int | None = None,
+        streaming_process_func: Callable = None,
         **kwargs,
     ) -> None:
         """Initializes the iModel instance.
@@ -88,6 +95,9 @@ class iModel:
             invoke_with_endpoint (bool, optional):
                 If True, the endpoint is actually invoked. If False,
                 calls might be mocked or cached.
+            concurrency_limit (int | None, optional):
+                Maximum number of streaming concurrent requests allowed.
+                only applies to streaming requests.
             **kwargs:
                 Additional keyword arguments, such as `model`, or any other
                 provider-specific fields.
@@ -144,7 +154,14 @@ class iModel:
             interval=interval,
             limit_requests=limit_requests,
             limit_tokens=limit_tokens,
+            concurrency_limit=concurrency_limit,
         )
+        if not streaming_process_func and hasattr(
+            self.endpoint, "process_chunk"
+        ):
+            self.streaming_process_func = self.endpoint.process_chunk
+        else:
+            self.streaming_process_func = streaming_process_func
 
     def create_api_calling(self, **kwargs) -> APICalling:
         """Constructs an `APICalling` object from endpoint-specific payload.
@@ -179,9 +196,12 @@ class iModel:
             chunk:
                 A portion of the streamed data returned by the API.
         """
-        pass
+        if self.streaming_process_func and not isinstance(chunk, APICalling):
+            if is_coro_func(self.streaming_process_func):
+                return await self.streaming_process_func(chunk)
+            return self.streaming_process_func(chunk)
 
-    async def stream(self, **kwargs) -> APICalling | None:
+    async def stream(self, api_call=None, **kwargs) -> AsyncGenerator:
         """Performs a streaming API call with the given arguments.
 
         Args:
@@ -193,14 +213,38 @@ class iModel:
                 An APICalling instance upon success, or None if something
                 goes wrong.
         """
-        try:
+        if api_call is None:
             kwargs["stream"] = True
             api_call = self.create_api_calling(**kwargs)
-            async for i in api_call.stream():
-                await self.process_chunk(i)
-            return api_call
-        except Exception as e:
-            raise ValueError(f"Failed to stream API call: {e}")
+            await self.executor.append(api_call)
+
+        if (
+            self.executor.processor is None
+            or self.executor.processor.is_stopped()
+        ):
+            await self.executor.start()
+
+        if self.executor.processor._concurrency_sem:
+            async with self.executor.processor._concurrency_sem:
+                try:
+                    async for i in api_call.stream():
+                        result = await self.process_chunk(i)
+                        if result:
+                            yield result
+                except Exception as e:
+                    raise ValueError(f"Failed to stream API call: {e}")
+                finally:
+                    yield self.executor.pile.pop(api_call.id)
+        else:
+            try:
+                async for i in api_call.stream():
+                    result = await self.process_chunk(i)
+                    if result:
+                        yield result
+            except Exception as e:
+                raise ValueError(f"Failed to stream API call: {e}")
+            finally:
+                yield self.executor.pile.pop(api_call.id)
 
     async def invoke(
         self, api_call: APICalling = None, **kwargs
@@ -232,10 +276,20 @@ class iModel:
 
             await self.executor.append(api_call)
             await self.executor.forward()
-            if api_call.id in self.executor.completed_events:
-                return self.executor.pile.pop(api_call.id)
+            ctr = 0
+            while api_call.status not in (
+                EventStatus.COMPLETED,
+                EventStatus.FAILED,
+            ):
+                if ctr > 100:
+                    break
+                await self.executor.forward()
+                ctr += 1
+                await asyncio.sleep(0.1)
         except Exception as e:
             raise ValueError(f"Failed to invoke API call: {e}")
+        finally:
+            return self.executor.pile.pop(api_call.id)
 
     @property
     def allowed_roles(self) -> set[str]:

lionagi/session/branch.py

@@ -577,6 +577,7 @@ class Branch(Element, Communicatable, Relational):
         request_options: type[BaseModel] = None,
         description: str = None,
         update: bool = False,
+        **kwargs,
     ):
         if not imodel:
             imodel = iModel(
@@ -591,6 +592,7 @@ class Branch(Element, Communicatable, Relational):
                 limit_requests=limit_requests,
                 limit_tokens=limit_tokens,
                 invoke_with_endpoint=invoke_with_endpoint,
+                **kwargs,
             )
 
         if not update and name in self.tools:

lionagi/tools/{reader.py → file/reader.py}

@@ -6,7 +6,7 @@ from pydantic import BaseModel, Field, field_validator
 from lionagi.operatives.action.tool import Tool
 from lionagi.utils import to_num
 
-from .base import LionTool
+from ..base import LionTool
 
 
 class ReaderAction(str, Enum):
@@ -208,7 +208,7 @@ class ReaderTool(LionTool):
         e = min(length, end if end is not None else length)
 
         try:
-            with open(path, "r", encoding="utf-8") as f:
+            with open(path, encoding="utf-8") as f:
                 f.seek(s)
                 content = f.read(e - s)
         except Exception as ex:

lionagi/tools/types.py

@@ -1,3 +1,3 @@
-from .reader import ReaderTool
+from .file.reader import ReaderTool
 
 __all__ = ("ReaderTool",)

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.8.6"
+__version__ = "0.8.8"

{lionagi-0.8.6.dist-info → lionagi-0.8.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.8.6
+Version: 0.8.8
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -222,11 +222,11 @@ Requires-Python: >=3.10
 Requires-Dist: aiocache>=0.12.0
 Requires-Dist: aiohttp>=3.11.0
 Requires-Dist: jinja2>=3.1.0
-Requires-Dist: litellm>=1.55.3
 Requires-Dist: pandas>=2.0.0
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: tiktoken>=0.8.0
 Description-Content-Type: text/markdown
 
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
@@ -235,310 +235,137 @@ Description-Content-Type: text/markdown
 
 [Documentation](https://lion-agi.github.io/lionagi/) | [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
+# LION - Language InterOperable Network
 
-> Harness the power of next-generation AI while maintaining complete control and reliability.
+## An Intelligence Operating System
 
-## Why LION?
+LionAGI is a robust framework for orchestrating multi-step AI operations with precise control. Bring together multiple models, advanced ReAct reasoning, tool integrations, and custom validations in a single coherent pipeline.
 
-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
+## Why LionAGI?
 
+- **Structured**: LLM interactions are validated and typed (via Pydantic).
+- **Expandable**: Integrate multiple providers (OpenAI, Anthropic, Perplexity, custom) with minimal friction.
+- **Controlled**: Built-in safety checks, concurrency strategies, and advanced multi-step flows—like ReAct with verbose outputs.
+- **Transparent**: Real-time logging, message introspection, and easy debugging of tool usage.
 
 
 ## Installation
 
-LION maintains minimal dependencies for maximum reliability:
-
-```bash
-uv pip install lionagi
+```
+pip install lionagi
 ```
 
 Dependencies:
-- litellm
-- jinja2
-- pandas
-- pillow
-- python-dotenv
-
+	•	aiocahce
+  •	aiohttp
+	•	jinja2
+	•	pandas
+	•	pillow
+  •	pydantic
+	•	python-dotenv
+  •	tiktoken
 
 ## Quick Start
-
 ```python
-from lionagi import iModel, Branch
+from lionagi import Branch, iModel
 
-# Initialize model
-gpt4o = iModel(provider="openai", task="chat", model="gpt-4o")
+# Pick a model
+gpt4o = iModel(provider="openai", model="gpt-4o")
 
+# Create a Branch (conversation context)
 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.",
+  chat_model=gpt4o,
 )
 
-# Chat asynchronously
-print(await hunter.communicate("I am a dragon"))
+# Communicate asynchronously
+response = await hunter.communicate("I am a dragon")
+print(response)
 ```
 
 ```
 You claim to be a dragon, oh what a braggin'!
 ```
+### Structured Responses
 
-## 📦 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.
+Use Pydantic to keep outputs structured:
 
 ```python
 from pydantic import BaseModel
 
 class Joke(BaseModel):
-  joke: str
+    joke: str
 
-sonnet = iModel(
-  provider="anthropic",
-  model="claude-3-5-sonnet-20241022",
-  max_tokens=100,                    # max_tokens is required for anthropic models
+res = await hunter.communicate(
+    "Tell me a short dragon joke",
+    response_format=Joke
 )
-
-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!')
+With fiery claws, dragons hide their laughter flaws!
 ```
 
+### ReAct and Tools
 
-### 2. Complete Observability
+LionAGI supports advanced multi-step reasoning with ReAct. Tools let the LLM invoke external actions:
 
 ```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 perplexity model
+from lionagi.tools.types import ReaderTool
+
+branch = Branch(chat_model=gpt4o, tools=ReaderTool)
+result = await branch.ReAct(
+    instruct={
+      "instruction": "Summarize my PDF and compare with relevant papers.",
+      "context": {"paper_file_path": "/path/to/paper.pdf"},
+    },
+    extension_allowed=True,     # allow multi-round expansions
+    max_extensions=5,
+    verbose=True,      # see step-by-step chain-of-thought
 )
-
-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/'}]}
+print(result)
 ```
 
+The LLM can now open the PDF, read in slices, fetch references, and produce a final structured summary.
 
-### 3. Easy composition of complex workflows
-
+### Observability & Debugging
+- Inspect messages:
 ```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,
-  )
-
+df = branch.to_df()
+print(df.tail())
 ```
+- Action logs show each tool call, arguments, and outcomes.
+- Verbose ReAct provides chain-of-thought analysis (helpful for debugging multi-step flows).
 
-```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.
-```
+### Example: Multi-Model Orchestration
 
 ```python
-result2 = await analyze(context2)
+from lionagi import Branch, iModel
 
-print("\nThoughts:")
-for i in result2.thought:
-    print(i.thought)
-
-print("\nAnalysis:")    
-print(result2.analysis)
+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
+)
 
-print("\nReasoning:")
-for i in result2.reason:
-    print(i.reason)
+branch = Branch(chat_model=gpt4o)
+# Switch mid-flow
+analysis = await branch.communicate("Analyze these stats", imodel=sonnet)
 ```
 
-```
-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.
-```
+Seamlessly route to different models in the same workflow.
 
+## Community & Contributing
 
+We welcome issues, ideas, and pull requests:
+- Discord: Join to chat or get help
+- Issues / PRs: GitHub
 
-## 🌟 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
+### Citation
 ```
-
-
-## 🤝 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},
@@ -547,3 +374,6 @@ Join our [Discord community](https://discord.gg/aqSJ2v46vu) to:
   url = {https://github.com/lion-agi/lionagi},
 }
 ```
+
+**🦁 LionAGI**
+> Because real AI orchestration demands more than a single prompt. Try it out and discover the next evolution in structured, multi-model, safe AI.

{lionagi-0.8.6.dist-info → lionagi-0.8.8.dist-info}/RECORD

@@ -4,7 +4,7 @@ lionagi/_errors.py,sha256=wNKdnVQvE_CHEstK7htrrj334RA_vbGcIds-3pUiRkc,455
 lionagi/_types.py,sha256=9g7iytvSj3UjZxD-jL06_fxuNfgZyWT3Qnp0XYp1wQU,63
 lionagi/settings.py,sha256=k9zRJXv57TveyfHO3Vr9VGiKrSwlRUUVKt5zf6v9RU4,1627
 lionagi/utils.py,sha256=QbF4E1PG-BaRcEVH3kJIYCJVNq-oRNoTxjda5k8NYW4,73177
-lionagi/version.py,sha256=VpASnrti7EGWxUfSWGgERUfe7NLJltfVXYosOzHbpPg,22
+lionagi/version.py,sha256=S5bBAK8bL7bybaXGJQuNE98fa3H65zGjTASMiyKGJGw,22
 lionagi/libs/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/libs/parse.py,sha256=tpEbmIRGuHhLCJlUlm6fjmqm_Z6XJLAXGNFHNuk422I,1011
 lionagi/libs/file/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
@@ -48,7 +48,7 @@ lionagi/operations/__init__.py,sha256=O7nV0tedpUe7_OlUWmCcduGPFtqtzWZcR_SIOnjLsr
 lionagi/operations/manager.py,sha256=H7UY86PIxvxKdzJY9YVsWyJcqlwLWhVyvm4sYePH_uY,565
 lionagi/operations/types.py,sha256=LIa68xcyKLVafof-DSFwKtSkneuYPFqrtGyClohYI6o,704
 lionagi/operations/utils.py,sha256=Twy6L_UFt9JqJFRYuKKTKVZIXsePidNl5ipcYcCbesI,1220
-lionagi/operations/ReAct/ReAct.py,sha256=odFcuNMuwJ2NjUGGdTekFJzD43WFvNFNHCjzS1X6HT8,4962
+lionagi/operations/ReAct/ReAct.py,sha256=_PwoP3RgazGsAaDEOWEABATpBujI7e5OQhbc9AyIA1o,5082
 lionagi/operations/ReAct/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/operations/ReAct/utils.py,sha256=uWPZC1aJVAPvJweAgr3NdXpYszeagN5OnJIkUdrSvlw,3228
 lionagi/operations/_act/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
@@ -129,10 +129,10 @@ lionagi/protocols/adapters/pandas_/pd_dataframe_adapter.py,sha256=ULGZVhK5aaOuTr
 lionagi/protocols/adapters/pandas_/pd_series_adapter.py,sha256=TX3cqFtgEip8JqVqkjdJYOu4PQGpW1yYU6POhvz8Jeg,1388
 lionagi/protocols/generic/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/protocols/generic/element.py,sha256=6RPUqs3FOdSC65QOwnfBD9yKVsWnmb878kmfas0m928,14169
-lionagi/protocols/generic/event.py,sha256=SjR9N4Egr5_oqOBSKVsxQjsn6MlqNcwf48bee-qIT6Y,4879
+lionagi/protocols/generic/event.py,sha256=8_581UqtCPCRPYVjTRtFQc_huky10xV4Rn9dxIwMjaA,5200
 lionagi/protocols/generic/log.py,sha256=xi8dRKwxtxVYU8T_E4wYJE4lCQzkERgAUARcAN7ZngI,7441
 lionagi/protocols/generic/pile.py,sha256=Nx4IkWDC5Tdykrw_uGrudgS6Yrz1v1Sykv8t74Deuic,31434
-lionagi/protocols/generic/processor.py,sha256=4Gkie1DxE0U-uZAdNBTuTibUlyeEGm_OyVlMXilCEm8,10115
+lionagi/protocols/generic/processor.py,sha256=n1DFmLY4bfvrSQNQ5tQ0_Pkyq0lzP9cYtDAmX4yC5Pc,10382
 lionagi/protocols/generic/progression.py,sha256=OAirlukJ34rKRipv8MtG7PvvJRkq8nz-RIYB-Yi39Mo,15189
 lionagi/protocols/graph/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/protocols/graph/edge.py,sha256=cEbhqapsdJqHx5VhPwXwOkahfC7E7XZNbRqGixt_EFc,5229
@@ -161,14 +161,14 @@ lionagi/protocols/messages/templates/instruction_message.jinja2,sha256=L-ptw5OHx
 lionagi/protocols/messages/templates/system_message.jinja2,sha256=JRKJ0aFpYfaXSFouKc_N4unZ35C3yZTOWhIrIdCB5qk,215
 lionagi/protocols/messages/templates/tool_schemas.jinja2,sha256=ozIaSDCRjIAhLyA8VM6S-YqS0w2NcctALSwx4LjDwII,126
 lionagi/service/__init__.py,sha256=DMGXIqPsmut9H5GT0ZeSzQIzYzzPwI-2gLXydpbwiV8,21
-lionagi/service/imodel.py,sha256=zQq9cdVPpEAPB7IscntExvtHOYA5ToiWonmD2n93pEw,12273
+lionagi/service/imodel.py,sha256=KCIwRXf8djr5S-t_Vc9dZGvVIzLyirDWDbOcb7ECMsw,14470
 lionagi/service/manager.py,sha256=MKSYBkg23s7YhZy5GEFdnpspEnhPVfFhpkpoJe20D7k,1435
 lionagi/service/types.py,sha256=v9SAn5-GTmds4Mar13Or_VFrRHCinBK99dmeDUd-QNk,486
 lionagi/service/endpoints/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/service/endpoints/base.py,sha256=SaYobDBCdKd4398TyFPp5u3PKyMnzEbm6PsoUxVkZDA,18605
-lionagi/service/endpoints/chat_completion.py,sha256=9ltSQaKPH43WdEDW32_-f5x07I9hOU8g-T_PAG-nYsQ,2529
+lionagi/service/endpoints/base.py,sha256=KovCttNJ0h22vmg3wSxZK7IE7jsydw4L3xXbjTOynq8,23134
+lionagi/service/endpoints/chat_completion.py,sha256=-LsmBdYEwEhREEbti_81nTMy_pgaX9xteukj8IPq_bI,2783
 lionagi/service/endpoints/match_endpoint.py,sha256=hIGYyok1y53FfI6av5NfYMygRIpDWYZbdCj0pJJfmPY,1874
-lionagi/service/endpoints/rate_limited_processor.py,sha256=umri0FofbyBSFdAQBEsviDB5K6N12LkRiXQgSOorGKg,4663
+lionagi/service/endpoints/rate_limited_processor.py,sha256=kOFp7oTKZXQDdbgyCYKvR-zUIq_WPEfeRDF0SkCbtCs,5199
 lionagi/service/endpoints/token_calculator.py,sha256=MflqImGUr_1jh465hB7cUAaIPICBkjirvre1fWGXLrA,6161
 lionagi/service/providers/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/service/providers/types.py,sha256=NS91ysRFwOs0cpNeQgFhmtl7JrSz2pJm-tt7sZILmQY,683
@@ -188,13 +188,14 @@ lionagi/service/providers/perplexity_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZK
 lionagi/service/providers/perplexity_/chat_completions.py,sha256=jhE-KHWRX6yYEeKWLMCKLgK3bQzieSv2viqQWDP8q0Q,1197
 lionagi/service/providers/perplexity_/models.py,sha256=gXH4XGkhZ4aFxvMSDTlHq9Rz1mhu3aTENXAtE-BIr6U,4866
 lionagi/session/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/session/branch.py,sha256=EH1JhOe1ZGlCVXpf0znz_xAA3GibNIGFATwLAyxiCK0,67835
+lionagi/session/branch.py,sha256=cSdhebkS3Shc-ZwS1KpoEOidiq2AqQBidli1jwezFz4,67879
 lionagi/session/session.py,sha256=po6C7PnM0iu_ISHUo4PBzzQ61HFOgcsAUfPoO--eLak,8987
 lionagi/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/tools/base.py,sha256=ffaIcLF_uwEphCkP_wsa3UfkqVenML3HpsnR5kRCTtA,236
-lionagi/tools/reader.py,sha256=TyjSqhSIQwxdkwgYSz760YKBbqJ5OfwZegRwQz47R24,7509
-lionagi/tools/types.py,sha256=_OWzoTHTcqNwPs3OGrPkpO9m_vHDCxVDL-FN-t6ZD60,58
-lionagi-0.8.6.dist-info/METADATA,sha256=SmTcVVpZcb_nfuNo5WrDS6ilr16Tj0qL_yX-AAP1ri0,22819
-lionagi-0.8.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.8.6.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.8.6.dist-info/RECORD,,
+lionagi/tools/types.py,sha256=O6ipx7zX0piaIQ3c8V3zHWrXH-1gdIe-KQ4xTPSiLp0,63
+lionagi/tools/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/tools/file/reader.py,sha256=o6tgqNmxNq64al4hqNS_whPQbH2CP7YygYQUhTmfjQU,7505
+lionagi-0.8.8.dist-info/METADATA,sha256=_BdfHxsxVZfXAAFEu--AZNNVPrlfeThuhogbDWq9I4s,18053
+lionagi-0.8.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.8.8.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.8.8.dist-info/RECORD,,