lionagi 0.8.7__tar.gz → 0.8.8__tar.gz

{lionagi-0.8.7 → lionagi-0.8.8}/PKG-INFO

@@ -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 → lionagi-0.8.8}/README.md

@@ -25,11 +25,14 @@ pip install lionagi
 ```
 
 Dependencies:
-	•	litellm
+	•	aiocahce
+  •	aiohttp
 	•	jinja2
 	•	pandas
 	•	pillow
+  •	pydantic
 	•	python-dotenv
+  •	tiktoken
 
 ## Quick Start
 ```python

{lionagi-0.8.7 → lionagi-0.8.8}/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-0.8.7 → lionagi-0.8.8}/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-0.8.7 → lionagi-0.8.8}/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-0.8.7 → lionagi-0.8.8}/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-0.8.7 → lionagi-0.8.8}/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-0.8.7 → lionagi-0.8.8}/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-0.8.7 → lionagi-0.8.8}/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-0.8.7/lionagi/tools → lionagi-0.8.8/lionagi/tools/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-0.8.8/lionagi/tools/types.py

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

lionagi-0.8.8/lionagi/version.py

@@ -0,0 +1 @@
+__version__ = "0.8.8"

{lionagi-0.8.7 → lionagi-0.8.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lionagi"
-version = "0.8.7"
+version = "0.8.8"
 description = "An Intelligence Operating System."
 authors = [
     { name = "HaiyangLi", email = "quantocean.li@gmail.com" },
@@ -11,11 +11,11 @@ dependencies = [
     "aiocache>=0.12.0",
     "aiohttp>=3.11.0",
     "jinja2>=3.1.0",
-    "litellm>=1.55.3",
     "pandas>=2.0.0",
     "pillow>=10.0.0",
     "pydantic>=2.0.0",
     "python-dotenv>=1.0.1",
+    "tiktoken>=0.8.0",
 ]
 license = {file = "LICENSE"}
 classifiers=[
@@ -49,6 +49,7 @@ dev = [
 ]
 tools = [
     "docling>=2.15.1",
+    "litellm>=1.59.5",
 ]
 
 [tool.black]