runloop-api-client 1.13.1__tar.gz → 1.13.3__tar.gz

runloop_api_client-1.13.3/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.13.3"
+}

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 1.13.3 (2026-03-26)
+
+Full Changelog: [v1.13.2...v1.13.3](https://github.com/runloopai/api-client-python/compare/v1.13.2...v1.13.3)
+
+### Bug Fixes
+
+* **api:** surface scenario setup failures instead of silently dropping them ([#8300](https://github.com/runloopai/api-client-python/issues/8300)) ([dd910d0](https://github.com/runloopai/api-client-python/commit/dd910d0e867e9964d24cb792b27dd9b56d670a98))
+* **devbox:** `get_tunnel_url` now derives tunnel domain from base url ([#771](https://github.com/runloopai/api-client-python/issues/771)) ([2634c64](https://github.com/runloopai/api-client-python/commit/2634c64f91e187633d0252dcda6449d72631bc09))
+
+
+### Chores
+
+* **axon:** add axon to sdk readme ([#769](https://github.com/runloopai/api-client-python/issues/769)) ([68afe5a](https://github.com/runloopai/api-client-python/commit/68afe5aa20120ed5c0aed061d540e287df945f6c))
+
+## 1.13.2 (2026-03-25)
+
+Full Changelog: [v1.13.1...v1.13.2](https://github.com/runloopai/api-client-python/compare/v1.13.1...v1.13.2)
+
+### Bug Fixes
+
+* adding axon SQL to sdk ([#767](https://github.com/runloopai/api-client-python/issues/767)) ([d683fd1](https://github.com/runloopai/api-client-python/commit/d683fd189b45120c0d2abe2963236ccb394a5eef))
+
 ## 1.13.1 (2026-03-25)
 
 Full Changelog: [v1.13.0...v1.13.1](https://github.com/runloopai/api-client-python/compare/v1.13.0...v1.13.1)

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: runloop_api_client
-Version: 1.13.1
+Version: 1.13.3
 Summary: The official Python library for the runloop API
 Project-URL: Homepage, https://github.com/runloopai/api-client-python
 Project-URL: Repository, https://github.com/runloopai/api-client-python

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/README-SDK.md

@@ -25,6 +25,10 @@ The `RunloopSDK` builds on top of the underlying REST client and provides a Pyth
   - [StorageObject](#storageobject)
     - [Storage Object Upload Helpers](#storage-object-upload-helpers)
   - [Mounting Storage Objects to Devboxes](#mounting-storage-objects-to-devboxes)
+  - [Axon](#axon)
+    - [Publishing Events](#publishing-events)
+    - [Subscribing to Events (SSE)](#subscribing-to-events-sse)
+    - [SQL Operations](#sql-operations)
 - [Accessing the Underlying REST Client](#accessing-the-underlying-rest-client)
 - [Error Handling](#error-handling)
 - [Advanced Configuration](#advanced-configuration)
@@ -116,6 +120,7 @@ The SDK provides object-oriented interfaces for all major Runloop resources:
 - **`runloop.blueprint`** - Blueprint management (create, list, build blueprints)
 - **`runloop.snapshot`** - Snapshot management (list disk snapshots)
 - **`runloop.storage_object`** - Storage object management (upload, download, list objects)
+- **`runloop.axon`** - [Beta] Axon management (create, publish events, subscribe to SSE streams, SQL queries)
 - **`runloop.secret`** - Secret management (create, update, list, delete encrypted key-value pairs)
 - **`runloop.api`** - Direct access to the underlying REST API client
 
@@ -679,6 +684,112 @@ result = devbox_with_archive.cmd.exec("ls -la /home/user/project/")
 print(result.stdout())
 ```
 
+### Axon
+
+> **Beta:** Axon APIs are in beta and may change.
+
+Object-oriented interface for working with axons — event communication channels that support
+publishing events, subscribing to event streams via SSE, and executing SQL queries against an
+embedded SQLite database. Created via `runloop.axon.create()` or `runloop.axon.from_id()`:
+
+```python
+# Create a new axon
+axon = runloop.axon.create(name="my-axon")
+
+# Or get an existing one
+axon = runloop.axon.from_id(axon_id="axn_123")
+
+# List all axons
+axons = runloop.axon.list()
+
+# Get axon details
+info = axon.get_info()
+print(f"Axon {info.name} created at {info.created_at_ms}")
+```
+
+#### Publishing Events
+
+Publish structured events to an axon:
+
+```python
+result = axon.publish(
+    event_type="task_completed",
+    origin="AGENT_EVENT",     # EXTERNAL_EVENT | AGENT_EVENT | USER_EVENT
+    payload='{"task_id": 42, "status": "done"}',
+    source="my-agent",
+)
+print(f"Sequence: {result.sequence}, Timestamp: {result.timestamp_ms}")
+```
+
+#### Subscribing to Events (SSE)
+
+Subscribe to real-time events via server-sent events:
+
+```python
+with axon.subscribe_sse() as stream:
+    for event in stream:
+        print(f"[{event.source}] {event.event_type}: {event.payload}")
+        # event.axon_id, event.origin, event.sequence, event.timestamp_ms also available
+```
+
+Async:
+
+```python
+async with await axon.subscribe_sse() as stream:
+    async for event in stream:
+        print(f"[{event.source}] {event.event_type}: {event.payload}")
+```
+
+#### SQL Operations
+
+Each axon has an embedded SQLite database accessible via `axon.sql`:
+
+```python
+# Create a table
+axon.sql.query(sql="CREATE TABLE tasks (id INTEGER PRIMARY KEY, name TEXT, done INTEGER)")
+
+# Insert with parameterized queries (? placeholders)
+axon.sql.query(
+    sql="INSERT INTO tasks (id, name, done) VALUES (?, ?, ?)",
+    params=[1, "Write docs", 0],
+)
+
+# Query
+result = axon.sql.query(sql="SELECT * FROM tasks WHERE done = ?", params=[0])
+for row in result.rows:
+    print(row)           # e.g. [1, "Write docs", 0]
+print(result.columns)    # [SqlColumnMetaView(name="id", type="INTEGER"), ...]
+print(result.meta)       # SqlResultMetaView(changes=0, duration_ms=0.5, rows_read_limit_reached=False)
+```
+
+Execute multiple statements atomically with `batch`:
+
+```python
+result = axon.sql.batch(
+    statements=[
+        {"sql": "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)"},
+        {"sql": "INSERT INTO users (id, name) VALUES (?, ?)", "params": [1, "Alice"]},
+        {"sql": "INSERT INTO users (id, name) VALUES (?, ?)", "params": [2, "Bob"]},
+        {"sql": "SELECT * FROM users ORDER BY id"},
+    ],
+)
+
+# Each statement gets a result
+for step in result.results:
+    if step.success:
+        print(f"Rows: {step.success.rows}, Changes: {step.success.meta.changes}")
+    elif step.error:
+        print(f"Error: {step.error}")
+```
+
+**Key methods:**
+
+- `axon.get_info()` – Get axon details (name, created_at_ms)
+- `axon.publish()` – Publish an event (event_type, origin, payload, source)
+- `axon.subscribe_sse()` – Subscribe to event stream (returns `Stream[AxonEventView]`)
+- `axon.sql.query()` – Execute a single SQL statement with optional params
+- `axon.sql.batch()` – Execute multiple SQL statements atomically
+
 ## Accessing the Underlying REST Client
 
 The SDK always exposes the underlying client through the `.api` attribute:

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runloop_api_client"
-version = "1.13.1"
+version = "1.13.3"
 description = "The official Python library for the runloop API"
 dynamic = ["readme"]
 license = "MIT"

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/src/runloop_api_client/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "runloop_api_client"
-__version__ = "1.13.1"  # x-release-please-version
+__version__ = "1.13.3"  # x-release-please-version

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/src/runloop_api_client/sdk/__init__.py

@@ -5,7 +5,7 @@ Provides both sync (`RunloopSDK`) and async (`AsyncRunloopSDK`) interfaces.
 
 from __future__ import annotations
 
-from .axon import Axon
+from .axon import Axon, AxonSqlOps
 from .sync import (
     AxonOps,
     AgentOps,
@@ -48,7 +48,7 @@ from .snapshot import Snapshot
 from .benchmark import Benchmark
 from .blueprint import Blueprint
 from .execution import Execution
-from .async_axon import AsyncAxon
+from .async_axon import AsyncAxon, AsyncAxonSqlOps
 from .mcp_config import McpConfig
 from .async_agent import AsyncAgent
 from .async_devbox import AsyncDevbox, AsyncNamedShell
@@ -111,6 +111,8 @@ __all__ = [
     "AsyncAgent",
     "Axon",
     "AsyncAxon",
+    "AxonSqlOps",
+    "AsyncAxonSqlOps",
     "AsyncSecret",
     "Benchmark",
     "AsyncBenchmark",

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/src/runloop_api_client/sdk/_types.py

@@ -42,6 +42,8 @@ from ..lib.polling import PollingConfig
 from ..types.devboxes import DiskSnapshotListParams, DiskSnapshotUpdateParams
 from ..types.scenarios import ScorerListParams, ScorerCreateParams, ScorerUpdateParams
 from ..types.devbox_create_params import DevboxBaseCreateParams
+from ..types.axons.sql_batch_params import SqlBatchParams
+from ..types.axons.sql_query_params import SqlQueryParams
 from ..types.scenario_start_run_params import ScenarioStartRunBaseParams
 from ..types.benchmark_start_run_params import BenchmarkSelfStartRunParams
 from ..types.devbox_execute_async_params import DevboxNiceExecuteAsyncParams
@@ -196,6 +198,14 @@ class SDKAxonPublishParams(AxonPublishParams, LongRequestOptions):
     pass
 
 
+class SDKAxonSqlQueryParams(SqlQueryParams, LongRequestOptions):
+    pass
+
+
+class SDKAxonSqlBatchParams(SqlBatchParams, LongRequestOptions):
+    pass
+
+
 class SDKScenarioListParams(ScenarioListParams, BaseRequestOptions):
     pass
 

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/src/runloop_api_client/sdk/async_axon.py

@@ -7,19 +7,48 @@ from typing_extensions import Unpack, override
 from ._types import (
     BaseRequestOptions,
     SDKAxonPublishParams,
+    SDKAxonSqlBatchParams,
+    SDKAxonSqlQueryParams,
 )
 from .._client import AsyncRunloop
 from .._streaming import AsyncStream
 from ..types.axon_view import AxonView
 from ..types.axon_event_view import AxonEventView
 from ..types.publish_result_view import PublishResultView
+from ..types.axons.sql_batch_result_view import SqlBatchResultView
+from ..types.axons.sql_query_result_view import SqlQueryResultView
+
+
+class AsyncAxonSqlOps:
+    """[Beta] Async SQL operations for an axon's SQLite database.
+
+    Access via ``axon.sql``.
+
+    Example:
+        >>> axon = await runloop.axon.create()
+        >>> await axon.sql.query(sql="CREATE TABLE tasks (id INTEGER PRIMARY KEY, name TEXT)")
+        >>> result = await axon.sql.query(sql="SELECT * FROM tasks WHERE id = ?", params=[1])
+    """
+
+    def __init__(self, client: AsyncRunloop, axon_id: str) -> None:
+        self._client = client
+        self._axon_id = axon_id
+
+    async def query(self, **params: Unpack[SDKAxonSqlQueryParams]) -> SqlQueryResultView:
+        """[Beta] Execute a single parameterized SQL statement against this axon's SQLite database."""
+        return await self._client.axons.sql.query(self._axon_id, **params)
+
+    async def batch(self, **params: Unpack[SDKAxonSqlBatchParams]) -> SqlBatchResultView:
+        """[Beta] Execute multiple SQL statements atomically within a single transaction."""
+        return await self._client.axons.sql.batch(self._axon_id, **params)
 
 
 class AsyncAxon:
     """[Beta] Wrapper around asynchronous axon operations.
 
-    Axons are event communication channels that support publishing events
-    and subscribing to event streams via server-sent events (SSE).
+    Axons are event communication channels that support publishing events,
+    subscribing to event streams via server-sent events (SSE), and executing
+    SQL queries against an embedded SQLite database.
     Obtain instances via ``runloop.axon.create()`` or ``runloop.axon.from_id()``.
 
     Example:
@@ -29,11 +58,17 @@ class AsyncAxon:
         >>> async with await axon.subscribe_sse() as stream:
         ...     async for event in stream:
         ...         print(event.event_type, event.payload)
+        >>> await axon.sql.query(sql="CREATE TABLE tasks (id INTEGER PRIMARY KEY, name TEXT)")
     """
 
     def __init__(self, client: AsyncRunloop, axon_id: str) -> None:
         self._client = client
         self._id = axon_id
+        self._sql = AsyncAxonSqlOps(client, axon_id)
+
+    @property
+    def sql(self) -> AsyncAxonSqlOps:
+        return self._sql
 
     @override
     def __repr__(self) -> str:

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/src/runloop_api_client/sdk/async_devbox.py

@@ -161,7 +161,9 @@ class AsyncDevbox:
         tunnel_view = await self.get_tunnel(**options)
         if tunnel_view is None:
             return None
-        return f"https://{port}-{tunnel_view.tunnel_key}.tunnel.runloop.ai"
+        api_host = self._client.base_url.host
+        base_domain = api_host[4:] if api_host.startswith("api.") else api_host
+        return f"https://{port}-{tunnel_view.tunnel_key}.tunnel.{base_domain}"
 
     async def logs(
         self,

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/src/runloop_api_client/sdk/axon.py

@@ -7,19 +7,48 @@ from typing_extensions import Unpack, override
 from ._types import (
     BaseRequestOptions,
     SDKAxonPublishParams,
+    SDKAxonSqlBatchParams,
+    SDKAxonSqlQueryParams,
 )
 from .._client import Runloop
 from .._streaming import Stream
 from ..types.axon_view import AxonView
 from ..types.axon_event_view import AxonEventView
 from ..types.publish_result_view import PublishResultView
+from ..types.axons.sql_batch_result_view import SqlBatchResultView
+from ..types.axons.sql_query_result_view import SqlQueryResultView
+
+
+class AxonSqlOps:
+    """[Beta] SQL operations for an axon's SQLite database.
+
+    Access via ``axon.sql``.
+
+    Example:
+        >>> axon = runloop.axon.create()
+        >>> axon.sql.query(sql="CREATE TABLE tasks (id INTEGER PRIMARY KEY, name TEXT)")
+        >>> result = axon.sql.query(sql="SELECT * FROM tasks WHERE id = ?", params=[1])
+    """
+
+    def __init__(self, client: Runloop, axon_id: str) -> None:
+        self._client = client
+        self._axon_id = axon_id
+
+    def query(self, **params: Unpack[SDKAxonSqlQueryParams]) -> SqlQueryResultView:
+        """[Beta] Execute a single parameterized SQL statement against this axon's SQLite database."""
+        return self._client.axons.sql.query(self._axon_id, **params)
+
+    def batch(self, **params: Unpack[SDKAxonSqlBatchParams]) -> SqlBatchResultView:
+        """[Beta] Execute multiple SQL statements atomically within a single transaction."""
+        return self._client.axons.sql.batch(self._axon_id, **params)
 
 
 class Axon:
     """[Beta] Wrapper around synchronous axon operations.
 
-    Axons are event communication channels that support publishing events
-    and subscribing to event streams via server-sent events (SSE).
+    Axons are event communication channels that support publishing events,
+    subscribing to event streams via server-sent events (SSE), and executing
+    SQL queries against an embedded SQLite database.
     Obtain instances via ``runloop.axon.create()`` or ``runloop.axon.from_id()``.
 
     Example:
@@ -29,11 +58,17 @@ class Axon:
         >>> with axon.subscribe_sse() as stream:
         ...     for event in stream:
         ...         print(event.event_type, event.payload)
+        >>> axon.sql.query(sql="CREATE TABLE tasks (id INTEGER PRIMARY KEY, name TEXT)")
     """
 
     def __init__(self, client: Runloop, axon_id: str) -> None:
         self._client = client
         self._id = axon_id
+        self._sql = AxonSqlOps(client, axon_id)
+
+    @property
+    def sql(self) -> AxonSqlOps:
+        return self._sql
 
     @override
     def __repr__(self) -> str:

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/src/runloop_api_client/sdk/devbox.py

@@ -160,7 +160,9 @@ class Devbox:
         tunnel_view = self.get_tunnel(**options)
         if tunnel_view is None:
             return None
-        return f"https://{port}-{tunnel_view.tunnel_key}.tunnel.runloop.ai"
+        api_host = self._client.base_url.host
+        base_domain = api_host[4:] if api_host.startswith("api.") else api_host
+        return f"https://{port}-{tunnel_view.tunnel_key}.tunnel.{base_domain}"
 
     def logs(
         self,

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/src/runloop_api_client/types/benchmark_job_view.py

@@ -53,9 +53,6 @@ class BenchmarkOutcomeScenarioOutcome(BaseModel):
     scenario_name: str
     """The name of the scenario."""
 
-    scenario_run_id: str
-    """The ID of the scenario run."""
-
     state: Literal["COMPLETED", "FAILED", "TIMEOUT", "CANCELED"]
     """The final state of the scenario execution."""
 
@@ -68,6 +65,12 @@ class BenchmarkOutcomeScenarioOutcome(BaseModel):
     Contains exception type and message.
     """
 
+    scenario_run_id: Optional[str] = None
+    """The ID of the scenario run.
+
+    May be absent if the scenario failed during setup before a run was created.
+    """
+
     score: Optional[float] = None
     """The score achieved for this scenario (0.0 to 1.0).
 

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/tests/sdk/async_devbox/test_core.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from types import SimpleNamespace
 from unittest.mock import AsyncMock
 
+import httpx
 import pytest
 
 from tests.sdk.conftest import MockDevboxView
@@ -377,6 +378,7 @@ class TestAsyncDevbox:
             tunnel=tunnel_view,
         )
         mock_async_client.devboxes.retrieve = AsyncMock(return_value=devbox_view_with_tunnel)
+        mock_async_client.base_url = httpx.URL("https://api.runloop.ai")
 
         devbox = AsyncDevbox(mock_async_client, "dbx_123")
         result = await devbox.get_tunnel_url(8080)
@@ -384,6 +386,28 @@ class TestAsyncDevbox:
         assert result == "https://8080-abc123xyz.tunnel.runloop.ai"
         mock_async_client.devboxes.retrieve.assert_called_once_with("dbx_123")
 
+    @pytest.mark.asyncio
+    async def test_get_tunnel_url_derives_domain_from_base_url(self, mock_async_client: AsyncMock) -> None:
+        """Test get_tunnel_url derives tunnel domain from client base_url."""
+        tunnel_view = SimpleNamespace(
+            tunnel_key="abc123xyz",
+            auth_mode="open",
+            create_time_ms=1234567890000,
+        )
+        devbox_view_with_tunnel = SimpleNamespace(
+            id="dbx_123",
+            status="running",
+            tunnel=tunnel_view,
+        )
+        mock_async_client.devboxes.retrieve = AsyncMock(return_value=devbox_view_with_tunnel)
+        devbox = AsyncDevbox(mock_async_client, "dbx_123")
+
+        mock_async_client.base_url = httpx.URL("https://api.runloop.pro")
+        assert await devbox.get_tunnel_url(8080) == "https://8080-abc123xyz.tunnel.runloop.pro"
+
+        mock_async_client.base_url = httpx.URL("http://127.0.0.1:8080")
+        assert await devbox.get_tunnel_url(8080) == "https://8080-abc123xyz.tunnel.127.0.0.1"
+
     @pytest.mark.asyncio
     async def test_get_tunnel_url_returns_none_when_no_tunnel(self, mock_async_client: AsyncMock) -> None:
         """Test get_tunnel_url returns None when no tunnel is enabled."""

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/tests/sdk/conftest.py

@@ -133,6 +133,47 @@ class MockPublishResultView:
     timestamp_ms: int = 1234567890000
 
 
+@dataclass
+class MockSqlColumnMetaView:
+    """Mock SqlColumnMetaView for testing."""
+
+    name: str = "id"
+    type: str = "INTEGER"
+
+
+@dataclass
+class MockSqlResultMetaView:
+    """Mock SqlResultMetaView for testing."""
+
+    changes: int = 0
+    duration_ms: float = 1.5
+    rows_read_limit_reached: bool = False
+
+
+@dataclass
+class MockSqlQueryResultView:
+    """Mock SqlQueryResultView for testing."""
+
+    columns: list[Any] = field(default_factory=lambda: [MockSqlColumnMetaView()])
+    meta: Any = field(default_factory=MockSqlResultMetaView)
+    rows: list[Any] = field(default_factory=lambda: [[1, "hello"]])
+
+
+@dataclass
+class MockSqlStepResultView:
+    """Mock SqlStepResultView for testing."""
+
+    success: Any = field(default_factory=lambda: MockSqlQueryResultView())
+    error: Any = None
+
+
+@dataclass
+class MockSqlBatchResultView:
+    """Mock SqlBatchResultView for testing."""
+
+    results: list[Any] = field(default_factory=lambda: [MockSqlStepResultView()])
+
+
 @dataclass
 class MockScenarioView:
     """Mock ScenarioView for testing."""

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/tests/sdk/devbox/test_core.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from types import SimpleNamespace
 from unittest.mock import Mock
 
+import httpx
 import pytest
 
 from tests.sdk.conftest import (
@@ -373,6 +374,7 @@ class TestDevbox:
             tunnel=tunnel_view,
         )
         mock_client.devboxes.retrieve.return_value = devbox_view_with_tunnel
+        mock_client.base_url = httpx.URL("https://api.runloop.ai")
 
         devbox = Devbox(mock_client, "dbx_123")
         result = devbox.get_tunnel_url(8080)
@@ -380,6 +382,27 @@ class TestDevbox:
         assert result == "https://8080-abc123xyz.tunnel.runloop.ai"
         mock_client.devboxes.retrieve.assert_called_once_with("dbx_123")
 
+    def test_get_tunnel_url_derives_domain_from_base_url(self, mock_client: Mock) -> None:
+        """Test get_tunnel_url derives tunnel domain from client base_url."""
+        tunnel_view = SimpleNamespace(
+            tunnel_key="abc123xyz",
+            auth_mode="open",
+            create_time_ms=1234567890000,
+        )
+        devbox_view_with_tunnel = SimpleNamespace(
+            id="dbx_123",
+            status="running",
+            tunnel=tunnel_view,
+        )
+        mock_client.devboxes.retrieve.return_value = devbox_view_with_tunnel
+        devbox = Devbox(mock_client, "dbx_123")
+
+        mock_client.base_url = httpx.URL("https://api.runloop.pro")
+        assert devbox.get_tunnel_url(8080) == "https://8080-abc123xyz.tunnel.runloop.pro"
+
+        mock_client.base_url = httpx.URL("http://127.0.0.1:8080")
+        assert devbox.get_tunnel_url(8080) == "https://8080-abc123xyz.tunnel.127.0.0.1"
+
     def test_get_tunnel_url_returns_none_when_no_tunnel(self, mock_client: Mock) -> None:
         """Test get_tunnel_url returns None when no tunnel is enabled."""
         devbox_view_no_tunnel = SimpleNamespace(

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/tests/sdk/test_async_axon.py

@@ -6,8 +6,9 @@ from unittest.mock import AsyncMock
 
 import pytest
 
-from tests.sdk.conftest import MockAxonView, MockPublishResultView
+from tests.sdk.conftest import MockAxonView, MockPublishResultView, MockSqlBatchResultView, MockSqlQueryResultView
 from runloop_api_client.sdk import AsyncAxon
+from runloop_api_client.types.axons.sql_statement_params import SqlStatementParams
 
 
 class TestAsyncAxon:
@@ -75,3 +76,38 @@ class TestAsyncAxon:
 
         assert result == mock_stream
         mock_async_client.axons.subscribe_sse.assert_awaited_once_with("axn_123")
+
+    @pytest.mark.asyncio
+    async def test_sql_query(self, mock_async_client: AsyncMock) -> None:
+        """Test sql.query method delegates to client.axons.sql.query."""
+        mock_result = MockSqlQueryResultView()
+        mock_async_client.axons.sql.query = AsyncMock(return_value=mock_result)
+
+        axon = AsyncAxon(mock_async_client, "axn_123")
+        result = await axon.sql.query(sql="SELECT * FROM test WHERE id = ?", params=[1])
+
+        assert result == mock_result
+        mock_async_client.axons.sql.query.assert_awaited_once_with(
+            "axn_123",
+            sql="SELECT * FROM test WHERE id = ?",
+            params=[1],
+        )
+
+    @pytest.mark.asyncio
+    async def test_sql_batch(self, mock_async_client: AsyncMock) -> None:
+        """Test sql.batch method delegates to client.axons.sql.batch."""
+        mock_result = MockSqlBatchResultView()
+        mock_async_client.axons.sql.batch = AsyncMock(return_value=mock_result)
+
+        statements: list[SqlStatementParams] = [
+            {"sql": "CREATE TABLE t (id INTEGER PRIMARY KEY)"},
+            {"sql": "INSERT INTO t (id) VALUES (?)", "params": [1]},
+        ]
+        axon = AsyncAxon(mock_async_client, "axn_123")
+        result = await axon.sql.batch(statements=statements)
+
+        assert result == mock_result
+        mock_async_client.axons.sql.batch.assert_awaited_once_with(
+            "axn_123",
+            statements=statements,
+        )

{runloop_api_client-1.13.1 → runloop_api_client-1.13.3}/tests/sdk/test_axon.py

@@ -4,8 +4,9 @@ from __future__ import annotations
 
 from unittest.mock import Mock
 
-from tests.sdk.conftest import MockAxonView, MockPublishResultView
+from tests.sdk.conftest import MockAxonView, MockPublishResultView, MockSqlBatchResultView, MockSqlQueryResultView
 from runloop_api_client.sdk import Axon
+from runloop_api_client.types.axons.sql_statement_params import SqlStatementParams
 
 
 class TestAxon:
@@ -70,3 +71,36 @@ class TestAxon:
 
         assert result == mock_stream
         mock_client.axons.subscribe_sse.assert_called_once_with("axn_123")
+
+    def test_sql_query(self, mock_client: Mock) -> None:
+        """Test sql.query method delegates to client.axons.sql.query."""
+        mock_result = MockSqlQueryResultView()
+        mock_client.axons.sql.query.return_value = mock_result
+
+        axon = Axon(mock_client, "axn_123")
+        result = axon.sql.query(sql="SELECT * FROM test WHERE id = ?", params=[1])
+
+        assert result == mock_result
+        mock_client.axons.sql.query.assert_called_once_with(
+            "axn_123",
+            sql="SELECT * FROM test WHERE id = ?",
+            params=[1],
+        )
+
+    def test_sql_batch(self, mock_client: Mock) -> None:
+        """Test sql.batch method delegates to client.axons.sql.batch."""
+        mock_result = MockSqlBatchResultView()
+        mock_client.axons.sql.batch.return_value = mock_result
+
+        statements: list[SqlStatementParams] = [
+            {"sql": "CREATE TABLE t (id INTEGER PRIMARY KEY)"},
+            {"sql": "INSERT INTO t (id) VALUES (?)", "params": [1]},
+        ]
+        axon = Axon(mock_client, "axn_123")
+        result = axon.sql.batch(statements=statements)
+
+        assert result == mock_result
+        mock_client.axons.sql.batch.assert_called_once_with(
+            "axn_123",
+            statements=statements,
+        )