uno-sdk 1.0.0__py3-none-any.whl

uno_sdk/__init__.py

@@ -0,0 +1,19 @@
+"""Uno SDK — search and call 2000+ tools in two lines of Python.
+
+Install::
+
+    pip install uno-sdk
+
+Quick start::
+
+    from uno_sdk import Uno
+    uno = Uno(api_key="uk-...")
+    tools = uno.search("weather")
+    result = uno.call("weather-free.get_current_weather", {"location": "Beijing"})
+"""
+
+from uno_sdk._version import __version__
+from uno_sdk.client import AsyncUno, Uno
+from uno_sdk.models import CallResult, Tool
+
+__all__ = ["AsyncUno", "CallResult", "Tool", "Uno", "__version__"]

uno_sdk/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

uno_sdk/adapters/__init__.py

@@ -0,0 +1,11 @@
+"""Framework adapters — convert UNO tools to framework-native format."""
+
+from uno_sdk.adapters.openai import OpenAIAdapter
+
+__all__ = ["OpenAIAdapter"]
+
+try:
+    from uno_sdk.adapters.anthropic import AnthropicAdapter
+    __all__.append("AnthropicAdapter")
+except ImportError:
+    pass

uno_sdk/adapters/anthropic.py

@@ -0,0 +1,60 @@
+"""Anthropic tool_use adapter.
+
+Converts UNO Tool objects to the format expected by
+anthropic.messages.create(tools=[...]).
+
+Usage::
+
+    from uno_sdk import Uno
+    from uno_sdk.adapters import AnthropicAdapter
+
+    uno = Uno(api_key="uk-xxx")
+    tools = uno.search("weather", adapter=AnthropicAdapter())
+
+    import anthropic
+    response = anthropic.messages.create(
+        model="claude-sonnet-4-20250514",
+        messages=[{"role": "user", "content": "What's the weather?"}],
+        tools=tools,
+    )
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from uno_sdk.models import Tool
+
+
+class AnthropicAdapter:
+    """Convert UNO tools to Anthropic tool_use format."""
+
+    def wrap_tool(self, tool: Tool) -> dict[str, Any]:
+        """Convert a single tool to Anthropic tool schema.
+
+        Anthropic tool names must match ^[a-zA-Z0-9_-]{1,64}$ so we
+        replace dots with double underscores (same as OpenAI adapter).
+        """
+        func_name = tool.slug.replace(".", "__")
+
+        schema = dict(tool.input_schema) if tool.input_schema else {}
+        if "type" not in schema:
+            schema["type"] = "object"
+
+        desc = tool.description or tool.name
+        if tool.auth_required:
+            desc = f"[OAuth required] {desc}"
+
+        return {
+            "name": func_name,
+            "description": desc[:1024],
+            "input_schema": schema,
+        }
+
+    def wrap_tools(self, tools: list[Tool]) -> list[dict[str, Any]]:
+        return [self.wrap_tool(t) for t in tools]
+
+    @staticmethod
+    def slug_from_tool_name(tool_name: str) -> str:
+        """Reverse: weather__get_current → weather.get_current."""
+        return tool_name.replace("__", ".", 1)

uno_sdk/adapters/openai.py

@@ -0,0 +1,66 @@
+"""OpenAI function calling adapter.
+
+Converts UNO Tool objects to the format expected by
+openai.chat.completions.create(tools=[...]).
+
+Usage::
+
+    from uno_sdk import Uno
+    from uno_sdk.adapters import OpenAIAdapter
+
+    uno = Uno(api_key="uk-xxx")
+    tools = uno.search("email", adapter=OpenAIAdapter())
+
+    import openai
+    response = openai.chat.completions.create(
+        model="gpt-4o",
+        messages=[{"role": "user", "content": "Send an email to ..."}],
+        tools=tools,
+    )
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from uno_sdk.models import Tool
+
+
+class OpenAIAdapter:
+    """Convert UNO tools to OpenAI function calling format."""
+
+    def wrap_tool(self, tool: Tool) -> dict[str, Any]:
+        """Convert a single tool to OpenAI function schema.
+
+        OpenAI function names must match ^[a-zA-Z0-9_-]+$ so we replace
+        dots in UNO slugs with double underscores.
+        """
+        # OpenAI function name: replace dots with __ (reversible)
+        func_name = tool.slug.replace(".", "__")
+
+        schema = dict(tool.input_schema) if tool.input_schema else {}
+        # Ensure schema has type: object (OpenAI requirement)
+        if "type" not in schema:
+            schema["type"] = "object"
+
+        desc = tool.description or tool.name
+        if tool.auth_required:
+            desc = f"[OAuth required] {desc}"
+
+        return {
+            "type": "function",
+            "function": {
+                "name": func_name,
+                "description": desc[:1024],
+                "parameters": schema,
+            },
+        }
+
+    def wrap_tools(self, tools: list[Tool]) -> list[dict[str, Any]]:
+        """Convert a list of tools."""
+        return [self.wrap_tool(t) for t in tools]
+
+    @staticmethod
+    def slug_from_function_name(func_name: str) -> str:
+        """Reverse the name encoding: weather__get_current → weather.get_current."""
+        return func_name.replace("__", ".", 1)

uno_sdk/client.py

@@ -0,0 +1,136 @@
+"""Uno SDK client — synchronous and asynchronous."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from uno_sdk.exceptions import AuthError, AuthRequiredError, QuotaError, ToolNotFoundError, UnoError
+from uno_sdk.models import CallResult, Tool
+
+_DEFAULT_BASE = "https://clawdtools.uno"
+
+
+def _handle_error(resp_data: dict) -> None:
+    """Raise the appropriate exception based on error code."""
+    error = resp_data.get("error")
+    if not error:
+        return
+    msg = resp_data.get("message", str(error))
+    code = error if isinstance(error, str) else None
+
+    if code == "auth_required":
+        raise AuthRequiredError(msg, auth_url=resp_data.get("auth_url"), code=code)
+    if code == "insufficient_credits":
+        raise QuotaError(msg, code=code)
+    if code == "tool_not_found":
+        raise ToolNotFoundError(msg, code=code)
+    if code in ("invalid_api_key", "not_authenticated"):
+        raise AuthError(msg, code=code)
+    raise UnoError(msg, code=code)
+
+
+class Uno:
+    """Synchronous Uno client.
+
+    Usage::
+
+        from uno_sdk import Uno
+        uno = Uno(api_key="uk-xxx")
+        tools = uno.search("send email")
+        result = uno.call("email.send_email", {"to": "a@b.com", "subject": "Hi"})
+    """
+
+    def __init__(self, api_key: str, base_url: str = _DEFAULT_BASE, timeout: float = 180):
+        self._base = base_url.rstrip("/")
+        self._client = httpx.Client(
+            base_url=self._base,
+            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            timeout=timeout,
+        )
+
+    def search(self, query: str = "", *, limit: int = 10, adapter: Any = None) -> list[Tool] | list[dict]:
+        """Search tools. If adapter is provided, return framework-native format."""
+        resp = self._client.get("/v1/tools", params={"q": query, "limit": limit})
+        resp.raise_for_status()
+        data = resp.json()
+        tools = [Tool.from_api(t) for t in data.get("tools", [])]
+        if adapter:
+            return adapter.wrap_tools(tools)
+        return tools
+
+    def call(self, tool: str, arguments: dict[str, Any] | None = None) -> CallResult:
+        """Call a tool and return the result."""
+        resp = self._client.post("/v1/call", json={"tool": tool, "arguments": arguments or {}})
+        if resp.status_code == 401:
+            raise AuthError("Invalid API key", code="invalid_api_key", status=401)
+        data = resp.json()
+        _handle_error(data)
+        return CallResult.from_api(data)
+
+    def me(self) -> dict:
+        """Get current user info (credits, plan, etc.)."""
+        resp = self._client.get("/v1/auth/me")
+        resp.raise_for_status()
+        return resp.json()
+
+    def close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class AsyncUno:
+    """Asynchronous Uno client.
+
+    Usage::
+
+        from uno_sdk import AsyncUno
+        async with AsyncUno(api_key="uk-xxx") as uno:
+            tools = await uno.search("weather")
+            result = await uno.call("weather.get_current", {"city": "Beijing"})
+    """
+
+    def __init__(self, api_key: str, base_url: str = _DEFAULT_BASE, timeout: float = 180):
+        self._base = base_url.rstrip("/")
+        self._client = httpx.AsyncClient(
+            base_url=self._base,
+            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            timeout=timeout,
+        )
+
+    async def search(self, query: str = "", *, limit: int = 10, adapter: Any = None) -> list[Tool] | list[dict]:
+        resp = await self._client.get("/v1/tools", params={"q": query, "limit": limit})
+        resp.raise_for_status()
+        data = resp.json()
+        tools = [Tool.from_api(t) for t in data.get("tools", [])]
+        if adapter:
+            return adapter.wrap_tools(tools)
+        return tools
+
+    async def call(self, tool: str, arguments: dict[str, Any] | None = None) -> CallResult:
+        resp = await self._client.post("/v1/call", json={"tool": tool, "arguments": arguments or {}})
+        if resp.status_code == 401:
+            raise AuthError("Invalid API key", code="invalid_api_key", status=401)
+        data = resp.json()
+        _handle_error(data)
+        return CallResult.from_api(data)
+
+    async def me(self) -> dict:
+        resp = await self._client.get("/v1/auth/me")
+        resp.raise_for_status()
+        return resp.json()
+
+    async def close(self):
+        await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.close()

uno_sdk/exceptions.py

@@ -0,0 +1,31 @@
+"""Uno SDK exceptions."""
+
+
+class UnoError(Exception):
+    """Base exception for Uno SDK."""
+    def __init__(self, message: str, code: str | None = None, status: int | None = None):
+        super().__init__(message)
+        self.code = code
+        self.status = status
+
+
+class AuthError(UnoError):
+    """Authentication failed (invalid or missing API key)."""
+    pass
+
+
+class QuotaError(UnoError):
+    """Insufficient credits."""
+    pass
+
+
+class ToolNotFoundError(UnoError):
+    """The requested tool does not exist."""
+    pass
+
+
+class AuthRequiredError(UnoError):
+    """The tool requires OAuth authorization."""
+    def __init__(self, message: str, auth_url: str | None = None, **kw):
+        super().__init__(message, **kw)
+        self.auth_url = auth_url

uno_sdk/models.py

@@ -0,0 +1,52 @@
+"""Data models for the Uno SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Tool:
+    """A tool returned by search."""
+    slug: str
+    name: str
+    description: str
+    input_schema: dict[str, Any] = field(default_factory=dict)
+    auth_required: bool = False
+    pricing_mode: str = "free"
+    credit_cost: float = 0
+    stats: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_api(cls, data: dict) -> Tool:
+        return cls(
+            slug=data.get("tool", ""),
+            name=data.get("name", ""),
+            description=data.get("desc") or data.get("description", ""),
+            input_schema=data.get("input_schema", {}),
+            auth_required=data.get("auth_required", False),
+            pricing_mode=data.get("pricing", {}).get("mode", "free"),
+            credit_cost=data.get("pricing", {}).get("cost", 0),
+            stats=data.get("stats", {}),
+        )
+
+
+@dataclass
+class CallResult:
+    """Result of calling a tool."""
+    data: Any = None
+    error: str | None = None
+    meta: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def ok(self) -> bool:
+        return self.error is None
+
+    @classmethod
+    def from_api(cls, data: dict) -> CallResult:
+        return cls(
+            data=data.get("data"),
+            error=data.get("error"),
+            meta=data.get("meta", {}),
+        )

uno_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: uno-sdk
+Version: 1.0.0
+Summary: Python SDK for Uno — the ClawdChat agent tool gateway (2000+ tools). Sync & async clients, OpenAI/Anthropic adapters.
+Project-URL: Homepage, https://clawdtools.uno
+Project-URL: Documentation, https://clawdtools.uno/docs/sdk/python
+Project-URL: Repository, https://github.com/xray918/uno-sdk
+Project-URL: Issues, https://github.com/xray918/uno-sdk/issues
+Author-email: ClawdChat <dev@clawdchat.cn>
+License: MIT
+License-File: LICENSE
+Keywords: agent,anthropic,clawdchat,llm,mcp,openai,sdk,tool-gateway,uno
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: all
+Requires-Dist: anthropic>=0.30; extra == 'all'
+Requires-Dist: openai>=1.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.30; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: respx>=0.21.0; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# Uno SDK for Python
+
+> Search and call **2000+ real-world tools** from Python in two lines. Powered by [ClawdChat](https://clawdtools.uno).
+
+[![PyPI](https://img.shields.io/pypi/v/uno-sdk.svg)](https://pypi.org/project/uno-sdk/)
+[![Python](https://img.shields.io/pypi/pyversions/uno-sdk.svg)](https://pypi.org/project/uno-sdk/)
+[![License](https://img.shields.io/pypi/l/uno-sdk.svg)](https://github.com/xray918/uno-sdk/blob/main/LICENSE)
+
+## Install
+
+```bash
+pip install uno-sdk                    # core
+pip install uno-sdk[openai]            # + OpenAI adapter
+pip install uno-sdk[anthropic]         # + Anthropic adapter
+pip install uno-sdk[all]               # everything
+```
+
+> Note on naming: the PyPI distribution is **`uno-sdk`** and the import name is **`uno_sdk`**. The bare `uno` PyPI slot is held by an unrelated Python 2-era package (2014, no longer installable) — `uno_sdk` keeps our namespace clean.
+
+## Quick Start
+
+```python
+from uno_sdk import Uno
+
+uno = Uno(api_key="uk-xxx")
+
+# Search tools
+tools = uno.search("send email")
+print(tools[0].name, tools[0].description)
+
+# Call a tool
+result = uno.call("email.send_email", {
+    "to": "alice@example.com",
+    "subject": "Hello",
+    "body": "Hi from Uno!"
+})
+print(result.data)
+```
+
+## OpenAI Integration
+
+```python
+from uno_sdk import Uno
+from uno_sdk.adapters import OpenAIAdapter
+from openai import OpenAI
+
+uno = Uno(api_key="uk-xxx")
+openai_client = OpenAI()
+
+# Get tools in OpenAI format
+tools = uno.search("weather", adapter=OpenAIAdapter())
+
+# Use with chat completions
+response = openai_client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "What's the weather in Beijing?"}],
+    tools=tools,
+)
+
+# Execute the tool call
+if response.choices[0].message.tool_calls:
+    tc = response.choices[0].message.tool_calls[0]
+    import json
+    slug = OpenAIAdapter.slug_from_function_name(tc.function.name)
+    result = uno.call(slug, json.loads(tc.function.arguments))
+    print(result.data)
+```
+
+## Anthropic Integration
+
+```python
+from uno_sdk import Uno
+from uno_sdk.adapters import AnthropicAdapter
+import anthropic
+
+uno = Uno(api_key="uk-xxx")
+client = anthropic.Anthropic()
+
+tools = uno.search("search", adapter=AnthropicAdapter())
+response = client.messages.create(
+    model="claude-sonnet-4-20250514",
+    messages=[{"role": "user", "content": "Search for AI news"}],
+    tools=tools,
+    max_tokens=1024,
+)
+```
+
+## Async
+
+```python
+from uno_sdk import AsyncUno
+
+async with AsyncUno(api_key="uk-xxx") as uno:
+    tools = await uno.search("translate")
+    result = await uno.call("translate.text", {"text": "hello", "to": "zh"})
+```
+
+## MCP (Claude Desktop / Cursor)
+
+No SDK needed — connect directly:
+
+```json
+{
+  "mcpServers": {
+    "uno": {
+      "url": "https://clawdtools.uno/mcp"
+    }
+  }
+}
+```
+
+OAuth login opens automatically in your browser.
+
+## Error Handling
+
+```python
+from uno_sdk.exceptions import AuthRequiredError, QuotaError, ToolNotFoundError
+
+try:
+    result = uno.call("github.list_repos", {})
+except AuthRequiredError as e:
+    print(f"Please authorize: {e.auth_url}")
+except QuotaError:
+    print("Out of credits — visit https://clawdtools.uno/pricing")
+except ToolNotFoundError:
+    print("Tool not found — search first")
+```
+
+## API
+
+### `Uno(api_key, base_url="https://clawdtools.uno", timeout=180)`
+
+| Method | Returns | Description |
+|---|---|---|
+| `search(query, limit=10, adapter=None)` | `list[Tool]` or `list[dict]` | Search tools |
+| `call(tool, arguments={})` | `CallResult` | Call a tool |
+| `me()` | `dict` | Current user info |
+
+`AsyncUno` has the same methods, all `async`.
+
+### `Tool`
+
+| Field | Type | Description |
+|---|---|---|
+| `slug` | `str` | Tool identifier (e.g. `weather.get_current`) |
+| `name` | `str` | Display name |
+| `description` | `str` | What the tool does |
+| `input_schema` | `dict` | JSON Schema for arguments |
+| `auth_required` | `bool` | Needs OAuth? |
+| `pricing_mode` | `str` | `free` / `per_call` / `per_token` |
+| `credit_cost` | `float` | Credits per call |
+
+### `CallResult`
+
+| Field | Type | Description |
+|---|---|---|
+| `data` | `Any` | Tool response data |
+| `error` | `str \| None` | Error message if failed |
+| `meta` | `dict` | Latency, credits used |
+| `ok` | `bool` | `True` if no error |
+
+## Companion: Uno CLI
+
+Prefer a command-line flow? `pip install uno-cli` ships the `uno` command (search, call, multi-account OAuth, scope enforcement) — same credentials file, same gateway. See [`uno-cli`](https://pypi.org/project/uno-cli/).
+
+## Get an API Key
+
+1. Visit [clawdtools.uno/login](https://clawdtools.uno/login)
+2. Log in with ClawdChat / Google / Phone
+3. Copy your API key from the Dashboard
+
+## License
+
+MIT © ClawdChat.

uno_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+uno_sdk/__init__.py,sha256=lx7FXE4kyZKoS10xTdF029lRcrPkvIGOL6skHO0MVn0,495
+uno_sdk/_version.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+uno_sdk/client.py,sha256=Q_VHcBSILr-UghbQBngyugV_fe0578d3l3MZu3kRpsw,4660
+uno_sdk/exceptions.py,sha256=mBZdzpJdI1zmt5LhWozw1GGvY6uIvL5K6weFV1olpVI,765
+uno_sdk/models.py,sha256=fMo8GreS_mhpDYhIhPjTXorjt5CXdduS5Z5aKp5BtSY,1443
+uno_sdk/adapters/__init__.py,sha256=8_BL79-OQJWGgrwtixsl4ip6m38Ix8Sj0Jv0z0sM9F4,289
+uno_sdk/adapters/anthropic.py,sha256=XPTjW8q2bzqaXtLCS1WmOQlZfKhGRRJYxrePrwzixtQ,1715
+uno_sdk/adapters/openai.py,sha256=bA2A5uuzBG6tyeN6mDJekQp_DjZcwwFltuGXWoIDoGw,1961
+uno_sdk-1.0.0.dist-info/METADATA,sha256=IF5lR09DZeHrsNBlgejERyAO1ZHXzsbm0WFEQI46aMc,6338
+uno_sdk-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+uno_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=P4MQssWPW9flLESkfwI7OzqoIg0jvtSpk4Q7ltDC2y4,1066
+uno_sdk-1.0.0.dist-info/RECORD,,

uno_sdk-1.0.0.dist-info/WHEEL

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

uno_sdk-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ClawdChat
+
+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.