liteai-sdk 0.3.2__tar.gz

liteai_sdk-0.3.2/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.2/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: liteai_sdk
+Version: 0.3.2
+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("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("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.2/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("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("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.2/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.2"
+
+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.2/src/liteai_sdk/__init__.py

@@ -0,0 +1,220 @@
+import asyncio
+import json
+import queue
+from typing import cast
+from collections.abc import AsyncGenerator, Generator
+from litellm import ChatCompletionAssistantToolCall, CustomStreamWrapper, completion, acompletion
+from litellm.utils import get_valid_models
+from litellm.types.utils import LlmProviders,\
+                                ModelResponse as LiteLlmModelResponse,\
+                                ModelResponseStream as LiteLlmModelResponseStream,\
+                                Choices as LiteLlmModelResponseChoices
+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.message import ChatMessage, AssistantMessageChunk, UserMessage, SystemMessage, AssistantMessage, ToolMessage
+
+class LLM:
+    def __init__(self,
+                 provider: LlmProviders,
+                 base_url: str,
+                 api_key: str):
+        self.provider = provider
+        self.base_url = base_url
+        self.api_key = api_key
+
+    def _parse_params_nonstream(self, params: LlmRequestParams):
+        tools = params.tools and prepare_tools(params.tools)
+        return {
+            "model": f"{self.provider.value}/{params.model}",
+            "messages": [message.to_litellm_message() for message in params.messages],
+            "base_url": self.base_url,
+            "api_key": self.api_key,
+            "tools": tools,
+            "tool_choice": params.tool_choice,
+            "stream": False,
+            "timeout": params.timeout_sec,
+            "extra_headers": params.headers,
+            **(params.extra_args or {})
+        }
+
+    def _parse_params_stream(self, params: LlmRequestParams):
+        tools = params.tools and prepare_tools(params.tools)
+        return {
+            "model": f"{self.provider.value}/{params.model}",
+            "messages": [message.to_litellm_message() for message in params.messages],
+            "base_url": self.base_url,
+            "api_key": self.api_key,
+            "tools": tools,
+            "tool_choice": params.tool_choice,
+            "stream": True,
+            "timeout": params.timeout_sec,
+            "extra_headers": params.headers,
+            **(params.extra_args or {})
+        }
+
+    @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)
+        result = []
+        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)
+            ret = await execute_tool(target_tool, parsed_arguments)
+            result.append(ToolMessage(
+                id=id,
+                name=function_name,
+                arguments=parsed_arguments,
+                result=ret))
+        return result
+
+    @staticmethod
+    def _execute_tool_calls_sync(
+        tools: list[ToolFn | ToolDef | RawToolDef],
+        tool_calls: list[ChatCompletionAssistantToolCall]
+        ) -> list[ToolMessage]:
+        executable_tools = filter_executable_tools(tools)
+        result = []
+        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)
+            ret = execute_tool_sync(target_tool, parsed_arguments)
+            result.append(ToolMessage(
+                id=id,
+                name=function_name,
+                arguments=parsed_arguments,
+                result=ret))
+        return result
+
+    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._parse_params_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._parse_params_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[AssistantMessageChunk]:
+            nonlocal message_collector
+            for chunk in response:
+                chunk = cast(LiteLlmModelResponseStream, chunk)
+                yield AssistantMessageChunk.from_litellm_chunk(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._parse_params_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[AssistantMessageChunk]:
+            nonlocal message_collector
+            async for chunk in response:
+                chunk = cast(LiteLlmModelResponseStream, chunk)
+                yield AssistantMessageChunk.from_litellm_chunk(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._parse_params_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__ = [
+    "LLM",
+    "LlmRequestParams",
+    "ToolFn",
+    "ToolDef",
+    "RawToolDef",
+
+    "ChatMessage",
+    "UserMessage",
+    "SystemMessage",
+    "AssistantMessage",
+    "ToolMessage",
+    "AssistantMessageChunk",
+
+    "GenerateTextResponse",
+    "StreamTextResponseSync",
+    "StreamTextResponseAsync"
+]

liteai_sdk-0.3.2/src/liteai_sdk/stream.py

@@ -0,0 +1,79 @@
+import dataclasses
+from litellm import ChatCompletionAssistantToolCall
+from litellm.types.utils import ChatCompletionDeltaToolCall,\
+                                ModelResponseStream as LiteLlmModelResponseStream
+from .types.message import AssistantMessage
+
+@dataclasses.dataclass
+class ToolCallTemp:
+    id: str | None = None
+    name: str = ""
+    arguments: str = ""
+
+class ToolCallCollector:
+    def __init__(self):
+        self.tool_call_buf: list[ToolCallTemp] = []
+        self._max_index = 0
+
+    def collect(self, tool_call_chunk: ChatCompletionDeltaToolCall):
+        if tool_call_chunk.index >= self._max_index:
+            self._max_index = tool_call_chunk.index
+            self.tool_call_buf.append(ToolCallTemp())
+
+        temp_tool_call = self.tool_call_buf[tool_call_chunk.index]
+        if tool_call_chunk.get("id"):
+            temp_tool_call.id = tool_call_chunk.id
+        if tool_call_chunk.function.get("name"):
+            assert tool_call_chunk.function.name is not None
+            temp_tool_call.name += tool_call_chunk.function.name
+        if tool_call_chunk.function.get("arguments"):
+            assert tool_call_chunk.function.arguments is not None
+            temp_tool_call.arguments += tool_call_chunk.function.arguments
+
+    def get_tool_calls(self) -> list[ChatCompletionAssistantToolCall]:
+        return [{
+            "id": tool_call.id,
+            "function": {
+                "name": tool_call.name,
+                "arguments": tool_call.arguments,
+            },
+            "type": "function"
+        } for tool_call in self.tool_call_buf]
+
+class AssistantMessageCollector:
+    def __init__(self):
+        self.message_buf = AssistantMessage(None)
+        self.tool_call_collector = ToolCallCollector()
+
+    def collect(self, chunk: LiteLlmModelResponseStream):
+        delta = chunk.choices[0].delta
+        if delta.get("content"):
+            assert delta.content is not None
+            if self.message_buf.content is None:
+                self.message_buf.content = ""
+            self.message_buf.content += delta.content
+
+        if delta.get("reasoning_content"):
+            assert delta.reasoning_content is not None
+            if self.message_buf.reasoning_content is None:
+                self.message_buf.reasoning_content = ""
+            self.message_buf.reasoning_content += delta.reasoning_content
+
+        if delta.get("tool_calls"):
+            assert delta.tool_calls is not None
+            for tool_call_chunk in delta.tool_calls:
+                self.tool_call_collector.collect(tool_call_chunk)
+        
+        if delta.get("images"):
+            assert delta.images is not None
+            if self.message_buf.images is None:
+                self.message_buf.images = []
+            self.message_buf.images = delta.images
+        
+        if delta.get("audio"):
+            assert delta.audio is not None
+            self.message_buf.audio = delta.audio
+
+    def get_message(self) -> AssistantMessage:
+        self.message_buf.tool_calls = self.tool_call_collector.get_tool_calls()
+        return self.message_buf

liteai_sdk-0.3.2/src/liteai_sdk/tool/__init__.py

@@ -0,0 +1,307 @@
+"""
+source: https://github.com/mozilla-ai/any-llm/blob/main/src/any_llm/tools.py
+"""
+
+import dataclasses
+import enum
+import inspect
+import types as _types
+from collections.abc import Callable, Mapping, Sequence
+from datetime import date, datetime, time
+from typing import Annotated as _Annotated, Literal as _Literal, is_typeddict as _is_typeddict,\
+                   Any, Awaitable, get_args, get_origin, get_type_hints
+from pydantic import BaseModel as PydanticBaseModel
+
+ToolFn = Callable[..., Any] | Callable[..., Awaitable[Any]]
+"""
+RawToolDef example:
+{
+    "name": "get_current_weather",
+    "description": "Get the current weather in a given location",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "location": {
+                "type": "string",
+                "description": "The city and state, e.g. San Francisco, CA",
+            },
+            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+        },
+        "required": ["location"],
+    }
+}
+"""
+RawToolDef = dict[str, Any]
+
+@dataclasses.dataclass
+class ToolDef:
+    name: str
+    description: str
+    execute: ToolFn
+
+def _python_type_to_json_schema(python_type: Any) -> dict[str, Any]:
+    """Convert Python type annotation to a JSON Schema for a parameter.
+
+    Supported mappings (subset tailored for LLM tool schemas):
+    - Primitives: str/int/float/bool -> string/integer/number/boolean
+    - bytes -> string with contentEncoding base64
+    - datetime/date/time -> string with format date-time/date/time
+    - list[T] / Sequence[T] / set[T] / frozenset[T] -> array with items=schema(T)
+      - set/frozenset include uniqueItems=true
+      - list without type args defaults items to string
+    - dict[K,V] / Mapping[K,V] -> object with additionalProperties=schema(V)
+      - dict without type args defaults additionalProperties to string
+    - tuple[T1, T2, ...] -> array with prefixItems per element and min/maxItems
+    - tuple[T, ...] -> array with items=schema(T)
+    - Union[X, Y] and X | Y -> oneOf=[schema(X), schema(Y)] (without top-level type)
+    - Optional[T] (Union[T, None]) -> schema(T) (nullability not encoded)
+    - Literal[...]/Enum -> enum with appropriate type inference when uniform
+    - TypedDict -> object with properties/required per annotations
+    - dataclass/Pydantic BaseModel -> object with nested properties inferred from fields
+    """
+    origin = get_origin(python_type)
+    args = get_args(python_type)
+
+    if _Annotated is not None and origin is _Annotated and len(args) >= 1:
+        python_type = args[0]
+        origin = get_origin(python_type)
+        args = get_args(python_type)
+
+    if python_type is Any:
+        return {"type": "string"}
+
+    primitive_map = {str: "string", int: "integer", float: "number", bool: "boolean"}
+    if python_type in primitive_map:
+        return {"type": primitive_map[python_type]}
+
+    if python_type is bytes:
+        return {"type": "string", "contentEncoding": "base64"}
+    if python_type is datetime:
+        return {"type": "string", "format": "date-time"}
+    if python_type is date:
+        return {"type": "string", "format": "date"}
+    if python_type is time:
+        return {"type": "string", "format": "time"}
+
+    if python_type is list:
+        return {"type": "array", "items": {"type": "string"}}
+    if python_type is dict:
+        return {"type": "object", "additionalProperties": {"type": "string"}}
+
+    if origin is _Literal:
+        literal_values = list(args)
+        schema_lit: dict[str, Any] = {"enum": literal_values}
+        if all(isinstance(v, bool) for v in literal_values):
+            schema_lit["type"] = "boolean"
+        elif all(isinstance(v, str) for v in literal_values):
+            schema_lit["type"] = "string"
+        elif all(isinstance(v, int) and not isinstance(v, bool) for v in literal_values):
+            schema_lit["type"] = "integer"
+        elif all(isinstance(v, int | float) and not isinstance(v, bool) for v in literal_values):
+            schema_lit["type"] = "number"
+        return schema_lit
+
+    if inspect.isclass(python_type) and issubclass(python_type, enum.Enum):
+        enum_values = [e.value for e in python_type]
+        value_types = {type(v) for v in enum_values}
+        schema: dict[str, Any] = {"enum": enum_values}
+        if value_types == {str}:
+            schema["type"] = "string"
+        elif value_types == {int}:
+            schema["type"] = "integer"
+        elif value_types <= {int, float}:
+            schema["type"] = "number"
+        elif value_types == {bool}:
+            schema["type"] = "boolean"
+        return schema
+
+    if _is_typeddict(python_type):
+        annotations: dict[str, Any] = getattr(python_type, "__annotations__", {}) or {}
+        required_keys = set(getattr(python_type, "__required_keys__", set()))
+        td_properties: dict[str, Any] = {}
+        td_required: list[str] = []
+        for field_name, field_type in annotations.items():
+            td_properties[field_name] = _python_type_to_json_schema(field_type)
+            if field_name in required_keys:
+                td_required.append(field_name)
+        schema_td: dict[str, Any] = {
+            "type": "object",
+            "properties": td_properties,
+        }
+        if td_required:
+            schema_td["required"] = td_required
+        return schema_td
+
+    if inspect.isclass(python_type) and dataclasses.is_dataclass(python_type):
+        type_hints = get_type_hints(python_type)
+        dc_properties: dict[str, Any] = {}
+        dc_required: list[str] = []
+        for field in dataclasses.fields(python_type):
+            field_type = type_hints.get(field.name, Any)
+            dc_properties[field.name] = _python_type_to_json_schema(field_type)
+            if (
+                field.default is dataclasses.MISSING
+                and getattr(field, "default_factory", dataclasses.MISSING) is dataclasses.MISSING
+            ):
+                dc_required.append(field.name)
+        schema_dc: dict[str, Any] = {"type": "object", "properties": dc_properties}
+        if dc_required:
+            schema_dc["required"] = dc_required
+        return schema_dc
+
+    if inspect.isclass(python_type) and issubclass(python_type, PydanticBaseModel):
+        model_type_hints = get_type_hints(python_type)
+        pd_properties: dict[str, Any] = {}
+        pd_required: list[str] = []
+        model_fields = getattr(python_type, "model_fields", {})
+        for name, field_info in model_fields.items():
+            pd_properties[name] = _python_type_to_json_schema(model_type_hints.get(name, Any))
+            is_required = getattr(field_info, "is_required", None)
+            if callable(is_required) and is_required():
+                pd_required.append(name)
+        schema_pd: dict[str, Any] = {"type": "object", "properties": pd_properties}
+        if pd_required:
+            schema_pd["required"] = pd_required
+        return schema_pd
+
+    if origin in (list, Sequence, set, frozenset):
+        item_type = args[0] if args else Any
+        item_schema = _python_type_to_json_schema(item_type)
+        schema_arr: dict[str, Any] = {"type": "array", "items": item_schema or {"type": "string"}}
+        if origin in (set, frozenset):
+            schema_arr["uniqueItems"] = True
+        return schema_arr
+    if origin is tuple:
+        if not args:
+            return {"type": "array", "items": {"type": "string"}}
+        if len(args) == 2 and args[1] is Ellipsis:
+            return {"type": "array", "items": _python_type_to_json_schema(args[0])}
+        prefix_items = [_python_type_to_json_schema(a) for a in args]
+        return {
+            "type": "array",
+            "prefixItems": prefix_items,
+            "minItems": len(prefix_items),
+            "maxItems": len(prefix_items),
+        }
+
+    if origin in (dict, Mapping):
+        value_type = args[1] if len(args) >= 2 else Any
+        value_schema = _python_type_to_json_schema(value_type)
+        return {"type": "object", "additionalProperties": value_schema or {"type": "string"}}
+
+    typing_union = getattr(__import__("typing"), "Union", None)
+    if origin in (typing_union, _types.UnionType):
+        non_none_args = [a for a in args if a is not type(None)]
+        if len(non_none_args) > 1:
+            schemas = [_python_type_to_json_schema(arg) for arg in non_none_args]
+            return {"oneOf": schemas}
+        if non_none_args:
+            return _python_type_to_json_schema(non_none_args[0])
+        return {"type": "string"}
+
+    return {"type": "string"}
+
+def _parse_callable_properties(func: ToolFn) -> tuple[dict[str, dict[str, Any]], list[str]]:
+    sig = inspect.signature(func)
+    type_hints = get_type_hints(func)
+
+    properties: dict[str, dict[str, Any]] = {}
+    required: list[str] = []
+
+    for param_name, param in sig.parameters.items():
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            continue
+
+        annotated_type = type_hints.get(param_name, str)
+        param_schema = _python_type_to_json_schema(annotated_type)
+
+        type_name = getattr(annotated_type, "__name__", str(annotated_type))
+        properties[param_name] = {
+            **param_schema,
+            "description": f"Parameter {param_name} of type {type_name}",
+        }
+
+        if param.default == inspect.Parameter.empty:
+            required.append(param_name)
+
+    return properties, required
+
+def generate_tool_definition_from_callable(func: ToolFn) -> dict[str, Any]:
+    """Convert a Python callable to OpenAI tools format.
+
+    Args:
+        func: A Python callable (function) to convert to a tool
+
+    Returns:
+        Dictionary in OpenAI tools format
+
+    Raises:
+        ValueError: If the function doesn't have proper docstring or type annotations
+
+    Example:
+        >>> def get_weather(location: str, unit: str = "celsius") -> str:
+        ...     '''Get weather information for a location.'''
+        ...     return f"Weather in {location} is sunny, 25°{unit[0].upper()}"
+        >>>
+        >>> tool = generate_tool_definition_from_callable(get_weather)
+        >>> # Returns OpenAI tools format dict
+
+    """
+    if not func.__doc__:
+        msg = f"Function {func.__name__} must have a docstring"
+        raise ValueError(msg)
+
+    properties, required = _parse_callable_properties(func)
+    return {
+        "type": "function",
+        "function": {
+            "name": func.__name__,
+            "description": func.__doc__.strip(),
+            "parameters": {"type": "object", "properties": properties, "required": required},
+        },
+    }
+
+def generate_tool_definition_from_tool_def(tool_def: ToolDef) -> dict[str, Any]:
+    """Convert a ToolDef to OpenAI tools format.
+
+    Args:
+        tool_def: A ToolDef to convert to a tool
+
+    Returns:
+        Dictionary in OpenAI tools format
+
+    Example:
+        >>> tool_def = ToolDef(
+        ...     name="get_weather",
+        ...     description="Get weather information for a location.",
+        ...     execute=SomeFunction(),
+        ... )
+        >>> tool = generate_tool_definition_from_tool_def(tool_def)
+        >>> # Returns OpenAI tools format dict
+    """
+    properties, required = _parse_callable_properties(tool_def.execute)
+    return {
+        "type": "function",
+        "function": {
+            "name": tool_def.name,
+            "description": tool_def.description,
+            "parameters": {"type": "object", "properties": properties, "required": required},
+        },
+    }
+
+def generate_tool_definition_from_raw_tool_def(raw_tool_def: RawToolDef) -> dict[str, Any]:
+    return {
+        "type": "function",
+        "function": raw_tool_def,
+    }
+
+def prepare_tools(tools: list[ToolFn | ToolDef | RawToolDef]) -> list[dict]:
+    tool_defs = []
+    for tool in tools:
+        if callable(tool):
+            tool_defs.append(generate_tool_definition_from_callable(tool))
+        elif isinstance(tool, ToolDef):
+            tool_defs.append(generate_tool_definition_from_tool_def(tool))
+        else:
+            tool_defs.append(generate_tool_definition_from_raw_tool_def(tool))
+    return tool_defs

liteai_sdk-0.3.2/src/liteai_sdk/tool/execute.py

@@ -0,0 +1,59 @@
+import asyncio
+import json
+from functools import singledispatch
+from typing import Any, Awaitable, Callable, cast
+from types import FunctionType, CoroutineType
+from . import ToolDef
+
+async def _coroutine_wrapper(awaitable: Awaitable[Any]) -> CoroutineType:
+    return await awaitable
+
+def _arguments_normalizer(arguments: str | dict) -> dict:
+    if type(arguments) == str:
+        return parse_arguments(arguments)
+    elif type(arguments) == dict:
+        return arguments
+    else:
+        raise ValueError(f"Invalid arguments type: {type(arguments)}")
+
+def parse_arguments(arguments: str) -> dict:
+    args = json.loads(arguments)
+    return cast(dict, args)
+
+@singledispatch
+def execute_tool_sync(tool, arguments: str | dict) -> Any: pass
+
+@execute_tool_sync.register(FunctionType)
+def _(toolfn: Callable, arguments: str | dict) -> Any:
+    arguments = _arguments_normalizer(arguments)
+    if asyncio.iscoroutinefunction(toolfn):
+        return asyncio.run(
+            _coroutine_wrapper(
+                toolfn(**arguments)))
+    return toolfn(**arguments)
+
+@execute_tool_sync.register(ToolDef)
+def _(tooldef: ToolDef, arguments: str | dict):
+    arguments = _arguments_normalizer(arguments)
+    if asyncio.iscoroutinefunction(tooldef.execute):
+        return asyncio.run(
+            _coroutine_wrapper(
+                tooldef.execute(**arguments)))
+    return tooldef.execute(**arguments)
+
+@singledispatch
+async def execute_tool(tool, arguments: str | dict) -> Any: pass
+
+@execute_tool.register(FunctionType)
+async def _(toolfn: Callable, arguments: str | dict) -> Any:
+    arguments = _arguments_normalizer(arguments)
+    if asyncio.iscoroutinefunction(toolfn):
+        return await toolfn(**arguments)
+    return toolfn(**arguments)
+
+@execute_tool.register(ToolDef)
+async def _(tooldef: ToolDef, arguments: str | dict):
+    arguments = _arguments_normalizer(arguments)
+    if asyncio.iscoroutinefunction(tooldef.execute):
+        return await tooldef.execute(**arguments)
+    return tooldef.execute(**arguments)

liteai_sdk-0.3.2/src/liteai_sdk/tool/utils.py

@@ -0,0 +1,19 @@
+from typing import Any
+from . import ToolFn, ToolDef, RawToolDef
+
+def filter_executable_tools(tools: list[ToolFn | ToolDef | RawToolDef]) -> list[ToolFn | ToolDef]:
+    """
+    Since when we are going to execute the tools,
+    we do not care the raw tool definitions, they are usually the built-in tools from the provider.
+    """
+    return [tool for tool in tools if callable(tool) or isinstance(tool, ToolDef)]
+
+def find_tool_by_name(tools: list[ToolFn | ToolDef | RawToolDef], name: str) -> ToolFn | ToolDef | RawToolDef | None:
+    for tool in tools:
+        if callable(tool) and tool.__name__ == name:
+            return tool
+        elif isinstance(tool, ToolDef) and tool.name == name:
+            return tool
+        elif isinstance(tool, dict) and tool.get("function", {}).get("name") == name:
+            return tool
+    return None

liteai_sdk-0.3.2/src/liteai_sdk/types/__init__.py

@@ -0,0 +1,32 @@
+import asyncio
+import dataclasses
+import queue
+from typing import Any, Generator, Literal
+from collections.abc import AsyncGenerator, Generator
+from ..tool import ToolFn, ToolDef, RawToolDef
+from .message import AssistantMessageChunk, ChatMessage, AssistantMessage, ToolMessage
+
+@dataclasses.dataclass
+class LlmRequestParams:
+    model: str
+    messages: list[ChatMessage]
+    tools: list[ToolFn | ToolDef | RawToolDef] | None = None
+    tool_choice: Literal["auto", "required", "none"] = "auto"
+    execute_tools: bool = False
+
+    timeout_sec: float | None = None
+    temperature: float | None = None
+    max_tokens: int | None = None
+    headers: dict[str, str] | None = None
+
+    extra_args: dict[str, Any] | None = None
+
+# --- --- --- --- --- ---
+
+GenerateTextResponse = list[AssistantMessage | ToolMessage]
+StreamTextResponseSync = tuple[
+    Generator[AssistantMessageChunk],
+    queue.Queue[AssistantMessage | ToolMessage | None]]
+StreamTextResponseAsync = tuple[
+    AsyncGenerator[AssistantMessageChunk],
+    asyncio.Queue[AssistantMessage | ToolMessage | None]]

liteai_sdk-0.3.2/src/liteai_sdk/types/message.py

@@ -0,0 +1,119 @@
+from abc import ABC
+import json
+from typing import Any, Literal
+from litellm.types.utils import Message as LiteLlmMessage,\
+                                ModelResponseStream as LiteLlmModelResponseStream,\
+                                ChatCompletionAudioResponse
+from litellm.types.llms.openai import (
+    AllMessageValues,
+    OpenAIMessageContent,
+    ChatCompletionAssistantToolCall,
+    ImageURLListItem as ChatCompletionImageURL,
+
+    ChatCompletionUserMessage,
+    ChatCompletionAssistantMessage,
+    ChatCompletionToolMessage,
+    ChatCompletionSystemMessage,
+)
+
+class ChatMessage(ABC):
+    def to_litellm_message(self) -> AllMessageValues: ...
+
+class UserMessage(ChatMessage):
+    role: Literal["user"] = "user"
+    def __init__(self, content: OpenAIMessageContent):
+        self.content = content
+
+    def to_litellm_message(self) -> ChatCompletionUserMessage:
+        return ChatCompletionUserMessage(role=self.role, content=self.content)
+
+class AssistantMessage(ChatMessage):
+    role: Literal["assistant"] = "assistant"
+    def __init__(self,
+                 content: str | None,
+                 reasoning_content: str | None = None,
+                 tool_calls: list[ChatCompletionAssistantToolCall] | None = None):
+        self.content = content
+        self.reasoning_content = reasoning_content
+        self.tool_calls = tool_calls
+        self.audio: ChatCompletionAudioResponse | None = None
+        self.images: list[ChatCompletionImageURL] | None = None
+
+    @staticmethod
+    def from_litellm_message(message: LiteLlmMessage) -> "AssistantMessage":
+        tool_calls: list[ChatCompletionAssistantToolCall] | None = None
+        if message.get("tool_calls"):
+            assert message.tool_calls is not None
+            tool_calls = [{
+                "id": tool_call.id,
+                "function": {
+                    "name": tool_call.function.name,
+                    "arguments": tool_call.function.arguments,
+                },
+                "type": "function",
+            } for tool_call in message.tool_calls]
+
+        result = AssistantMessage(
+            content=message.get("content"),
+            reasoning_content=message.get("reasoning_content"),
+            tool_calls=tool_calls)
+
+        if message.get("audio"):
+            result.audio = message.audio
+        if message.get("images"):
+            result.images = message.images
+
+        return result
+
+    def to_litellm_message(self) -> ChatCompletionAssistantMessage:
+        return ChatCompletionAssistantMessage(role=self.role,
+                                              content=self.content,
+                                              reasoning_content=self.reasoning_content,
+                                              tool_calls=self.tool_calls)
+
+class ToolMessage(ChatMessage):
+    role: Literal["tool"] = "tool"
+    def __init__(self, id: str, name: str, arguments: dict, result: Any):
+        self.id = id
+        self.name = name
+        self.arguments = arguments
+        self.result = result
+
+    def to_litellm_message(self) -> ChatCompletionToolMessage:
+        return ChatCompletionToolMessage(
+            role=self.role,
+            content=json.dumps(self.result),
+            tool_call_id=self.id)
+
+class SystemMessage(ChatMessage):
+    role: Literal["system"] = "system"
+    def __init__(self, content: str):
+        self.content = content
+
+    def to_litellm_message(self) -> ChatCompletionSystemMessage:
+        return ChatCompletionSystemMessage(role=self.role, content=self.content)
+
+class AssistantMessageChunk:
+    def __init__(self,
+                 content: str | None = None,
+                 reasoning_content: str | None = None,
+                 audio: ChatCompletionAudioResponse | None = None,
+                 images: list[ChatCompletionImageURL] | None = None):
+        self.content = content
+        self.reasoning_content = reasoning_content
+        self.audio = audio
+        self.images = images
+
+    @staticmethod
+    def from_litellm_chunk(chunk: LiteLlmModelResponseStream) -> "AssistantMessageChunk":
+        delta = chunk.choices[0].delta
+        temp_chunk = AssistantMessageChunk()
+        if delta.get("content"):
+            temp_chunk.content = delta.content
+        if delta.get("reasoning_content"):
+            temp_chunk.reasoning_content = delta.reasoning_content
+        if delta.get("audio"):
+            temp_chunk.audio = delta.audio
+        if delta.get("images"):
+            temp_chunk.images = delta.images
+        return temp_chunk