nowy-sdk 0.1.0__tar.gz

nowy_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: nowy-sdk
+Version: 0.1.0
+Summary: Nowy protocol WebSocket client SDK with generated capability types
+Author: Nowy contributors
+License-Expression: MIT
+Keywords: nowy,websocket,agent,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=13.0
+Requires-Dist: python-ulid>=3.0.0
+Requires-Dist: httpx>=0.28.0
+
+# nowy-sdk
+
+Python client for the [Nowy](https://github.com/) protocol — WebSocket Node Agent, Supabase auth helpers, and generated capability types.
+
+## Install
+
+```bash
+pip install nowy-sdk
+```
+
+## Quick start
+
+```python
+import asyncio
+from nowy_sdk import NowyClient
+from nowy_sdk.auth import resolve_auth_token
+
+async def main():
+    token = resolve_auth_token()  # NOWY_EMAIL/PASSWORD in .env
+    client = NowyClient()
+    await client.connect(auth_token=token)
+    req = await client.send_text("hola nowy")
+    await client.wait_for_request(req)
+    print(client.last_response_text)
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Types
+
+Generated from `specs/capabilities/*.yaml`:
+
+```python
+from nowy_sdk import ReminderCreateInput, CAPABILITY_IDS
+```
+
+Regenerate locally: `python scripts/codegen_capabilities.py` (from repo root).

nowy_sdk-0.1.0/README.md

@@ -0,0 +1,38 @@
+# nowy-sdk
+
+Python client for the [Nowy](https://github.com/) protocol — WebSocket Node Agent, Supabase auth helpers, and generated capability types.
+
+## Install
+
+```bash
+pip install nowy-sdk
+```
+
+## Quick start
+
+```python
+import asyncio
+from nowy_sdk import NowyClient
+from nowy_sdk.auth import resolve_auth_token
+
+async def main():
+    token = resolve_auth_token()  # NOWY_EMAIL/PASSWORD in .env
+    client = NowyClient()
+    await client.connect(auth_token=token)
+    req = await client.send_text("hola nowy")
+    await client.wait_for_request(req)
+    print(client.last_response_text)
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Types
+
+Generated from `specs/capabilities/*.yaml`:
+
+```python
+from nowy_sdk import ReminderCreateInput, CAPABILITY_IDS
+```
+
+Regenerate locally: `python scripts/codegen_capabilities.py` (from repo root).

nowy_sdk-0.1.0/nowy_sdk/__init__.py

@@ -0,0 +1,34 @@
+"""Nowy Python SDK — Phase 2."""
+
+from nowy_sdk.client import NowyClient
+from nowy_sdk.generated.capabilities import (
+    CAPABILITY_IDS,
+    CalendarTodayInput,
+    CalendarTodayOutput,
+    ReminderCreateInput,
+    ReminderCreateOutput,
+    ReminderListInput,
+    ReminderListOutput,
+    SearchDocumentInput,
+    SearchDocumentOutput,
+)
+from nowy_sdk.wire import DEFAULT_PROTOCOL_VERSION, DEFAULT_WS_PATH, new_request_id, new_runtime_id, wire_message
+
+__version__ = "0.1.0"
+__all__ = [
+    "CAPABILITY_IDS",
+    "CalendarTodayInput",
+    "CalendarTodayOutput",
+    "DEFAULT_PROTOCOL_VERSION",
+    "DEFAULT_WS_PATH",
+    "NowyClient",
+    "ReminderCreateInput",
+    "ReminderCreateOutput",
+    "ReminderListInput",
+    "ReminderListOutput",
+    "SearchDocumentInput",
+    "SearchDocumentOutput",
+    "new_request_id",
+    "new_runtime_id",
+    "wire_message",
+]

nowy_sdk-0.1.0/nowy_sdk/auth.py

@@ -0,0 +1,95 @@
+"""Resolve a Supabase JWT for SDK smoke tests and scripts."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import httpx
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+
+
+def _parse_dotenv(path: Path) -> dict[str, str]:
+    if not path.is_file():
+        return {}
+    values: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, value = stripped.split("=", 1)
+        values[key.strip()] = value.strip().strip('"').strip("'")
+    return values
+
+
+def _load_supabase_config() -> tuple[str, str]:
+    client_url = ""
+    client_key = ""
+    client_json = REPO_ROOT / "clients" / "nowy_app" / ".env.client.json"
+    if client_json.is_file():
+        data = json.loads(client_json.read_text(encoding="utf-8"))
+        client_url = str(data.get("SUPABASE_URL", "")).strip()
+        client_key = str(data.get("SUPABASE_ANON_KEY", "")).strip()
+
+    root_env = _parse_dotenv(REPO_ROOT / ".env")
+    url = (
+        os.environ.get("SUPABASE_URL", "").strip()
+        or root_env.get("SUPABASE_URL", "")
+        or client_url
+    )
+    # Client login must use the same publishable key as Flutter (.env.client.json).
+    anon_key = (
+        client_key
+        or os.environ.get("SUPABASE_ANON_KEY", "").strip()
+        or root_env.get("SUPABASE_ANON_KEY", "")
+    )
+    return url, anon_key
+
+
+def _login_with_password(supabase_url: str, anon_key: str, email: str, password: str) -> str:
+    endpoint = f"{supabase_url.rstrip('/')}/auth/v1/token?grant_type=password"
+    headers = {
+        "apikey": anon_key,
+        "Content-Type": "application/json",
+    }
+    # Legacy JWT anon keys may be mirrored in Authorization; publishable keys must not.
+    if anon_key.startswith("eyJ"):
+        headers["Authorization"] = f"Bearer {anon_key}"
+    response = httpx.post(
+        endpoint,
+        headers=headers,
+        json={"email": email, "password": password},
+        timeout=15.0,
+    )
+    if response.status_code >= 400:
+        detail = response.text
+        try:
+            detail = response.json().get("error_description") or response.json().get("msg") or detail
+        except Exception:  # noqa: BLE001
+            pass
+        raise RuntimeError(f"Supabase login failed ({response.status_code}): {detail}")
+    token = response.json().get("access_token")
+    if not token:
+        raise RuntimeError("Supabase login OK but access_token missing")
+    return str(token)
+
+
+def resolve_auth_token() -> str | None:
+    """Return JWT from env, or sign in with NOWY_EMAIL + NOWY_PASSWORD."""
+    direct = os.environ.get("NOWY_AUTH_TOKEN", "").strip()
+    if direct:
+        return direct
+
+    root_env = _parse_dotenv(REPO_ROOT / ".env")
+    email = os.environ.get("NOWY_EMAIL", root_env.get("NOWY_EMAIL", "")).strip()
+    password = os.environ.get("NOWY_PASSWORD", root_env.get("NOWY_PASSWORD", "")).strip()
+    if not email or not password:
+        return None
+
+    supabase_url, anon_key = _load_supabase_config()
+    if not supabase_url or not anon_key:
+        raise RuntimeError("SUPABASE_URL y SUPABASE_ANON_KEY requeridos para login automatico")
+
+    return _login_with_password(supabase_url, anon_key, email, password)

nowy_sdk-0.1.0/nowy_sdk/client.py

@@ -0,0 +1,213 @@
+"""Minimal async WebSocket client for the Nowy runtime."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+import websockets
+from websockets.asyncio.client import ClientConnection
+
+from nowy_sdk.wire import DEFAULT_PROTOCOL_VERSION, new_request_id, new_runtime_id, wire_message
+
+MessageHandler = Callable[[dict[str, Any]], Awaitable[None] | None]
+
+
+class NowyClient:
+    def __init__(
+        self,
+        *,
+        url: str = "ws://127.0.0.1:8000/nowy/v1/connect",
+        client_name: str = "nowy-sdk-python",
+        client_version: str = "0.1.0",
+        platform: str = "web",
+    ) -> None:
+        self.url = url
+        self.client_name = client_name
+        self.client_version = client_version
+        self.platform = platform
+        self._ws: ClientConnection | None = None
+        self._recv_task: asyncio.Task[None] | None = None
+        self._handlers: list[MessageHandler] = []
+        self.runtime_id = new_runtime_id()
+        self.session_id: str | None = None
+        self.protocol_version = DEFAULT_PROTOCOL_VERSION
+        self.heartbeat_interval_ms = 30_000
+        self._heartbeat_task: asyncio.Task[None] | None = None
+        self._ready = asyncio.Event()
+        self.last_response_text = ""
+        self.last_notification: dict[str, Any] | None = None
+
+    def on_message(self, handler: MessageHandler) -> None:
+        self._handlers.append(handler)
+
+    async def connect(self, *, auth_token: str | None = None) -> None:
+        await self.close()
+        self._ws = await websockets.connect(self.url)
+        self._recv_task = asyncio.create_task(self._recv_loop())
+        await self._send(
+            wire_message(
+                type="protocol.hello",
+                payload={
+                    "protocolVersion": DEFAULT_PROTOCOL_VERSION,
+                    "supportedVersions": [DEFAULT_PROTOCOL_VERSION],
+                    "client": {
+                        "name": self.client_name,
+                        "version": self.client_version,
+                        "platform": self.platform,
+                    },
+                },
+            )
+        )
+        welcome = await self._wait_for("protocol.welcome")
+        payload = welcome.get("payload", {})
+        if payload.get("accepted") is False:
+            raise ConnectionError(f"protocol rejected: {payload.get('reason')}")
+        self.protocol_version = int(payload.get("negotiatedVersion", DEFAULT_PROTOCOL_VERSION))
+
+        reg_request_id = new_request_id()
+        register_payload: dict[str, Any] = {
+            "platform": self.platform,
+            "nodeType": self.platform,
+            "locale": "es",
+            "declaredHardware": ["display"],
+        }
+        if auth_token:
+            register_payload["auth"] = {"token": auth_token}
+        await self._send(
+            wire_message(
+                type="runtime.register",
+                protocol_version=self.protocol_version,
+                runtime_id=self.runtime_id,
+                request_id=reg_request_id,
+                correlation_id=reg_request_id,
+                payload=register_payload,
+            )
+        )
+        registered = await self._wait_for("runtime.registered", request_id=reg_request_id)
+        reg_payload = registered.get("payload", {})
+        self.session_id = reg_payload.get("sessionId")
+        self.heartbeat_interval_ms = int(reg_payload.get("heartbeatIntervalMs", 30_000))
+        self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+        self._ready.set()
+
+    async def send_text(self, text: str, *, locale: str = "es") -> str:
+        await self._ready.wait()
+        if not self.session_id:
+            raise RuntimeError("not registered")
+        request_id = new_request_id()
+        await self._send(
+            wire_message(
+                type="context.input.text",
+                protocol_version=self.protocol_version,
+                runtime_id=self.runtime_id,
+                session_id=self.session_id,
+                request_id=request_id,
+                correlation_id=request_id,
+                payload={"text": text.strip(), "locale": locale},
+            )
+        )
+        return request_id
+
+    async def wait_for_request(self, request_id: str, *, timeout: float = 60.0) -> dict[str, Any]:
+        future: asyncio.Future[dict[str, Any]] = asyncio.get_running_loop().create_future()
+
+        async def on_message(msg: dict[str, Any]) -> None:
+            if msg.get("requestId") != request_id:
+                return
+            if msg.get("type") == "request.completed" and not future.done():
+                future.set_result(msg)
+
+        self.on_message(on_message)
+        return await asyncio.wait_for(future, timeout=timeout)
+
+    async def close(self) -> None:
+        self._ready.clear()
+        if self._heartbeat_task:
+            self._heartbeat_task.cancel()
+            self._heartbeat_task = None
+        if self._recv_task:
+            self._recv_task.cancel()
+            self._recv_task = None
+        if self._ws:
+            await self._ws.close()
+            self._ws = None
+        self.session_id = None
+
+    async def _send(self, message: dict[str, Any]) -> None:
+        if not self._ws:
+            raise RuntimeError("not connected")
+        await self._ws.send(json.dumps(message))
+
+    async def _recv_loop(self) -> None:
+        assert self._ws is not None
+        try:
+            async for raw in self._ws:
+                msg = json.loads(raw)
+                self._track_wire_state(msg)
+                for handler in self._handlers:
+                    result = handler(msg)
+                    if asyncio.iscoroutine(result):
+                        await result
+        except asyncio.CancelledError:
+            return
+
+    def _track_wire_state(self, msg: dict[str, Any]) -> None:
+        msg_type = msg.get("type", "")
+        payload = msg.get("payload", {})
+        if msg_type in ("response.partial", "response.completed"):
+            text = payload.get("text")
+            if isinstance(text, str):
+                self.last_response_text = text
+        if msg_type == "notification.reminder":
+            self.last_notification = payload if isinstance(payload, dict) else None
+
+    async def _heartbeat_loop(self) -> None:
+        interval = max(self.heartbeat_interval_ms, 5_000) / 1000
+        while True:
+            await asyncio.sleep(interval)
+            if not self.session_id:
+                continue
+            await self._send(
+                wire_message(
+                    type="runtime.heartbeat",
+                    protocol_version=self.protocol_version,
+                    runtime_id=self.runtime_id,
+                    session_id=self.session_id,
+                    payload={},
+                )
+            )
+
+    async def _wait_for(
+        self,
+        message_type: str,
+        *,
+        request_id: str | None = None,
+        timeout: float = 10.0,
+    ) -> dict[str, Any]:
+        future: asyncio.Future[dict[str, Any]] = asyncio.get_running_loop().create_future()
+
+        async def on_message(msg: dict[str, Any]) -> None:
+            if request_id is not None and msg.get("requestId") != request_id:
+                return
+            if msg.get("type") == "protocol.error" and not future.done():
+                payload = msg.get("payload", {})
+                code = payload.get("code", "PROTOCOL_ERROR")
+                message = payload.get("message", "protocol error")
+                future.set_exception(ConnectionError(f"{code}: {message}"))
+                return
+            if msg.get("type") != message_type:
+                return
+            if not future.done():
+                future.set_result(msg)
+
+        self.on_message(on_message)
+        try:
+            return await asyncio.wait_for(future, timeout=timeout)
+        except TimeoutError as exc:
+            hint = ""
+            if message_type == "runtime.registered":
+                hint = " (¿auth requerido? exporta NOWY_AUTH_TOKEN con un JWT de Supabase)"
+            raise TimeoutError(f"timed out waiting for {message_type}{hint}") from exc

nowy_sdk-0.1.0/nowy_sdk/generated/__init__.py

@@ -0,0 +1 @@
+"""Generated capability types."""

nowy_sdk-0.1.0/nowy_sdk/generated/capabilities.py

@@ -0,0 +1,57 @@
+"""AUTO-GENERATED — do not edit. Run: python scripts/codegen_capabilities.py."""
+
+from __future__ import annotations
+
+from typing import TypedDict
+
+class CalendarTodayEventsItem(TypedDict, total=False):
+    title: str
+    start: str
+    end: str
+
+
+class ReminderListRemindersItem(TypedDict, total=False):
+    id: str
+    text: str
+    fire_at: str
+    status: str
+    created_at: str
+
+
+class SearchDocumentDocumentsItem(TypedDict, total=False):
+    id: str
+    title: str
+    snippet: str
+
+
+class CalendarTodayInput(TypedDict, total=False):
+    timezone: str
+
+class CalendarTodayOutput(TypedDict, total=False):
+    events: list[CalendarTodayEventsItem]
+
+class ReminderCreateInput(TypedDict, total=False):
+    text: str
+    datetime: str
+
+class ReminderCreateOutput(TypedDict, total=False):
+    reminderId: str
+
+class ReminderListInput(TypedDict, total=False):
+    status: str
+
+class ReminderListOutput(TypedDict, total=False):
+    reminders: list[ReminderListRemindersItem]
+
+class SearchDocumentInput(TypedDict, total=False):
+    query: str
+
+class SearchDocumentOutput(TypedDict, total=False):
+    documents: list[SearchDocumentDocumentsItem]
+
+CAPABILITY_IDS: tuple[str, ...] = (
+    "calendar.today",
+    "reminder.create",
+    "reminder.list",
+    "search.document",
+)

nowy_sdk-0.1.0/nowy_sdk/wire.py

@@ -0,0 +1,49 @@
+"""Wire message helpers for the Nowy protocol."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from ulid import ULID
+
+DEFAULT_PROTOCOL_VERSION = 1
+DEFAULT_WS_PATH = "/nowy/v1/connect"
+
+
+def new_runtime_id() -> str:
+    return f"rt_{ULID()}"
+
+
+def new_request_id() -> str:
+    return f"req_{ULID()}"
+
+
+def wire_message(
+    *,
+    type: str,
+    payload: dict[str, Any],
+    protocol_version: int = DEFAULT_PROTOCOL_VERSION,
+    runtime_id: str | None = None,
+    session_id: str | None = None,
+    request_id: str | None = None,
+    correlation_id: str | None = None,
+) -> dict[str, Any]:
+    msg: dict[str, Any] = {
+        "messageId": str(uuid.uuid4()),
+        "type": type,
+        "timestamp": datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z",
+        "payload": payload,
+    }
+    if type != "protocol.hello":
+        msg["protocolVersion"] = protocol_version
+    if runtime_id:
+        msg["runtimeId"] = runtime_id
+    if session_id:
+        msg["sessionId"] = session_id
+    if request_id:
+        msg["requestId"] = request_id
+    if correlation_id:
+        msg["correlationId"] = correlation_id
+    return msg

nowy_sdk-0.1.0/nowy_sdk.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: nowy-sdk
+Version: 0.1.0
+Summary: Nowy protocol WebSocket client SDK with generated capability types
+Author: Nowy contributors
+License-Expression: MIT
+Keywords: nowy,websocket,agent,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=13.0
+Requires-Dist: python-ulid>=3.0.0
+Requires-Dist: httpx>=0.28.0
+
+# nowy-sdk
+
+Python client for the [Nowy](https://github.com/) protocol — WebSocket Node Agent, Supabase auth helpers, and generated capability types.
+
+## Install
+
+```bash
+pip install nowy-sdk
+```
+
+## Quick start
+
+```python
+import asyncio
+from nowy_sdk import NowyClient
+from nowy_sdk.auth import resolve_auth_token
+
+async def main():
+    token = resolve_auth_token()  # NOWY_EMAIL/PASSWORD in .env
+    client = NowyClient()
+    await client.connect(auth_token=token)
+    req = await client.send_text("hola nowy")
+    await client.wait_for_request(req)
+    print(client.last_response_text)
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Types
+
+Generated from `specs/capabilities/*.yaml`:
+
+```python
+from nowy_sdk import ReminderCreateInput, CAPABILITY_IDS
+```
+
+Regenerate locally: `python scripts/codegen_capabilities.py` (from repo root).

nowy_sdk-0.1.0/nowy_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+nowy_sdk/__init__.py
+nowy_sdk/auth.py
+nowy_sdk/client.py
+nowy_sdk/wire.py
+nowy_sdk.egg-info/PKG-INFO
+nowy_sdk.egg-info/SOURCES.txt
+nowy_sdk.egg-info/dependency_links.txt
+nowy_sdk.egg-info/requires.txt
+nowy_sdk.egg-info/top_level.txt
+nowy_sdk/generated/__init__.py
+nowy_sdk/generated/capabilities.py

nowy_sdk-0.1.0/nowy_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nowy_sdk-0.1.0/nowy_sdk.egg-info/requires.txt

@@ -0,0 +1,3 @@
+websockets>=13.0
+python-ulid>=3.0.0
+httpx>=0.28.0

nowy_sdk-0.1.0/nowy_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+nowy_sdk

nowy_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nowy-sdk"
+version = "0.1.0"
+description = "Nowy protocol WebSocket client SDK with generated capability types"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [{ name = "Nowy contributors" }]
+keywords = ["nowy", "websocket", "agent", "sdk"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+dependencies = [
+    "websockets>=13.0",
+    "python-ulid>=3.0.0",
+    "httpx>=0.28.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["nowy_sdk*"]
+
+[tool.setuptools.package-data]
+nowy_sdk = ["py.typed"]

nowy_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+