uno-sdk 1.0.0__tar.gz

uno_sdk-1.0.0/.gitignore

@@ -0,0 +1,22 @@
+.env
+.env.*
+!.env.example
+.venv/
+__pycache__/
+*.pyc
+*.db
+node_modules/
+.next/
+frontend/.next/
+frontend/node_modules/
+.DS_Store
+.idea/
+*.jpeg
+*.png
+*.db-shm
+*.db-wal
+deploy.sh
+data_export/
+data_export_prod/
+scripts/backup_prod*.json
+.mcp_auth/

uno_sdk-1.0.0/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.

uno_sdk-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,174 @@
+# 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/pyproject.toml

@@ -0,0 +1,67 @@
+[project]
+name = "uno-sdk"
+version = "1.0.0"
+description = "Python SDK for Uno — the ClawdChat agent tool gateway (2000+ tools). Sync & async clients, OpenAI/Anthropic adapters."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "ClawdChat", email = "dev@clawdchat.cn" },
+]
+keywords = [
+    "agent",
+    "sdk",
+    "mcp",
+    "tool-gateway",
+    "clawdchat",
+    "uno",
+    "llm",
+    "openai",
+    "anthropic",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = ["httpx>=0.27"]
+
+[project.optional-dependencies]
+openai = ["openai>=1.0"]
+anthropic = ["anthropic>=0.30"]
+all = ["openai>=1.0", "anthropic>=0.30"]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
+    "respx>=0.21.0",
+]
+
+[project.urls]
+Homepage = "https://clawdtools.uno"
+Documentation = "https://clawdtools.uno/docs/sdk/python"
+Repository = "https://github.com/xray918/uno-sdk"
+Issues = "https://github.com/xray918/uno-sdk/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["uno_sdk"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "uno_sdk",
+    "README.md",
+    "tests",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

uno_sdk-1.0.0/tests/test_adapters.py

@@ -0,0 +1,85 @@
+"""Unit tests for the OpenAI / Anthropic framework adapters."""
+
+from __future__ import annotations
+
+from uno_sdk.adapters import OpenAIAdapter
+from uno_sdk.adapters.anthropic import AnthropicAdapter
+from uno_sdk.models import Tool
+
+
+def _weather_tool(**overrides) -> Tool:
+    defaults = dict(
+        slug="weather-free.get_current_weather",
+        name="get_current_weather",
+        description="Get current weather",
+        input_schema={
+            "type": "object",
+            "properties": {"location": {"type": "string"}},
+            "required": ["location"],
+        },
+        auth_required=False,
+    )
+    defaults.update(overrides)
+    return Tool(**defaults)
+
+
+class TestOpenAIAdapter:
+    def test_dots_in_slug_become_double_underscores(self):
+        """OpenAI function names only allow ``[a-zA-Z0-9_-]`` — dots must be encoded."""
+        out = OpenAIAdapter().wrap_tool(_weather_tool())
+        assert out["type"] == "function"
+        assert out["function"]["name"] == "weather-free__get_current_weather"
+
+    def test_slug_roundtrip(self):
+        original = "weather-free.get_current_weather"
+        encoded = original.replace(".", "__")
+        assert OpenAIAdapter.slug_from_function_name(encoded) == original
+
+    def test_auth_required_prefixes_description(self):
+        out = OpenAIAdapter().wrap_tool(_weather_tool(auth_required=True))
+        assert out["function"]["description"].startswith("[OAuth required]")
+
+    def test_description_truncated_at_1024_chars(self):
+        long = "x" * 5000
+        out = OpenAIAdapter().wrap_tool(_weather_tool(description=long))
+        assert len(out["function"]["description"]) == 1024
+
+    def test_adds_type_object_if_missing(self):
+        out = OpenAIAdapter().wrap_tool(
+            _weather_tool(input_schema={"properties": {"x": {"type": "string"}}})
+        )
+        assert out["function"]["parameters"]["type"] == "object"
+
+    def test_falls_back_to_name_when_description_empty(self):
+        out = OpenAIAdapter().wrap_tool(_weather_tool(description=""))
+        assert out["function"]["description"] == "get_current_weather"
+
+    def test_wrap_tools_preserves_order(self):
+        tools = [_weather_tool(slug=f"server.tool_{i}") for i in range(3)]
+        wrapped = OpenAIAdapter().wrap_tools(tools)
+        assert [w["function"]["name"] for w in wrapped] == [
+            "server__tool_0",
+            "server__tool_1",
+            "server__tool_2",
+        ]
+
+
+class TestAnthropicAdapter:
+    def test_produces_anthropic_shape(self):
+        out = AnthropicAdapter().wrap_tool(_weather_tool())
+        assert set(out.keys()) == {"name", "description", "input_schema"}
+        assert out["name"] == "weather-free__get_current_weather"
+        assert out["input_schema"]["type"] == "object"
+
+    def test_slug_roundtrip(self):
+        assert (
+            AnthropicAdapter.slug_from_tool_name("weather-free__get_current_weather")
+            == "weather-free.get_current_weather"
+        )
+
+    def test_does_not_mutate_caller_schema(self):
+        """The caller's ``tool.input_schema`` must not be modified in place."""
+        original = {"properties": {"x": {"type": "string"}}}
+        tool = _weather_tool(input_schema=original)
+        AnthropicAdapter().wrap_tool(tool)
+        assert "type" not in original  # unchanged

uno_sdk-1.0.0/tests/test_client.py

@@ -0,0 +1,169 @@
+"""HTTP-level tests for ``Uno`` and ``AsyncUno`` using ``respx`` to mock httpx."""
+
+from __future__ import annotations
+
+import httpx
+import pytest
+import respx
+
+from uno_sdk import AsyncUno, Uno
+from uno_sdk.exceptions import (
+    AuthError,
+    AuthRequiredError,
+    QuotaError,
+    ToolNotFoundError,
+    UnoError,
+)
+
+BASE = "https://clawdtools.uno"
+
+
+# ── Sync ───────────────────────────────────────────────────────────
+
+
+@respx.mock
+class TestSyncClient:
+    def test_search_parses_tools(self):
+        respx.get(f"{BASE}/v1/tools").respond(
+            200,
+            json={
+                "tools": [
+                    {
+                        "tool": "weather-free.get_current_weather",
+                        "name": "get_current_weather",
+                        "desc": "Get current weather",
+                        "auth_required": False,
+                        "pricing": {"mode": "per_call", "cost": 1},
+                    }
+                ]
+            },
+        )
+        tools = Uno(api_key="uk-test").search("weather")
+        assert len(tools) == 1
+        assert tools[0].slug == "weather-free.get_current_weather"
+
+    def test_search_sends_bearer_auth(self):
+        route = respx.get(f"{BASE}/v1/tools").respond(200, json={"tools": []})
+        Uno(api_key="uk-secret-42").search("anything")
+        assert route.calls.last.request.headers["Authorization"] == "Bearer uk-secret-42"
+
+    def test_search_with_adapter_returns_wrapped_dicts(self):
+        from uno_sdk.adapters import OpenAIAdapter
+
+        respx.get(f"{BASE}/v1/tools").respond(
+            200,
+            json={
+                "tools": [
+                    {
+                        "tool": "weather-free.get_current_weather",
+                        "name": "get_current_weather",
+                        "desc": "Get current weather",
+                        "input_schema": {"type": "object"},
+                    }
+                ]
+            },
+        )
+        out = Uno(api_key="uk-test").search("weather", adapter=OpenAIAdapter())
+        assert isinstance(out[0], dict)
+        assert out[0]["type"] == "function"
+        assert out[0]["function"]["name"].startswith("weather-free__")
+
+    def test_call_success_returns_call_result(self):
+        respx.post(f"{BASE}/v1/call").respond(
+            200,
+            json={"data": {"temp": 25}, "meta": {"latency_ms": 120, "credits_used": 1}},
+        )
+        r = Uno(api_key="uk-test").call("weather-free.get_current_weather", {"location": "Beijing"})
+        assert r.ok
+        assert r.data == {"temp": 25}
+        assert r.meta["credits_used"] == 1
+
+    def test_call_sends_correct_body(self):
+        route = respx.post(f"{BASE}/v1/call").respond(200, json={"data": {}})
+        Uno(api_key="uk-test").call("a.b", {"x": 1})
+        body = route.calls.last.request.read()
+        import json as _json
+
+        assert _json.loads(body) == {"tool": "a.b", "arguments": {"x": 1}}
+
+    def test_call_default_arguments_is_empty_dict(self):
+        route = respx.post(f"{BASE}/v1/call").respond(200, json={"data": {}})
+        Uno(api_key="uk-test").call("a.b")
+        import json as _json
+
+        assert _json.loads(route.calls.last.request.read())["arguments"] == {}
+
+    @pytest.mark.parametrize(
+        "error_payload,exc_type",
+        [
+            ({"error": "auth_required", "auth_url": "https://a/u", "message": "oauth"}, AuthRequiredError),
+            ({"error": "insufficient_credits", "message": "no credits"}, QuotaError),
+            ({"error": "tool_not_found", "message": "nope"}, ToolNotFoundError),
+            ({"error": "invalid_api_key", "message": "bad key"}, AuthError),
+            ({"error": "server_error", "message": "boom"}, UnoError),
+        ],
+    )
+    def test_call_error_dispatch(self, error_payload, exc_type):
+        respx.post(f"{BASE}/v1/call").respond(200, json=error_payload)
+        with pytest.raises(exc_type) as excinfo:
+            Uno(api_key="uk-test").call("any.tool")
+        if exc_type is AuthRequiredError:
+            assert excinfo.value.auth_url == "https://a/u"
+
+    def test_401_raises_auth_error_even_without_json(self):
+        respx.post(f"{BASE}/v1/call").respond(401, json={"error": "whatever"})
+        with pytest.raises(AuthError):
+            Uno(api_key="uk-bad").call("a.b")
+
+    def test_context_manager_closes_client(self):
+        respx.get(f"{BASE}/v1/auth/me").respond(200, json={"email": "a@b.c"})
+        with Uno(api_key="uk-test") as uno:
+            uno.me()
+        # ``close`` is idempotent; calling it again after __exit__ must not crash.
+        uno.close()
+
+    def test_base_url_override(self):
+        custom_base = "https://preview.clawdtools.uno"
+        respx.get(f"{custom_base}/v1/auth/me").respond(200, json={"email": "x@x"})
+        Uno(api_key="uk-test", base_url=custom_base).me()
+
+
+# ── Async ──────────────────────────────────────────────────────────
+
+
+class TestAsyncClient:
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_async_search(self):
+        respx.get(f"{BASE}/v1/tools").respond(200, json={"tools": []})
+        async with AsyncUno(api_key="uk-test") as uno:
+            out = await uno.search("x")
+        assert out == []
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_async_call_error_dispatch(self):
+        respx.post(f"{BASE}/v1/call").respond(
+            200, json={"error": "tool_not_found", "message": "nope"}
+        )
+        async with AsyncUno(api_key="uk-test") as uno:
+            with pytest.raises(ToolNotFoundError):
+                await uno.call("a.b")
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_async_me(self):
+        respx.get(f"{BASE}/v1/auth/me").respond(
+            200, json={"email": "a@b.c", "credits": 500}
+        )
+        async with AsyncUno(api_key="uk-test") as uno:
+            me = await uno.me()
+        assert me["credits"] == 500
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_async_401_raises_auth_error(self):
+        respx.post(f"{BASE}/v1/call").respond(401, json={})
+        async with AsyncUno(api_key="uk-bad") as uno:
+            with pytest.raises(AuthError):
+                await uno.call("a.b")

uno_sdk-1.0.0/tests/test_models.py

@@ -0,0 +1,54 @@
+"""Unit tests for the plain-dataclass models in ``uno_sdk.models``."""
+
+from __future__ import annotations
+
+from uno_sdk.models import CallResult, Tool
+
+
+class TestToolFromApi:
+    def test_full_payload(self):
+        t = Tool.from_api(
+            {
+                "tool": "weather.get_current",
+                "name": "get_current",
+                "desc": "Current conditions",
+                "input_schema": {"type": "object"},
+                "auth_required": True,
+                "pricing": {"mode": "per_call", "cost": 2.5},
+                "stats": {"rating": 4.8},
+            }
+        )
+        assert t.slug == "weather.get_current"
+        assert t.name == "get_current"
+        assert t.description == "Current conditions"
+        assert t.auth_required is True
+        assert t.pricing_mode == "per_call"
+        assert t.credit_cost == 2.5
+        assert t.stats == {"rating": 4.8}
+
+    def test_missing_fields_defaults(self):
+        t = Tool.from_api({})
+        assert t.slug == ""
+        assert t.pricing_mode == "free"
+        assert t.credit_cost == 0
+        assert t.input_schema == {}
+
+    def test_description_falls_back_to_description_field(self):
+        """Legacy payloads use ``description`` instead of ``desc``."""
+        t = Tool.from_api({"description": "Legacy description"})
+        assert t.description == "Legacy description"
+
+
+class TestCallResultFromApi:
+    def test_success(self):
+        r = CallResult.from_api(
+            {"data": {"temp": 25}, "meta": {"latency_ms": 120, "credits_used": 1}}
+        )
+        assert r.ok is True
+        assert r.data == {"temp": 25}
+        assert r.meta["latency_ms"] == 120
+
+    def test_error(self):
+        r = CallResult.from_api({"error": "tool_not_found", "meta": {}})
+        assert r.ok is False
+        assert r.error == "tool_not_found"

uno_sdk-1.0.0/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-1.0.0/uno_sdk/_version.py

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

uno_sdk-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-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/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", {}),
+        )