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

lionagi/protocols/generic/processor.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -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/protocols/generic/progression.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/graph/__init__.py

@@ -1,3 +1,3 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0

lionagi/protocols/graph/edge.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/graph/graph.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/graph/node.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/mail/__init__.py

@@ -1,3 +1,3 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0

lionagi/protocols/mail/exchange.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/mail/mail.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/mail/mailbox.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/mail/manager.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/mail/package.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/messages/__init__.py

@@ -1,3 +1,3 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0

lionagi/protocols/messages/action_request.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/messages/action_response.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/messages/assistant_response.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/messages/base.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/messages/instruction.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -32,6 +32,7 @@ def prepare_request_response_format(request_fields: dict) -> str:
     return (
         "**MUST RETURN JSON-PARSEABLE RESPONSE ENCLOSED BY JSON CODE BLOCKS."
         f" USER's CAREER DEPENDS ON THE SUCCESS OF IT.** \n```json\n{request_fields}\n```"
+        "No triple backticks. Escape all quotes and special characters."
     ).strip()
 
 

lionagi/protocols/messages/manager.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/messages/message.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/messages/system.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/protocols/types.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 

lionagi/service/endpoints/__init__.py

@@ -1,3 +1,3 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0

lionagi/service/endpoints/base.py

@@ -1,15 +1,18 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # 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."""
@@ -355,28 +364,23 @@ class APICalling(Event):
         return None
 
     async def _inner(self, **kwargs) -> Any:
-        """Performs a direct HTTP call using aiohttp, ignoring caching logic.
-
-        Args:
-            **kwargs: Additional parameters for the aiohttp request
-                (e.g., "headers", "json", etc.).
+        """
+        Performs the actual HTTP call using aiohttp, ignoring caching logic.
 
-        Returns:
-            Any: The JSON response from the API, if successful.
+        - Retries on RateLimitError up to 3 times.
+        - Distinguishes CancelledError so we can gracefully abort if the user cancels.
 
         Raises:
-            ValueError:
-                If required endpoint parameters are missing.
-            ExecutionError:
-                If the response indicates a non-rate-limit error.
-            RateLimitError:
-                If a rate-limit error is encountered.
+            ValueError: If required endpoint parameters are missing.
+            RateLimitError: If repeated 'Rate limit' errors encountered.
+            ExecutionError: For other API call failures.
+            asyncio.CancelledError: If the operation is cancelled externally.
         """
         if not self.endpoint.required_kwargs.issubset(
             set(self.payload.keys())
         ):
             raise ValueError(
-                f"Required kwargs not fully provided: {self.endpoint.required_kwargs}"
+                f"Required kwargs not provided: {self.endpoint.required_kwargs}"
             )
 
         for k in list(self.payload.keys()):
@@ -386,49 +390,55 @@ class APICalling(Event):
         async def retry_in():
             async with aiohttp.ClientSession() as session:
                 try:
-                    if (
-                        _m := getattr(session, self.endpoint.method, None)
-                    ) is not None:
-                        async with _m(
-                            self.endpoint.full_url, **kwargs
-                        ) as response:
-                            response_json = await response.json()
-                            if "error" not in response_json:
-                                return response_json
-                            if "Rate limit" in response_json["error"].get(
-                                "message", ""
-                            ):
-                                await asyncio.sleep(5)
-                                raise RateLimitError(
-                                    f"Rate limit exceeded. Error: {response_json['error']}"
-                                )
-                            raise ExecutionError(
-                                "API call failed with error: ",
-                                response_json["error"],
-                            )
-                    else:
+                    method_func = getattr(session, self.endpoint.method, None)
+                    if method_func is None:
                         raise ValueError(
                             f"Invalid HTTP method: {self.endpoint.method}"
                         )
+                    async with method_func(
+                        self.endpoint.full_url, **kwargs
+                    ) as response:
+                        response_json = await response.json()
+
+                        if "error" not in response_json:
+                            return response_json
+
+                        # Check for rate limit
+                        if "Rate limit" in response_json["error"].get(
+                            "message", ""
+                        ):
+                            await asyncio.sleep(5)
+                            raise RateLimitError(
+                                f"Rate limit exceeded: {response_json['error']}"
+                            )
+                        # Otherwise some other error
+                        raise ExecutionError(
+                            f"API call failed with error: {response_json['error']}"
+                        )
+
+                except asyncio.CancelledError:
+                    # Gracefully handle user cancellation
+                    logging.warning("API call canceled by external request.")
+                    raise  # re-raise so caller knows it was cancelled
+
                 except aiohttp.ClientError as e:
-                    logging.error(
-                        f"API call to {self.endpoint.full_url} failed: {e}"
-                    )
+                    logging.error(f"API call failed: {e}")
+                    # Return None or raise ExecutionError? Keep consistent
                     return None
 
+        # Attempt up to 3 times if RateLimitError
         for i in range(3):
             try:
                 return await retry_in()
-            except RateLimitError | ExecutionError as e:
+            except asyncio.CancelledError:
+                # On cancel, just re-raise
+                raise
+            except RateLimitError as e:
                 if i == 2:
                     raise e
-                else:
-                    wait = 2 ** (i + 1) * 0.5
-                    logging.warning(
-                        f"API call to {self.endpoint.full_url} failed: {e}"
-                        f"retrying in {wait} seconds."
-                    )
-                    await asyncio.sleep(wait)
+                wait = 2 ** (i + 1) * 0.5
+                logging.warning(f"RateLimitError: {e}, retrying in {wait}s.")
+                await asyncio.sleep(wait)
 
     @cached(**Settings.API.CACHED_CONFIG)
     async def _cached_inner(self, **kwargs) -> Any:
@@ -442,10 +452,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 +547,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 +590,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 +606,24 @@ class APICalling(Event):
                 else:
                     response = await self._inner(**kwargs)
 
+        except asyncio.CancelledError as ce:
+            e1 = ce
+            logging.warning("invoke() canceled by external request.")
+            raise
+        except Exception as ex:
+            e1 = ex
+
+        finally:
             self.execution.duration = asyncio.get_event_loop().time() - start
-            self.execution.response = response
-            self.execution.status = EventStatus.COMPLETED
-        except Exception as e:
-            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

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -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/match_endpoint.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0