singularity-grid 0.1.0__tar.gz

singularity_grid-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

singularity_grid-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+dist/
+*.egg-info/
+.venv/

singularity_grid-0.1.0/LICENSE

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

singularity_grid-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: singularity-grid
+Version: 0.1.0
+Summary: Python SDK for the SGL Network confidential compute grid
+Project-URL: Homepage, https://singularitylayer.xyz
+Project-URL: Repository, https://github.com/SingularityLayer/sgl-network-sdk
+Project-URL: Documentation, https://docs.singularitylayer.xyz/sdk
+Author-email: Singularity Layer <dev@singularitylayer.xyz>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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 :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Requires-Dist: pydantic>=2.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# singularity-grid
+
+Python SDK for the SGL Network confidential compute grid. Submit inference jobs to TEE-verified nodes, check grid capacity, and use the OpenAI-compatible chat completions endpoint -- all from a single package.
+
+## Installation
+
+```bash
+pip install singularity-grid
+```
+
+To use the OpenAI compatibility helper:
+
+```bash
+pip install singularity-grid[openai]
+```
+
+## Quick start
+
+### 1. OpenAI-compatible usage (simplest)
+
+The SGL Network orchestrator exposes an OpenAI-compatible `/v1/chat/completions` endpoint. You can use the standard `openai` package with no wrapper:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://sgl-network-orchestrator.ivaavimusicproductions.workers.dev/v1",
+    api_key="scg_your_api_key",
+)
+
+response = client.chat.completions.create(
+    model="gemma-4-26b",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(response.choices[0].message.content)
+```
+
+### 2. Helper function
+
+If you prefer not to copy the URL, use the built-in helper:
+
+```python
+from singularity_grid import create_openai_client
+
+client = create_openai_client(api_key="scg_your_api_key")
+
+response = client.chat.completions.create(
+    model="gemma-4-26b",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(response.choices[0].message.content)
+```
+
+### 3. GridClient (full grid features)
+
+For grid-specific features like job submission, TEE attestation, capacity checks, and pricing:
+
+```python
+from singularity_grid import GridClient
+
+# Public endpoints -- no auth required
+grid = GridClient()
+capacity = grid.capacity()
+models = grid.models()
+pricing = grid.pricing()
+
+print(f"Active nodes: {capacity.active_nodes}/{capacity.total_nodes}")
+for m in models:
+    print(f"  {m.id} -- {m.sgl_node_count} nodes")
+
+# Authenticated endpoints
+grid = GridClient(api_key="scg_your_api_key")
+
+job = grid.submit_job(
+    model="gemma-4-26b",
+    input_payload={
+        "messages": [{"role": "user", "content": "Analyze this data"}]
+    },
+    submitter_wallet="0xYourWallet",
+    submitter_chain="base",
+)
+
+print(f"Job {job.job_id}: {job.status}")
+
+# Retrieve result and attestation
+result = grid.get_job(job.job_id)
+attestation = grid.get_attestation(job.job_id)
+print(f"TEE verified: {attestation.verified}")
+```
+
+## API reference
+
+### GridClient
+
+| Method | Auth | Description |
+|---|---|---|
+| `capacity()` | No | Grid-wide capacity summary |
+| `models()` | No | Available models with pricing and TEE info |
+| `pricing()` | No | Pricing table for all models |
+| `submit_job(model, input_payload, ...)` | Yes | Submit a compute job |
+| `get_job(job_id)` | Yes | Get job status and result |
+| `get_attestation(job_id)` | Yes | Get TEE attestation proof |
+
+### Exceptions
+
+| Exception | When |
+|---|---|
+| `SGLError` | Base class for all SDK errors |
+| `SGLAPIError` | Non-2xx response from the API |
+| `SGLAuthError` | 401 or 403 response |
+| `SGLNotFoundError` | 404 response |
+| `SGLConnectionError` | Orchestrator unreachable or timeout |
+
+### Configuration
+
+| Parameter | Default | Description |
+|---|---|---|
+| `api_key` | `None` | Bearer token for authenticated endpoints |
+| `base_url` | orchestrator URL | Override the orchestrator URL |
+| `timeout` | `60.0` | Request timeout in seconds |
+
+## License
+
+MIT

singularity_grid-0.1.0/README.md

@@ -0,0 +1,124 @@
+# singularity-grid
+
+Python SDK for the SGL Network confidential compute grid. Submit inference jobs to TEE-verified nodes, check grid capacity, and use the OpenAI-compatible chat completions endpoint -- all from a single package.
+
+## Installation
+
+```bash
+pip install singularity-grid
+```
+
+To use the OpenAI compatibility helper:
+
+```bash
+pip install singularity-grid[openai]
+```
+
+## Quick start
+
+### 1. OpenAI-compatible usage (simplest)
+
+The SGL Network orchestrator exposes an OpenAI-compatible `/v1/chat/completions` endpoint. You can use the standard `openai` package with no wrapper:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://sgl-network-orchestrator.ivaavimusicproductions.workers.dev/v1",
+    api_key="scg_your_api_key",
+)
+
+response = client.chat.completions.create(
+    model="gemma-4-26b",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(response.choices[0].message.content)
+```
+
+### 2. Helper function
+
+If you prefer not to copy the URL, use the built-in helper:
+
+```python
+from singularity_grid import create_openai_client
+
+client = create_openai_client(api_key="scg_your_api_key")
+
+response = client.chat.completions.create(
+    model="gemma-4-26b",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(response.choices[0].message.content)
+```
+
+### 3. GridClient (full grid features)
+
+For grid-specific features like job submission, TEE attestation, capacity checks, and pricing:
+
+```python
+from singularity_grid import GridClient
+
+# Public endpoints -- no auth required
+grid = GridClient()
+capacity = grid.capacity()
+models = grid.models()
+pricing = grid.pricing()
+
+print(f"Active nodes: {capacity.active_nodes}/{capacity.total_nodes}")
+for m in models:
+    print(f"  {m.id} -- {m.sgl_node_count} nodes")
+
+# Authenticated endpoints
+grid = GridClient(api_key="scg_your_api_key")
+
+job = grid.submit_job(
+    model="gemma-4-26b",
+    input_payload={
+        "messages": [{"role": "user", "content": "Analyze this data"}]
+    },
+    submitter_wallet="0xYourWallet",
+    submitter_chain="base",
+)
+
+print(f"Job {job.job_id}: {job.status}")
+
+# Retrieve result and attestation
+result = grid.get_job(job.job_id)
+attestation = grid.get_attestation(job.job_id)
+print(f"TEE verified: {attestation.verified}")
+```
+
+## API reference
+
+### GridClient
+
+| Method | Auth | Description |
+|---|---|---|
+| `capacity()` | No | Grid-wide capacity summary |
+| `models()` | No | Available models with pricing and TEE info |
+| `pricing()` | No | Pricing table for all models |
+| `submit_job(model, input_payload, ...)` | Yes | Submit a compute job |
+| `get_job(job_id)` | Yes | Get job status and result |
+| `get_attestation(job_id)` | Yes | Get TEE attestation proof |
+
+### Exceptions
+
+| Exception | When |
+|---|---|
+| `SGLError` | Base class for all SDK errors |
+| `SGLAPIError` | Non-2xx response from the API |
+| `SGLAuthError` | 401 or 403 response |
+| `SGLNotFoundError` | 404 response |
+| `SGLConnectionError` | Orchestrator unreachable or timeout |
+
+### Configuration
+
+| Parameter | Default | Description |
+|---|---|---|
+| `api_key` | `None` | Bearer token for authenticated endpoints |
+| `base_url` | orchestrator URL | Override the orchestrator URL |
+| `timeout` | `60.0` | Request timeout in seconds |
+
+## License
+
+MIT

singularity_grid-0.1.0/examples/check_capacity.py

@@ -0,0 +1,28 @@
+"""Check grid capacity, available models, and pricing (no auth required)."""
+
+from singularity_grid import GridClient
+
+grid = GridClient()
+
+# Grid capacity
+capacity = grid.capacity()
+print(f"Nodes: {capacity.active_nodes}/{capacity.total_nodes} active")
+for tee in capacity.by_tee_type:
+    print(f"  {tee.tee_type}: {tee.active_nodes}/{tee.total_nodes}")
+
+# Available models
+print("\nModels:")
+models = grid.models()
+for m in models:
+    tees = ", ".join(m.sgl_tee_types) if m.sgl_tee_types else "none"
+    print(f"  {m.id} -- {m.sgl_node_count} nodes, TEE: {tees}")
+
+# Pricing
+print("\nPricing:")
+pricing = grid.pricing()
+for p in pricing:
+    print(
+        f"  {p.model}: "
+        f"${p.price_per_1k_input_tokens_usd}/1k input, "
+        f"${p.price_per_1k_output_tokens_usd}/1k output"
+    )

singularity_grid-0.1.0/examples/openai_compatible.py

@@ -0,0 +1,39 @@
+"""Use the SGL Network with the standard OpenAI Python SDK.
+
+The SGL Network orchestrator exposes an OpenAI-compatible /v1/chat/completions
+endpoint, so you can use the openai package directly with no code changes
+beyond swapping the base URL and API key.
+"""
+
+# --- Option 1: raw OpenAI SDK (no singularity-grid import needed) ----------
+
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://sgl-network-orchestrator.ivaavimusicproductions.workers.dev/v1",
+    api_key="scg_your_api_key_here",
+)
+
+response = client.chat.completions.create(
+    model="gemma-4-26b",
+    messages=[{"role": "user", "content": "Hello from the SGL Network!"}],
+)
+print(response.choices[0].message.content)
+
+
+# --- Option 2: use the helper from singularity-grid -----------------------
+
+from singularity_grid import create_openai_client
+
+client2 = create_openai_client(api_key="scg_your_api_key_here")
+
+response2 = client2.chat.completions.create(
+    model="gemma-4-26b",
+    messages=[{"role": "user", "content": "What TEE type processed this?"}],
+)
+print(response2.choices[0].message.content)
+
+# List available models
+models = client2.models.list()
+for m in models.data:
+    print(f"  {m.id} (owned by {m.owned_by})")

singularity_grid-0.1.0/examples/quickstart.py

@@ -0,0 +1,31 @@
+"""Quickstart: submit a job to the SGL Network and retrieve its result."""
+
+from singularity_grid import GridClient
+
+# Authenticated client for job submission
+grid = GridClient(api_key="scg_your_api_key_here")
+
+# Submit an inference job
+job = grid.submit_job(
+    model="gemma-4-26b",
+    input_payload={
+        "messages": [{"role": "user", "content": "Explain zero-knowledge proofs in one paragraph."}]
+    },
+    submitter_wallet="0xYourWalletAddress",
+    submitter_chain="base",
+)
+
+print(f"Job submitted: {job.job_id} (status: {job.status})")
+print(f"Estimated cost: ${job.estimated_cost_usd}")
+
+# Poll for result (in production, use a callback or webhook)
+result = grid.get_job(job.job_id)
+print(f"Job status: {result.status}")
+
+if result.status == "completed":
+    print(f"Result: {result.result}")
+
+    # Verify TEE attestation
+    attestation = grid.get_attestation(job.job_id)
+    print(f"TEE type: {attestation.tee_type}")
+    print(f"Verified: {attestation.verified}")

singularity_grid-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "singularity-grid"
+version = "0.1.0"
+description = "Python SDK for the SGL Network confidential compute grid"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "Singularity Layer", email = "dev@singularitylayer.xyz" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "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",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "httpx>=0.24",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+openai = ["openai>=1.0"]
+
+[project.urls]
+Homepage = "https://singularitylayer.xyz"
+Repository = "https://github.com/SingularityLayer/sgl-network-sdk"
+Documentation = "https://docs.singularitylayer.xyz/sdk"

singularity_grid-0.1.0/singularity_grid/__init__.py

@@ -0,0 +1,50 @@
+"""singularity-grid -- Python SDK for the SGL Network compute grid."""
+
+from .client import (
+    DEFAULT_BASE_URL,
+    GridClient,
+    SGLAPIError,
+    SGLAuthError,
+    SGLConnectionError,
+    SGLError,
+    SGLNotFoundError,
+)
+from .models import (
+    AttestationProof,
+    CapacityResponse,
+    JobResponse,
+    JobResult,
+    ModelInfo,
+    ModelPricing,
+    ModelsResponse,
+    PricingInfo,
+    PricingResponse,
+    TeeCapacity,
+)
+from .openai_compat import create_openai_client
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Client
+    "GridClient",
+    "create_openai_client",
+    "DEFAULT_BASE_URL",
+    # Exceptions
+    "SGLError",
+    "SGLAPIError",
+    "SGLAuthError",
+    "SGLConnectionError",
+    "SGLNotFoundError",
+    # Models
+    "AttestationProof",
+    "CapacityResponse",
+    "JobResponse",
+    "JobResult",
+    "ModelInfo",
+    "ModelPricing",
+    "ModelsResponse",
+    "PricingInfo",
+    "PricingResponse",
+    "TeeCapacity",
+]

singularity_grid-0.1.0/singularity_grid/client.py

@@ -0,0 +1,213 @@
+"""GridClient — main entry point for the SGL Network compute grid."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from .models import (
+    AttestationProof,
+    CapacityResponse,
+    JobResponse,
+    JobResult,
+    ModelInfo,
+    ModelsResponse,
+    PricingInfo,
+    PricingResponse,
+)
+
+DEFAULT_BASE_URL = (
+    "https://sgl-network-orchestrator.ivaavimusicproductions.workers.dev"
+)
+
+DEFAULT_TIMEOUT = 60.0
+
+
+# ---------------------------------------------------------------------------
+# Exceptions
+# ---------------------------------------------------------------------------
+
+class SGLError(Exception):
+    """Base exception for all SGL Network SDK errors."""
+
+
+class SGLAPIError(SGLError):
+    """Raised when the API returns a non-2xx status code."""
+
+    def __init__(
+        self,
+        status_code: int,
+        message: str,
+        body: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.status_code = status_code
+        self.body = body
+        super().__init__(f"HTTP {status_code}: {message}")
+
+
+class SGLAuthError(SGLAPIError):
+    """Raised on 401/403 responses."""
+
+
+class SGLNotFoundError(SGLAPIError):
+    """Raised on 404 responses."""
+
+
+class SGLConnectionError(SGLError):
+    """Raised when the orchestrator is unreachable."""
+
+
+# ---------------------------------------------------------------------------
+# Client
+# ---------------------------------------------------------------------------
+
+class GridClient:
+    """Client for the SGL Network orchestrator API.
+
+    Parameters
+    ----------
+    api_key:
+        Bearer token for authenticated endpoints (e.g. ``scg_...``).
+        Not required for public endpoints like ``capacity()``.
+    base_url:
+        Override the default orchestrator URL.
+    timeout:
+        Request timeout in seconds (default 60).
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        headers: Dict[str, str] = {"Accept": "application/json"}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        self._client = httpx.Client(
+            base_url=self._base_url,
+            headers=headers,
+            timeout=timeout,
+        )
+
+    # -- helpers ------------------------------------------------------------
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Make an HTTP request and return the parsed JSON body."""
+        try:
+            response = self._client.request(
+                method, path, json=json, params=params
+            )
+        except httpx.ConnectError as exc:
+            raise SGLConnectionError(
+                f"Could not connect to {self._base_url}: {exc}"
+            ) from exc
+        except httpx.TimeoutException as exc:
+            raise SGLConnectionError(
+                f"Request to {self._base_url}{path} timed out: {exc}"
+            ) from exc
+
+        if response.status_code >= 400:
+            body: Optional[Dict[str, Any]] = None
+            message = response.text
+            try:
+                body = response.json()
+                message = body.get("error", {}).get("message", message) if isinstance(body.get("error"), dict) else body.get("error", message)
+            except Exception:
+                pass
+
+            if response.status_code in (401, 403):
+                raise SGLAuthError(response.status_code, str(message), body)
+            if response.status_code == 404:
+                raise SGLNotFoundError(response.status_code, str(message), body)
+            raise SGLAPIError(response.status_code, str(message), body)
+
+        if response.status_code == 204:
+            return {}
+        return response.json()  # type: ignore[no-any-return]
+
+    # -- public endpoints (no auth required) --------------------------------
+
+    def capacity(self) -> CapacityResponse:
+        """Return grid-wide capacity summary."""
+        data = self._request("GET", "/grid/capacity")
+        return CapacityResponse.model_validate(data)
+
+    def models(self) -> List[ModelInfo]:
+        """Return available models with pricing and node info."""
+        data = self._request("GET", "/grid/models")
+        wrapped = ModelsResponse.model_validate(data)
+        return wrapped.models
+
+    def pricing(self) -> List[PricingInfo]:
+        """Return the pricing table for all models."""
+        data = self._request("GET", "/grid/pricing")
+        wrapped = PricingResponse.model_validate(data)
+        return wrapped.pricing
+
+    # -- authenticated endpoints --------------------------------------------
+
+    def submit_job(
+        self,
+        model: str,
+        input_payload: Dict[str, Any],
+        *,
+        submitter_wallet: Optional[str] = None,
+        submitter_chain: Optional[str] = None,
+    ) -> JobResponse:
+        """Submit a compute job to the grid.
+
+        Parameters
+        ----------
+        model:
+            Model identifier (e.g. ``"gemma-4-26b"``).
+        input_payload:
+            The request body for the model (e.g. chat messages).
+        submitter_wallet:
+            On-chain wallet address of the submitter.
+        submitter_chain:
+            Chain identifier (e.g. ``"base"``, ``"ethereum"``).
+        """
+        body: Dict[str, Any] = {
+            "model": model,
+            "input": input_payload,
+        }
+        if submitter_wallet is not None:
+            body["submitter_wallet"] = submitter_wallet
+        if submitter_chain is not None:
+            body["submitter_chain"] = submitter_chain
+
+        data = self._request("POST", "/grid/jobs", json=body)
+        return JobResponse.model_validate(data)
+
+    def get_job(self, job_id: str) -> JobResult:
+        """Get the status and result of a previously submitted job."""
+        data = self._request("GET", f"/grid/jobs/{job_id}")
+        return JobResult.model_validate(data)
+
+    def get_attestation(self, job_id: str) -> AttestationProof:
+        """Retrieve the TEE attestation proof for a completed job."""
+        data = self._request("GET", f"/grid/jobs/{job_id}/attestation")
+        return AttestationProof.model_validate(data)
+
+    # -- lifecycle ----------------------------------------------------------
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._client.close()
+
+    def __enter__(self) -> "GridClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

singularity_grid-0.1.0/singularity_grid/models.py

@@ -0,0 +1,110 @@
+"""Pydantic models for SGL Network API responses."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+# ---------------------------------------------------------------------------
+# Capacity
+# ---------------------------------------------------------------------------
+
+class TeeCapacity(BaseModel):
+    """Capacity breakdown for a single TEE type."""
+    tee_type: str
+    total_nodes: int = 0
+    active_nodes: int = 0
+    available_nodes: int = 0
+
+
+class CapacityResponse(BaseModel):
+    """Grid-wide capacity summary returned by GET /grid/capacity."""
+    total_nodes: int = 0
+    active_nodes: int = 0
+    available_nodes: int = 0
+    by_tee_type: List[TeeCapacity] = Field(default_factory=list)
+    updated_at: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Models
+# ---------------------------------------------------------------------------
+
+class ModelPricing(BaseModel):
+    """Pricing for a specific model."""
+    price_per_1k_input_tokens_usd: float = 0.0
+    price_per_1k_output_tokens_usd: float = 0.0
+
+
+class ModelInfo(BaseModel):
+    """Model descriptor returned by GET /grid/models."""
+    id: str
+    owned_by: str = ""
+    sgl_node_count: int = 0
+    sgl_tee_types: List[str] = Field(default_factory=list)
+    sgl_pricing: Optional[ModelPricing] = None
+
+
+class ModelsResponse(BaseModel):
+    """Wrapper for the models list."""
+    models: List[ModelInfo] = Field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Pricing
+# ---------------------------------------------------------------------------
+
+class PricingInfo(BaseModel):
+    """Pricing entry for a single model."""
+    model: str
+    price_per_1k_input_tokens_usd: float = 0.0
+    price_per_1k_output_tokens_usd: float = 0.0
+
+
+class PricingResponse(BaseModel):
+    """Full pricing table returned by GET /grid/pricing."""
+    pricing: List[PricingInfo] = Field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Jobs
+# ---------------------------------------------------------------------------
+
+class JobResponse(BaseModel):
+    """Response from POST /grid/jobs (job submission)."""
+    job_id: str
+    status: str = "pending"
+    model: str = ""
+    node_id: Optional[str] = None
+    tee_type: Optional[str] = None
+    estimated_cost_usd: Optional[float] = None
+    created_at: Optional[str] = None
+
+
+class AttestationProof(BaseModel):
+    """TEE attestation proof for a completed job."""
+    node_id: str = ""
+    tee_type: str = ""
+    job_id: str = ""
+    attestation_signature: str = ""
+    attestation_report: Optional[str] = None
+    verified: bool = False
+    verified_at: Optional[str] = None
+
+
+class JobResult(BaseModel):
+    """Full job result returned by GET /grid/jobs/:id."""
+    id: str
+    status: str = "pending"
+    model: str = ""
+    node_id: Optional[str] = None
+    tee_type: Optional[str] = None
+    result: Optional[Dict[str, Any]] = None
+    encrypted_result: Optional[str] = None
+    attestation_proof: Optional[AttestationProof] = None
+    cost_usd: Optional[float] = None
+    created_at: Optional[str] = None
+    completed_at: Optional[str] = None
+    error: Optional[str] = None

singularity_grid-0.1.0/singularity_grid/openai_compat.py

@@ -0,0 +1,51 @@
+"""Helper to configure the OpenAI SDK for use with the SGL Network."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .client import DEFAULT_BASE_URL
+
+
+def create_openai_client(
+    api_key: str = "sgl-anonymous",
+    base_url: Optional[str] = None,
+    **kwargs,
+):
+    """Return an ``openai.OpenAI`` instance pointed at the SGL Network.
+
+    Parameters
+    ----------
+    api_key:
+        API key for the orchestrator (e.g. ``"scg_..."``).
+        Defaults to ``"sgl-anonymous"`` for unauthenticated access.
+    base_url:
+        Override the default orchestrator URL. The ``/v1`` suffix is
+        appended automatically if not already present.
+    **kwargs:
+        Additional keyword arguments forwarded to ``openai.OpenAI()``.
+
+    Returns
+    -------
+    openai.OpenAI
+        A configured OpenAI client.
+
+    Raises
+    ------
+    ImportError
+        If the ``openai`` package is not installed. Install it with
+        ``pip install singularity-grid[openai]``.
+    """
+    try:
+        from openai import OpenAI  # type: ignore[import-untyped]
+    except ImportError:
+        raise ImportError(
+            "The openai package is required for create_openai_client(). "
+            "Install it with: pip install singularity-grid[openai]"
+        ) from None
+
+    url = base_url or DEFAULT_BASE_URL
+    if not url.endswith("/v1"):
+        url = url.rstrip("/") + "/v1"
+
+    return OpenAI(api_key=api_key, base_url=url, **kwargs)