hexel 0.1.0__py3-none-any.whl

hexel/__init__.py

@@ -0,0 +1,4 @@
+from hexel._client import Hexel
+
+__all__ = ["Hexel"]
+__version__ = "0.1.0"

hexel/_client.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from hexel._internal.auth import AuthManager
+from hexel._internal.http import HttpClient
+from hexel.compute import ComputeClient
+
+
+class Hexel:
+    """
+    Hexel SDK client.
+
+    Usage:
+        from hexel import Hexel
+
+        client = Hexel(api_key="studio_live_xxxx")
+        sandbox = client.compute.sandbox.create(tier="standard")
+        result = sandbox.execute("print(1 + 1)")
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        base_url: str = "https://compute.hexelstudio.com",
+        sts_url: str = "https://sts.hexelstudio.com",
+        timeout: float = 30.0,
+    ):
+        self._auth = AuthManager(
+            api_key=api_key,
+            client_id=client_id,
+            client_secret=client_secret,
+            sts_url=sts_url,
+        )
+        self._http = HttpClient(base_url=base_url, auth=self._auth, timeout=timeout)
+        self.compute = ComputeClient(self._http)

hexel/_internal/__init__.py

@@ -0,0 +1 @@
+

hexel/_internal/auth.py

@@ -0,0 +1,52 @@
+"""Token management — handles API key and client_credentials auth flows."""
+from __future__ import annotations
+import time
+import httpx
+
+
+class AuthManager:
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        sts_url: str = "https://sts.hexelstudio.com",
+    ):
+        self._api_key = api_key
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._sts_url = sts_url
+        self._access_token: str | None = None
+        self._expires_at: float = 0
+        self._http = httpx.Client(timeout=10)
+
+        if not api_key and not (client_id and client_secret):
+            raise ValueError("Provide api_key or (client_id + client_secret)")
+
+    @property
+    def token(self) -> str:
+        if self._access_token and time.time() < self._expires_at - 30:
+            return self._access_token
+        self._refresh()
+        return self._access_token
+
+    def _refresh(self):
+        if self._api_key:
+            resp = self._http.post(
+                f"{self._sts_url}/token",
+                headers={"X-API-Key": self._api_key},
+            )
+        else:
+            resp = self._http.post(
+                f"{self._sts_url}/token",
+                json={
+                    "grant_type": "client_credentials",
+                    "client_id": self._client_id,
+                    "client_secret": self._client_secret,
+                },
+            )
+        resp.raise_for_status()
+        data = resp.json()
+        self._access_token = data["access_token"]
+        self._expires_at = time.time() + data.get("expires_in", 900)

hexel/_internal/http.py

@@ -0,0 +1,48 @@
+"""HTTP request pipeline — retries, auth refresh, error handling."""
+from __future__ import annotations
+import time
+import httpx
+from hexel._internal.auth import AuthManager
+
+RETRY_STATUS = {429, 500, 502, 503}
+MAX_RETRIES = 3
+
+
+class HttpClient:
+    def __init__(self, *, base_url: str, auth: AuthManager, timeout: float = 30.0):
+        self._base_url = base_url.rstrip("/")
+        self._auth = auth
+        self._client = httpx.Client(timeout=timeout)
+
+    def request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        url = f"{self._base_url}{path}"
+        headers = kwargs.pop("headers", {})
+        headers["Authorization"] = f"Bearer {self._auth.token}"
+        headers.setdefault("Content-Type", "application/json")
+
+        for attempt in range(MAX_RETRIES + 1):
+            resp = self._client.request(method, url, headers=headers, **kwargs)
+            if resp.status_code == 401 and attempt == 0:
+                self._auth._refresh()
+                headers["Authorization"] = f"Bearer {self._auth.token}"
+                continue
+            if resp.status_code in RETRY_STATUS and attempt < MAX_RETRIES:
+                time.sleep(0.5 * (2 ** attempt))
+                continue
+            return resp
+        return resp
+
+    def get(self, path, **kw) -> httpx.Response:
+        return self.request("GET", path, **kw)
+
+    def post(self, path, **kw) -> httpx.Response:
+        return self.request("POST", path, **kw)
+
+    def put(self, path, **kw) -> httpx.Response:
+        return self.request("PUT", path, **kw)
+
+    def delete(self, path, **kw) -> httpx.Response:
+        return self.request("DELETE", path, **kw)
+
+    def patch(self, path, **kw) -> httpx.Response:
+        return self.request("PATCH", path, **kw)

hexel/_internal/ws.py

@@ -0,0 +1,30 @@
+"""WebSocket client for sandbox execution."""
+from __future__ import annotations
+import json
+from websockets.sync.client import connect
+from hexel._internal.auth import AuthManager
+
+
+class WSConnection:
+    """Persistent WebSocket connection to a sandbox's agentd."""
+
+    def __init__(self, url: str, auth: AuthManager):
+        self._ws = connect(url, additional_headers={"Authorization": f"Bearer {auth.token}"})
+        msg = json.loads(self._ws.recv())
+        self.context_id = msg.get("data", "")
+
+    def send(self, msg: dict) -> list[dict]:
+        self._ws.send(json.dumps(msg))
+        results = []
+        while True:
+            data = json.loads(self._ws.recv())
+            results.append(data)
+            if data.get("type") in ("done", "execution_complete", "error"):
+                break
+        return results
+
+    def close(self):
+        try:
+            self._ws.close()
+        except Exception:
+            pass

hexel/compute/__init__.py

@@ -0,0 +1,15 @@
+"""Generated by hexel-sdk-generator. Do not edit manually."""
+from hexel.compute._sandbox import SandboxClient
+from hexel.compute._agent import AgentClient
+from hexel.compute._instance import InstanceClient
+
+__all__ = ["ComputeClient", "SandboxClient", "AgentClient", "InstanceClient"]
+
+
+class ComputeClient:
+    """Hexel Compute — deploy agents and run sandboxes."""
+
+    def __init__(self, http):
+        self.sandbox = SandboxClient(http)
+        self.agent = AgentClient(http)
+        self.instance = InstanceClient(http)

hexel/compute/_agent.py

@@ -0,0 +1,45 @@
+"""Generated by hexel-sdk-generator. Do not edit manually."""
+from __future__ import annotations
+from hexel._internal.http import HttpClient
+
+
+class AgentClient:
+    """Agent registry — register and manage agent images"""
+
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def register(self, **kwargs) -> dict:
+        """Register a new agent in the catalog"""
+        resp = self._http.post("/registry/v1/agents", json=kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def list(self) -> dict:
+        """List agents with optional filters"""
+        resp = self._http.get("/registry/v1/agents")
+        resp.raise_for_status()
+        return resp.json()
+
+    def get(self, id: str) -> dict:
+        """Get agent by ID"""
+        resp = self._http.get("/registry/v1/agents/{id}".replace("{id}", id))
+        resp.raise_for_status()
+        return resp.json()
+
+    def update(self, id: str, **kwargs) -> dict:
+        """Update agent fields"""
+        resp = self._http.put("/registry/v1/agents/{id}".replace("{id}", id), json=kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete(self, id: str) -> None:
+        """Delete agent by ID"""
+        resp = self._http.delete("/registry/v1/agents/{id}".replace("{id}", id))
+        resp.raise_for_status()
+
+    def search(self) -> dict:
+        """Find agents matching given capabilities"""
+        resp = self._http.get("/registry/v1/agents/search")
+        resp.raise_for_status()
+        return resp.json()

hexel/compute/_instance.py

@@ -0,0 +1,46 @@
+"""Generated by hexel-sdk-generator. Do not edit manually."""
+from __future__ import annotations
+from hexel._internal.http import HttpClient
+
+
+class InstanceClient:
+    """Agent deployments — deploy agents and manage instances"""
+
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def deploy(self, agent_id: str) -> dict:
+        """Creates a new deployment from a registered agent. Returns a deployment_id to use for all subsequent operations."""
+        resp = self._http.post("/compute/v1/agents/{agent_id}/deploy".replace("{agent_id}", agent_id))
+        resp.raise_for_status()
+        return resp.json()
+
+    def list(self) -> dict:
+        """List all deployments"""
+        resp = self._http.get("/compute/v1/deployments")
+        resp.raise_for_status()
+        data = resp.json()
+        return data if isinstance(data, list) else data.get("agents", data.get("items", []))
+
+    def get(self, deployment_id: str) -> dict:
+        """Get deployment by ID"""
+        resp = self._http.get("/compute/v1/deployments/{deployment_id}".replace("{deployment_id}", deployment_id))
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete(self, deployment_id: str) -> None:
+        """Delete a deployment"""
+        resp = self._http.delete("/compute/v1/deployments/{deployment_id}".replace("{deployment_id}", deployment_id))
+        resp.raise_for_status()
+
+    def stop(self, deployment_id: str) -> dict:
+        """Stop a deployment"""
+        resp = self._http.post("/compute/v1/deployments/{deployment_id}/stop".replace("{deployment_id}", deployment_id))
+        resp.raise_for_status()
+        return resp.json()
+
+    def redeploy(self, deployment_id: str) -> dict:
+        """Redeploy (stop + start)"""
+        resp = self._http.post("/compute/v1/deployments/{deployment_id}/redeploy".replace("{deployment_id}", deployment_id))
+        resp.raise_for_status()
+        return resp.json()

hexel/compute/_sandbox.py

@@ -0,0 +1,52 @@
+"""Generated by hexel-sdk-generator. Do not edit manually."""
+from __future__ import annotations
+from hexel._internal.http import HttpClient
+from hexel._internal.ws import WSConnection
+
+
+class SandboxClient:
+    """Isolated execution environments"""
+
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def create(self, **kwargs) -> dict:
+        """Allocates a VM from the pool or creates a new one for the requesting org"""
+        resp = self._http.post("/compute/v1/vms/allocate", json=kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def list(self) -> dict:
+        """Returns VMs scoped to the caller's org"""
+        resp = self._http.get("/compute/v1/vms")
+        resp.raise_for_status()
+        data = resp.json()
+        return data if isinstance(data, list) else data.get("agents", data.get("items", []))
+
+    def get(self, id: str) -> dict:
+        """Get Agent VM by ID"""
+        resp = self._http.get("/compute/v1/vms/{id}".replace("{id}", id))
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete(self, id: str) -> None:
+        """Delete Agent VM"""
+        resp = self._http.delete("/compute/v1/vms/{id}".replace("{id}", id))
+        resp.raise_for_status()
+
+    def release(self, id: str, **kwargs) -> dict:
+        """Release Agent VM"""
+        resp = self._http.post("/compute/v1/vms/{id}/release".replace("{id}", id), json=kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def renew(self, id: str, **kwargs) -> dict:
+        """Renew Agent VM TTL"""
+        resp = self._http.post("/compute/v1/vms/{id}/renew".replace("{id}", id), json=kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def execute(self, id: str) -> None:
+        """Runs code or shell commands in an allocated sandbox VM"""
+        resp = self._http.post("/compute/v1/vms/{id}/execute".replace("{id}", id))
+        resp.raise_for_status()

hexel/compute/types.py

@@ -0,0 +1,444 @@
+"""Generated by hexel-sdk-generator. Do not edit manually."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any
+
+@dataclass
+class OAuthClient:
+    """iamclient.OAuthClient"""
+    client_id: str | None = None
+    created_at: str | None = None
+    is_active: bool | None = None
+    name: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "OAuthClient":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class OAuthClientResponse:
+    """iamclient.OAuthClientResponse"""
+    client_id: str | None = None
+    client_secret: str | None = None
+    name: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "OAuthClientResponse":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class InstanceInfo:
+    """models.Agent"""
+    allowed_org_ids: list[str] | None = None
+    author: str | None = None
+    capabilities: list[str] | None = None
+    created_at: str | None = None
+    description: str | None = None
+    endpoint: str | None = None
+    id: str | None = None
+    image: str | None = None
+    image_pull_secret: models.ImagePullSecret | None = None
+    manifest: models.AgentManifest | None = None
+    metadata: dict[str, string] | None = None
+    name: str | None = None
+    org_id: str | None = None
+    public_key: str | None = None
+    state: str | None = None
+    updated_at: str | None = None
+    version: str | None = None
+    visibility: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "InstanceInfo":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class SandboxInfo:
+    """models.AgentVM"""
+    allocated_at: str | None = None
+    created_at: str | None = None
+    expires_at: str | None = None
+    id: str | None = None
+    metadata: dict[str, string] | None = None
+    released_at: str | None = None
+    skills: list[str] | None = None
+    state: str | None = None
+    tier: str | None = None
+    token: str | None = None
+    ttl_seconds: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "SandboxInfo":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class CreateSandboxRequest:
+    """models.AllocateRequest"""
+    env: dict[str, string] | None = None
+    metadata: dict[str, string] | None = None
+    org_id: str | None = None
+    secure_runtime: str | None = None
+    skills: list[str] | None = None
+    tier: str
+    ttl_seconds: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "CreateSandboxRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class SandboxResponse:
+    """models.AllocateResponse"""
+    endpoint: str | None = None
+    expires_at: str | None = None
+    skills_loaded: list[str] | None = None
+    state: str | None = None
+    tier: str | None = None
+    token: str | None = None
+    vm_id: str | None = None
+    ws_url: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "SandboxResponse":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class CreateSkillRequest:
+    """models.CreateSkillRequest"""
+    content: str
+    description: str | None = None
+    name: str
+    resources: dict[str, string] | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "CreateSkillRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class ErrorResponse:
+    """models.ErrorResponse"""
+    code: int | None = None
+    message: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "ErrorResponse":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class PoolConfig:
+    """models.PoolConfig"""
+    default_skills: list[str] | None = None
+    default_tier: str | None = None
+    idle_ttl_seconds: int | None = None
+    max_total: int | None = None
+    max_vm_ttl_seconds: int | None = None
+    max_warm: int | None = None
+    min_warm: int | None = None
+    recycle: bool | None = None
+    scale_up_threshold: float | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "PoolConfig":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class PoolStatus:
+    """models.PoolStatus"""
+    allocated: int | None = None
+    by_tier: dict[str, integer] | None = None
+    total: int | None = None
+    warm: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "PoolStatus":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class ReleaseRequest:
+    """models.ReleaseRequest"""
+    recycle: bool | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "ReleaseRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class RenewRequest:
+    """models.RenewRequest"""
+    ttl_seconds: int
+    @classmethod
+    def from_dict(cls, d: dict) -> "RenewRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class Skill:
+    """models.Skill"""
+    content: str | None = None
+    content_hash: str | None = None
+    created_at: str | None = None
+    description: str | None = None
+    name: str | None = None
+    resources: dict[str, string] | None = None
+    updated_at: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "Skill":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class UsageRecord:
+    """models.UsageRecord"""
+    duration_seconds: int | None = None
+    ended_at: str | None = None
+    reason: str | None = None
+    started_at: str | None = None
+    tier: str | None = None
+    vm_id: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "UsageRecord":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class UsageSummary:
+    """models.UsageSummary"""
+    by_tier: dict[str, integer] | None = None
+    period_end: str | None = None
+    period_start: str | None = None
+    total_seconds: int | None = None
+    vm_count: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "UsageSummary":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class AgentManifest:
+    """models.AgentManifest"""
+    authentication: dict | None = None
+    capabilities: dict | None = None
+    description: str | None = None
+    input_schema: dict | None = None
+    name: str | None = None
+    output_schema: dict | None = None
+    runtime: dict | None = None
+    skills: list[models.ManifestSkill] | None = None
+    url: str | None = None
+    version: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "AgentManifest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class AgentResponse:
+    """models.AgentResponse"""
+    agent: models.Agent | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "AgentResponse":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class AgentsListResponse:
+    """models.AgentsListResponse"""
+    agents: list[models.Agent] | None = None
+    total: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "AgentsListResponse":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class CreateAgentRequest:
+    """models.CreateAgentRequest"""
+    author: str | None = None
+    capabilities: list[str] | None = None
+    description: str | None = None
+    endpoint: str | None = None
+    image: str
+    image_pull_secret: models.ImagePullSecret | None = None
+    manifest: models.AgentManifest | None = None
+    metadata: dict[str, string] | None = None
+    name: str
+    org_id: str
+    version: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "CreateAgentRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class CreateToolRequest:
+    """models.CreateToolRequest"""
+    category: str | None = None
+    description: str | None = None
+    id: str
+    name: str
+    @classmethod
+    def from_dict(cls, d: dict) -> "CreateToolRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class ImagePullSecret:
+    """models.ImagePullSecret"""
+    password: str | None = None
+    registry: str | None = None
+    username: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "ImagePullSecret":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class ManifestSkill:
+    """models.ManifestSkill"""
+    id: str | None = None
+    inputModes: list[str] | None = None
+    outputModes: list[str] | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "ManifestSkill":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class Tool:
+    """models.Tool"""
+    category: str | None = None
+    created_at: str | None = None
+    description: str | None = None
+    id: str | None = None
+    name: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "Tool":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class ToolResponse:
+    """models.ToolResponse"""
+    tool: models.Tool | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "ToolResponse":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class ToolsListResponse:
+    """models.ToolsListResponse"""
+    tools: list[models.Tool] | None = None
+    total: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "ToolsListResponse":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class UpdateAgentRequest:
+    """models.UpdateAgentRequest"""
+    capabilities: list[str] | None = None
+    description: str | None = None
+    endpoint: str | None = None
+    image: str | None = None
+    manifest: models.AgentManifest | None = None
+    metadata: dict[str, string] | None = None
+    name: str | None = None
+    public_key: str | None = None
+    state: str | None = None
+    version: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "UpdateAgentRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class CodeContext:
+    """models.CodeContext"""
+    created_at: str | None = None
+    id: str | None = None
+    kernel_id: str | None = None
+    language: str | None = None
+    session_id: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "CodeContext":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class CommandStatus:
+    """models.CommandStatus"""
+    exit_code: int | None = None
+    finished_at: str | None = None
+    id: str | None = None
+    running: bool | None = None
+    started_at: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "CommandStatus":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class CreateContextRequest:
+    """models.CreateContextRequest"""
+    language: str
+    session_id: str
+    @classmethod
+    def from_dict(cls, d: dict) -> "CreateContextRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class ExecuteCodeRequest:
+    """models.ExecuteCodeRequest"""
+    code: str
+    context_id: str
+    @classmethod
+    def from_dict(cls, d: dict) -> "ExecuteCodeRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class ExecuteRequest:
+    """models.ExecuteRequest"""
+    @classmethod
+    def from_dict(cls, d: dict) -> "ExecuteRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class FileInfo:
+    """models.FileInfo"""
+    group: str | None = None
+    is_dir: bool | None = None
+    mod_time: str | None = None
+    mode: str | None = None
+    owner: str | None = None
+    path: str | None = None
+    size: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "FileInfo":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class LoadSkillsRequest:
+    """models.LoadSkillsRequest"""
+    skills: list[str]
+    @classmethod
+    def from_dict(cls, d: dict) -> "LoadSkillsRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class MetricsSnapshot:
+    """models.MetricsSnapshot"""
+    cpu_percent: float | None = None
+    mem_total_bytes: int | None = None
+    mem_used_bytes: int | None = None
+    tokens_total: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "MetricsSnapshot":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class RunCommandRequest:
+    """models.RunCommandRequest"""
+    background: bool | None = None
+    command: str
+    cwd: str | None = None
+    envs: dict[str, string] | None = None
+    gid: int | None = None
+    timeout_ms: int | None = None
+    uid: int | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "RunCommandRequest":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class SSEEvent:
+    """models.SSEEvent"""
+    data: str | None = None
+    event: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "SSEEvent":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+@dataclass
+class SkillInfo:
+    """models.SkillInfo"""
+    loaded: bool | None = None
+    name: str | None = None
+    path: str | None = None
+    @classmethod
+    def from_dict(cls, d: dict) -> "SkillInfo":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+

hexel-0.1.0.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: hexel
+Version: 0.1.0
+Summary: Hexel Studio SDK — deploy and run AI agents
+Project-URL: Homepage, https://hexelstudio.com
+Project-URL: Documentation, https://docs.hexelstudio.com
+Project-URL: Repository, https://github.com/hexelstudio/python-sdk
+Project-URL: Changelog, https://docs.hexelstudio.com/changelog
+Author-email: Hexel Studio <support@hexelstudio.com>
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,code-execution,compute,hexel,sandbox
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: jinja2; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Hexel Python SDK
+
+The official Python SDK for [Hexel Studio](https://hexelstudio.com) — build, deploy, and run AI agents.
+
+## Install
+
+```bash
+pip install hexel
+```
+
+## Quick Start
+
+```python
+from hexel import Hexel
+
+client = Hexel(api_key="your_api_key")
+
+# Create a sandbox and execute code
+sandbox = client.compute.sandbox.create(tier="standard")
+print(sandbox)  # {"vm_id": "...", "state": "allocated", ...}
+
+# Register an agent
+agent = client.compute.agent.register(
+    name="my-agent",
+    image="ghcr.io/org/agent:v1",
+    capabilities=["chat", "streaming"],
+)
+
+# Deploy an agent
+instance = client.compute.instance.deploy(agent["id"], env={"MODEL": "gpt-4"})
+print(instance["endpoint"])  # https://zeal-isle-a620.compute.hexelstudio.com
+```
+
+## Authentication
+
+Two authentication methods are supported:
+
+```python
+# API Key (recommended for development)
+client = Hexel(api_key="studio_live_xxxx")
+
+# OAuth Client Credentials (recommended for production)
+client = Hexel(client_id="your_client_id", client_secret="your_client_secret")
+```
+
+Both methods exchange credentials for a short-lived STS token automatically. Tokens are cached and refreshed transparently.
+
+## Sandboxes
+
+Sandboxes are isolated execution environments allocated instantly.
+
+```python
+# Create
+sandbox = client.compute.sandbox.create(tier="standard")
+
+# Execute code (HTTP)
+result = client.compute.sandbox.execute(sandbox["vm_id"], code="print(1+1)", language="python")
+
+# List
+sandboxes = client.compute.sandbox.list()
+
+# Renew TTL
+client.compute.sandbox.renew(sandbox["vm_id"], ttl_seconds=3600)
+
+# Release
+client.compute.sandbox.release(sandbox["vm_id"], recycle=True)
+
+# Delete
+client.compute.sandbox.delete(sandbox["vm_id"])
+```
+
+## Agents
+
+Agents are Docker images registered in the Hexel registry.
+
+```python
+# Register
+agent = client.compute.agent.register(
+    name="fraud-detector",
+    image="ghcr.io/org/fraud-agent:v1",
+    capabilities=["fraud-detection"],
+)
+
+# List
+agents = client.compute.agent.list()
+
+# Get
+agent = client.compute.agent.get("agent-id")
+
+# Search
+results = client.compute.agent.search(q="fraud")
+
+# Delete
+client.compute.agent.delete("agent-id")
+```
+
+## Instances
+
+Instances are running deployments of agents with permanent endpoints.
+
+```python
+# Deploy
+instance = client.compute.instance.deploy("agent-id", env={"MODEL": "gpt-4"})
+
+# List
+instances = client.compute.instance.list()
+
+# Get
+instance = client.compute.instance.get("deployment-id")
+
+# Stop
+client.compute.instance.stop("deployment-id")
+
+# Redeploy
+client.compute.instance.redeploy("deployment-id")
+
+# Delete
+client.compute.instance.delete("deployment-id")
+```
+
+## Configuration
+
+```python
+client = Hexel(
+    api_key="...",
+)
+```
+
+## Requirements
+
+- Python 3.10+
+- `httpx` for HTTP
+- `websockets` for WebSocket connections
+
+## License
+
+MIT

hexel-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+hexel/__init__.py,sha256=pqLIT-XJ5MV5_lwu0uRjq4k0rN46hIThTAj_VT_kJ3o,75
+hexel/_client.py,sha256=0v7U4uKDvbqj0Xuj0NcIK-gSckjNBQixLxNN_rbNqMg,1048
+hexel/_internal/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hexel/_internal/auth.py,sha256=OEIXIcLOYY5TpbNYN5d0MDOti0yi0Zx0iOYaR3w5bIw,1690
+hexel/_internal/http.py,sha256=asf6z0mNSmIO8FN4ogEpYE-ZHvSP7LztdWpDAq9PTkw,1755
+hexel/_internal/ws.py,sha256=e7k21FbcJ-8ntSwLfCC8trJBYk-Fp6AbKPOpts_pOak,938
+hexel/compute/__init__.py,sha256=oJO8SyRlraF6VOh1Oiqov3CZmG_8lzE2oNZ8f-XrOWk,528
+hexel/compute/_agent.py,sha256=_67qe_I4pxhXiZ7dqRNNXrKILM-nUGGhVXzv2eNWGVQ,1529
+hexel/compute/_instance.py,sha256=PgI2oPeQ6LGLQ_DQ4nOIScRLM87G3VR8Li1I9XS17Fw,1936
+hexel/compute/_sandbox.py,sha256=4I1BJ-gfX80Y-tiMlR_Q4i5ENymCfP5UIRh7OF1cNjQ,1940
+hexel/compute/types.py,sha256=g8eAOzDTbfHdADv8gCIc4PxzrblNZaxkxqsNvuprNw0,14172
+hexel-0.1.0.dist-info/METADATA,sha256=gDydkxiz9mWx7sU3ztWItH90ltTvMQqfnVdDhTZ-MZY,3996
+hexel-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+hexel-0.1.0.dist-info/licenses/LICENSE,sha256=ySBBNUwEDBWR30cEUtGKYC6OaT0HCSY1Unk4YnNJfB8,1069
+hexel-0.1.0.dist-info/RECORD,,

hexel-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hexel-0.1.0.dist-info/licenses/LICENSE

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