dais-sdk 0.6.0__py3-none-any.whl

dais_sdk/tool/toolset/mcp_toolset.py

@@ -0,0 +1,94 @@
+from dataclasses import replace
+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
+from ...mcp_client.local_mcp_client import LocalMcpClient, LocalServerParams
+from ...mcp_client.remote_mcp_client import RemoteMcpClient, RemoteServerParams, OAuthParams
+from ...types.tool import ToolDef
+from ...logger import logger
+
+class McpToolset(Toolset):
+    def __init__(self, client: McpClient):
+        self._client = client
+        self._tools_cache: list[ToolDef] | None = None
+
+    def _mcp_tool_to_tool_def(self, mcp_tool: Tool) -> ToolDef:
+        async def wrapper(**kwargs) -> str:
+            result = await self._client.call_tool(mcp_tool.name, kwargs)
+            return self._format_tool_result(result)
+
+        tool_def = ToolDef(
+            name=mcp_tool.name,
+            description=mcp_tool.description or f"MCP tool: {mcp_tool.name}",
+            parameters=mcp_tool.inputSchema,
+            execute=wrapper
+        )
+        return tool_def
+
+    def _format_tool_result(self, result: ToolResult) -> str:
+        is_error, content = result.is_error, result.content
+        content_parts = []
+
+        if is_error:
+            content_parts.append("Error executing tool:")
+
+        for block in content:
+            match block:
+                case TextContent():
+                    content_parts.append(block.text)
+                case ImageContent():
+                    content_parts.append(f"[Generated Image: {block.mimeType}]")
+                case AudioContent():
+                    content_parts.append(f"[Generated Audio: {block.mimeType}]")
+                case ResourceLink():
+                    details = [f"Resource Reference: {block.uri}"]
+                    if block.mimeType: details.append(f"Type: {block.mimeType}")
+                    if block.size: details.append(f"Size: {block.size} bytes")
+                    if block.description: details.append(f"Description: {block.description}")
+                    content_parts.append("\n".join(details))
+                case EmbeddedResource():
+                    resource = block.resource
+                    header = f"Resource ({resource.uri}):"
+                    if isinstance(resource, TextResourceContents):
+                        content_parts.append(f"{header}\n{resource.text}")
+                    elif isinstance(resource, BlobResourceContents):
+                        content_parts.append(f"{header}\n[Binary data: {resource.mimeType}]")
+                case _:
+                    logger.warning(f"Unknown tool result block type: {type(block)}")
+
+        return "\n\n".join(content_parts)
+
+    async def connect(self) -> None:
+        await self._client.connect()
+        await self.refresh_tools()
+
+    async def disconnect(self) -> None:
+        await self._client.disconnect()
+        self._tools_cache = None
+
+    async def refresh_tools(self) -> None:
+        mcp_tools = await self._client.list_tools()
+        self._tools_cache = [self._mcp_tool_to_tool_def(tool)
+                             for tool in mcp_tools]
+
+    @property
+    def name(self) -> str:
+        return self._client.name
+
+    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")
+        if not namespaced_tool_name:
+            return list(self._tools_cache)
+        return [replace(tool, name=self.format_tool_name(tool.name)) for tool in self._tools_cache]
+
+
+class LocalMcpToolset(McpToolset):
+    def __init__(self, name: str, params: LocalServerParams):
+        client = LocalMcpClient(name, params)
+        super().__init__(client)
+
+class RemoteMcpToolset(McpToolset):
+    def __init__(self, name: str, params: RemoteServerParams):
+        client = RemoteMcpClient(name, params)
+        super().__init__(client)

dais_sdk/tool/toolset/python_toolset.py

@@ -0,0 +1,31 @@
+import inspect
+from typing import Any, Callable, TypeVar
+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:
+    setattr(func, TOOL_FLAG, True)
+    return func
+
+class PythonToolset(Toolset):
+    @property
+    def name(self) -> str:
+        """
+        Since the usage of PythonToolset is to inherit and define methods as tools,
+        the name of the toolset is the name of the subclass.
+        """
+        return self.__class__.__name__
+
+    def get_tools(self, namespaced_tool_name: bool = True) -> list[ToolDef]:
+        result = []
+        for _, method in inspect.getmembers(self, predicate=inspect.ismethod):
+            if not getattr(method, TOOL_FLAG, False): continue
+            tool_def = ToolDef.from_tool_fn(method)
+            tool_def.name = (self.format_tool_name(tool_def.name)
+                             if namespaced_tool_name
+                             else tool_def.name)
+            result.append(tool_def)
+        return result

dais_sdk/tool/toolset/toolset.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from ...types.tool import ToolDef
+
+class Toolset(ABC):
+    def format_tool_name(self, tool_name: str) -> str:
+        return f"{self.name}__{tool_name}"
+
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+
+    @abstractmethod
+    def get_tools(self) -> list[ToolDef]: ...

dais_sdk/tool/utils.py

@@ -0,0 +1,11 @@
+from ..types.tool import ToolFn, ToolDef, ToolLike
+
+def find_tool_by_name(tools: list[ToolLike], name: str) -> ToolLike | 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("name") == name:
+            return tool
+    return None

dais_sdk/types/__init__.py

@@ -0,0 +1,20 @@
+import asyncio
+import queue
+from collections.abc import AsyncGenerator, Generator
+from .message import AssistantMessage, ToolMessage, MessageChunk
+
+# --- --- --- --- --- ---
+
+GenerateTextResponse = list[AssistantMessage | ToolMessage]
+FullMessageQueueSync = queue.Queue[AssistantMessage | ToolMessage | None]
+FullMessageQueueAsync = asyncio.Queue[AssistantMessage | ToolMessage | None]
+StreamTextResponseSync = tuple[Generator[MessageChunk], FullMessageQueueSync]
+StreamTextResponseAsync = tuple[AsyncGenerator[MessageChunk], FullMessageQueueAsync]
+
+__all__ = [
+    "GenerateTextResponse",
+    "StreamTextResponseSync",
+    "StreamTextResponseAsync",
+    "FullMessageQueueSync",
+    "FullMessageQueueAsync",
+]

dais_sdk/types/exceptions.py

@@ -0,0 +1,27 @@
+from litellm.exceptions import (  
+    AuthenticationError,
+    PermissionDeniedError,
+    RateLimitError,
+    ContextWindowExceededError,
+    BadRequestError,
+    InvalidRequestError,
+    InternalServerError,
+    ServiceUnavailableError,
+    ContentPolicyViolationError,
+    APIError,
+    Timeout,
+)
+
+__all__ = [
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "RateLimitError",
+    "ContextWindowExceededError",
+    "BadRequestError",
+    "InvalidRequestError",
+    "InternalServerError",
+    "ServiceUnavailableError",
+    "ContentPolicyViolationError",
+    "APIError",
+    "Timeout",
+]

dais_sdk/types/message.py

@@ -0,0 +1,211 @@
+import json
+import dataclasses
+import uuid
+from abc import ABC, abstractmethod
+from typing import Any, Literal, NamedTuple, cast
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from litellm.types.utils import (
+    Message as LiteLlmMessage,
+    ModelResponse as LiteLlmModelResponse,
+    ModelResponseStream as LiteLlmModelResponseStream,
+    Choices as LiteLlmModelResponseChoices,
+    ChatCompletionAudioResponse,
+    ChatCompletionMessageToolCall,
+    ChatCompletionDeltaToolCall,
+    Usage as LiteLlmUsage
+)
+from litellm.types.llms.openai import (
+    AllMessageValues,
+    OpenAIMessageContent,
+    ChatCompletionAssistantToolCall,
+    ImageURLListItem as ChatCompletionImageURL,
+
+    ChatCompletionUserMessage,
+    ChatCompletionAssistantMessage,
+    ChatCompletionToolMessage,
+    ChatCompletionSystemMessage,
+)
+from ..logger import logger
+
+class ChatMessage(BaseModel, ABC):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        validate_assignment=True,
+    )
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+
+    @abstractmethod
+    def to_litellm_message(self) -> AllMessageValues: ...
+
+class UserMessage(ChatMessage):
+    content: OpenAIMessageContent
+    role: Literal["user"] = "user"
+
+    def to_litellm_message(self) -> ChatCompletionUserMessage:
+        return ChatCompletionUserMessage(role=self.role, content=self.content)
+
+class ToolMessage(ChatMessage):
+    tool_call_id: str
+    name: str
+    arguments: str
+    result: str | None = None
+    error: str | None = None
+    role: Literal["tool"] = "tool"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    @field_validator("result", mode="before")
+    def validate_result(cls, v: Any) -> Any:
+        if v is None: return v
+        if isinstance(v, str): return v
+        return json.dumps(v, ensure_ascii=False)
+
+    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, "
+                              "result and error cannot be both None")
+
+        if self.error is not None:
+            content = json.dumps({"error": self.error}, ensure_ascii=False)
+        else:
+            assert self.result is not None
+            content = self.result
+
+        return ChatCompletionToolMessage(
+            role=self.role,
+            content=content,
+            tool_call_id=self.tool_call_id)
+
+class AssistantMessage(ChatMessage):
+    content: str | None = None
+    reasoning_content: str | None = None
+    tool_calls: list[ChatCompletionAssistantToolCall] | None = None
+    audio: ChatCompletionAudioResponse | None = None
+    images: list[ChatCompletionImageURL] | None = None
+    usage: LiteLlmUsage | None = None
+    role: Literal["assistant"] = "assistant"
+
+    @classmethod
+    def from_litellm_message(cls, response: LiteLlmModelResponse) -> "AssistantMessage":
+        choices = cast(list[LiteLlmModelResponseChoices], response.choices)
+        message = choices[0].message
+
+        tool_calls: list[ChatCompletionAssistantToolCall] | None = None
+        if (message_tool_calls := message.get("tool_calls")) is not None:
+            tool_calls = [ChatCompletionAssistantToolCall(
+                id=tool_call.id,
+                function={
+                    "name": tool_call.function.name,
+                    "arguments": tool_call.function.arguments,
+                },
+                type="function",
+            ) for tool_call in cast(list[ChatCompletionMessageToolCall], message_tool_calls)]
+
+        return cls.model_construct(
+            content=message.get("content"),
+            reasoning_content=message.get("reasoning_content"),
+            tool_calls=tool_calls,
+            audio=message.get("audio"),
+            images=message.get("images"),
+            usage=response.get("usage"),
+        )
+
+    def to_litellm_message(self) -> ChatCompletionAssistantMessage:
+        return ChatCompletionAssistantMessage(role=self.role,
+                                              content=self.content or "",
+                                              reasoning_content=self.reasoning_content,
+                                              tool_calls=self.tool_calls)
+
+    def get_incomplete_tool_messages(self) -> list[ToolMessage] | None:
+        """
+        Get a incomplete tool message from the assistant message.
+        The returned tool message is incomplete,
+        which means it only contains the tool call id, name and arguments.
+        Returns None if there is no tool call in the assistant message.
+        """
+        if self.tool_calls is None: return None
+        results: list[ToolMessage] = []
+        for tool_call in self.tool_calls:
+            id = tool_call.get("id")
+            function = tool_call.get("function") # this can not be None
+            function_name = function.get("name")
+            function_arguments = function.get("arguments", "")
+            if (id is None or
+                function is None or
+                function_name is None):
+                logger.warning(f"Broken tool call: {tool_call}")
+                continue # broken tool call
+            results.append(ToolMessage(
+                tool_call_id=id,
+                name=function_name,
+                arguments=function_arguments,
+                result=None,
+                error=None))
+        return results
+
+class SystemMessage(ChatMessage):
+    content: str
+    role: Literal["system"] = "system"
+
+    def to_litellm_message(self) -> ChatCompletionSystemMessage:
+        return ChatCompletionSystemMessage(role=self.role, content=self.content)
+
+@dataclasses.dataclass
+class TextChunk:
+    content: str
+
+@dataclasses.dataclass
+class UsageChunk:
+    input_tokens: int
+    output_tokens: int
+    total_tokens: int
+
+@dataclasses.dataclass
+class ReasoningChunk:
+    content: str
+
+@dataclasses.dataclass
+class AudioChunk:
+    data: ChatCompletionAudioResponse
+
+@dataclasses.dataclass
+class ImageChunk:
+    data: list[ChatCompletionImageURL]
+
+@dataclasses.dataclass
+class ToolCallChunk:
+    id: str | None
+    name: str | None
+    arguments: str
+    index: int
+
+MessageChunk = TextChunk | UsageChunk | ReasoningChunk | AudioChunk | ImageChunk | ToolCallChunk
+
+def openai_chunk_normalizer(
+        chunk: LiteLlmModelResponseStream
+        ) -> list[MessageChunk]:
+    if len(chunk.choices) == 0: return []
+
+    result = []
+    delta = chunk.choices[0].delta
+    if delta.get("content"):
+        result.append(TextChunk(cast(str, delta.content)))
+    if delta.get("reasoning_content"):
+        result.append(ReasoningChunk(cast(str, delta.reasoning_content)))
+    if delta.get("audio"):
+        result.append(AudioChunk(cast(ChatCompletionAudioResponse, delta.audio)))
+    if delta.get("images"):
+        result.append(ImageChunk(cast(list[ChatCompletionImageURL], delta.images)))
+    if delta.get("tool_calls"):
+        for tool_call in cast(list[ChatCompletionDeltaToolCall], delta.tool_calls):
+            result.append(ToolCallChunk(
+                tool_call.id,
+                tool_call.function.name,
+                tool_call.function.arguments,
+                tool_call.index))
+    if (usage := getattr(chunk, "usage", None)) is not None:
+        usage = cast(LiteLlmUsage, usage)
+        result.append(UsageChunk(
+            input_tokens=usage.prompt_tokens,
+            output_tokens=usage.completion_tokens,
+            total_tokens=usage.total_tokens))
+    return result

dais_sdk/types/request_params.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass, field
+from typing import Any, Literal
+from .tool import ToolLike
+from .message import ChatMessage
+from ..tool.toolset import Toolset
+from ..tool.utils import find_tool_by_name
+
+@dataclass
+class LlmRequestParams:
+    model: str
+    messages: list[ChatMessage]
+    tools: list[ToolLike] | None = None
+    toolsets: list[Toolset] | 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
+
+    _extract_tools_cache: list[ToolLike] | None = field(default=None, init=False, repr=False)
+
+    def extract_tools(self) -> list[ToolLike] | None:
+        if self._extract_tools_cache is not None:
+            return self._extract_tools_cache
+
+        if self.tools is None and self.toolsets is None:
+            return None
+        tools = []
+        if self.tools:
+            tools = self.tools
+        if self.toolsets:
+            for toolset in self.toolsets:
+                tools.extend(toolset.get_tools())
+
+        self._extract_tools_cache = tools
+        return tools
+
+    def find_tool(self, tool_name: str) -> ToolLike | None:
+        has_tool_def = ((self.tools is not None and len(self.tools) > 0) or
+                        (self.toolsets is not None and len(self.toolsets) > 0))
+        if not has_tool_def: return None
+
+        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

@@ -0,0 +1,47 @@
+import dataclasses
+from collections.abc import Callable
+from typing import Any, Awaitable
+from ..logger import logger
+
+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
+    parameters: dict[str, Any] | None = None
+    metadata: dict[str, Any] = dataclasses.field(default_factory=dict)
+
+    @staticmethod
+    def from_tool_fn(tool_fn: ToolFn) -> "ToolDef":
+        if tool_fn.__doc__ is None:
+            logger.warning(f"Tool function {tool_fn.__name__} has no docstring, "
+                            "which is recommended to be used as the tool description")
+        return ToolDef(
+            name=tool_fn.__name__,
+            description=tool_fn.__doc__ or "",
+            execute=tool_fn,
+        )
+
+ToolLike = ToolDef | RawToolDef | ToolFn

dais_sdk-0.6.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: dais-sdk
+Version: 0.6.0
+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: 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
+
+Dais-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 dais_sdk
+```
+
+## Examples
+
+Below is a simple example of just a API call:
+
+```python
+import os
+from dotenv import load_dotenv
+from dais_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 dais_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)
+```
+

dais_sdk-0.6.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+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,,

dais_sdk-0.6.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dais_sdk-0.6.0.dist-info/licenses/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.