adk-code-mode 1.6.0__tar.gz → 2.0.0__tar.gz

adk_code_mode-2.0.0/.release-please-manifest.json

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

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [2.0.0](https://github.com/a2anet/adk-code-mode/compare/adk-code-mode-v1.6.1...adk-code-mode-v2.0.0) (2026-09-25)
+
+
+### ⚠ BREAKING CHANGES
+
+* sandbox code that checked a tool result for an `error` key now gets an exception instead, and the sandbox image must be rebuilt for protocol version 3.
+
+### Features
+
+* raise when a tool call fails instead of returning the error ([#22](https://github.com/a2anet/adk-code-mode/issues/22)) ([489083d](https://github.com/a2anet/adk-code-mode/commit/489083d988cd7e958e94f3ef6acba6443284abd8))
+* stop a timed-out block without losing the turn's state ([#23](https://github.com/a2anet/adk-code-mode/issues/23)) ([4720156](https://github.com/a2anet/adk-code-mode/commit/47201568d0bb06527e32f850b7abb1b465e36920))
+
+## [1.6.1](https://github.com/a2anet/adk-code-mode/compare/adk-code-mode-v1.6.0...adk-code-mode-v1.6.1) (2026-09-22)
+
+
+### Bug Fixes
+
+* exit the sandbox when the host disconnects mid-block ([bd3fb0f](https://github.com/a2anet/adk-code-mode/commit/bd3fb0fb0d8a0cab9370f2ad6db56dfacf566cb4))
+
 ## [1.6.0](https://github.com/a2anet/adk-code-mode/compare/adk-code-mode-v1.5.0...adk-code-mode-v1.6.0) (2026-08-29)
 
 

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: adk-code-mode
-Version: 1.6.0
+Version: 2.0.0
 Summary: A "Code Mode" sandboxed code-execution tool for ADK agents to interact with tools, files, and custom packages with Python
 Project-URL: Documentation, https://github.com/A2ANet/adk-code-mode#readme
 Project-URL: Issues, https://github.com/A2ANet/adk-code-mode/issues
@@ -39,6 +39,7 @@ Inspired by Cloudflare's [Code Mode](https://blog.cloudflare.com/code-mode/) and
 ## ✨ Features
 
 - **Call ADK tools from sandbox code** — imports against the `tools` package proxy back to the host and run through ADK's `before_tool` / `after_tool` / `on_error` callbacks and the plugin manager exactly as direct tool calls would.
+- **Failed tool calls raise** — a REST tool whose API answers with an HTTP error raises `HTTPStatusError` (with `status_code` and `body`), and any other failure, including an MCP tool that reports one, raises `ToolError`. ADK returns these as values for a model to read, but sandbox code reads return values, so it would otherwise carry on as if the call had worked.
 - **Bake any Python package into the image** — extend the published base image with anything the model's code needs to `import`, no runtime `pip install` required. The sandbox reports what it has installed, so the model is told about it automatically.
 - **Cross-turn persistence via ADK Artifacts** — `save_artifact` / `load_artifact` / `list_artifacts` are auto-injected and route through your configured `ArtifactService`. Files the code creates or changes are saved as artifacts automatically too.
 - **Tool results saved as artifacts** — on by default; every tool's result is persisted as a `code_mode.tool_result` artifact (with optional model-supplied name/description) so hosts can forward outputs and large results stay out of the prompt. Opt out with `save_tool_results_as_artifacts=False`.
@@ -300,7 +301,7 @@ All settings are `ExecuteCodeTool` constructor arguments:
 | `max_code_mode_metadata_chars` | `50_000` | Budget for the whole rendered `<code-mode>` block, tags included. Oversized blocks degrade in tiers rather than disappearing — see [What the model sees](#what-the-model-sees). |
 | `max_output_chars` | `50_000` | Caps stdout/stderr handed back to the model. Overflow is saved as a session artifact at `code_mode/stdout/<call-id>.txt` and the model sees a head-and-tail view pointing to it. |
 | `max_code_chars` | `1_000_000` | Rejects oversized code payloads before starting a container. |
-| `timeout_seconds` | `60` | Caps overall execution time of one `execute_code` call, and with it every tool the block calls. `None` lifts the cap, leaving the platform request timeout (e.g. Cloud Run `--timeout`) as the only bound. |
+| `timeout_seconds` | `60` | Caps overall execution time of one `execute_code` call, and with it every tool the block calls. A block past the cap is stopped with its output so far, keeping the turn's variables and working directory. If it won't stop within a few seconds or leaves a worker thread or child process running, its sandbox is restarted and its output and state are lost. The model is told the cap. `None` lifts it, leaving the platform request timeout (e.g. Cloud Run `--timeout`) as the only bound. |
 | `per_tool_timeout_seconds` | `None` | Caps each individual tool call made from within the sandbox. |
 | `session_idle_timeout_seconds` | `600` | Idle reaper: closes a turn's container once it goes untouched this long. Backstop for turns that never call `release_invocation`. |
 

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/README.md

@@ -12,6 +12,7 @@ Inspired by Cloudflare's [Code Mode](https://blog.cloudflare.com/code-mode/) and
 ## ✨ Features
 
 - **Call ADK tools from sandbox code** — imports against the `tools` package proxy back to the host and run through ADK's `before_tool` / `after_tool` / `on_error` callbacks and the plugin manager exactly as direct tool calls would.
+- **Failed tool calls raise** — a REST tool whose API answers with an HTTP error raises `HTTPStatusError` (with `status_code` and `body`), and any other failure, including an MCP tool that reports one, raises `ToolError`. ADK returns these as values for a model to read, but sandbox code reads return values, so it would otherwise carry on as if the call had worked.
 - **Bake any Python package into the image** — extend the published base image with anything the model's code needs to `import`, no runtime `pip install` required. The sandbox reports what it has installed, so the model is told about it automatically.
 - **Cross-turn persistence via ADK Artifacts** — `save_artifact` / `load_artifact` / `list_artifacts` are auto-injected and route through your configured `ArtifactService`. Files the code creates or changes are saved as artifacts automatically too.
 - **Tool results saved as artifacts** — on by default; every tool's result is persisted as a `code_mode.tool_result` artifact (with optional model-supplied name/description) so hosts can forward outputs and large results stay out of the prompt. Opt out with `save_tool_results_as_artifacts=False`.
@@ -273,7 +274,7 @@ All settings are `ExecuteCodeTool` constructor arguments:
 | `max_code_mode_metadata_chars` | `50_000` | Budget for the whole rendered `<code-mode>` block, tags included. Oversized blocks degrade in tiers rather than disappearing — see [What the model sees](#what-the-model-sees). |
 | `max_output_chars` | `50_000` | Caps stdout/stderr handed back to the model. Overflow is saved as a session artifact at `code_mode/stdout/<call-id>.txt` and the model sees a head-and-tail view pointing to it. |
 | `max_code_chars` | `1_000_000` | Rejects oversized code payloads before starting a container. |
-| `timeout_seconds` | `60` | Caps overall execution time of one `execute_code` call, and with it every tool the block calls. `None` lifts the cap, leaving the platform request timeout (e.g. Cloud Run `--timeout`) as the only bound. |
+| `timeout_seconds` | `60` | Caps overall execution time of one `execute_code` call, and with it every tool the block calls. A block past the cap is stopped with its output so far, keeping the turn's variables and working directory. If it won't stop within a few seconds or leaves a worker thread or child process running, its sandbox is restarted and its output and state are lost. The model is told the cap. `None` lifts it, leaving the platform request timeout (e.g. Cloud Run `--timeout`) as the only bound. |
 | `per_tool_timeout_seconds` | `None` | Caps each individual tool call made from within the sandbox. |
 | `session_idle_timeout_seconds` | `600` | Idle reaper: closes a turn's container once it goes untouched this long. Backstop for turns that never call `release_invocation`. |
 

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/sandbox-wheel/src/adk_code_mode_sandbox/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "1.6.0"  # x-release-please-version
+__version__ = "2.0.0"  # x-release-please-version

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/sandbox-wheel/src/adk_code_mode_sandbox/_entry.py

@@ -28,11 +28,13 @@ import io
 import os
 import platform
 import socket
+import subprocess
 import sys
+import threading
 import traceback
 from typing import Any
 
-from adk_code_mode_sandbox import _rpc_client
+from adk_code_mode_sandbox import _interrupt, _rpc_client
 from adk_code_mode_sandbox._rpc_client import RpcClient
 from adk_code_mode_sandbox.protocol import (
     DoneFrame,
@@ -184,7 +186,8 @@ def _exec_into(code: str, globs: dict[str, Any]) -> int:
         traceback.print_exc()
         return 1
     try:
-        exec(compiled, globs)
+        with _interrupt.running():
+            exec(compiled, globs)
     except SystemExit as exc:
         code_val = exc.code
         if code_val is None:
@@ -199,7 +202,54 @@ def _exec_into(code: str, globs: dict[str, Any]) -> int:
     return 0
 
 
-def run_block(code: str, globs: dict[str, Any]) -> tuple[str, str, int]:
+def _has_linux_child_processes(task_dir: str = "/proc/self/task") -> bool:
+    """Check each Linux thread for child processes still running."""
+    checked = False
+    try:
+        with os.scandir(task_dir) as tasks:
+            for task in tasks:
+                try:
+                    with open(f"{task.path}/children") as children:
+                        checked = True
+                        if children.read().strip():
+                            return True
+                except FileNotFoundError:
+                    continue
+    except OSError:
+        return True
+    return not checked
+
+
+def _has_child_processes() -> bool:
+    """Check whether user code left a child process running."""
+    if sys.platform == "linux":
+        return _has_linux_child_processes()
+    try:
+        probe = subprocess.Popen(["ps", "-axo", "pid=,ppid="], stdout=subprocess.PIPE, text=True)
+        try:
+            output, _ = probe.communicate(timeout=2)
+        except subprocess.TimeoutExpired:
+            probe.kill()
+            probe.wait()
+            return True
+    except OSError:
+        return True
+    if probe.returncode != 0:
+        return True
+    return any(
+        int(pid) != probe.pid and int(ppid) == os.getpid()
+        for pid, ppid in (line.split() for line in output.splitlines())
+    )
+
+
+def _has_background_work() -> bool:
+    """Check whether code remains active outside the interrupted execution thread."""
+    reader_thread = _rpc_client.get()._reader_thread
+    trusted = {threading.current_thread(), threading.main_thread(), reader_thread}
+    return any(thread not in trusted for thread in threading.enumerate()) or _has_child_processes()
+
+
+def run_block(code: str, globs: dict[str, Any]) -> tuple[str, str, int, bool]:
     """Run one code block with its stdout/stderr captured.
 
     Redirects ``sys.stdout`` / ``sys.stderr`` to in-memory buffers for the
@@ -216,7 +266,7 @@ def run_block(code: str, globs: dict[str, Any]) -> tuple[str, str, int]:
     finally:
         sys.stdout = old_stdout
         sys.stderr = old_stderr
-    return capture_out.getvalue(), capture_err.getvalue(), exit_code
+    return capture_out.getvalue(), capture_err.getvalue(), exit_code, _has_background_work()
 
 
 def main() -> int:
@@ -228,7 +278,6 @@ def main() -> int:
         port = int(os.environ.get("PORT", "8080"))
         token = os.environ.get(AUTH_TOKEN_ENV)
         asyncio.run(serve(port, token))
-        return 0
 
     reader, writer = _open_control_streams()
     client = RpcClient(reader=reader, writer=writer)
@@ -247,8 +296,8 @@ def main() -> int:
         if isinstance(frame, ShutdownFrame):
             return 0
         if isinstance(frame, RunFrame):
-            stdout_text, stderr_text, exit_code = run_block(frame.code, globs)
-            client.send(DoneFrame(exit_code=exit_code))
+            stdout_text, stderr_text, exit_code, background_work = run_block(frame.code, globs)
+            client.send(DoneFrame(exit_code=exit_code, background_work=background_work))
             client.send(OutputFrame(stdout=stdout_text, stderr=stderr_text, exit_code=exit_code))
             continue
         # Any other frame kind is a host protocol error; keep going but log.

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/sandbox-wheel/src/adk_code_mode_sandbox/_http_server.py

@@ -38,7 +38,7 @@ import shutil
 import tarfile
 import tempfile
 from http import HTTPStatus
-from typing import Any
+from typing import Any, NoReturn
 
 import websockets
 import websockets.asyncio.server
@@ -112,10 +112,11 @@ class _WsBridgeWriter:
         pass
 
 
-async def serve(port: int, token: str | None) -> None:
+async def serve(port: int, token: str | None) -> NoReturn:
     """Start the WebSocket server on *port* with optional bearer *token* auth.
 
-    Accepts exactly one WebSocket connection, runs user code, then returns.
+    Accepts exactly one WebSocket connection, runs user code, then exits the
+    process.
     """
     stop = asyncio.Event()
     accepted = False
@@ -136,9 +137,15 @@ async def serve(port: int, token: str | None) -> None:
         return None
 
     async def handler(ws: Any) -> None:
+        turn = asyncio.create_task(_handle_connection(ws))
+        # End the turn when the socket closes, even mid-block: user code that
+        # ignores the disconnect would otherwise keep this single-use container
+        # alive, answering every later connection with "Busy".
+        ws_closed = asyncio.create_task(ws.wait_closed())
+        ws_closed.add_done_callback(lambda _: turn.cancel())
         try:
-            await _handle_connection(ws)
-        except websockets.ConnectionClosed:
+            await turn
+        except (websockets.ConnectionClosed, asyncio.CancelledError):
             logger.debug("client disconnected")
         except Exception:
             logger.exception("error handling WebSocket connection")
@@ -154,6 +161,9 @@ async def serve(port: int, token: str | None) -> None:
     ):
         logger.info("sandbox HTTP server listening on port %d", port)
         await stop.wait()
+    # Don't let interpreter shutdown join a worker thread still running user code
+    # the host has given up on.
+    os._exit(0)
 
 
 async def _handle_connection(ws: Any) -> None:
@@ -248,7 +258,7 @@ async def _run_one_block(
     _rpc_client.install(client)
     pump_task = asyncio.create_task(_pump_ws_to_reader(ws, bridge_reader))
     try:
-        stdout_text, stderr_text, exit_code = await loop.run_in_executor(
+        stdout_text, stderr_text, exit_code, background_work = await loop.run_in_executor(
             None, run_block, run_frame.code, globs
         )
     finally:
@@ -259,7 +269,9 @@ async def _run_one_block(
             pass
 
     # d-f. DoneFrame, OutputFrame, then the updated workspace tar (binary).
-    await ws.send(encode(DoneFrame(exit_code=exit_code)).decode("utf-8"))
+    await ws.send(
+        encode(DoneFrame(exit_code=exit_code, background_work=background_work)).decode("utf-8")
+    )
     await ws.send(
         encode(OutputFrame(stdout=stdout_text, stderr=stderr_text, exit_code=exit_code)).decode(
             "utf-8"

adk_code_mode-2.0.0/sandbox-wheel/src/adk_code_mode_sandbox/_interrupt.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Stop the running code block when the host asks, keeping the sandbox's state.
+
+The host sends an ``InterruptFrame`` when a block runs past its timeout. Raising
+``CodeTimeout`` in the thread running the block ends it like any other exception,
+so its output so far, the globals and the working directory all survive for the
+turn's next block. Code stuck outside the interpreter (a C call, a long
+``time.sleep``) only sees the exception once it returns, which is why the host
+still falls back to restarting the sandbox after a grace period.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import threading
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+
+class CodeTimeout(BaseException):
+    """Raised in running code when the host stops it at its timeout.
+
+    A ``BaseException`` so the code's own ``except Exception`` can't swallow it.
+    """
+
+    message = ""
+
+    def __init__(self, *args: object) -> None:
+        # The interpreter raises an asynchronous exception without arguments.
+        super().__init__(*(args or (type(self).message,)))
+
+
+_lock = threading.Lock()
+_running_thread: int | None = None
+
+
+def _set_async_exc(thread_id: int, exc: type[BaseException] | None) -> None:
+    ctypes.pythonapi.PyThreadState_SetAsyncExc(
+        ctypes.c_ulong(thread_id), ctypes.py_object(exc) if exc else None
+    )
+
+
+@contextmanager
+def running() -> Iterator[None]:
+    """Mark the current thread as the one running a code block."""
+    global _running_thread
+    with _lock:
+        _running_thread = threading.get_ident()
+    try:
+        yield
+    finally:
+        with _lock:
+            _running_thread = None
+            # A stop that arrived as the block finished must not fire in the
+            # sandbox's own code afterwards.
+            _set_async_exc(threading.get_ident(), None)
+
+
+def interrupt(message: str) -> None:
+    """Raise ``CodeTimeout`` with ``message`` in the running block, if there is one."""
+    with _lock:
+        if _running_thread is None:
+            return
+        CodeTimeout.message = message
+        _set_async_exc(_running_thread, CodeTimeout)

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/sandbox-wheel/src/adk_code_mode_sandbox/_rpc_client.py

@@ -19,8 +19,10 @@ import threading
 import uuid
 from typing import Any
 
+from adk_code_mode_sandbox import _interrupt
 from adk_code_mode_sandbox.protocol import (
     Frame,
+    InterruptFrame,
     ProtocolError,
     ToolCallFrame,
     ToolResultFrame,
@@ -38,6 +40,15 @@ class ToolError(RuntimeError):
         self.trace = trace
 
 
+class HTTPStatusError(Exception):
+    """Raised inside the sandbox when a tool's API answers with an HTTP error status."""
+
+    def __init__(self, message: str, status_code: int, body: Any) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+
+
 class RpcClient:
     """Synchronous, thread-safe RPC client over the sandbox control pipe.
 
@@ -85,6 +96,8 @@ class RpcClient:
             err = frame.error
             if err is None:
                 raise ToolError("Error", "tool call failed without error payload")
+            if err.type == "HTTPStatusError" and err.status_code is not None:
+                raise HTTPStatusError(err.message, err.status_code, err.body)
             raise ToolError(err.type, err.message, err.trace)
 
     def _read_loop(self) -> None:
@@ -94,6 +107,11 @@ class RpcClient:
                 if not line:
                     raise ProtocolError("control pipe closed by host")
                 frame = decode(line)
+                # Handled here, off the thread running the code, so a stop reaches
+                # a block that is busy or waiting on a tool call.
+                if isinstance(frame, InterruptFrame):
+                    _interrupt.interrupt(frame.message)
+                    continue
                 with self._state_changed:
                     if isinstance(frame, ToolResultFrame):
                         self._pending_results[frame.id] = frame
@@ -126,4 +144,4 @@ def call(name: str, args: dict[str, Any], timeout: float | None = None) -> Any:
     return get().call(name, args, timeout)
 
 
-__all__ = ["RpcClient", "ToolError", "call", "get", "install"]
+__all__ = ["HTTPStatusError", "RpcClient", "ToolError", "call", "get", "install"]

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/sandbox-wheel/src/adk_code_mode_sandbox/protocol.py

@@ -22,7 +22,7 @@ import json
 from dataclasses import asdict, dataclass, field
 from typing import Any, Literal
 
-PROTOCOL_VERSION = 2
+PROTOCOL_VERSION = 4
 
 
 FrameKind = Literal[
@@ -34,6 +34,7 @@ FrameKind = Literal[
     "done",
     "output",
     "shutdown",
+    "interrupt",
 ]
 
 
@@ -81,6 +82,8 @@ class ToolErrorPayload:
     type: str
     message: str
     trace: str | None = None
+    status_code: int | None = None
+    body: Any = None
 
 
 @dataclass(frozen=True)
@@ -108,6 +111,7 @@ class DoneFrame:
     """Sandbox → host. User code finished. Host drains stdout/stderr next."""
 
     exit_code: int = 0
+    background_work: bool = False
     kind: Literal["done"] = "done"
 
 
@@ -132,6 +136,14 @@ class ShutdownFrame:
     kind: Literal["shutdown"] = "shutdown"
 
 
+@dataclass(frozen=True)
+class InterruptFrame:
+    """Host → sandbox. Stop the running block, raising ``message`` in its code."""
+
+    message: str = ""
+    kind: Literal["interrupt"] = "interrupt"
+
+
 Frame = (
     ReadyFrame
     | RunFrame
@@ -141,6 +153,7 @@ Frame = (
     | DoneFrame
     | OutputFrame
     | ShutdownFrame
+    | InterruptFrame
 )
 
 
@@ -153,6 +166,7 @@ _KIND_TO_CLS: dict[str, type] = {
     "done": DoneFrame,
     "output": OutputFrame,
     "shutdown": ShutdownFrame,
+    "interrupt": InterruptFrame,
 }
 
 
@@ -199,6 +213,8 @@ def decode(line: bytes | str) -> Frame:
             type=str(err.get("type", "Error")),
             message=str(err.get("message", "")),
             trace=err.get("trace"),
+            status_code=err.get("status_code"),
+            body=err.get("body"),
         )
     valid_fields = {f for f in cls.__dataclass_fields__}  # type: ignore[attr-defined]
     filtered = {k: v for k, v in obj.items() if k in valid_fields}
@@ -221,6 +237,7 @@ __all__ = [
     "DoneFrame",
     "OutputFrame",
     "ShutdownFrame",
+    "InterruptFrame",
     "ProtocolError",
     "encode",
     "decode",

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/src/adk_code_mode/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "1.6.0"  # x-release-please-version
+__version__ = "2.0.0"  # x-release-please-version

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/src/adk_code_mode/runtime/base.py

@@ -42,6 +42,7 @@ class SandboxResult:
     stdout: str
     stderr: str
     exit_code: int
+    background_work: bool = False
 
 
 @dataclass(frozen=True)

{adk_code_mode-1.6.0 → adk_code_mode-2.0.0}/src/adk_code_mode/runtime/protocol.py

@@ -22,7 +22,7 @@ import json
 from dataclasses import asdict, dataclass, field
 from typing import Any, Literal
 
-PROTOCOL_VERSION = 2
+PROTOCOL_VERSION = 4
 
 
 FrameKind = Literal[
@@ -34,6 +34,7 @@ FrameKind = Literal[
     "done",
     "output",
     "shutdown",
+    "interrupt",
 ]
 
 
@@ -81,6 +82,8 @@ class ToolErrorPayload:
     type: str
     message: str
     trace: str | None = None
+    status_code: int | None = None
+    body: Any = None
 
 
 @dataclass(frozen=True)
@@ -108,6 +111,7 @@ class DoneFrame:
     """Sandbox → host. User code finished. Host drains stdout/stderr next."""
 
     exit_code: int = 0
+    background_work: bool = False
     kind: Literal["done"] = "done"
 
 
@@ -132,6 +136,14 @@ class ShutdownFrame:
     kind: Literal["shutdown"] = "shutdown"
 
 
+@dataclass(frozen=True)
+class InterruptFrame:
+    """Host → sandbox. Stop the running block, raising ``message`` in its code."""
+
+    message: str = ""
+    kind: Literal["interrupt"] = "interrupt"
+
+
 Frame = (
     ReadyFrame
     | RunFrame
@@ -141,6 +153,7 @@ Frame = (
     | DoneFrame
     | OutputFrame
     | ShutdownFrame
+    | InterruptFrame
 )
 
 
@@ -153,6 +166,7 @@ _KIND_TO_CLS: dict[str, type] = {
     "done": DoneFrame,
     "output": OutputFrame,
     "shutdown": ShutdownFrame,
+    "interrupt": InterruptFrame,
 }
 
 
@@ -199,6 +213,8 @@ def decode(line: bytes | str) -> Frame:
             type=str(err.get("type", "Error")),
             message=str(err.get("message", "")),
             trace=err.get("trace"),
+            status_code=err.get("status_code"),
+            body=err.get("body"),
         )
     valid_fields = {f for f in cls.__dataclass_fields__}  # type: ignore[attr-defined]
     filtered = {k: v for k, v in obj.items() if k in valid_fields}
@@ -221,6 +237,7 @@ __all__ = [
     "DoneFrame",
     "OutputFrame",
     "ShutdownFrame",
+    "InterruptFrame",
     "ProtocolError",
     "encode",
     "decode",