sinas 0.1.0__py3-none-any.whl

sinas/__init__.py

@@ -0,0 +1,20 @@
+"""SINAS Python SDK - AI Agent Platform Client."""
+
+from sinas.client import SinasClient
+from sinas.exceptions import (
+    SinasError,
+    SinasAPIError,
+    SinasAuthError,
+    SinasNotFoundError,
+    SinasValidationError,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "SinasClient",
+    "SinasError",
+    "SinasAPIError",
+    "SinasAuthError",
+    "SinasNotFoundError",
+    "SinasValidationError",
+]

sinas/auth.py

@@ -0,0 +1,100 @@
+"""Runtime Authentication API."""
+
+from typing import TYPE_CHECKING, Any, Dict
+
+if TYPE_CHECKING:
+    from sinas.client import SinasClient
+
+
+class AuthAPI:
+    """Runtime Authentication API methods."""
+
+    def __init__(self, client: "SinasClient") -> None:
+        self._client = client
+
+    def login(self, email: str) -> Dict[str, Any]:
+        """Initiate login by sending OTP to email.
+
+        Args:
+            email: User's email address.
+
+        Returns:
+            Login response with message and session_id.
+            Example: {"message": "OTP sent to your email", "session_id": "uuid-here"}
+        """
+        return self._client._request("POST", "/auth/login", json={"email": email})
+
+    def verify_otp(self, session_id: str, otp_code: str) -> Dict[str, Any]:
+        """Verify OTP and get access + refresh tokens.
+
+        Args:
+            session_id: Session ID from login() response.
+            otp_code: One-time password code from email.
+
+        Returns:
+            Response with access token, refresh token, and user info.
+            Example: {"access_token": "jwt-token", "refresh_token": "refresh-token",
+                     "token_type": "bearer", "expires_in": 900, "user": {...}}
+        """
+        response = self._client._request(
+            "POST", "/auth/verify-otp",
+            json={"session_id": session_id, "otp_code": otp_code}
+        )
+        # Automatically set the token on the client
+        if "access_token" in response:
+            self._client.set_token(response["access_token"])
+        return response
+
+    def external_auth(self, token: str) -> Dict[str, Any]:
+        """Exchange external OIDC token for SINAS JWT.
+
+        Args:
+            token: External OIDC token.
+
+        Returns:
+            Response with access token, refresh token, and user info.
+        """
+        response = self._client._request(
+            "POST", "/auth/external-auth",
+            json={"token": token}
+        )
+        if "access_token" in response:
+            self._client.set_token(response["access_token"])
+        return response
+
+    def refresh(self, refresh_token: str) -> Dict[str, Any]:
+        """Refresh access token using refresh token.
+
+        Args:
+            refresh_token: Refresh token from login/verify response.
+
+        Returns:
+            Response with new access token.
+            Example: {"access_token": "jwt-token", "token_type": "bearer", "expires_in": 900}
+        """
+        response = self._client._request(
+            "POST", "/auth/refresh",
+            json={"refresh_token": refresh_token}
+        )
+        if "access_token" in response:
+            self._client.set_token(response["access_token"])
+        return response
+
+    def logout(self, refresh_token: str) -> None:
+        """Logout by revoking refresh token.
+
+        Args:
+            refresh_token: Refresh token to revoke.
+        """
+        self._client._request(
+            "POST", "/auth/logout",
+            json={"refresh_token": refresh_token}
+        )
+
+    def get_me(self) -> Dict[str, Any]:
+        """Get current authenticated user info.
+
+        Returns:
+            User information.
+        """
+        return self._client._request("GET", "/auth/me")

sinas/chats.py

@@ -0,0 +1,130 @@
+"""Runtime Chats API."""
+
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Union
+
+if TYPE_CHECKING:
+    from sinas.client import SinasClient
+
+
+class ChatsAPI:
+    """Runtime Chats API methods."""
+
+    def __init__(self, client: "SinasClient") -> None:
+        self._client = client
+
+    def create(
+        self,
+        namespace: str,
+        agent_name: str,
+        input: Optional[Dict[str, Any]] = None,
+        title: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a new chat with an agent.
+
+        Args:
+            namespace: Agent namespace.
+            agent_name: Agent name.
+            input: Optional input data validated against agent's input_schema.
+            title: Optional chat title.
+
+        Returns:
+            Created chat information.
+        """
+        data: Dict[str, Any] = {}
+        if input is not None:
+            data["input"] = input
+        if title is not None:
+            data["title"] = title
+
+        return self._client._request(
+            "POST",
+            f"/agents/{namespace}/{agent_name}/chats",
+            json=data
+        )
+
+    def send(
+        self,
+        chat_id: str,
+        content: Union[str, List[Dict[str, Any]]],
+    ) -> Dict[str, Any]:
+        """Send message to chat and get response (blocking).
+
+        Args:
+            chat_id: Chat ID (UUID).
+            content: Message content (string or list of content blocks).
+
+        Returns:
+            Message response from the agent.
+        """
+        return self._client._request(
+            "POST",
+            f"/chats/{chat_id}/messages",
+            json={"content": content}
+        )
+
+    def stream(
+        self,
+        chat_id: str,
+        content: Union[str, List[Dict[str, Any]]],
+    ) -> Iterator[str]:
+        """Send message to chat and stream response via SSE.
+
+        Args:
+            chat_id: Chat ID (UUID).
+            content: Message content (string or list of content blocks).
+
+        Yields:
+            Server-sent event data chunks.
+        """
+        return self._client._stream(
+            "POST",
+            f"/chats/{chat_id}/messages/stream",
+            json={"content": content}
+        )
+
+    def get(self, chat_id: str) -> Dict[str, Any]:
+        """Get a chat with all messages.
+
+        Args:
+            chat_id: Chat ID (UUID).
+
+        Returns:
+            Chat information with messages.
+        """
+        return self._client._request("GET", f"/chats/{chat_id}")
+
+    def list(self) -> List[Dict[str, Any]]:
+        """List all chats for the current user.
+
+        Returns:
+            List of chats.
+        """
+        return self._client._request("GET", "/chats")
+
+    def update(
+        self,
+        chat_id: str,
+        title: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Update a chat.
+
+        Args:
+            chat_id: Chat ID (UUID).
+            title: New title.
+
+        Returns:
+            Updated chat information.
+        """
+        data: Dict[str, Any] = {}
+        if title is not None:
+            data["title"] = title
+
+        return self._client._request("PUT", f"/chats/{chat_id}", json=data)
+
+    def delete(self, chat_id: str) -> None:
+        """Delete a chat and all its messages.
+
+        Args:
+            chat_id: Chat ID (UUID).
+        """
+        self._client._request("DELETE", f"/chats/{chat_id}")

sinas/client.py

@@ -0,0 +1,198 @@
+"""SINAS SDK client."""
+
+import os
+from typing import Any, Dict, Iterator, Optional
+
+import httpx
+
+from sinas.auth import AuthAPI
+from sinas.chats import ChatsAPI
+from sinas.executions import ExecutionsAPI
+from sinas.exceptions import SinasAPIError, SinasAuthError, SinasNotFoundError, SinasValidationError
+from sinas.state import StateAPI
+from sinas.webhooks import WebhooksAPI
+
+
+class SinasClient:
+    """SINAS Runtime API client."""
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        token: Optional[str] = None,
+        timeout: float = 30.0,
+    ) -> None:
+        """Initialize SINAS Runtime client.
+
+        Args:
+            base_url: Base URL for SINAS API. Defaults to SINAS_BASE_URL env var.
+            api_key: API key for authentication. Defaults to SINAS_API_KEY env var.
+            token: JWT token for authentication. Defaults to SINAS_TOKEN env var.
+            timeout: Request timeout in seconds.
+        """
+        self.base_url = (base_url or os.getenv("SINAS_BASE_URL", "")).rstrip("/")
+        if not self.base_url:
+            raise ValueError(
+                "base_url must be provided or SINAS_BASE_URL environment variable must be set"
+            )
+
+        self._api_key = api_key or os.getenv("SINAS_API_KEY")
+        self._token = token or os.getenv("SINAS_TOKEN")
+        self._timeout = timeout
+
+        self._client = httpx.Client(timeout=timeout)
+
+        # Initialize Runtime API modules
+        self.auth = AuthAPI(self)
+        self.state = StateAPI(self)
+        self.chats = ChatsAPI(self)
+        self.webhooks = WebhooksAPI(self)
+        self.executions = ExecutionsAPI(self)
+
+    def __enter__(self) -> "SinasClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self._client.close()
+
+    def _get_headers(self) -> Dict[str, str]:
+        """Get headers for API requests."""
+        headers = {"Content-Type": "application/json"}
+
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+        elif self._api_key:
+            headers["Authorization"] = f"Bearer {self._api_key}"
+
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Make an HTTP request to the API.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, PATCH).
+            path: API path (without base URL).
+            json: JSON request body.
+            params: Query parameters.
+
+        Returns:
+            Response data.
+
+        Raises:
+            SinasAPIError: If the request fails.
+        """
+        url = f"{self.base_url}{path}"
+        headers = self._get_headers()
+
+        try:
+            response = self._client.request(
+                method=method,
+                url=url,
+                json=json,
+                params=params,
+                headers=headers,
+            )
+            self._handle_response(response)
+
+            if response.status_code == 204:
+                return None
+
+            return response.json()
+        except httpx.HTTPError as e:
+            raise SinasAPIError(f"HTTP request failed: {e}")
+
+    def _stream(
+        self,
+        method: str,
+        path: str,
+        json: Optional[Dict[str, Any]] = None,
+    ) -> Iterator[str]:
+        """Make a streaming HTTP request to the API.
+
+        Args:
+            method: HTTP method.
+            path: API path (without base URL).
+            json: JSON request body.
+
+        Yields:
+            Server-sent event data.
+
+        Raises:
+            SinasAPIError: If the request fails.
+        """
+        url = f"{self.base_url}{path}"
+        headers = self._get_headers()
+
+        try:
+            with self._client.stream(
+                method=method,
+                url=url,
+                json=json,
+                headers=headers,
+            ) as response:
+                self._handle_response(response)
+                for line in response.iter_lines():
+                    if line.startswith("data: "):
+                        yield line[6:]
+        except httpx.HTTPError as e:
+            raise SinasAPIError(f"HTTP streaming request failed: {e}")
+
+    def _handle_response(self, response: httpx.Response) -> None:
+        """Handle HTTP response and raise appropriate exceptions.
+
+        Args:
+            response: HTTP response.
+
+        Raises:
+            SinasAuthError: If authentication fails.
+            SinasNotFoundError: If resource is not found.
+            SinasValidationError: If validation fails.
+            SinasAPIError: For other API errors.
+        """
+        if response.is_success:
+            return
+
+        try:
+            error_data = response.json()
+        except Exception:
+            error_data = {}
+
+        message = error_data.get("detail", f"HTTP {response.status_code}")
+
+        if response.status_code == 401:
+            raise SinasAuthError(message, status_code=response.status_code, response=error_data)
+        elif response.status_code == 404:
+            raise SinasNotFoundError(message, status_code=response.status_code, response=error_data)
+        elif response.status_code == 422:
+            raise SinasValidationError(
+                message, status_code=response.status_code, response=error_data
+            )
+        else:
+            raise SinasAPIError(message, status_code=response.status_code, response=error_data)
+
+    def set_token(self, token: str) -> None:
+        """Set the authentication token.
+
+        Args:
+            token: JWT token.
+        """
+        self._token = token
+
+    def set_api_key(self, api_key: str) -> None:
+        """Set the API key.
+
+        Args:
+            api_key: API key.
+        """
+        self._api_key = api_key

sinas/exceptions.py

@@ -0,0 +1,41 @@
+"""SINAS SDK exceptions."""
+
+from typing import Any, Dict, Optional
+
+
+class SinasError(Exception):
+    """Base exception for SINAS SDK."""
+
+    pass
+
+
+class SinasAPIError(SinasError):
+    """Exception raised for API errors."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+
+class SinasAuthError(SinasAPIError):
+    """Exception raised for authentication errors."""
+
+    pass
+
+
+class SinasNotFoundError(SinasAPIError):
+    """Exception raised when a resource is not found."""
+
+    pass
+
+
+class SinasValidationError(SinasAPIError):
+    """Exception raised for validation errors."""
+
+    pass

sinas/executions.py

@@ -0,0 +1,81 @@
+"""Runtime Executions API."""
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from sinas.client import SinasClient
+
+
+class ExecutionsAPI:
+    """Runtime Executions API methods."""
+
+    def __init__(self, client: "SinasClient") -> None:
+        self._client = client
+
+    def list(
+        self,
+        function_name: Optional[str] = None,
+        status: Optional[str] = None,
+        skip: int = 0,
+        limit: int = 100,
+    ) -> List[Dict[str, Any]]:
+        """List function executions.
+
+        Args:
+            function_name: Filter by function name.
+            status: Filter by execution status (running, completed, failed, awaiting_input).
+            skip: Number of executions to skip (pagination).
+            limit: Maximum number of executions to return (1-1000).
+
+        Returns:
+            List of executions.
+        """
+        params: Dict[str, Any] = {"skip": skip, "limit": limit}
+        if function_name is not None:
+            params["function_name"] = function_name
+        if status is not None:
+            params["status"] = status
+
+        return self._client._request("GET", "/executions", params=params)
+
+    def get(self, execution_id: str) -> Dict[str, Any]:
+        """Get a specific execution.
+
+        Args:
+            execution_id: Execution ID.
+
+        Returns:
+            Execution details.
+        """
+        return self._client._request("GET", f"/executions/{execution_id}")
+
+    def get_steps(self, execution_id: str) -> List[Dict[str, Any]]:
+        """Get all steps for an execution.
+
+        Args:
+            execution_id: Execution ID.
+
+        Returns:
+            List of execution steps.
+        """
+        return self._client._request("GET", f"/executions/{execution_id}/steps")
+
+    def continue_execution(
+        self,
+        execution_id: str,
+        input: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Continue a paused execution with user input.
+
+        Args:
+            execution_id: Execution ID.
+            input: User input data.
+
+        Returns:
+            Continuation response with execution status, output_data, or next prompt.
+        """
+        return self._client._request(
+            "POST",
+            f"/executions/{execution_id}/continue",
+            json={"input": input}
+        )

sinas/integrations/__init__.py

@@ -0,0 +1,20 @@
+"""SINAS integrations for web frameworks."""
+
+from sinas.integrations.fastapi import SinasAuth, SinasFastAPI
+from sinas.integrations.routers import (
+    create_chat_router,
+    create_executions_router,
+    create_runtime_router,
+    create_state_router,
+    create_webhook_router,
+)
+
+__all__ = [
+    "SinasAuth",
+    "SinasFastAPI",
+    "create_runtime_router",
+    "create_state_router",
+    "create_chat_router",
+    "create_webhook_router",
+    "create_executions_router",
+]