singularity-grid 0.9.1__tar.gz → 0.9.2__tar.gz

{singularity_grid-0.9.1 → singularity_grid-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: singularity-grid
-Version: 0.9.1
+Version: 0.9.2
 Summary: Python SDK for the SGL Network confidential compute grid (end-to-end encrypted + streaming)
 Project-URL: Homepage, https://singularitylayer.xyz
 Project-URL: Repository, https://github.com/Singularity-Layer/sgl-network-sdk
@@ -119,6 +119,39 @@ attestation = grid.get_attestation(job.job_id)
 print(f"TEE verified: {attestation.verified}")
 ```
 
+### 4. System One / Laya
+
+Laya is served as a typed-decision model, not as chat completions.
+
+```python
+from singularity_grid import GridClient
+
+grid = GridClient(api_key="x402c_your_api_key")
+
+systemone_models = grid.systemone_models()
+print([model["id"] for model in systemone_models])
+
+decision = grid.system_one(
+    model="convaiinnovations/laya",
+    state={"ticket": "Enterprise customer cannot access billing exports"},
+    questions={
+        "route": {
+            "type": "choice",
+            "instructions": "Choose the best team.",
+            "criteria": {
+                "billing": "Billing, invoice, refund, or account credit issue.",
+                "support": "Product defect or technical troubleshooting.",
+            },
+        },
+        "urgency": {
+            "type": "score",
+            "instructions": "Score urgency from 0 to 1.",
+        },
+    },
+)
+print(decision["answers"])
+```
+
 ## API reference
 
 ### GridClient
@@ -127,7 +160,10 @@ print(f"TEE verified: {attestation.verified}")
 |---|---|---|
 | `capacity()` | No | Grid-wide capacity summary |
 | `models()` | No | Available models with pricing and TEE info |
+| `v1_models(type=None)` | No | OpenAI-compatible model list; pass `type="systemone"` for Laya |
+| `systemone_models()` | No | List Laya/System One typed-decision models |
 | `pricing()` | No | Pricing table for all models |
+| `system_one(state, questions, ...)` | Yes | Call `/v1/systemone` for typed decisions |
 | `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 |

{singularity_grid-0.9.1 → singularity_grid-0.9.2}/README.md

@@ -88,6 +88,39 @@ attestation = grid.get_attestation(job.job_id)
 print(f"TEE verified: {attestation.verified}")
 ```
 
+### 4. System One / Laya
+
+Laya is served as a typed-decision model, not as chat completions.
+
+```python
+from singularity_grid import GridClient
+
+grid = GridClient(api_key="x402c_your_api_key")
+
+systemone_models = grid.systemone_models()
+print([model["id"] for model in systemone_models])
+
+decision = grid.system_one(
+    model="convaiinnovations/laya",
+    state={"ticket": "Enterprise customer cannot access billing exports"},
+    questions={
+        "route": {
+            "type": "choice",
+            "instructions": "Choose the best team.",
+            "criteria": {
+                "billing": "Billing, invoice, refund, or account credit issue.",
+                "support": "Product defect or technical troubleshooting.",
+            },
+        },
+        "urgency": {
+            "type": "score",
+            "instructions": "Score urgency from 0 to 1.",
+        },
+    },
+)
+print(decision["answers"])
+```
+
 ## API reference
 
 ### GridClient
@@ -96,7 +129,10 @@ print(f"TEE verified: {attestation.verified}")
 |---|---|---|
 | `capacity()` | No | Grid-wide capacity summary |
 | `models()` | No | Available models with pricing and TEE info |
+| `v1_models(type=None)` | No | OpenAI-compatible model list; pass `type="systemone"` for Laya |
+| `systemone_models()` | No | List Laya/System One typed-decision models |
 | `pricing()` | No | Pricing table for all models |
+| `system_one(state, questions, ...)` | Yes | Call `/v1/systemone` for typed decisions |
 | `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 |

{singularity_grid-0.9.1 → singularity_grid-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "singularity-grid"
-version = "0.9.1"
+version = "0.9.2"
 description = "Python SDK for the SGL Network confidential compute grid (end-to-end encrypted + streaming)"
 readme = "README.md"
 license = "MIT"

{singularity_grid-0.9.1 → singularity_grid-0.9.2}/singularity_grid/__init__.py

@@ -29,7 +29,7 @@ from .models import (
 )
 from .openai_compat import create_openai_client
 
-__version__ = "0.2.0"
+__version__ = "0.9.2"
 
 __all__ = [
     # Processors — a SEPARATE client on processors.x402compute.cc. Until 0.9.0 these methods

{singularity_grid-0.9.1 → singularity_grid-0.9.2}/singularity_grid/client.py

@@ -170,6 +170,22 @@ class GridClient:
         wrapped = PricingResponse.model_validate(data)
         return wrapped.pricing
 
+    def v1_models(self, type: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Return OpenAI-compatible ``/v1/models`` descriptors.
+
+        Pass ``type="systemone"`` to discover Laya/Jev-style typed-decision
+        models.
+        """
+        params: Dict[str, Any] = {}
+        if type is not None:
+            params["type"] = type
+        data = self._request("GET", "/v1/models", params=params or None)
+        return list(data.get("data", []))
+
+    def systemone_models(self) -> List[Dict[str, Any]]:
+        """List Laya/Jev-style System One typed-decision models."""
+        return self.v1_models(type="systemone")
+
     # -- authenticated endpoints --------------------------------------------
 
     def submit_job(
@@ -310,6 +326,9 @@ class GridClient:
         sealed = data.get("sealed_result")
         if not sealed:
             raise SGLAPIError(500, "No sealed result returned")
+        # Prove WHO produced this before opening it. AEAD only proves someone
+        # sealed it to our key, and the orchestrator knows that key.
+        e2e.require_verified_reply(reservation, data)
         plain = e2e.open_output(resp_sk, resp_pub, sealed["ephemeral_public_key"], sealed["ciphertext"])
         parsed = _json.loads(plain)
         return {
@@ -357,6 +376,44 @@ class GridClient:
                 raise SGLAPIError(402, "Payment required — pass api_key (credits); the Python GridClient does not sign x402 payments.") from err
             raise
 
+    def system_one(
+        self,
+        state: Dict[str, Any],
+        questions: Dict[str, Dict[str, Any]],
+        *,
+        model: str = "convaiinnovations/laya",
+        node: Optional[str] = None,
+        cluster: Optional[str] = None,
+        max_price: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Call Laya/System One typed decisions via ``POST /v1/systemone``.
+
+        This is not a chat-completions model. Use it for compact typed outputs
+        such as choices, scores, and no-output-language summaries. Requires
+        ``api_key`` (credits); x402 pay-per-call is not signed by this client.
+        """
+        body: Dict[str, Any] = {
+            "model": model,
+            "state": state,
+            "questions": questions,
+        }
+        if node is not None:
+            body["node"] = node
+        if cluster is not None:
+            body["cluster"] = cluster
+        if max_price is not None:
+            body["max_price"] = max_price
+        try:
+            return self._request("POST", "/v1/systemone", json=body)
+        except SGLAPIError as err:
+            if err.status_code == 402:
+                raise SGLAPIError(402, "Payment required — pass api_key (credits); the Python GridClient does not sign x402 payments.") from err
+            raise
+
+    def systemone(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """Alias for :meth:`system_one` matching the HTTP endpoint spelling."""
+        return self.system_one(*args, **kwargs)
+
     def embed(self, model: str, input: Any, **kwargs: Any) -> List[List[float]]:
         """Convenience wrapper around :meth:`embeddings` that returns just the list of
         vectors, ordered to match ``input``."""
@@ -417,6 +474,9 @@ class GridClient:
                 sealed = data.get("sealed_result")
                 if not sealed:
                     raise SGLAPIError(500, "No sealed result returned")
+                # Same check on the non-streaming fallback: an orchestrator that
+                # can force this path must not get an unverified reply through it.
+                e2e.require_verified_reply(reservation, data)
                 plain = e2e.open_output(resp_sk, resp_pub, sealed["ephemeral_public_key"], sealed["ciphertext"])
                 content = _json.loads(plain).get("content", "")
                 if content:
@@ -453,6 +513,24 @@ class GridClient:
                         raise SGLAPIError(502, "stream chunk 0 missing ephemeral key")
                     out_key = e2e.stream_out_key(resp_sk, stream_eph)
                 is_final = chunk.get("final") is True
+                # Verify EVERY chunk before opening it. The node signs each with
+                # kind "stream:{seq}:{final}" over the chunk ciphertext, and the
+                # orchestrator relays that signature rather than consuming it.
+                # Without this a compromised relay could splice or invent chunks,
+                # i.e. edit the answer as it arrives.
+                if chunk.get("sigv") and chunk["sigv"] != "v1":
+                    raise e2e.UnverifiedReply(f"unknown chunk envelope version {chunk['sigv']!r}")
+                kind = f"stream:{seq}:{1 if is_final else 0}"
+                if not e2e.verify_result_envelope(
+                    reservation.get("node_ed25519_pubkey"),
+                    chunk.get("job"),
+                    kind,
+                    chunk["ct"],
+                    chunk.get("sig"),
+                ):
+                    raise e2e.UnverifiedReply(
+                        f"stream chunk {seq} is not signed by the reserved node — refusing it."
+                    )
                 text = e2e.open_stream_chunk(out_key, resp_pub, stream_eph, nonce, seq, is_final, chunk["ct"]).decode()
                 if text:
                     yield text

{singularity_grid-0.9.1 → singularity_grid-0.9.2}/singularity_grid/e2e.py

@@ -80,6 +80,83 @@ def seal_input(node_pub_b58: str, resp_pub_b58: str, plaintext: bytes) -> tuple[
     return _b58e(nonce + ct), eph_b58
 
 
+class UnverifiedReply(Exception):
+    """A sealed reply could not be proven to come from the reserved node."""
+
+
+def verify_result_envelope(
+    node_ed25519_b58: str | None,
+    job_id: str | None,
+    kind: str,
+    ciphertext: str,
+    signature_b58: str | None,
+) -> bool:
+    """Verify the node's v1 envelope signature over a sealed reply.
+
+    The signature covers the PUBLIC ciphertext, not the plaintext, so it can be
+    checked exactly -- no re-serialising, no key-ordering problem. Message:
+    ``sgl-result-v1\\n{job_id}\\n{kind}\\n{sha256_hex(ciphertext)}``, and the
+    ciphertext is hashed as the literal UTF-8 string, not as decoded bytes.
+    """
+    if not node_ed25519_b58 or not signature_b58 or not job_id:
+        return False
+    try:
+        from hashlib import sha256
+
+        from nacl.signing import VerifyKey
+
+        digest = sha256(ciphertext.encode()).hexdigest()
+        msg = f"sgl-result-v1\n{job_id}\n{kind}\n{digest}".encode()
+        VerifyKey(_b58d(node_ed25519_b58)).verify(msg, _b58d(signature_b58))
+        return True
+    except Exception:
+        return False
+
+
+def require_verified_reply(
+    reservation: dict,
+    data: dict,
+    kind: str = "sealed",
+) -> None:
+    """Refuse a sealed reply we cannot attribute to the reserved node.
+
+    Why this is mandatory rather than best-effort: ``client_response_pubkey``
+    reaches the orchestrator in cleartext, so a compromised orchestrator cannot
+    READ a prompt but CAN fabricate a reply, seal it to that key, and have it
+    decrypt cleanly. AEAD proves only that someone sealed it to us; this proves
+    WHO. Without it the grid could put words in the model's mouth -- and for an
+    agentic caller, tool calls in its hands.
+
+    A MISSING signature fails exactly like an invalid one. Every sealed reply
+    carries one, so absence means something is wrong, and "warn and continue" is
+    what let this gap survive unnoticed in the first place.
+    """
+    sealed = data.get("sealed_result") or {}
+    version = data.get("result_envelope_version")
+    if version is not None and version != "v1":
+        raise UnverifiedReply(f"unknown result envelope version {version!r}")
+    # `job_id` is explicit on current grids; older ones only embed it in `id`.
+    job_id = data.get("job_id")
+    if not job_id:
+        raw_id = data.get("id") or ""
+        job_id = raw_id[len("chatcmpl-") :] if raw_id.startswith("chatcmpl-") else None
+    ok = verify_result_envelope(
+        reservation.get("node_ed25519_pubkey"),
+        job_id,
+        kind,
+        sealed.get("ciphertext", ""),
+        data.get("result_envelope_signature"),
+    )
+    if not ok:
+        # NEVER fall back to `result_signature`: that legacy field signs the
+        # PLAINTEXT and is always absent for sealed replies, so reaching for it
+        # would make this check silently meaningless.
+        raise UnverifiedReply(
+            "sealed reply is not signed by the reserved node — refusing it. "
+            "Update the grid if this persists."
+        )
+
+
 def open_output(resp_sk: bytes, resp_pub_b58: str, node_eph_b58: str, ct_b58: str) -> bytes:
     """Open the node's (non-stream) reply sealed to our response key."""
     shared = bindings.crypto_scalarmult(resp_sk, _b58d(node_eph_b58))