liteai-sdk 0.3.11__tar.gz

liteai_sdk-0.3.11/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BHznJNs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

liteai_sdk-0.3.11/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: liteai_sdk
+Version: 0.3.11
+Summary: A wrapper of LiteLLM
+Author-email: BHznJNs <bhznjns@outlook.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+License-File: LICENSE
+Requires-Dist: litellm>=1.80.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.2.1 ; extra == "dev"
+Requires-Dist: pytest-cov ; extra == "test"
+Requires-Dist: pytest-mock ; extra == "test"
+Requires-Dist: pytest-runner ; extra == "test"
+Requires-Dist: pytest ; extra == "test"
+Requires-Dist: pytest-github-actions-annotate-failures ; extra == "test"
+Project-URL: Source, https://github.com/BHznJNs/liteai
+Project-URL: Tracker, https://github.com/BHznJNs/liteai/issues
+Provides-Extra: dev
+Provides-Extra: test
+
+# LiteAI-SDK
+
+LiteAI-SDK is a wrapper of LiteLLM which provides a more intuitive API and [AI SDK](https://github.com/vercel/ai) like DX.
+
+## Installation
+
+```
+pip install liteai-sdk
+```
+
+### Develop with coding agent
+
+You can access the complete usage guidance with [llms.txt](https://raw.githubusercontent.com/BHznJNs/liteai/refs/heads/main/llms.txt), just give it to your coding agent to tell it how to use LiteAI-SDK.
+
+## Examples
+
+Below is a simple example of just a API call:
+
+```python
+import os
+from dotenv import load_dotenv
+from liteai_sdk import LLM, LlmProviders, LlmRequestParams, UserMessage
+
+load_dotenv()
+
+llm = LLM(provider=LlmProviders.OPENAI,
+          api_key=os.getenv("API_KEY", ""),
+          base_url=os.getenv("BASE_URL", ""))
+
+response = llm.generate_text_sync( # sync API of generate_text
+    LlmRequestParams(
+        model="deepseek-v3.1",
+        messages=[UserMessage(content="Hello.")]))
+print(response)
+```
+
+Below is an example that shows the automatically tool call:
+
+```python
+import os
+from dotenv import load_dotenv
+from liteai_sdk import LLM, LlmProviders, LlmRequestParams, UserMessage
+
+load_dotenv()
+
+def example_tool():
+    """
+    This is a test tool that is used to test the tool calling functionality.
+    """
+    print("The example tool is called.")
+    return "Hello World"
+
+llm = LLM(provider=LlmProviders.OPENAI,
+          api_key=os.getenv("API_KEY", ""),
+          base_url=os.getenv("BASE_URL", ""))
+
+params = LlmRequestParams(
+        model="deepseek-v3.1",
+        tools=[example_tool],
+        execute_tools=True,
+        messages=[UserMessage(content="Please call the tool example_tool.")])
+
+print("User: ", "Please call the tool example_tool.")
+messages = llm.generate_text_sync(params)
+for message in messages:
+    match message.role:
+        case "assistant":
+            print("Assistant: ", message.content)
+        case "tool":
+            print("Tool: ", message.result)
+```
+

liteai_sdk-0.3.11/README.md

@@ -0,0 +1,71 @@
+# LiteAI-SDK
+
+LiteAI-SDK is a wrapper of LiteLLM which provides a more intuitive API and [AI SDK](https://github.com/vercel/ai) like DX.
+
+## Installation
+
+```
+pip install liteai-sdk
+```
+
+### Develop with coding agent
+
+You can access the complete usage guidance with [llms.txt](https://raw.githubusercontent.com/BHznJNs/liteai/refs/heads/main/llms.txt), just give it to your coding agent to tell it how to use LiteAI-SDK.
+
+## Examples
+
+Below is a simple example of just a API call:
+
+```python
+import os
+from dotenv import load_dotenv
+from liteai_sdk import LLM, LlmProviders, LlmRequestParams, UserMessage
+
+load_dotenv()
+
+llm = LLM(provider=LlmProviders.OPENAI,
+          api_key=os.getenv("API_KEY", ""),
+          base_url=os.getenv("BASE_URL", ""))
+
+response = llm.generate_text_sync( # sync API of generate_text
+    LlmRequestParams(
+        model="deepseek-v3.1",
+        messages=[UserMessage(content="Hello.")]))
+print(response)
+```
+
+Below is an example that shows the automatically tool call:
+
+```python
+import os
+from dotenv import load_dotenv
+from liteai_sdk import LLM, LlmProviders, LlmRequestParams, UserMessage
+
+load_dotenv()
+
+def example_tool():
+    """
+    This is a test tool that is used to test the tool calling functionality.
+    """
+    print("The example tool is called.")
+    return "Hello World"
+
+llm = LLM(provider=LlmProviders.OPENAI,
+          api_key=os.getenv("API_KEY", ""),
+          base_url=os.getenv("BASE_URL", ""))
+
+params = LlmRequestParams(
+        model="deepseek-v3.1",
+        tools=[example_tool],
+        execute_tools=True,
+        messages=[UserMessage(content="Please call the tool example_tool.")])
+
+print("User: ", "Please call the tool example_tool.")
+messages = llm.generate_text_sync(params)
+for message in messages:
+    match message.role:
+        case "assistant":
+            print("Assistant: ", message.content)
+        case "tool":
+            print("Tool: ", message.result)
+```

liteai_sdk-0.3.11/pyproject.toml

@@ -0,0 +1,231 @@
+[build-system]
+requires = ["flit_core >=2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "liteai_sdk"
+authors = [{ name = "BHznJNs", email = "bhznjns@outlook.com" }]
+description = "A wrapper of LiteLLM"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+requires-python = ">=3.10"
+version = "0.3.11"
+
+dependencies = [
+    "litellm>=1.80.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "python-dotenv>=1.2.1"
+]
+test = [
+    "pytest-cov",
+    "pytest-mock",
+    "pytest-runner",
+    "pytest",
+    "pytest-github-actions-annotate-failures",
+]
+
+[project.urls]
+Source = "https://github.com/BHznJNs/liteai"
+Tracker = "https://github.com/BHznJNs/liteai/issues"
+
+[tool.flit.module]
+name = "liteai_sdk"
+
+[tool.bandit]
+exclude_dirs = ["build", "dist", "tests", "scripts"]
+number = 4
+recursive = true
+targets = "src"
+
+[tool.black]
+line-length = 120
+fast = true
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.report]
+fail_under = 100
+
+[tool.flake8]
+max-line-length = 120
+select = "F,E,W,B,B901,B902,B903"
+exclude = [
+    ".eggs",
+    ".git",
+    ".tox",
+    "nssm",
+    "obj",
+    "out",
+    "packages",
+    "pywin32",
+    "tests",
+    "swagger_client",
+]
+ignore = ["E722", "B001", "W503", "E203"]
+
+[tool.pyright]
+include = ["src"]
+exclude = ["**/node_modules", "**/__pycache__"]
+venv = "env37"
+
+reportMissingImports = true
+reportMissingTypeStubs = false
+
+pythonVersion = "3.10"
+pythonPlatform = "Linux"
+
+executionEnvironments = [{ root = "src" }]
+
+[tool.pytest.ini_options]
+addopts = "--cov-report xml:coverage.xml --cov src --cov-fail-under 0 --cov-append -m 'not integration'"
+pythonpath = ["src"]
+testpaths = "tests"
+junit_family = "xunit2"
+markers = [
+    "integration: marks as integration test",
+    "notebooks: marks as notebook test",
+    "gpu: marks as gpu test",
+    "spark: marks tests which need Spark",
+    "slow: marks tests as slow",
+    "unit: fast offline tests",
+]
+
+[tool.pylint]
+extension-pkg-whitelist = [
+    "numpy",
+    "torch",
+    "cv2",
+    "pyodbc",
+    "pydantic",
+    "ciso8601",
+    "netcdf4",
+    "scipy",
+]
+ignore = "CVS"
+ignore-patterns = "test.*?py,conftest.py"
+init-hook = 'import sys; sys.setrecursionlimit(8 * sys.getrecursionlimit())'
+jobs = 0
+limit-inference-results = 100
+persistent = "yes"
+suggestion-mode = "yes"
+unsafe-load-any-extension = "no"
+
+[tool.pylint.'MESSAGES CONTROL']
+enable = "c-extension-no-member"
+
+[tool.pylint.'REPORTS']
+evaluation = "10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)"
+output-format = "text"
+reports = "no"
+score = "yes"
+
+[tool.pylint.'REFACTORING']
+max-nested-blocks = 5
+never-returning-functions = "sys.exit"
+
+[tool.pylint.'BASIC']
+argument-naming-style = "snake_case"
+attr-naming-style = "snake_case"
+bad-names = ["foo", "bar"]
+class-attribute-naming-style = "any"
+class-naming-style = "PascalCase"
+const-naming-style = "UPPER_CASE"
+docstring-min-length = -1
+function-naming-style = "snake_case"
+good-names = ["i", "j", "k", "ex", "Run", "_"]
+include-naming-hint = "yes"
+inlinevar-naming-style = "any"
+method-naming-style = "snake_case"
+module-naming-style = "any"
+no-docstring-rgx = "^_"
+property-classes = "abc.abstractproperty"
+variable-naming-style = "snake_case"
+
+[tool.pylint.'FORMAT']
+ignore-long-lines = "^\\s*(# )?.*['\"]?<?https?://\\S+>?"
+indent-after-paren = 4
+indent-string = '    '
+max-line-length = 120
+max-module-lines = 1000
+single-line-class-stmt = "no"
+single-line-if-stmt = "no"
+
+[tool.pylint.'LOGGING']
+logging-format-style = "old"
+logging-modules = "logging"
+
+[tool.pylint.'MISCELLANEOUS']
+notes = ["FIXME", "XXX", "TODO"]
+
+[tool.pylint.'SIMILARITIES']
+ignore-comments = "yes"
+ignore-docstrings = "yes"
+ignore-imports = "yes"
+min-similarity-lines = 7
+
+[tool.pylint.'SPELLING']
+max-spelling-suggestions = 4
+spelling-store-unknown-words = "no"
+
+[tool.pylint.'STRING']
+check-str-concat-over-line-jumps = "no"
+
+[tool.pylint.'TYPECHECK']
+contextmanager-decorators = "contextlib.contextmanager"
+generated-members = "numpy.*,np.*,pyspark.sql.functions,collect_list"
+ignore-mixin-members = "yes"
+ignore-none = "yes"
+ignore-on-opaque-inference = "yes"
+ignored-classes = "optparse.Values,thread._local,_thread._local,numpy,torch,swagger_client"
+ignored-modules = "numpy,torch,swagger_client,netCDF4,scipy"
+missing-member-hint = "yes"
+missing-member-hint-distance = 1
+missing-member-max-choices = 1
+
+[tool.pylint.'VARIABLES']
+additional-builtins = "dbutils"
+allow-global-unused-variables = "yes"
+callbacks = ["cb_", "_cb"]
+dummy-variables-rgx = "_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_"
+ignored-argument-names = "_.*|^ignored_|^unused_"
+init-import = "no"
+redefining-builtins-modules = "six.moves,past.builtins,future.builtins,builtins,io"
+
+[tool.pylint.'CLASSES']
+defining-attr-methods = ["__init__", "__new__", "setUp", "__post_init__"]
+exclude-protected = ["_asdict", "_fields", "_replace", "_source", "_make"]
+valid-classmethod-first-arg = "cls"
+valid-metaclass-classmethod-first-arg = "cls"
+
+[tool.pylint.'DESIGN']
+max-args = 5
+max-attributes = 7
+max-bool-expr = 5
+max-branches = 12
+max-locals = 15
+max-parents = 7
+max-public-methods = 20
+max-returns = 6
+max-statements = 50
+min-public-methods = 2
+
+[tool.pylint.'IMPORTS']
+allow-wildcard-with-all = "no"
+analyse-fallback-blocks = "no"
+deprecated-modules = "optparse,tkinter.tix"
+
+[tool.pylint.'EXCEPTIONS']
+overgeneral-exceptions = ["BaseException", "Exception"]

liteai_sdk-0.3.11/src/liteai_sdk/__init__.py

@@ -0,0 +1,260 @@
+import asyncio
+import queue
+from typing import cast
+from collections.abc import AsyncGenerator, Generator
+from litellm import ChatCompletionAssistantToolCall, CustomStreamWrapper, completion, acompletion
+from litellm.exceptions import (  
+    AuthenticationError,
+    PermissionDeniedError,
+    RateLimitError,
+    ContextWindowExceededError,
+    BadRequestError,
+    InvalidRequestError,
+    InternalServerError,
+    ServiceUnavailableError,
+    ContentPolicyViolationError,
+    APIError,
+    Timeout,
+)
+from litellm.utils import get_valid_models
+from litellm.types.utils import LlmProviders,\
+                                ModelResponse as LiteLlmModelResponse,\
+                                ModelResponseStream as LiteLlmModelResponseStream,\
+                                Choices as LiteLlmModelResponseChoices
+from .debug import enable_debugging
+from .param_parser import ParamParser
+from .stream import AssistantMessageCollector
+from .tool import ToolFn, ToolDef, RawToolDef, prepare_tools
+from .tool.execute import execute_tool_sync, execute_tool, parse_arguments
+from .tool.utils import filter_executable_tools, find_tool_by_name
+from .types import LlmRequestParams, GenerateTextResponse, StreamTextResponseSync, StreamTextResponseAsync
+from .types.exceptions import *
+from .types.message import ChatMessage, UserMessage, SystemMessage, AssistantMessage, ToolMessage,\
+                           MessageChunk, TextChunk, ReasoningChunk, AudioChunk, ImageChunk, ToolCallChunk,\
+                           openai_chunk_normalizer
+
+class LLM:
+    """
+    The `stream_text` API will returns ToolMessage in the queue only if `params.execute_tools` is True.
+
+    Possible exceptions raises for `generate_text` and `stream_text`:
+        - AuthenticationError
+        - PermissionDeniedError
+        - RateLimitError
+        - ContextWindowExceededError
+        - BadRequestError
+        - InvalidRequestError
+        - InternalServerError
+        - ServiceUnavailableError
+        - ContentPolicyViolationError
+
+        - APIError
+        - Timeout
+    """
+
+    def __init__(self,
+                 provider: LlmProviders,
+                 base_url: str,
+                 api_key: str):
+        self.provider = provider
+        self.base_url = base_url
+        self.api_key = api_key
+        self._param_parser = ParamParser(self.provider, self.base_url, self.api_key)
+
+    @staticmethod
+    def _should_resolve_tool_calls(
+            params: LlmRequestParams,
+            message: AssistantMessage,
+            ) -> tuple[list[ToolFn | ToolDef | RawToolDef],
+                       list[ChatCompletionAssistantToolCall]] | None:
+        message.tool_calls
+        condition = params.execute_tools and\
+                    params.tools is not None and\
+                    message.tool_calls is not None
+        if condition:
+            assert params.tools is not None
+            assert message.tool_calls is not None
+            return params.tools, message.tool_calls
+        return None
+    
+    @staticmethod
+    def _parse_tool_call(tool_call: ChatCompletionAssistantToolCall) -> tuple[str, str, str] | None:
+        id = tool_call.get("id")
+        function = tool_call.get("function")
+        function_name = function.get("name")
+        function_arguments = function.get("arguments")
+        if id is None or\
+           function is None or\
+           function_name is None or\
+           function_arguments is None: return None
+        return id, function_name, function_arguments
+
+    @staticmethod
+    async def _execute_tool_calls(
+        tools: list[ToolFn | ToolDef | RawToolDef],
+        tool_calls: list[ChatCompletionAssistantToolCall]
+        ) -> list[ToolMessage]:
+        executable_tools = filter_executable_tools(tools)
+        results = []
+        for tool_call in tool_calls:
+            if (tool_call_data := LLM._parse_tool_call(tool_call)) is None: continue
+            id, function_name, function_arguments = tool_call_data
+            if (target_tool := find_tool_by_name(cast(list, executable_tools), function_name)) is None: continue
+            parsed_arguments = parse_arguments(function_arguments)
+            result, error = None, None
+
+            try:
+                result = await execute_tool(target_tool, parsed_arguments)
+            except Exception as e:
+                error = f"{type(e).__name__}: {str(e)}"
+            results.append(ToolMessage(
+                id=id,
+                name=function_name,
+                arguments=parsed_arguments,
+                result=result,
+                error=error))
+        return results
+
+    @staticmethod
+    def _execute_tool_calls_sync(
+        tools: list[ToolFn | ToolDef | RawToolDef],
+        tool_calls: list[ChatCompletionAssistantToolCall]
+        ) -> list[ToolMessage]:
+        executable_tools = filter_executable_tools(tools)
+        results = []
+        for tool_call in tool_calls:
+            if (tool_call_data := LLM._parse_tool_call(tool_call)) is None: continue
+            id, function_name, function_arguments = tool_call_data
+            if (target_tool := find_tool_by_name(cast(list, executable_tools), function_name)) is None: continue
+            parsed_arguments = parse_arguments(function_arguments)
+            
+            result, error = None, None
+            try:
+                result = execute_tool_sync(target_tool, parsed_arguments)
+            except Exception as e:
+                error = f"{type(e).__name__}: {str(e)}"
+            results.append(ToolMessage(
+                id=id,
+                name=function_name,
+                arguments=parsed_arguments,
+                result=result,
+                error=error))
+        return results
+
+    def list_models(self) -> list[str]:
+        return get_valid_models(
+            custom_llm_provider=self.provider.value,
+            check_provider_endpoint=True,
+            api_base=self.base_url,
+            api_key=self.api_key)
+
+    def generate_text_sync(self, params: LlmRequestParams):
+        response = completion(**self._param_parser.parse_nonstream(params))
+        response = cast(LiteLlmModelResponse, response)
+        choices = cast(list[LiteLlmModelResponseChoices], response.choices)
+        message = choices[0].message
+        assistant_message = AssistantMessage.from_litellm_message(message)
+        result: GenerateTextResponse = [assistant_message]
+        if (tools_and_tool_calls := self._should_resolve_tool_calls(params, assistant_message)):
+            tools, tool_calls = tools_and_tool_calls
+            result += self._execute_tool_calls_sync(tools, tool_calls)
+        return result
+
+    async def generate_text(self, params: LlmRequestParams) -> GenerateTextResponse:
+        response = await acompletion(**self._param_parser.parse_nonstream(params))
+        response = cast(LiteLlmModelResponse, response)
+        choices = cast(list[LiteLlmModelResponseChoices], response.choices)
+        message = choices[0].message
+        assistant_message = AssistantMessage.from_litellm_message(message)
+        result: GenerateTextResponse = [assistant_message]
+        if (tools_and_tool_calls := self._should_resolve_tool_calls(params, assistant_message)):
+            tools, tool_calls = tools_and_tool_calls
+            result += await self._execute_tool_calls(tools, tool_calls)
+        return result
+
+    def stream_text_sync(self, params: LlmRequestParams) -> StreamTextResponseSync:
+        def stream(response: CustomStreamWrapper) -> Generator[MessageChunk]:
+            nonlocal message_collector
+            for chunk in response:
+                chunk = cast(LiteLlmModelResponseStream, chunk)
+                yield from openai_chunk_normalizer(chunk)
+                message_collector.collect(chunk)
+
+            message = message_collector.get_message()
+            full_message_queue.put(message)
+            if (tools_and_tool_calls := self._should_resolve_tool_calls(params, message)):
+                tools, tool_calls = tools_and_tool_calls
+                tool_messages = self._execute_tool_calls_sync(tools, tool_calls)
+                for tool_message in tool_messages:
+                    full_message_queue.put(tool_message)
+            full_message_queue.put(None)
+
+        response = completion(**self._param_parser.parse_stream(params))
+        message_collector = AssistantMessageCollector()
+        returned_stream = stream(cast(CustomStreamWrapper, response))
+        full_message_queue = queue.Queue[AssistantMessage | ToolMessage | None]()
+        return returned_stream, full_message_queue
+
+    async def stream_text(self, params: LlmRequestParams) -> StreamTextResponseAsync:
+        async def stream(response: CustomStreamWrapper) -> AsyncGenerator[TextChunk | ReasoningChunk | AudioChunk | ImageChunk | ToolCallChunk]:
+            nonlocal message_collector
+            async for chunk in response:
+                chunk = cast(LiteLlmModelResponseStream, chunk)
+                for normalized_chunk in openai_chunk_normalizer(chunk):
+                    yield normalized_chunk
+                message_collector.collect(chunk)
+
+            message = message_collector.get_message()
+            await full_message_queue.put(message)
+            if (tools_and_tool_calls := self._should_resolve_tool_calls(params, message)):
+                tools, tool_calls = tools_and_tool_calls
+                tool_messages = await self._execute_tool_calls(tools, tool_calls)
+                for tool_message in tool_messages:
+                    await full_message_queue.put(tool_message)
+            await full_message_queue.put(None)
+
+        response = await acompletion(**self._param_parser.parse_stream(params))
+        message_collector = AssistantMessageCollector()
+        returned_stream = stream(cast(CustomStreamWrapper, response))
+        full_message_queue = asyncio.Queue[AssistantMessage | ToolMessage | None]()
+        return returned_stream, full_message_queue
+
+__all__ = [
+    # Exceptions
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "RateLimitError",
+    "ContextWindowExceededError",
+    "BadRequestError",
+    "InvalidRequestError",
+    "InternalServerError",
+    "ServiceUnavailableError",
+    "ContentPolicyViolationError",
+    "APIError",
+    "Timeout",
+
+    "enable_debugging",
+
+    "LLM",
+    "LlmRequestParams",
+    "ToolFn",
+    "ToolDef",
+    "RawToolDef",
+
+    "ChatMessage",
+    "UserMessage",
+    "SystemMessage",
+    "AssistantMessage",
+    "ToolMessage",
+
+    "MessageChunk",
+    "TextChunk",
+    "ReasoningChunk",
+    "AudioChunk",
+    "ImageChunk",
+    "ToolCallChunk",
+
+    "GenerateTextResponse",
+    "StreamTextResponseSync",
+    "StreamTextResponseAsync"
+]

liteai_sdk-0.3.11/src/liteai_sdk/debug.py

@@ -0,0 +1,4 @@
+import litellm
+
+def enable_debugging():
+    litellm._turn_on_debug()