agentkernel-sdk 0.19.1__tar.gz → 0.20.0__tar.gz

{agentkernel_sdk-0.19.1 → agentkernel_sdk-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: agentkernel-sdk
-Version: 0.19.1
+Version: 0.20.0
 Summary: Python SDK for agentkernel — run AI coding agents in secure, isolated microVMs
 Project-URL: Homepage, https://github.com/thrashr888/agentkernel
 Project-URL: Repository, https://github.com/thrashr888/agentkernel/tree/main/sdk/python
@@ -18,15 +18,15 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: httpx-sse>=0.4
-Requires-Dist: httpx>=0.27
-Requires-Dist: pydantic>=2.0
+Requires-Dist: httpx-sse>=0.4.3
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.13.4
 Provides-Extra: dev
-Requires-Dist: mypy>=1.13; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
-Requires-Dist: pytest-httpx>=0.34; extra == 'dev'
-Requires-Dist: pytest>=8.0; extra == 'dev'
-Requires-Dist: ruff>=0.8; extra == 'dev'
+Requires-Dist: mypy>=2.3.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.4.0; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.36.2; extra == 'dev'
+Requires-Dist: pytest>=9.1.1; extra == 'dev'
+Requires-Dist: ruff>=0.16.4; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # agentkernel

{agentkernel_sdk-0.19.1 → agentkernel_sdk-0.20.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling>=1.32.0"]
 build-backend = "hatchling.build"
 
 [project]
 name = "agentkernel-sdk"
-version = "0.19.1"
+version = "0.20.0"
 description = "Python SDK for agentkernel — run AI coding agents in secure, isolated microVMs"
 readme = "README.md"
 license = "MIT"
@@ -23,15 +23,15 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
     "Typing :: Typed",
 ]
-dependencies = ["httpx>=0.27", "httpx-sse>=0.4", "pydantic>=2.0"]
+dependencies = ["httpx>=0.28.1", "httpx-sse>=0.4.3", "pydantic>=2.13.4"]
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=8.0",
-    "pytest-asyncio>=0.24",
-    "pytest-httpx>=0.34",
-    "mypy>=1.13",
-    "ruff>=0.8",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "pytest-httpx>=0.36.2",
+    "mypy>=2.3.1",
+    "ruff>=0.16.4",
 ]
 
 [project.urls]
@@ -48,6 +48,10 @@ line-length = 100
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "B"]
 
+[tool.ruff.lint.per-file-ignores]
+# This module embeds the canonical browser JavaScript and server scripts verbatim.
+"src/agentkernel/browser.py" = ["E501"]
+
 [tool.mypy]
 python_version = "3.10"
 strict = true

{agentkernel_sdk-0.19.1 → agentkernel_sdk-0.20.0}/src/agentkernel/_config.py

@@ -23,7 +23,9 @@ def resolve_config(
 ) -> Config:
     """Resolve config from constructor args > env vars > defaults."""
     return Config(
-        base_url=(base_url or os.environ.get("AGENTKERNEL_BASE_URL") or DEFAULT_BASE_URL).rstrip("/"),
+        base_url=(base_url or os.environ.get("AGENTKERNEL_BASE_URL") or DEFAULT_BASE_URL).rstrip(
+            "/"
+        ),
         api_key=api_key or os.environ.get("AGENTKERNEL_API_KEY"),
         timeout=timeout if timeout is not None else DEFAULT_TIMEOUT,
     )

{agentkernel_sdk-0.19.1 → agentkernel_sdk-0.20.0}/src/agentkernel/async_client.py

@@ -4,34 +4,33 @@ from __future__ import annotations
 
 from collections.abc import AsyncIterator
 from types import TracebackType
-from typing import Any
+from typing import TYPE_CHECKING, Any, cast
 
 import httpx
 
+if TYPE_CHECKING:
+    from .browser import AsyncBrowserSession
+
 from ._config import resolve_config
 from .errors import AgentKernelError, NetworkError, error_from_status
 from .types import (
     BatchFileWriteResponse,
     BatchRunResponse,
-    CreateSandboxOptions,
     DetachedCommand,
     DetachedLogsResponse,
-    ExecOptions,
     DurableObject,
     DurableStore,
     DurableStoreCommandResult,
     DurableStoreExecuteResult,
     DurableStoreQueryResult,
-    ExtendTtlResponse,
     FileReadResponse,
+    Orchestration,
     OrchestrationDefinition,
-    RunOptions,
     RunOutput,
     SandboxInfo,
+    Schedule,
     SecurityProfile,
-    Orchestration,
     SnapshotMeta,
-    Schedule,
     StreamEvent,
 )
 
@@ -56,7 +55,11 @@ class AsyncSandboxSession:
     ) -> RunOutput:
         """Run a command in this sandbox."""
         return await self._client.exec_in_sandbox(
-            self.name, command, env=env, workdir=workdir, sudo=sudo,
+            self.name,
+            command,
+            env=env,
+            workdir=workdir,
+            sudo=sudo,
         )
 
     async def info(self) -> SandboxInfo:
@@ -131,7 +134,7 @@ class AsyncAgentKernel:
 
     async def health(self) -> str:
         """Health check. Returns 'ok'."""
-        return await self._request("GET", "/health")
+        return cast(str, await self._request("GET", "/health"))
 
     async def run(
         self,
@@ -195,9 +198,13 @@ class AsyncAgentKernel:
             "POST",
             "/sandboxes",
             json={
-                "name": name, "image": image, "vcpus": vcpus,
-                "memory_mb": memory_mb, "profile": profile,
-                "source_url": source_url, "source_ref": source_ref,
+                "name": name,
+                "image": image,
+                "vcpus": vcpus,
+                "memory_mb": memory_mb,
+                "profile": profile,
+                "source_url": source_url,
+                "source_ref": source_ref,
                 "volumes": volumes,
             },
         )
@@ -251,24 +258,27 @@ class AsyncAgentKernel:
         encoding: str = "utf8",
     ) -> str:
         """Write a file to a sandbox."""
-        return await self._request(
-            "PUT",
-            f"/sandboxes/{name}/files/{path}",
-            json={"content": content, "encoding": encoding},
+        return cast(
+            str,
+            await self._request(
+                "PUT",
+                f"/sandboxes/{name}/files/{path}",
+                json={"content": content, "encoding": encoding},
+            ),
         )
 
     async def delete_file(self, name: str, path: str) -> str:
         """Delete a file from a sandbox."""
-        return await self._request("DELETE", f"/sandboxes/{name}/files/{path}")
+        return cast(str, await self._request("DELETE", f"/sandboxes/{name}/files/{path}"))
 
     async def write_files(self, name: str, files: dict[str, str]) -> BatchFileWriteResponse:
         """Write multiple files to a sandbox in one request."""
         data = await self._request("POST", f"/sandboxes/{name}/files", json={"files": files})
         return BatchFileWriteResponse(**data)
 
-    async def get_sandbox_logs(self, name: str) -> list[dict]:
+    async def get_sandbox_logs(self, name: str) -> list[dict[str, Any]]:
         """Get audit log entries for a sandbox."""
-        return await self._request("GET", f"/sandboxes/{name}/logs")
+        return cast(list[dict[str, Any]], await self._request("GET", f"/sandboxes/{name}/logs"))
 
     async def batch_run(self, commands: list[list[str]]) -> BatchRunResponse:
         """Run multiple commands in parallel."""
@@ -306,14 +316,15 @@ class AsyncAgentKernel:
     ) -> DetachedLogsResponse:
         """Get logs from a detached command."""
         query = f"?stream={stream}" if stream == "stderr" else ""
-        data = await self._request(
-            "GET", f"/sandboxes/{name}/exec/detached/{cmd_id}/logs{query}"
-        )
+        data = await self._request("GET", f"/sandboxes/{name}/exec/detached/{cmd_id}/logs{query}")
         return DetachedLogsResponse(**data)
 
     async def detached_kill(self, name: str, cmd_id: str) -> str:
         """Kill a detached command."""
-        return await self._request("DELETE", f"/sandboxes/{name}/exec/detached/{cmd_id}")
+        return cast(
+            str,
+            await self._request("DELETE", f"/sandboxes/{name}/exec/detached/{cmd_id}"),
+        )
 
     async def detached_list(self, name: str) -> list[DetachedCommand]:
         """List detached commands in a sandbox."""
@@ -322,109 +333,150 @@ class AsyncAgentKernel:
 
     async def list_orchestrations(self) -> list[Orchestration]:
         """List orchestrations."""
-        return await self._request("GET", "/orchestrations")
+        return cast(list[Orchestration], await self._request("GET", "/orchestrations"))
 
     async def create_orchestration(self, orchestration: Orchestration) -> Orchestration:
         """Create a new orchestration."""
-        return await self._request("POST", "/orchestrations", json=orchestration)
+        return cast(
+            Orchestration, await self._request("POST", "/orchestrations", json=orchestration)
+        )
 
     async def get_orchestration(self, orchestration_id: str) -> Orchestration:
         """Get an orchestration by identifier."""
-        return await self._request("GET", f"/orchestrations/{orchestration_id}")
+        return cast(
+            Orchestration, await self._request("GET", f"/orchestrations/{orchestration_id}")
+        )
 
     async def signal_orchestration(
-        self, orchestration_id: str, event: dict[str, Any],
+        self,
+        orchestration_id: str,
+        event: dict[str, Any],
     ) -> Orchestration:
         """Raise an external event for an orchestration."""
-        return await self._request(
-            "POST", f"/orchestrations/{orchestration_id}/events", json=event,
+        return cast(
+            Orchestration,
+            await self._request(
+                "POST",
+                f"/orchestrations/{orchestration_id}/events",
+                json=event,
+            ),
         )
 
     async def terminate_orchestration(
-        self, orchestration_id: str, payload: dict[str, Any] | None = None,
+        self,
+        orchestration_id: str,
+        payload: dict[str, Any] | None = None,
     ) -> Orchestration:
         """Terminate an orchestration."""
-        return await self._request(
-            "POST",
-            f"/orchestrations/{orchestration_id}/terminate",
-            json=payload or {},
+        return cast(
+            Orchestration,
+            await self._request(
+                "POST",
+                f"/orchestrations/{orchestration_id}/terminate",
+                json=payload or {},
+            ),
         )
 
     async def list_orchestration_definitions(self) -> list[OrchestrationDefinition]:
         """List orchestration definitions."""
-        return await self._request("GET", "/orchestrations/definitions")
+        return cast(
+            list[OrchestrationDefinition],
+            await self._request("GET", "/orchestrations/definitions"),
+        )
 
     async def upsert_orchestration_definition(
-        self, definition: OrchestrationDefinition,
+        self,
+        definition: OrchestrationDefinition,
     ) -> OrchestrationDefinition:
         """Register or update an orchestration definition."""
-        return await self._request("POST", "/orchestrations/definitions", json=definition)
+        return cast(
+            OrchestrationDefinition,
+            await self._request("POST", "/orchestrations/definitions", json=definition),
+        )
 
     async def get_orchestration_definition(self, name: str) -> OrchestrationDefinition:
         """Get an orchestration definition by name."""
-        return await self._request("GET", f"/orchestrations/definitions/{name}")
+        return cast(
+            OrchestrationDefinition,
+            await self._request("GET", f"/orchestrations/definitions/{name}"),
+        )
 
     async def delete_orchestration_definition(self, name: str) -> str:
         """Delete an orchestration definition by name."""
-        return await self._request("DELETE", f"/orchestrations/definitions/{name}")
+        return cast(str, await self._request("DELETE", f"/orchestrations/definitions/{name}"))
 
     async def list_objects(self) -> list[DurableObject]:
         """List objects."""
-        return await self._request("GET", "/objects")
+        return cast(list[DurableObject], await self._request("GET", "/objects"))
 
     async def create_object(self, obj: DurableObject) -> DurableObject:
         """Create a new object."""
-        return await self._request("POST", "/objects", json=obj)
+        return cast(DurableObject, await self._request("POST", "/objects", json=obj))
 
     async def get_object(self, object_id: str) -> DurableObject:
         """Get an object by identifier."""
-        return await self._request("GET", f"/objects/{object_id}")
+        return cast(DurableObject, await self._request("GET", f"/objects/{object_id}"))
 
     async def list_schedules(self) -> list[Schedule]:
         """List schedules."""
-        return await self._request("GET", "/schedules")
+        return cast(list[Schedule], await self._request("GET", "/schedules"))
 
     async def create_schedule(self, schedule: Schedule) -> Schedule:
         """Create a new schedule."""
-        return await self._request("POST", "/schedules", json=schedule)
+        return cast(Schedule, await self._request("POST", "/schedules", json=schedule))
 
     async def get_schedule(self, schedule_id: str) -> Schedule:
         """Get a schedule by identifier."""
-        return await self._request("GET", f"/schedules/{schedule_id}")
+        return cast(Schedule, await self._request("GET", f"/schedules/{schedule_id}"))
 
     async def list_stores(self) -> list[DurableStore]:
         """List durable stores."""
-        return await self._request("GET", "/stores")
+        return cast(list[DurableStore], await self._request("GET", "/stores"))
 
     async def create_store(self, store: DurableStore) -> DurableStore:
         """Create a durable store."""
-        return await self._request("POST", "/stores", json=store)
+        return cast(DurableStore, await self._request("POST", "/stores", json=store))
 
     async def get_store(self, store_id: str) -> DurableStore:
         """Get a durable store by identifier."""
-        return await self._request("GET", f"/stores/{store_id}")
+        return cast(DurableStore, await self._request("GET", f"/stores/{store_id}"))
 
     async def delete_store(self, store_id: str) -> str:
         """Delete a durable store by identifier."""
-        return await self._request("DELETE", f"/stores/{store_id}")
+        return cast(str, await self._request("DELETE", f"/stores/{store_id}"))
 
     async def query_store(
-        self, store_id: str, payload: dict[str, Any],
+        self,
+        store_id: str,
+        payload: dict[str, Any],
     ) -> DurableStoreQueryResult:
         """Run a read query against a durable store."""
-        return await self._request("POST", f"/stores/{store_id}/query", json=payload)
+        return cast(
+            DurableStoreQueryResult,
+            await self._request("POST", f"/stores/{store_id}/query", json=payload),
+        )
 
     async def execute_store(
-        self, store_id: str, payload: dict[str, Any],
+        self,
+        store_id: str,
+        payload: dict[str, Any],
     ) -> DurableStoreExecuteResult:
         """Run a write statement against a durable store."""
-        return await self._request("POST", f"/stores/{store_id}/execute", json=payload)
+        return cast(
+            DurableStoreExecuteResult,
+            await self._request("POST", f"/stores/{store_id}/execute", json=payload),
+        )
 
     async def command_store(
-        self, store_id: str, payload: dict[str, Any],
+        self,
+        store_id: str,
+        payload: dict[str, Any],
     ) -> DurableStoreCommandResult:
         """Run a command against a durable store (Redis-style engines)."""
-        return await self._request("POST", f"/stores/{store_id}/command", json=payload)
+        return cast(
+            DurableStoreCommandResult,
+            await self._request("POST", f"/stores/{store_id}/command", json=payload),
+        )
 
     async def extend_ttl(self, name: str, *, by: str) -> str | None:
         """Extend a sandbox's TTL. Returns the new expiry time."""
@@ -477,7 +529,9 @@ class AsyncAgentKernel:
                 await sb.run(["echo", "hello"])
             # sandbox auto-removed
         """
-        await self.create_sandbox(name, image=image, vcpus=vcpus, memory_mb=memory_mb, profile=profile)
+        await self.create_sandbox(
+            name, image=image, vcpus=vcpus, memory_mb=memory_mb, profile=profile
+        )
         return AsyncSandboxSession(name, self)
 
     async def browser(
@@ -498,10 +552,13 @@ class AsyncAgentKernel:
                 print(page.title, page.links)
             # sandbox auto-removed
         """
-        from .browser import AsyncBrowserSession, _SETUP_CMD
+        from .browser import _SETUP_CMD, AsyncBrowserSession
 
         await self.create_sandbox(
-            name, image="python:3.12-slim", memory_mb=memory_mb, profile="moderate",
+            name,
+            image="python:3.12-slim",
+            memory_mb=memory_mb,
+            profile="moderate",
         )
         await self.exec_in_sandbox(name, _SETUP_CMD)
         return AsyncBrowserSession(name, self)

{agentkernel_sdk-0.19.1 → agentkernel_sdk-0.20.0}/src/agentkernel/browser.py

@@ -4,9 +4,8 @@ from __future__ import annotations
 
 import base64
 import json
-import shlex
 from types import TracebackType
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from .types import AriaSnapshot, PageLink, PageResult, RunOutput
 
@@ -245,7 +244,7 @@ _ARIA_SNAPSHOT_JS = r"""
 })()
 """
 
-_BROWSER_SERVER_SCRIPT = r"""
+_BROWSER_SERVER_SCRIPT = r'''
 import asyncio, base64, json, sys, os, signal
 from http.server import HTTPServer, BaseHTTPRequestHandler
 from urllib.parse import urlparse, parse_qs
@@ -363,7 +362,7 @@ if __name__ == "__main__":
     def shutdown(sig, frame): server.shutdown(); sys.exit(0)
     signal.signal(signal.SIGTERM, shutdown); signal.signal(signal.SIGINT, shutdown)
     server.serve_forever()
-"""
+'''
 
 _BROWSER_START_SCRIPT = """
 import sys, json, subprocess, time, os, signal, select
@@ -419,7 +418,7 @@ class BrowserSession:
             title=data["title"],
             url=data["url"],
             text=data["text"],
-            links=[PageLink(**l) for l in data.get("links", [])],
+            links=[PageLink(**link) for link in data.get("links", [])],
         )
 
     def screenshot(self, url: str | None = None) -> bytes:
@@ -500,7 +499,7 @@ class BrowserSession:
         """List active page names."""
         result = self._browser_request("GET", "/pages")
         data = json.loads(result.output)
-        return data.get("pages", [])
+        return cast(list[str], data.get("pages", []))
 
     def _browser_request(self, method: str, path: str, body: str | None = None) -> RunOutput:
         """Send a request to the in-sandbox browser server."""
@@ -588,7 +587,7 @@ class AsyncBrowserSession:
             title=data["title"],
             url=data["url"],
             text=data["text"],
-            links=[PageLink(**l) for l in data.get("links", [])],
+            links=[PageLink(**link) for link in data.get("links", [])],
         )
 
     async def screenshot(self, url: str | None = None) -> bytes:
@@ -665,7 +664,7 @@ class AsyncBrowserSession:
         """List active page names."""
         result = await self._browser_request("GET", "/pages")
         data = json.loads(result.output)
-        return data.get("pages", [])
+        return cast(list[str], data.get("pages", []))
 
     async def _browser_request(self, method: str, path: str, body: str | None = None) -> RunOutput:
         """Send a request to the in-sandbox browser server."""
@@ -690,7 +689,14 @@ class AsyncBrowserSession:
             pass
         result = await self._client.exec_in_sandbox(
             self.name,
-            ["python3", "-c", _BROWSER_START_SCRIPT, _ARIA_SNAPSHOT_JS, "9222", _BROWSER_SERVER_SCRIPT],
+            [
+                "python3",
+                "-c",
+                _BROWSER_START_SCRIPT,
+                _ARIA_SNAPSHOT_JS,
+                "9222",
+                _BROWSER_SERVER_SCRIPT,
+            ],
         )
         data = json.loads(result.output)
         if "error" in data: