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

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):

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.7"
+__version__ = "0.8.8"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.8.7
+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)
@@ -256,11 +256,14 @@ pip install lionagi
 ```
 
 Dependencies:
-	•	litellm
+	•	aiocahce
+  •	aiohttp
 	•	jinja2
 	•	pandas
 	•	pillow
+  •	pydantic
 	•	python-dotenv
+  •	tiktoken
 
 ## Quick Start
 ```python

{lionagi-0.8.7.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=vTwvdJOZi8jZb9U-Em7-d50qNDNPS2z51IXqRoojeNM,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
@@ -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=jYWgEfyQZ7TR5-cW7ceGhz6b47eWlSS0bAvbCnHh1-I,7504
-lionagi/tools/types.py,sha256=_OWzoTHTcqNwPs3OGrPkpO9m_vHDCxVDL-FN-t6ZD60,58
-lionagi-0.8.7.dist-info/METADATA,sha256=-mm0T59W8n5E3bk73nVaqEsxn6bYCrgEIYNZ389h-Tw,18008
-lionagi-0.8.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.8.7.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.8.7.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,,