dais-sdk 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

dais_sdk/__init__.py

@@ -1,5 +1,4 @@
-import asyncio
-import queue
+import json
 from typing import cast
 from collections.abc import AsyncGenerator, Generator
 from litellm import CustomStreamWrapper, completion, acompletion
@@ -12,7 +11,10 @@ from litellm.types.utils import (
 from .debug import enable_debugging
 from .param_parser import ParamParser
 from .stream import AssistantMessageCollector
-from .tool.execute import execute_tool_sync, execute_tool
+from .tool.execute import (
+    ToolExceptionHandlerManager,
+    execute_tool_sync, execute_tool
+)
 from .tool.toolset import (
     Toolset,
     python_tool,
@@ -21,7 +23,7 @@ from .tool.toolset import (
     LocalMcpToolset,
     RemoteMcpToolset,
 )
-from .tool.utils import find_tool_by_name
+from .tool.utils import get_tool_name
 from .mcp_client import (
     McpClient,
     McpTool,
@@ -51,6 +53,10 @@ from .types.exceptions import (
     ContentPolicyViolationError,
     APIError,
     Timeout,
+    LlmToolException,
+    ToolDoesNotExistError,
+    ToolArgumentDecodeError,
+    ToolExecutionError,
 )
 from .types.message import (
     ChatMessage, UserMessage, SystemMessage, AssistantMessage, ToolMessage,
@@ -87,47 +93,49 @@ class LLM:
         self.provider = provider
         self.base_url = base_url
         self.api_key = api_key
+        self._tool_exception_handler_manager = ToolExceptionHandlerManager()
         self._param_parser = ParamParser(self.provider, self.base_url, self.api_key)
 
-    @staticmethod
-    async def execute_tool_call(
-            params: LlmRequestParams,
-            incomplete_tool_message: ToolMessage
-            ) -> tuple[str | None, str | None]:
+    @property
+    def tool_exception_handler_manager(self) -> ToolExceptionHandlerManager:
+        return self._tool_exception_handler_manager
+
+    async def execute_tool_call(self,
+                                tool_def: ToolLike,
+                                arguments: str | dict) -> tuple[str | None, str | None]:
         """
-        Receive incomplete tool messages, execute the tool calls and
-        return the result and error tuple.
+        Returns:
+            A tuple of (result, error)
         """
-        name, arguments = incomplete_tool_message.name, incomplete_tool_message.arguments
-        tool_def = params.find_tool(incomplete_tool_message.name)
-        if tool_def is None:
-            raise LlmRequestParams.ToolDoesNotExistError(name)
-
         result, error = None, None
         try:
             result = await execute_tool(tool_def, arguments)
+        except json.JSONDecodeError as e:
+            assert type(arguments) is str
+            _error = ToolArgumentDecodeError(get_tool_name(tool_def), arguments, e)
+            error = self._tool_exception_handler_manager.handle(_error)
         except Exception as e:
-            error = f"{type(e).__name__}: {str(e)}"
+            _error = ToolExecutionError(tool_def, arguments, e)
+            error = self._tool_exception_handler_manager.handle(_error)
         return result, error
 
-    @staticmethod
-    def execute_tool_call_sync(
-            params: LlmRequestParams,
-            incomplete_tool_message: ToolMessage
-            ) -> tuple[str | None, str | None]:
+    def execute_tool_call_sync(self,
+                               tool_def: ToolLike,
+                               arguments: str | dict
+                               ) -> tuple[str | None, str | None]:
         """
         Synchronous version of `execute_tool_call`.
         """
-        name, arguments = incomplete_tool_message.name, incomplete_tool_message.arguments
-        tool_def = params.find_tool(incomplete_tool_message.name)
-        if tool_def is None:
-            raise LlmRequestParams.ToolDoesNotExistError(name)
-
         result, error = None, None
         try:
             result = execute_tool_sync(tool_def, arguments)
+        except json.JSONDecodeError as e:
+            assert type(arguments) is str
+            _error = ToolArgumentDecodeError(get_tool_name(tool_def), arguments, e)
+            error = self._tool_exception_handler_manager.handle(_error)
         except Exception as e:
-            error = f"{type(e).__name__}: {str(e)}"
+            _error = ToolExecutionError(tool_def, arguments, e)
+            error = self._tool_exception_handler_manager.handle(_error)
         return result, error
 
     def _resolve_tool_calls_sync(self, params: LlmRequestParams, assistant_message: AssistantMessage) -> Generator[ToolMessage]:
@@ -136,17 +144,14 @@ class LLM:
             := assistant_message.get_incomplete_tool_messages()) is None:
             return
         for incomplete_tool_message in incomplete_tool_messages:
-            try:
-                result, error = LLM.execute_tool_call_sync(params, incomplete_tool_message)
-            except LlmRequestParams.ToolDoesNotExistError as e:
-                logger.warning(f"{e.message} Skipping this tool call.")
+            tool = params.find_tool(incomplete_tool_message.name)
+            if tool is None:
+                _error = ToolDoesNotExistError(incomplete_tool_message.name)
+                error = self._tool_exception_handler_manager.handle(_error)
+                yield incomplete_tool_message.with_result(None, error)
                 continue
-            yield ToolMessage(
-                tool_call_id=incomplete_tool_message.tool_call_id,
-                name=incomplete_tool_message.name,
-                arguments=incomplete_tool_message.arguments,
-                result=result,
-                error=error)
+            result, error = self.execute_tool_call_sync(tool, incomplete_tool_message.arguments)
+            yield incomplete_tool_message.with_result(result, error)
 
     async def _resolve_tool_calls(self, params: LlmRequestParams, assistant_message: AssistantMessage) -> AsyncGenerator[ToolMessage]:
         if not params.execute_tools: return
@@ -154,17 +159,14 @@ class LLM:
             assistant_message.get_incomplete_tool_messages()) is None:
             return
         for incomplete_tool_message in incomplete_tool_messages:
-            try:
-                result, error = await LLM.execute_tool_call(params, incomplete_tool_message)
-            except LlmRequestParams.ToolDoesNotExistError as e:
-                logger.warning(f"{e.message} Skipping this tool call.")
+            tool = params.find_tool(incomplete_tool_message.name)
+            if tool is None:
+                _error = ToolDoesNotExistError(incomplete_tool_message.name)
+                error = self._tool_exception_handler_manager.handle(_error)
+                yield incomplete_tool_message.with_result(None, error)
                 continue
-            yield ToolMessage(
-                tool_call_id=incomplete_tool_message.tool_call_id,
-                name=incomplete_tool_message.name,
-                arguments=incomplete_tool_message.arguments,
-                result=result,
-                error=error)
+            result, error = await self.execute_tool_call(tool, incomplete_tool_message.arguments)
+            yield incomplete_tool_message.with_result(result, error)
 
     def list_models(self) -> list[str]:
         provider_config = ProviderConfigManager.get_provider_model_info(
@@ -208,8 +210,8 @@ class LLM:
             - stream: Generator yielding `MessageChunk` objects
             - full_message_queue: Queue containing complete `AssistantMessage`, `ToolMessage` (or `None` when done)
         """
-        def stream(response: CustomStreamWrapper) -> Generator[MessageChunk]:
-            nonlocal message_collector
+        def stream(response: CustomStreamWrapper, full_message_queue: FullMessageQueueSync) -> Generator[MessageChunk]:
+            message_collector = AssistantMessageCollector()
             for chunk in response:
                 chunk = cast(LiteLlmModelResponseStream, chunk)
                 yield from openai_chunk_normalizer(chunk)
@@ -223,9 +225,8 @@ class LLM:
             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 = FullMessageQueueSync()
+        returned_stream = stream(cast(CustomStreamWrapper, response), full_message_queue)
         return returned_stream, full_message_queue
 
     async def stream_text(self, params: LlmRequestParams) -> StreamTextResponseAsync:
@@ -234,8 +235,8 @@ class LLM:
             - stream: Generator yielding `MessageChunk` objects
             - full_message_queue: Queue containing complete `AssistantMessage`, `ToolMessage` (or `None` when done)
         """
-        async def stream(response: CustomStreamWrapper) -> AsyncGenerator[MessageChunk]:
-            nonlocal message_collector
+        async def stream(response: CustomStreamWrapper, full_message_queue: FullMessageQueueAsync) -> AsyncGenerator[MessageChunk]:
+            message_collector = AssistantMessageCollector()
             async for chunk in response:
                 chunk = cast(LiteLlmModelResponseStream, chunk)
                 for normalized_chunk in openai_chunk_normalizer(chunk):
@@ -244,14 +245,14 @@ class LLM:
 
             message = message_collector.get_message()
             await full_message_queue.put(message)
+
             async for tool_message in self._resolve_tool_calls(params, message):
                 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 = FullMessageQueueAsync()
+        returned_stream = stream(cast(CustomStreamWrapper, response), full_message_queue)
         return returned_stream, full_message_queue
 
 __all__ = [
@@ -317,4 +318,8 @@ __all__ = [
     "ContentPolicyViolationError",
     "APIError",
     "Timeout",
+    "LlmToolException",
+    "ToolDoesNotExistError",
+    "ToolArgumentDecodeError",
+    "ToolExecutionError",
 ]

dais_sdk/mcp_client/local_mcp_client.py

@@ -1,10 +1,10 @@
 from contextlib import AsyncExitStack
-from typing import Any
+from typing import Any, override
 from mcp import ClientSession, StdioServerParameters as StdioServerParams
 from mcp.client.stdio import stdio_client
 from .base_mcp_client import McpClient, Tool, ToolResult, McpSessionNotEstablishedError
 
-LocalServerParams = StdioServerParams
+type LocalServerParams = StdioServerParams
 
 class LocalMcpClient(McpClient):
     def __init__(self, name: str, params: LocalServerParams):
@@ -14,9 +14,11 @@ class LocalMcpClient(McpClient):
         self._exit_stack: AsyncExitStack | None = None
 
     @property
+    @override
     def name(self) -> str:
         return self._name
 
+    @override
     async def connect(self):
         self._exit_stack = AsyncExitStack()
 
@@ -32,6 +34,7 @@ class LocalMcpClient(McpClient):
             await self.disconnect()
             raise
 
+    @override
     async def list_tools(self) -> list[Tool]:
         if not self._session:
             raise McpSessionNotEstablishedError()
@@ -39,6 +42,7 @@ class LocalMcpClient(McpClient):
         result = await self._session.list_tools()
         return result.tools
 
+    @override
     async def call_tool(
         self, tool_name: str, arguments: dict[str, Any] | None = None
     ) -> ToolResult:
@@ -48,6 +52,7 @@ class LocalMcpClient(McpClient):
         response = await self._session.call_tool(tool_name, arguments)
         return ToolResult(response.isError, response.content)
 
+    @override
     async def disconnect(self) -> None:
         if self._exit_stack:
             await self._exit_stack.aclose()

dais_sdk/mcp_client/remote_mcp_client.py

@@ -2,7 +2,7 @@ import httpx
 import webbrowser
 from dataclasses import dataclass
 from contextlib import AsyncExitStack
-from typing import Any, NamedTuple
+from typing import Any, NamedTuple, override
 from mcp import ClientSession
 from mcp.client.auth import OAuthClientProvider
 from mcp.client.streamable_http import streamable_http_client
@@ -49,6 +49,7 @@ class RemoteMcpClient(McpClient):
             self._params.oauth_params.oauth_token_storage = storage
 
     @property
+    @override
     def name(self) -> str:
         return self._name
 
@@ -98,13 +99,14 @@ class RemoteMcpClient(McpClient):
         try:
             webbrowser.open(url)
         except Exception as e:
-            logger.error(f"[OAuth] Not able to open browser: {e}")
+            logger.error(f"[OAuth] Not able to open browser", exc_info=e)
 
     async def _handle_oauth_callback(self) -> OAuthCode:
         if self._oauth_context is None:
             raise ValueError("OAuth context not initialized")
         return await self._oauth_context.server.wait_for_code()
 
+    @override
     async def connect(self):
         self._exit_stack = AsyncExitStack()
         if self._oauth_context:
@@ -126,6 +128,7 @@ class RemoteMcpClient(McpClient):
             await self.disconnect()
             raise
 
+    @override
     async def list_tools(self) -> list[Tool]:
         if not self._session:
             raise McpSessionNotEstablishedError()
@@ -133,6 +136,7 @@ class RemoteMcpClient(McpClient):
         result = await self._session.list_tools()
         return result.tools
 
+    @override
     async def call_tool(
         self, tool_name: str, arguments: dict[str, Any] | None = None
     ) -> ToolResult:
@@ -142,6 +146,7 @@ class RemoteMcpClient(McpClient):
         response = await self._session.call_tool(tool_name, arguments)
         return ToolResult(response.isError, response.content)
 
+    @override
     async def disconnect(self):
         try:
             if self._exit_stack:

dais_sdk/param_parser.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 from typing import Any, TYPE_CHECKING
 from litellm.types.utils import LlmProviders
 from .tool.prepare import prepare_tools

dais_sdk/tool/execute.py

@@ -1,12 +1,47 @@
 import asyncio
 import json
+import inspect
 from functools import singledispatch
-from typing import Any, Awaitable, Callable, cast
-from types import FunctionType, MethodType, CoroutineType
+from typing import Any, assert_never, Callable, cast
+from types import FunctionType, MethodType
 from ..types.tool import ToolDef, ToolLike
+from ..types.exceptions import LlmToolException
+from ..logger import logger
 
-async def _coroutine_wrapper(awaitable: Awaitable[Any]) -> CoroutineType:
-    return await awaitable
+type ExceptionHandler[E: LlmToolException] = Callable[[E], str]
+
+class ToolExceptionHandlerManager:
+    def __init__(self):
+        self._handlers: dict[type[LlmToolException], ExceptionHandler[Any]] = {}
+
+    def register[E: LlmToolException](self, exception_type: type[E]):
+        def decorator(handler: ExceptionHandler[E]) -> ExceptionHandler[E]:
+            self.set_handler(exception_type, handler)
+            return handler
+        return decorator
+
+    def set_handler[E: LlmToolException](self, exception_type: type[E], handler: ExceptionHandler[E]):
+        self._handlers[exception_type] = handler
+
+    def get_handler[E: LlmToolException](self, exception_type: type[E]) -> ExceptionHandler[E] | None:
+        return self._handlers.get(exception_type)
+
+    def handle(self, e: LlmToolException) -> str:
+        def find_best_handler[E: LlmToolException](exc_type: type[E]) -> ExceptionHandler[E] | None:
+            for cls in exc_type.__mro__:
+                if cls in self._handlers:
+                    return self._handlers[cls]
+            return None
+
+        # Searches the MRO of the exception type to make sure the subclasses of
+        # the registered exception type can also be handled.
+        handler = find_best_handler(type(e))
+        if handler is None:
+            logger.warning(f"Unhandled tool exception: {type(e).__name__}", exc_info=e)
+            return f"Unhandled tool exception | {type(e).__name__}: {e}"
+        return handler(e)
+
+# --- --- --- --- --- ---
 
 def _arguments_normalizer(arguments: str | dict) -> dict:
     if isinstance(arguments, str):
@@ -15,7 +50,7 @@ def _arguments_normalizer(arguments: str | dict) -> dict:
     elif isinstance(arguments, dict):
         return arguments
     else:
-        raise ValueError(f"Invalid arguments type: {type(arguments)}")
+        assert_never(arguments)
 
 def _result_normalizer(result: Any) -> str:
     if isinstance(result, str):
@@ -24,27 +59,37 @@ def _result_normalizer(result: Any) -> str:
 
 @singledispatch
 def execute_tool_sync(tool: ToolLike, arguments: str | dict) -> str:
+    """
+    Raises:
+        ValueError: If the tool type is not supported.
+        JSONDecodeError: If the arguments is a string but not valid JSON.
+    """
     raise ValueError(f"Invalid tool type: {type(tool)}")
 
 @execute_tool_sync.register(FunctionType)
 @execute_tool_sync.register(MethodType)
 def _(toolfn: Callable, arguments: str | dict) -> str:
     arguments = _arguments_normalizer(arguments)
-    result = (asyncio.run(_coroutine_wrapper(toolfn(**arguments)))
-              if asyncio.iscoroutinefunction(toolfn)
+    result = (asyncio.run(toolfn(**arguments))
+              if inspect.iscoroutinefunction(toolfn)
               else toolfn(**arguments))
     return _result_normalizer(result)
 
 @execute_tool_sync.register(ToolDef)
 def _(tooldef: ToolDef, arguments: str | dict) -> str:
     arguments = _arguments_normalizer(arguments)
-    result = (asyncio.run(_coroutine_wrapper(tooldef.execute(**arguments)))
-              if asyncio.iscoroutinefunction(tooldef.execute)
+    result = (asyncio.run(tooldef.execute(**arguments))
+              if inspect.iscoroutinefunction(tooldef.execute)
               else tooldef.execute(**arguments))
     return _result_normalizer(result)
 
 @singledispatch
 async def execute_tool(tool: ToolLike, arguments: str | dict) -> str:
+    """
+    Raises:
+        ValueError: If the tool type is not supported.
+        JSONDecodeError: If the arguments is a string but not valid JSON.
+    """
     raise ValueError(f"Invalid tool type: {type(tool)}")
 
 @execute_tool.register(FunctionType)
@@ -52,7 +97,7 @@ async def execute_tool(tool: ToolLike, arguments: str | dict) -> str:
 async def _(toolfn: Callable, arguments: str | dict) -> str:
     arguments = _arguments_normalizer(arguments)
     result = (await toolfn(**arguments)
-             if asyncio.iscoroutinefunction(toolfn)
+             if inspect.iscoroutinefunction(toolfn)
              else toolfn(**arguments))
     return _result_normalizer(result)
 
@@ -60,6 +105,6 @@ async def _(toolfn: Callable, arguments: str | dict) -> str:
 async def _(tooldef: ToolDef, arguments: str | dict) -> str:
     arguments = _arguments_normalizer(arguments)
     result = (await tooldef.execute(**arguments)
-             if asyncio.iscoroutinefunction(tooldef.execute)
+             if inspect.iscoroutinefunction(tooldef.execute)
              else tooldef.execute(**arguments))
     return _result_normalizer(result)

dais_sdk/tool/toolset/mcp_toolset.py

@@ -1,4 +1,5 @@
 from dataclasses import replace
+from typing import override
 from mcp.types import TextContent, ImageContent, AudioContent, ResourceLink, EmbeddedResource, TextResourceContents, BlobResourceContents
 from .toolset import Toolset
 from ...mcp_client.base_mcp_client import McpClient, Tool, ToolResult
@@ -72,9 +73,11 @@ class McpToolset(Toolset):
                              for tool in mcp_tools]
 
     @property
+    @override
     def name(self) -> str:
         return self._client.name
 
+    @override
     def get_tools(self, namespaced_tool_name: bool = True) -> list[ToolDef]:
         if self._tools_cache is None:
             raise RuntimeError(f"Not connected to MCP server. Call await {self.__class__.__name__}(...).connect() first")

dais_sdk/tool/toolset/python_toolset.py

@@ -1,17 +1,17 @@
 import inspect
-from typing import Any, Callable, TypeVar
+from typing import Any, Callable, override
 from .toolset import Toolset
 from ...types.tool import ToolDef
 
-F = TypeVar("F", bound=Callable[..., Any])
 TOOL_FLAG = "__is_tool__"
 
-def python_tool(func: F) -> F:
+def python_tool[F: Callable[..., Any]](func: F) -> F:
     setattr(func, TOOL_FLAG, True)
     return func
 
 class PythonToolset(Toolset):
     @property
+    @override
     def name(self) -> str:
         """
         Since the usage of PythonToolset is to inherit and define methods as tools,
@@ -19,6 +19,7 @@ class PythonToolset(Toolset):
         """
         return self.__class__.__name__
 
+    @override
     def get_tools(self, namespaced_tool_name: bool = True) -> list[ToolDef]:
         result = []
         for _, method in inspect.getmembers(self, predicate=inspect.ismethod):

dais_sdk/tool/utils.py

@@ -1,4 +1,15 @@
-from ..types.tool import ToolFn, ToolDef, ToolLike
+from typing import assert_never
+from ..types.tool import ToolDef, ToolLike
+
+def get_tool_name(tool: ToolLike) -> str:
+    if callable(tool):
+        return tool.__name__
+    elif isinstance(tool, ToolDef):
+        return tool.name
+    elif isinstance(tool, dict):
+        return tool.get("name", "")
+    else:
+        assert_never(tool)
 
 def find_tool_by_name(tools: list[ToolLike], name: str) -> ToolLike | None:
     for tool in tools:

dais_sdk/types/exceptions.py

@@ -1,4 +1,6 @@
-from litellm.exceptions import (  
+import json
+from typing import TYPE_CHECKING
+from litellm.exceptions import (
     AuthenticationError,
     PermissionDeniedError,
     RateLimitError,
@@ -12,6 +14,27 @@ from litellm.exceptions import (
     Timeout,
 )
 
+if TYPE_CHECKING:
+    from .tool import ToolLike
+
+class LlmToolException(Exception): pass
+
+class ToolDoesNotExistError(LlmToolException):
+    def __init__(self, tool_name: str):
+        self.tool_name = tool_name
+
+class ToolArgumentDecodeError(LlmToolException):
+    def __init__(self, tool_name: str, arguments: str, raw_error: json.JSONDecodeError):
+        self.tool_name = tool_name
+        self.arguments = arguments
+        self.raw_error = raw_error
+
+class ToolExecutionError(LlmToolException):
+    def __init__(self, tool: ToolLike, arguments: str | dict, raw_error: Exception):
+        self.tool = tool
+        self.arguments = arguments
+        self.raw_error = raw_error
+
 __all__ = [
     "AuthenticationError",
     "PermissionDeniedError",
@@ -24,4 +47,9 @@ __all__ = [
     "ContentPolicyViolationError",
     "APIError",
     "Timeout",
+
+    "LlmToolException",
+    "ToolDoesNotExistError",
+    "ToolArgumentDecodeError",
+    "ToolExecutionError",
 ]

dais_sdk/types/message.py

@@ -2,7 +2,7 @@ import json
 import dataclasses
 import uuid
 from abc import ABC, abstractmethod
-from typing import Any, Literal, NamedTuple, cast
+from typing import Any, Literal, cast
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 from litellm.types.utils import (
     Message as LiteLlmMessage,
@@ -59,6 +59,14 @@ class ToolMessage(ChatMessage):
         if isinstance(v, str): return v
         return json.dumps(v, ensure_ascii=False)
 
+    def with_result(self, result: str | None, error: str | None) -> "ToolMessage":
+        return ToolMessage(
+            tool_call_id=self.tool_call_id,
+            name=self.name,
+            arguments=self.arguments,
+            result=result,
+            error=error)
+
     def to_litellm_message(self) -> ChatCompletionToolMessage:
         if self.result is None and self.error is None:
             raise ValueError(f"ToolMessage({self.id}, {self.name}) is incomplete, "
@@ -178,7 +186,7 @@ class ToolCallChunk:
     arguments: str
     index: int
 
-MessageChunk = TextChunk | UsageChunk | ReasoningChunk | AudioChunk | ImageChunk | ToolCallChunk
+type MessageChunk = TextChunk | UsageChunk | ReasoningChunk | AudioChunk | ImageChunk | ToolCallChunk
 
 def openai_chunk_normalizer(
         chunk: LiteLlmModelResponseStream

dais_sdk/types/request_params.py

@@ -47,9 +47,3 @@ class LlmRequestParams:
         if (tools := self.extract_tools()) is None:
             return None
         return find_tool_by_name(tools, tool_name)
-
-    class ToolDoesNotExistError(Exception):
-        def __init__(self, tool_name: str):
-            self.tool_name = tool_name
-            self.message = f"Tool \"{tool_name}\" does not exist in the request params."
-            super().__init__(self.message)

dais_sdk/types/tool.py

@@ -3,7 +3,7 @@ from collections.abc import Callable
 from typing import Any, Awaitable
 from ..logger import logger
 
-ToolFn = Callable[..., Any] | Callable[..., Awaitable[Any]]
+type ToolFn = Callable[..., Any] | Callable[..., Awaitable[Any]]
 
 """
 RawToolDef example:
@@ -23,7 +23,7 @@ RawToolDef example:
     }
 }
 """
-RawToolDef = dict[str, Any]
+type RawToolDef = dict[str, Any]
 
 @dataclasses.dataclass
 class ToolDef:
@@ -44,4 +44,4 @@ class ToolDef:
             execute=tool_fn,
         )
 
-ToolLike = ToolDef | RawToolDef | ToolFn
+type ToolLike = ToolDef | RawToolDef | ToolFn

{dais_sdk-0.6.0.dist-info → dais_sdk-0.6.2.dist-info}/METADATA

@@ -1,17 +1,15 @@
 Metadata-Version: 2.4
 Name: dais-sdk
-Version: 0.6.0
+Version: 0.6.2
 Summary: A wrapper of LiteLLM
 Author-email: BHznJNs <bhznjns@outlook.com>
-Requires-Python: >=3.10
+Requires-Python: >=3.14
 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
+Classifier: Programming Language :: Python :: 3.14
 License-File: LICENSE
 Requires-Dist: litellm>=1.80.0
 Requires-Dist: pydantic>=2.0.0
@@ -19,16 +17,8 @@ Requires-Dist: httpx==0.28.1
 Requires-Dist: mcp==1.25.0
 Requires-Dist: starlette==0.50.0
 Requires-Dist: uvicorn==0.40.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/Dais-Project/Dais-SDK
 Project-URL: Tracker, https://github.com/Dais-Project/Dais-SDK/issues
-Provides-Extra: dev
-Provides-Extra: test
 
 # Dais-SDK
 
@@ -98,3 +88,20 @@ for message in messages:
             print("Tool: ", message.result)
 ```
 
+## Development
+
+Create virtual environment
+```
+uv venv
+```
+
+Install all dependencies
+```
+uv sync --all-groups
+```
+
+Run test
+```
+uv run pytest
+```
+

dais_sdk-0.6.2.dist-info/RECORD

@@ -0,0 +1,27 @@
+dais_sdk/__init__.py,sha256=5QAoL8GyyFuKfe4HZ-TiRVj9VIpHc45i2xMMYORoWXU,11805
+dais_sdk/debug.py,sha256=T7qIy1BeeUGlF40l9JCMMVn8pvvMJAEQeG4adQbOydA,69
+dais_sdk/logger.py,sha256=99vJAQRKcu4CuHgZYAJ2zDQtGea6Bn3vJJrS-mtza7c,677
+dais_sdk/param_parser.py,sha256=QIxt1izv69r725pzU1qhq5bilcrGUgzlpiItHEWOrdc,1874
+dais_sdk/stream.py,sha256=yu9Zvr3CUrPD9sGsjqwNXy_233Tw25Hd72kwjrraMAM,3170
+dais_sdk/mcp_client/__init__.py,sha256=B86aC4nnGzwfjk7H0CZ38YlMDiEx3EIDEAgJKUnwqIU,405
+dais_sdk/mcp_client/base_mcp_client.py,sha256=jWAfinzY00aL-qdNgyzYXKM-LhPHkmdqL24Uw439v-0,1055
+dais_sdk/mcp_client/local_mcp_client.py,sha256=fhCb69IAtTpaSQlicPqUNuuy0wED8K06ndw05qjjUcM,1956
+dais_sdk/mcp_client/oauth_server.py,sha256=pELKmAjE1QoNpy3_6BPNoORwWYu0j2BYOnnVfMd0iOA,3361
+dais_sdk/mcp_client/remote_mcp_client.py,sha256=8iPX-lGMRCR0FzT8MFi2CvYJXUCWHI_jYGaI30NaBuc,6039
+dais_sdk/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dais_sdk/tool/execute.py,sha256=wqIlfVounvK-I4mJ48iDXXqalySNQUplPPauNqFfSls,4220
+dais_sdk/tool/prepare.py,sha256=5UZiQc64Ao30Gh3aHqeJGeyUq7ud9A--GUU5QxYPC0M,11572
+dais_sdk/tool/utils.py,sha256=jYv_U6BHvi5Hh7H21_9nDRB9gp_qM_UEle0xq2XwX4M,706
+dais_sdk/tool/toolset/__init__.py,sha256=uh8hGSl1KSn0JI45fCPJnnk31hflOI0mYxC8cdbH-OQ,309
+dais_sdk/tool/toolset/mcp_toolset.py,sha256=J4gOsy8aR61Ui8tUj58AOG51fhKvLPWIL_SWIs-kmrE,4112
+dais_sdk/tool/toolset/python_toolset.py,sha256=p4QeBY_yZpzpnDT5w1S4EECtPOwt8dF8T_rTQv7CtME,1080
+dais_sdk/tool/toolset/toolset.py,sha256=X1xqWiWov4fboWQowB_YgJ_Tc-fIDmxbP8GreTj_7ME,322
+dais_sdk/types/__init__.py,sha256=-i1MYWIlUfjQIX0xZJta6phQNL44vXPSIx1eGyIYZXc,710
+dais_sdk/types/exceptions.py,sha256=ZlQW6QfzPatbfHJi_1s_2XBAHK4bZaeSreI3SUAX_5c,1439
+dais_sdk/types/message.py,sha256=a65Q6K3Hq1aVhsedUv2XjyJq2rQQJi9SkEAPPHcLtFw,7770
+dais_sdk/types/request_params.py,sha256=8Jq-aTeK933YENE-9ay_8q88hEr-oeZZGC7l52tOKEM,1635
+dais_sdk/types/tool.py,sha256=GT6gxjAGdnVzk6W84nPzZb24bLznzqilkHN6uvocf5M,1377
+dais_sdk-0.6.2.dist-info/licenses/LICENSE,sha256=Qwd-hsctqFqJErH4OWNNttmd0jccbH0ZCsf-YtAFNdo,1064
+dais_sdk-0.6.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+dais_sdk-0.6.2.dist-info/METADATA,sha256=SxuWO-Ip4vrW4qw4h_c1sW9SqBDbsbYrO_Ty7LYd5nQ,2612
+dais_sdk-0.6.2.dist-info/RECORD,,

{dais_sdk-0.6.0.dist-info → dais_sdk-0.6.2.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 BHznJNs
+Copyright (c) 2026 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

dais_sdk-0.6.0.dist-info/RECORD

@@ -1,27 +0,0 @@
-dais_sdk/__init__.py,sha256=84ALTOJxrC_SPKPrB5d1eUhBWBoOzRD3hn-sPuk3MUc,11245
-dais_sdk/debug.py,sha256=T7qIy1BeeUGlF40l9JCMMVn8pvvMJAEQeG4adQbOydA,69
-dais_sdk/logger.py,sha256=99vJAQRKcu4CuHgZYAJ2zDQtGea6Bn3vJJrS-mtza7c,677
-dais_sdk/param_parser.py,sha256=gXRFoCi74ZA9xdisqMPgQmWR2i6aTlPEeot78y2vyhM,1909
-dais_sdk/stream.py,sha256=yu9Zvr3CUrPD9sGsjqwNXy_233Tw25Hd72kwjrraMAM,3170
-dais_sdk/mcp_client/__init__.py,sha256=B86aC4nnGzwfjk7H0CZ38YlMDiEx3EIDEAgJKUnwqIU,405
-dais_sdk/mcp_client/base_mcp_client.py,sha256=jWAfinzY00aL-qdNgyzYXKM-LhPHkmdqL24Uw439v-0,1055
-dais_sdk/mcp_client/local_mcp_client.py,sha256=unuS-cp4zi0A2x2EYnDFzSpJUzOgVQbnEK0mLBFudy8,1871
-dais_sdk/mcp_client/oauth_server.py,sha256=pELKmAjE1QoNpy3_6BPNoORwWYu0j2BYOnnVfMd0iOA,3361
-dais_sdk/mcp_client/remote_mcp_client.py,sha256=JAy5zszMQeHdxsgK2seQ6kaN40kxhvnFTKSLT9uWDXU,5952
-dais_sdk/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dais_sdk/tool/execute.py,sha256=Yj4GHty0aHCsB38SI8WJ5ZA_FmqaKRRUqhfsQJR9l04,2507
-dais_sdk/tool/prepare.py,sha256=5UZiQc64Ao30Gh3aHqeJGeyUq7ud9A--GUU5QxYPC0M,11572
-dais_sdk/tool/utils.py,sha256=A_4Jx1BacRX1KmK3t_9rDXrmSXj6v4fzNtqLsN12S0I,420
-dais_sdk/tool/toolset/__init__.py,sha256=uh8hGSl1KSn0JI45fCPJnnk31hflOI0mYxC8cdbH-OQ,309
-dais_sdk/tool/toolset/mcp_toolset.py,sha256=-sivM6EUiC3V3gcISnh4u5dosf-lnwVjd7YM3L0U3Ik,4056
-dais_sdk/tool/toolset/python_toolset.py,sha256=JlYw49LH9xDL6tk_82EogqxW2U71hhsygamrb-lNvcE,1071
-dais_sdk/tool/toolset/toolset.py,sha256=X1xqWiWov4fboWQowB_YgJ_Tc-fIDmxbP8GreTj_7ME,322
-dais_sdk/types/__init__.py,sha256=-i1MYWIlUfjQIX0xZJta6phQNL44vXPSIx1eGyIYZXc,710
-dais_sdk/types/exceptions.py,sha256=hIGu06htOJxfEBAHx7KTvLQr0Y8GYnBLFJFlr_IGpDs,602
-dais_sdk/types/message.py,sha256=M5ZOkpF3QDtHsAduDFqO_-8NLv5z9PJvEBvnaXUz4us,7503
-dais_sdk/types/request_params.py,sha256=fWo6gF_DvaThvUEIGUkJ3O7BpoJXF5Oe9WYD0Ky9iws,1895
-dais_sdk/types/tool.py,sha256=s0sPwXPl-BeijWgRxgXkXguz_quzmP92sVS2aT7n_nA,1362
-dais_sdk-0.6.0.dist-info/licenses/LICENSE,sha256=cTeVgQVJJcRdm1boa2P1FBnOeXfA_egV6s4PouyrCxg,1064
-dais_sdk-0.6.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-dais_sdk-0.6.0.dist-info/METADATA,sha256=FeP-GU4pFHaGpHedW95e-VN9FrF5SoqksH9MdaSciFo,2910
-dais_sdk-0.6.0.dist-info/RECORD,,