osva-sdk 1.0.0__tar.gz

osva_sdk-1.0.0/.gitignore

@@ -0,0 +1,53 @@
+node_modules/
+.pnpm-store/
+.next/
+dist/
+/dist-helm-rc/
+build/
+out/
+coverage/
+.turbo/
+.osva/
+
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+.DS_Store
+Thumbs.db
+desktop.ini
+
+.idea/
+.vscode/*
+!.vscode/extensions.json
+
+playwright-report/
+test-results/
+blob-report/
+
+*.sqlite
+*.sqlite3
+data/
+tmp/
+temp/
+
+docker-compose.override.yml
+*.tsbuildinfo
+.cache/
+
+# Python SDK artifacts
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.egg-info/
+.venv/
+sdks/python/dist/
+sdks/python/build/

osva_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.5
+Name: osva-sdk
+Version: 1.0.0
+Summary: Official OSVA SDK for Python
+Project-URL: Homepage, https://github.com/Osva-AI/osva
+Project-URL: Repository, https://github.com/Osva-AI/osva
+Project-URL: Documentation, https://github.com/Osva-AI/osva/blob/main/docs/OSS-1.0-QUICKSTART.md
+License-Expression: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.13; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# osva-sdk
+
+Official OSVA SDK for Python (>=3.11).
+
+The package is publish-ready but not yet published to PyPI.

osva_sdk-1.0.0/README.md

@@ -0,0 +1,5 @@
+# osva-sdk
+
+Official OSVA SDK for Python (>=3.11).
+
+The package is publish-ready but not yet published to PyPI.

osva_sdk-1.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "osva-sdk"
+version = "1.0.0"
+description = "Official OSVA SDK for Python"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.11"
+dependencies = [
+  "httpx>=0.27",
+]
+
+[project.urls]
+Homepage = "https://github.com/Osva-AI/osva"
+Repository = "https://github.com/Osva-AI/osva"
+Documentation = "https://github.com/Osva-AI/osva/blob/main/docs/OSS-1.0-QUICKSTART.md"
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2",
+  "mypy>=1.13",
+  "pytest>=8.3",
+  "pytest-asyncio>=0.24",
+  "ruff>=0.8",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/osva"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+packages = ["osva"]
+mypy_path = "src"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

osva_sdk-1.0.0/scripts/integration_runtime_server.py

@@ -0,0 +1,128 @@
+"""Minimal REMOTE_HTTP runtime server for OSVA integration tests."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any
+
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+from osva.runtime.runtime import Runtime
+
+runtime = Runtime()
+
+
+@runtime.execute
+async def execute(input: Any, context: Any) -> Any:
+    if isinstance(input, dict) and input.get("mode") == "model":
+        result = await context.models.generate_text(
+            binding="primary",
+            messages=[{"role": "user", "content": "hello from python"}],
+        )
+        return {"text": result["text"]}
+    if isinstance(input, dict):
+        return {"echo": input}
+    return input
+
+
+class Handler(BaseHTTPRequestHandler):
+    def do_POST(self) -> None:  # noqa: N802
+        if self.path != "/execute":
+            self.send_response(404)
+            self.end_headers()
+            return
+
+        raw = self._read_body()
+        try:
+            body = json.loads(raw.decode("utf-8"))
+        except json.JSONDecodeError:
+            self._send_json(
+                400,
+                {
+                    "protocolVersion": "1",
+                    "outcome": "FAILED",
+                    "error": {
+                        "code": "RUNTIME_PROTOCOL_FAILURE",
+                        "message": "Request body must be valid JSON.",
+                    },
+                },
+            )
+            return
+
+        if not isinstance(body, dict):
+            self._send_json(
+                400,
+                {
+                    "protocolVersion": "1",
+                    "outcome": "FAILED",
+                    "error": {
+                        "code": "RUNTIME_PROTOCOL_FAILURE",
+                        "message": "Request body must be a JSON object.",
+                    },
+                },
+            )
+            return
+
+        try:
+            result = _run_async(runtime.handle_execute_request(body))
+        except Exception as error:  # noqa: BLE001
+            self._send_json(
+                400,
+                {
+                    "protocolVersion": "1",
+                    "outcome": "FAILED",
+                    "error": {
+                        "code": "RUNTIME_PROTOCOL_FAILURE",
+                        "message": str(error),
+                    },
+                },
+            )
+            return
+
+        self._send_json(200, result)
+
+    def _read_body(self) -> bytes:
+        length = self.headers.get("content-length")
+        if length is None:
+            raise ValueError("Content-Length header is required.")
+        return self.rfile.read(int(length))
+
+    def log_message(self, format: str, *args: Any) -> None:
+        return
+
+    def _send_json(self, status: int, payload: dict[str, Any]) -> None:
+        encoded = json.dumps(payload).encode("utf-8")
+        self.send_response(status)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+
+def _run_async(coro: Any) -> Any:
+    loop = asyncio.new_event_loop()
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        loop.close()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=0)
+    args = parser.parse_args()
+
+    server = ThreadingHTTPServer((args.host, args.port), Handler)
+    host, port = server.server_address
+    print(json.dumps({"host": host, "port": port}), flush=True)
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

osva_sdk-1.0.0/src/osva/__init__.py

@@ -0,0 +1,6 @@
+"""Official OSVA SDK for Python."""
+
+from osva.client import OSVAClient
+from osva.errors import OSVAAPIError, OSVATransportError
+
+__all__ = ["OSVAClient", "OSVAAPIError", "OSVATransportError"]

osva_sdk-1.0.0/src/osva/client.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from osva.http_client import HTTPClient
+from osva.resources.agents import AgentsResource
+from osva.resources.approvals import ApprovalsResource
+from osva.resources.artifacts import ArtifactsResource
+from osva.resources.office import (
+    AssignmentsResource,
+    GoalsResource,
+    OfficeWorkersResource,
+    RolesResource,
+    TeamsResource,
+)
+from osva.resources.runs import RunsResource
+from osva.resources.schedules import SchedulesResource
+from osva.resources.workflow_runs import WorkflowRunsResource
+from osva.resources.workflows import WorkflowsResource
+
+
+class OSVAClient:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        timeout_seconds: float = 30.0,
+        client: HTTPClient | None = None,
+    ) -> None:
+        self._http = client or HTTPClient(
+            base_url,
+            api_key=api_key,
+            timeout_seconds=timeout_seconds,
+        )
+        self.agents = AgentsResource(self._http)
+        self.runs = RunsResource(self._http)
+        self.workflows = WorkflowsResource(self._http)
+        self.workflow_runs = WorkflowRunsResource(self._http)
+        self.approvals = ApprovalsResource(self._http)
+        self.schedules = SchedulesResource(self._http)
+        self.artifacts = ArtifactsResource(self._http)
+        self.office_workers = OfficeWorkersResource(self._http)
+        self.roles = RolesResource(self._http)
+        self.teams = TeamsResource(self._http)
+        self.goals = GoalsResource(self._http)
+        self.assignments = AssignmentsResource(self._http)

osva_sdk-1.0.0/src/osva/errors.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class OSVAAPIError(Exception):
+    def __init__(self, status: int, body: dict[str, Any]) -> None:
+        domain = body.get("status", "error")
+        super().__init__(f"OSVA API request failed with HTTP {status} ({domain}).")
+        self.status = status
+        self.body = body
+
+
+class OSVATransportError(Exception):
+    pass

osva_sdk-1.0.0/src/osva/http_client.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+from osva.errors import OSVAAPIError, OSVATransportError
+
+
+class HTTPClient:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        api_key: str,
+        timeout_seconds: float = 30.0,
+        client: httpx.Client | None = None,
+    ) -> None:
+        normalized = base_url.strip().rstrip("/")
+        if not normalized:
+            raise ValueError("base_url must not be empty.")
+        trimmed_key = api_key.strip()
+        if not trimmed_key:
+            raise ValueError("api_key must not be empty.")
+        self._base_url = normalized
+        self._timeout = timeout_seconds
+        self._api_key = trimmed_key
+        self._client = client or httpx.Client(timeout=timeout_seconds)
+
+    def _auth_headers(self, headers: dict[str, str] | None = None) -> dict[str, str]:
+        merged = dict(headers or {})
+        merged.setdefault("authorization", f"Bearer {self._api_key}")
+        return merged
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: dict[str, str | None] | None = None,
+        body: Any | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        params = {key: value for key, value in (query or {}).items() if value is not None}
+        url = f"{self._base_url}{path if path.startswith('/') else f'/{path}'}"
+        request_headers = self._auth_headers(headers)
+        if body is not None:
+            request_headers = {**request_headers, "content-type": "application/json"}
+        try:
+            response = self._client.request(
+                method,
+                url,
+                params=params,
+                json=body,
+                headers=request_headers,
+            )
+        except httpx.HTTPError as error:
+            raise OSVATransportError("OSVA API transport failed.") from error
+
+        try:
+            payload = response.json()
+        except json.JSONDecodeError as error:
+            raise OSVATransportError("OSVA API returned a non-JSON response.") from error
+
+        if response.status_code >= 400:
+            if isinstance(payload, dict) and isinstance(payload.get("status"), str):
+                body_dict = payload
+            else:
+                body_dict = {"status": "error"}
+            raise OSVAAPIError(response.status_code, body_dict)
+
+        if not isinstance(payload, dict):
+            raise OSVATransportError("OSVA API returned an unexpected response shape.")
+        return payload
+
+    def upload_multipart(
+        self,
+        path: str,
+        *,
+        data: dict[str, str],
+        files: dict[str, tuple[str, bytes, str | None]],
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self._base_url}{path if path.startswith('/') else f'/{path}'}"
+        try:
+            response = self._client.post(
+                url,
+                data=data,
+                files=files,
+                headers=self._auth_headers(headers),
+            )
+        except httpx.HTTPError as error:
+            raise OSVATransportError("OSVA API transport failed.") from error
+
+        try:
+            payload = response.json()
+        except json.JSONDecodeError as error:
+            raise OSVATransportError("OSVA API returned a non-JSON response.") from error
+
+        if response.status_code >= 400:
+            if isinstance(payload, dict) and isinstance(payload.get("status"), str):
+                body_dict = payload
+            else:
+                body_dict = {"status": "error"}
+            raise OSVAAPIError(response.status_code, body_dict)
+
+        if not isinstance(payload, dict):
+            raise OSVATransportError("OSVA API returned an unexpected response shape.")
+        return payload
+
+    def download(
+        self,
+        path: str,
+        *,
+        query: dict[str, str | None] | None = None,
+    ) -> httpx.Response:
+        params = {key: value for key, value in (query or {}).items() if value is not None}
+        url = f"{self._base_url}{path if path.startswith('/') else f'/{path}'}"
+        try:
+            response = self._client.get(
+                url,
+                params=params,
+                headers=self._auth_headers(),
+            )
+        except httpx.HTTPError as error:
+            raise OSVATransportError("OSVA API transport failed.") from error
+
+        if response.status_code >= 400:
+            try:
+                payload = response.json()
+            except json.JSONDecodeError:
+                payload = {"status": "error"}
+            if isinstance(payload, dict) and isinstance(payload.get("status"), str):
+                body_dict = payload
+            else:
+                body_dict = {"status": "error"}
+            raise OSVAAPIError(response.status_code, body_dict)
+
+        return response

osva_sdk-1.0.0/src/osva/resources/__init__.py

@@ -0,0 +1 @@
+"""Control-plane resource clients."""

osva_sdk-1.0.0/src/osva/resources/agents.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Any
+
+from osva.http_client import HTTPClient
+
+
+class AgentsResource:
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def list(self) -> dict[str, Any]:
+        return self._client.request("GET", "/v1/agents")
+
+    def get(self, agent_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/v1/agents/{agent_id}")
+
+    def create(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("POST", "/v1/agents", body=payload)
+
+    def create_version(self, agent_id: str, payload: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request(
+            "POST",
+            f"/v1/agents/{agent_id}/versions",
+            body=payload,
+        )

osva_sdk-1.0.0/src/osva/resources/approvals.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Any
+
+from osva.http_client import HTTPClient
+
+
+class ApprovalsResource:
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def get(self, approval_request_id: str) -> dict[str, Any]:
+        return self._client.request(
+            "GET",
+            f"/v1/approval-requests/{approval_request_id}",
+        )
+
+    def decide(self, approval_request_id: str, payload: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request(
+            "POST",
+            f"/v1/approval-requests/{approval_request_id}/decision",
+            body=payload,
+        )

osva_sdk-1.0.0/src/osva/resources/artifacts.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from osva.http_client import HTTPClient
+
+
+class ArtifactsResource:
+    def __init__(self, http: HTTPClient) -> None:
+        self._http = http
+
+    def list(self, **query: str | None) -> dict[str, Any]:
+        return self._http.request("GET", "/v1/artifacts", query=query)
+
+    def get(self, artifact_id: str) -> dict[str, Any]:
+        return self._http.request("GET", f"/v1/artifacts/{artifact_id}")
+
+    def create(
+        self,
+        *,
+        name: str,
+        content: bytes,
+        media_type: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        expected_digest: str | None = None,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        data: dict[str, str] = {"name": name}
+        if media_type is not None:
+            data["mediaType"] = media_type
+        if metadata is not None:
+            data["metadata"] = __import__("json").dumps(metadata)
+        if expected_digest is not None:
+            data["expectedDigest"] = expected_digest
+        if idempotency_key is not None:
+            data["idempotencyKey"] = idempotency_key
+
+        files: dict[str, tuple[str, bytes, str | None]] = {
+            "file": (
+                name,
+                content,
+                media_type or "application/octet-stream",
+            )
+        }
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key is not None else None
+        return self._http.upload_multipart(
+            "/v1/artifacts",
+            data=data,
+            files=files,
+            headers=headers,
+        )
+
+    def download(self, artifact_id: str) -> httpx.Response:
+        return self._http.download(f"/v1/artifacts/{artifact_id}/content")