bazaar-compute-node 0.1.6__tar.gz → 0.1.7__tar.gz

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.6
+Version: 0.1.7
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -24,6 +24,7 @@ Harness 工具。
 - **自由组合**：根据使用场景分别选择 Channel 与 Runtime，并可独立替换和扩展。
 - **持续会话**：每个用户和对话拥有独立上下文，节点重启后仍可继续之前的任务。
 - **真实工作区**：Runtime 可以在独立工作区中分析、创建和修改文件，而不局限于文本回答。
+- **双向附件**：Channel 收到的媒体会进入会话工作区，Runtime 也可以通过 Channel 交付工作区中的文件。
 - **可靠交付**：自动处理长结果的分批发送并记录交付状态，避免任务结果静默丢失。
 - **安全边界**：复用所选 Harness 的权限机制，按任务需要控制文件与网络访问。
 - **跨平台运行**：支持 Linux、macOS 和 Windows，并以后台进程长期运行。
@@ -57,7 +58,6 @@ bcn 将沿着可组合的 Channel、Runtime 与节点通用能力继续扩展。
 
 ### 节点能力
 
-- **附件发送**：让 Agent 可以通过当前 Channel 交付生成的文件；
 - **定时任务**：创建一次性或周期性任务，由节点按计划自动执行并返回结果。
 
 ## 安装
@@ -91,7 +91,8 @@ Channel 即可。
 ### WeCom
 
 WeCom Channel 对接企业微信智能机器人，支持单聊、群聊、文本与媒体输入，以及 Markdown
-长消息分批返回。群聊中需要 @机器人，确保消息能够进入节点。
+长消息分批和附件返回。收到的媒体会以工作区相对路径提供给 Runtime；Runtime 可以把工作区内的
+普通文件作为附件发送，附件路径不能包含符号链接。群聊中需要 @机器人，确保消息能够进入节点。
 
 在 `~/.bcn/config.toml` 中配置 Bot ID：
 
@@ -128,9 +129,12 @@ Runtime 即可。
 [runtime]
 sandbox_mode = "workspace-write"
 network_access = true
+idle_timeout = 0
 ```
 
 如需覆盖 Codex 的默认模型或推理强度，可以在 `[runtime]` 中增加 `model` 和 `effort`。
+`idle_timeout` 以秒为单位并支持小数；默认值 `0` 与所有 `<= 0` 的值表示 runtime session
+常驻。设置为正值后，每条新收到的消息都会刷新空闲回收期限。
 除非你明确需要使用运行用户已有的主机权限，否则不要将 `sandbox_mode` 改为
 `danger-full-access`。
 

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.7}/README.md

@@ -11,6 +11,7 @@ Harness 工具。
 - **自由组合**：根据使用场景分别选择 Channel 与 Runtime，并可独立替换和扩展。
 - **持续会话**：每个用户和对话拥有独立上下文，节点重启后仍可继续之前的任务。
 - **真实工作区**：Runtime 可以在独立工作区中分析、创建和修改文件，而不局限于文本回答。
+- **双向附件**：Channel 收到的媒体会进入会话工作区，Runtime 也可以通过 Channel 交付工作区中的文件。
 - **可靠交付**：自动处理长结果的分批发送并记录交付状态，避免任务结果静默丢失。
 - **安全边界**：复用所选 Harness 的权限机制，按任务需要控制文件与网络访问。
 - **跨平台运行**：支持 Linux、macOS 和 Windows，并以后台进程长期运行。
@@ -44,7 +45,6 @@ bcn 将沿着可组合的 Channel、Runtime 与节点通用能力继续扩展。
 
 ### 节点能力
 
-- **附件发送**：让 Agent 可以通过当前 Channel 交付生成的文件；
 - **定时任务**：创建一次性或周期性任务，由节点按计划自动执行并返回结果。
 
 ## 安装
@@ -78,7 +78,8 @@ Channel 即可。
 ### WeCom
 
 WeCom Channel 对接企业微信智能机器人，支持单聊、群聊、文本与媒体输入，以及 Markdown
-长消息分批返回。群聊中需要 @机器人，确保消息能够进入节点。
+长消息分批和附件返回。收到的媒体会以工作区相对路径提供给 Runtime；Runtime 可以把工作区内的
+普通文件作为附件发送，附件路径不能包含符号链接。群聊中需要 @机器人，确保消息能够进入节点。
 
 在 `~/.bcn/config.toml` 中配置 Bot ID：
 
@@ -115,9 +116,12 @@ Runtime 即可。
 [runtime]
 sandbox_mode = "workspace-write"
 network_access = true
+idle_timeout = 0
 ```
 
 如需覆盖 Codex 的默认模型或推理强度，可以在 `[runtime]` 中增加 `model` 和 `effort`。
+`idle_timeout` 以秒为单位并支持小数；默认值 `0` 与所有 `<= 0` 的值表示 runtime session
+常驻。设置为正值后，每条新收到的消息都会刷新空闲回收期限。
 除非你明确需要使用运行用户已有的主机权限，否则不要将 `sandbox_mode` 改为
 `danger-full-access`。
 

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.6"
+version = "0.1.7"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -19,7 +19,7 @@ Repository = "https://github.com/yuchanns/bazaar-compute-node"
 bcn = "bazaar_compute_node.cli:main"
 
 [project.entry-points."bazaar_compute_node.runtimes"]
-codex = "bazaar_compute_node.contrib.codex_app_server.plugin:create_runtime"
+codex = "bazaar_compute_node.contrib.codex.plugin:create_runtime"
 
 [project.entry-points."bazaar_compute_node.channels"]
 wecom = "bazaar_compute_node.contrib.wecom.plugin:create_channel"

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.7}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.6"
+version = "0.1.7"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -19,7 +19,7 @@ Repository = "https://github.com/yuchanns/bazaar-compute-node"
 bcn = "bazaar_compute_node.cli:main"
 
 [project.entry-points."bazaar_compute_node.runtimes"]
-codex = "bazaar_compute_node.contrib.codex_app_server.plugin:create_runtime"
+codex = "bazaar_compute_node.contrib.codex.plugin:create_runtime"
 
 [project.entry-points."bazaar_compute_node.channels"]
 wecom = "bazaar_compute_node.contrib.wecom.plugin:create_channel"

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.7}/src/bazaar_compute_node/app/application.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import hmac
+import math
 import os
 import re
 import secrets
@@ -17,6 +18,7 @@ from ..core.orchestration import SessionOrchestrator
 from ..core.paths import resolve_data_dir, resolve_workspace_dir
 from ..core.runtime import IRuntime, RuntimeCommandContext, RuntimeSandboxMode
 from ..core.storage import IStorage, NodeIdentity
+from ..core.timerwheel import TimerWheel
 from .attachments import AttachmentMaterializer
 from .command import (
     CommandDispatcher,
@@ -64,6 +66,7 @@ class NodeApplication:
         runtime_options: Mapping[str, str] | None = None,
         runtime_sandbox_mode: RuntimeSandboxMode = RuntimeSandboxMode.WORKSPACE_WRITE,
         runtime_network_access: bool = True,
+        runtime_idle_timeout_seconds: float = 0,
         channel_options: Mapping[str, object] | None = None,
         runtime_environment_include: Sequence[str] = (),
         timeout_budget: TimeoutBudget | None = None,
@@ -81,8 +84,7 @@ class NodeApplication:
         self.command_log: list[CommandRecord] = []
         self._wrapper_path: Path | None = None
         self._identity: NodeIdentity | None = None
-        self._session_capabilities: dict[str, str] = {}
-        self._runtime_session_ids: dict[str, str] = {}
+        self._session_capabilities: dict[str, tuple[str, str]] = {}
         self._started = False
         self._stopped = asyncio.Event()
         self._runtime_environment_include = tuple(runtime_environment_include)
@@ -106,6 +108,23 @@ class NodeApplication:
             startup_timeout_seconds=self.timeout_budget.startup_seconds,
         )
         self.runtime: IRuntime = factories.runtime(self._runtime_context)
+        if (
+            isinstance(runtime_idle_timeout_seconds, bool)
+            or not isinstance(runtime_idle_timeout_seconds, int | float)
+            or not math.isfinite(runtime_idle_timeout_seconds)
+        ):
+            raise ValueError("runtime_idle_timeout_seconds must be a finite number")
+        self.timer_wheel = TimerWheel()
+        if (
+            runtime_idle_timeout_seconds > 0
+            and runtime_idle_timeout_seconds * 1_000 > self.timer_wheel.maximum_delay_ms
+        ):
+            raise ValueError("runtime_idle_timeout_seconds exceeds the timer horizon")
+        runtime_idle_timeout_ms = (
+            math.ceil(runtime_idle_timeout_seconds * 1_000)
+            if runtime_idle_timeout_seconds > 0
+            else 0
+        )
         self.orchestrator = SessionOrchestrator(
             node_id=node_id,
             workspace_id=workspace_id,
@@ -114,6 +133,8 @@ class NodeApplication:
             storage=self.storage,
             audit=self.audit,
             timeout_budget=self.timeout_budget,
+            timer_wheel=self.timer_wheel,
+            runtime_idle_timeout_ms=runtime_idle_timeout_ms,
             workspace=self._workspace_path,
             on_node_initialized=self._ensure_workspace,
         )
@@ -147,12 +168,16 @@ class NodeApplication:
             install_bcc_wrapper, self.data_dir / "bin"
         )
         try:
+            await self.timer_wheel.start()
             await self.command_server.start()
             await self.orchestrator.start(
                 timeout=self.timeout_budget.startup_seconds,
             )
         except BaseException:
-            await self.stop()
+            try:
+                await self.stop()
+            finally:
+                await self.timer_wheel.close()
             raise
         self._started = True
         self._stopped.clear()
@@ -168,7 +193,10 @@ class NodeApplication:
                 try:
                     await self.command_server.stop()
                 finally:
-                    await self._cleanup_bcc_wrapper()
+                    try:
+                        await self._cleanup_bcc_wrapper()
+                    finally:
+                        await self.timer_wheel.close()
             return
         self._started = False
         self.command_dispatcher.stop_accepting()
@@ -188,7 +216,10 @@ class NodeApplication:
                     try:
                         await self._cleanup_bcc_wrapper()
                     finally:
-                        self._stopped.set()
+                        try:
+                            await self.timer_wheel.close()
+                        finally:
+                            self._stopped.set()
 
     async def _cleanup_bcc_wrapper(self) -> None:
         wrapper_path = self._wrapper_path
@@ -278,18 +309,19 @@ class NodeApplication:
                     "SESSION_NOT_FOUND",
                     f"unknown bcn session: {session_id}",
                 )
-            runtime_session = await transaction.find_runtime_session(session_id)
-        if runtime_session is None or runtime_session_id != (runtime_session.id):
+        runtime_session = self.orchestrator.runtime_session(session_id)
+        if runtime_session is None or runtime_session_id != runtime_session.id:
             raise CommandDispatchError(
                 "SESSION_BINDING_FAILED",
                 "runtime session binding is invalid",
             )
-        expected_capability = self._session_capabilities.get(session_id)
+        capability_binding = self._session_capabilities.get(session_id)
         if (
-            expected_capability is None
+            capability_binding is None
+            or capability_binding[0] != runtime_session.id
             or not isinstance(session_capability, str)
             or not hmac.compare_digest(
-                session_capability.encode(), expected_capability.encode()
+                session_capability.encode(), capability_binding[1].encode()
             )
         ):
             raise CommandDispatchError(
@@ -298,7 +330,9 @@ class NodeApplication:
             )
 
     def _runtime_environment(self, session: RuntimeSession) -> Mapping[str, str]:
-        self._runtime_session_ids[session.bcn_session_id] = session.id
+        runtime_session = self.orchestrator.runtime_session(session.bcn_session_id)
+        if runtime_session is None or runtime_session.id != session.id:
+            raise RuntimeError("runtime session is not the current live binding")
         return self._build_command_environment(
             session.bcn_session_id,
             session.id,
@@ -316,10 +350,11 @@ class NodeApplication:
         wrapper_path = self._wrapper_path
         if wrapper_path is None:
             raise RuntimeError("bcc wrapper is not installed")
-        session_capability = self._session_capabilities.setdefault(
-            session_id,
-            secrets.token_urlsafe(32),
-        )
+        capability_binding = self._session_capabilities.get(session_id)
+        if capability_binding is None or capability_binding[0] != runtime_session_id:
+            capability_binding = (runtime_session_id, secrets.token_urlsafe(32))
+            self._session_capabilities[session_id] = capability_binding
+        session_capability = capability_binding[1]
         wrapper_directory = str(wrapper_path.parent)
         allowed = set(_PLATFORM_ENVIRONMENT)
         for name in self.runtime.environment_variable_names():
@@ -368,13 +403,12 @@ class NodeApplication:
         if wrapper_path is None:
             raise RuntimeError("bcc wrapper is not installed")
         self.command_log.append((session_id, tuple(arguments)))
-        runtime_session_id = self._runtime_session_ids.get(
-            session_id,
-            f"runtime-{session_id}",
-        )
+        runtime_session = self.orchestrator.runtime_session(session_id)
+        if runtime_session is None:
+            raise RuntimeError("runtime session is not live")
         environment = self._build_command_environment(
             session_id,
-            runtime_session_id,
+            runtime_session.id,
         )
         process = await asyncio.create_subprocess_exec(
             str(wrapper_path),

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.7}/src/bazaar_compute_node/app/config.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 import os
 import tomllib
 from dataclasses import dataclass
@@ -25,6 +26,7 @@ class NodeConfiguration:
     effort: str | None = None
     sandbox_mode: RuntimeSandboxMode = RuntimeSandboxMode.WORKSPACE_WRITE
     network_access: bool = True
+    runtime_idle_timeout_seconds: float = 0
     runtime_env_include: tuple[str, ...] = ()
     wecom_bot_id: str | None = None
     wecom_websocket_url: str | None = None
@@ -81,6 +83,13 @@ def load_node_configuration(path: Path | None = None) -> NodeConfiguration:
     network_access = runtime.get("network_access", True)
     if not isinstance(network_access, bool):
         raise ConfigurationError("runtime.network_access must be a boolean")
+    idle_timeout = runtime.get("idle_timeout", 0)
+    if (
+        isinstance(idle_timeout, bool)
+        or not isinstance(idle_timeout, int | float)
+        or not math.isfinite(idle_timeout)
+    ):
+        raise ConfigurationError("runtime.idle_timeout must be a finite number")
     return NodeConfiguration(
         channel=_optional_text(node.get("channel"), "node.channel"),
         runtime=_optional_text(node.get("runtime"), "node.runtime"),
@@ -92,6 +101,7 @@ def load_node_configuration(path: Path | None = None) -> NodeConfiguration:
         effort=_optional_text(runtime.get("effort"), "runtime.effort"),
         sandbox_mode=parsed_sandbox_mode,
         network_access=network_access,
+        runtime_idle_timeout_seconds=float(idle_timeout),
         runtime_env_include=_text_list(
             runtime_env.get("include", []), "runtime.env.include"
         ),

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.7}/src/bazaar_compute_node/cli.py

@@ -173,6 +173,7 @@ def _apply_runtime_configuration(
     if args.audit is None:
         args.audit = DEFAULT_AUDIT
     args.runtime_env_include = configuration.runtime_env_include
+    args.runtime_idle_timeout_seconds = configuration.runtime_idle_timeout_seconds
     args.channel_options = {
         "bot_id": configuration.wecom_bot_id,
         "websocket_url": configuration.wecom_websocket_url,
@@ -189,6 +190,7 @@ async def _run_node(args: argparse.Namespace, parser: argparse.ArgumentParser) -
         runtime_options=_runtime_options(args),
         runtime_sandbox_mode=args.sandbox_mode,
         runtime_network_access=args.network_access,
+        runtime_idle_timeout_seconds=args.runtime_idle_timeout_seconds,
         channel_options=args.channel_options if args.channel == "wecom" else {},
         runtime_environment_include=args.runtime_env_include,
     )

{bazaar_compute_node-0.1.6/src/bazaar_compute_node/contrib/codex_app_server → bazaar_compute_node-0.1.7/src/bazaar_compute_node/contrib/codex}/__init__.py

@@ -1,11 +1,12 @@
 """Codex App Server process, protocol, and runtime adapter."""
 
 from .client import (
-    CodexAppServerClient,
-    CodexAppServerProtocolError,
-    CodexErrorInfo,
-    CodexThreadInfo,
-    CodexTurnInfo,
+    Client,
+    ErrorInfo,
+    FsChangedInfo,
+    ThreadInfo,
+    TurnInfo,
+    build_fs_watch_params,
     build_initialize_params,
     build_thread_resume_params,
     build_thread_start_params,
@@ -13,18 +14,23 @@ from .client import (
     build_turn_start_params,
     build_turn_steer_params,
     parse_error_notification,
+    parse_fs_changed_notification,
+    parse_fs_watch_response,
+    parse_initialize_response,
+    parse_skills_changed_notification,
     parse_thread_response,
     parse_turn_notification,
     parse_turn_response,
     parse_turn_steer_response,
 )
-from .events import CodexTurnEventStream
+from .events import TurnEventStream
 from .process import (
     JsonlProcessSpec,
     JsonlProcessState,
     JsonlProcessSupervisor,
 )
 from .protocol import (
+    AppServerProtocolError,
     JsonlMessage,
     JsonlProcessExited,
     JsonlProcessNotRunning,
@@ -33,16 +39,13 @@ from .protocol import (
     JsonlRequestTimeout,
     JsonlTransportError,
 )
-from .runtime import CodexAppServerRuntime
+from .runtime import Runtime
 
 __all__ = [
-    "CodexAppServerClient",
-    "CodexAppServerProtocolError",
-    "CodexAppServerRuntime",
-    "CodexErrorInfo",
-    "CodexThreadInfo",
-    "CodexTurnEventStream",
-    "CodexTurnInfo",
+    "AppServerProtocolError",
+    "Client",
+    "ErrorInfo",
+    "FsChangedInfo",
     "JsonlMessage",
     "JsonlProcessExited",
     "JsonlProcessNotRunning",
@@ -53,6 +56,11 @@ __all__ = [
     "JsonlRemoteError",
     "JsonlRequestTimeout",
     "JsonlTransportError",
+    "Runtime",
+    "ThreadInfo",
+    "TurnEventStream",
+    "TurnInfo",
+    "build_fs_watch_params",
     "build_initialize_params",
     "build_thread_resume_params",
     "build_thread_start_params",
@@ -60,6 +68,10 @@ __all__ = [
     "build_turn_start_params",
     "build_turn_steer_params",
     "parse_error_notification",
+    "parse_fs_changed_notification",
+    "parse_fs_watch_response",
+    "parse_initialize_response",
+    "parse_skills_changed_notification",
     "parse_thread_response",
     "parse_turn_notification",
     "parse_turn_response",

{bazaar_compute_node-0.1.6/src/bazaar_compute_node/contrib/codex_app_server → bazaar_compute_node-0.1.7/src/bazaar_compute_node/contrib/codex}/approval.py

@@ -4,9 +4,15 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import cast
 
-from ...core.models import ApprovalDecision, ApprovalRequest, ApprovalResult
+from ...core.models import (
+    ApprovalDecision,
+    ApprovalResult,
+)
+from ...core.models import (
+    ApprovalRequest as CoreApprovalRequest,
+)
 from .protocol import (
-    CodexAppServerProtocolError,
+    AppServerProtocolError,
     JsonlMessage,
     JsonlRequestId,
     is_request_id,
@@ -26,13 +32,13 @@ _APPROVAL_METHODS = frozenset(
 
 
 @dataclass(frozen=True, slots=True)
-class CodexApprovalRequest:
+class ApprovalEnvelope:
     """Provider request plus its neutral approval projection."""
 
     request_id: JsonlRequestId
     method: str
     params: Mapping[str, object]
-    request: ApprovalRequest
+    request: CoreApprovalRequest
 
 
 def is_approval_method(method: object) -> bool:
@@ -47,28 +53,26 @@ def parse_approval_request(
     turn_id: str,
     provider_thread_id: str,
     provider_turn_id: str | None,
-) -> CodexApprovalRequest:
+) -> ApprovalEnvelope:
     method = message.get("method")
     if not isinstance(method, str) or not is_approval_method(method):
-        raise CodexAppServerProtocolError("message is not an approval request")
+        raise AppServerProtocolError("message is not an approval request")
     request_id = message.get("id")
     if not is_request_id(request_id):
-        raise CodexAppServerProtocolError(
-            "approval request id must be an integer or string"
-        )
+        raise AppServerProtocolError("approval request id must be an integer or string")
     request_id = cast(JsonlRequestId, request_id)
     params = message.get("params")
     if not isinstance(params, Mapping):
-        raise CodexAppServerProtocolError("approval request params must be an object")
+        raise AppServerProtocolError("approval request params must be an object")
 
     thread_value = _require_text(params, "threadId")
     if thread_value != provider_thread_id:
-        raise CodexAppServerProtocolError(
+        raise AppServerProtocolError(
             "approval request thread does not match runtime thread"
         )
     provider_turn_value = _require_text(params, "turnId")
     if provider_turn_id is None or provider_turn_value != provider_turn_id:
-        raise CodexAppServerProtocolError(
+        raise AppServerProtocolError(
             "approval request turn does not match runtime turn"
         )
     provider_item_id = _require_text(params, "itemId")
@@ -78,7 +82,7 @@ def parse_approval_request(
         or isinstance(started_at_ms, bool)
         or started_at_ms < 0
     ):
-        raise CodexAppServerProtocolError(
+        raise AppServerProtocolError(
             "approval request startedAtMs must be a non-negative integer"
         )
     action = {
@@ -89,7 +93,7 @@ def parse_approval_request(
     if method == _PERMISSIONS_METHOD and not isinstance(
         params.get("permissions"), Mapping
     ):
-        raise CodexAppServerProtocolError(
+        raise AppServerProtocolError(
             "permissions approval request has no permissions object"
         )
 
@@ -104,11 +108,11 @@ def parse_approval_request(
         value = params.get(provider_key)
         if isinstance(value, str) and value:
             metadata[metadata_key] = value
-    return CodexApprovalRequest(
+    return ApprovalEnvelope(
         request_id=request_id,
         method=method,
         params=params,
-        request=ApprovalRequest(
+        request=CoreApprovalRequest(
             request_id=str(request_id),
             session_id=session_id,
             runtime_session_id=runtime_session_id,
@@ -121,7 +125,7 @@ def parse_approval_request(
 
 
 def build_approval_response(
-    approval: CodexApprovalRequest,
+    approval: ApprovalEnvelope,
     result: ApprovalResult,
 ) -> Mapping[str, object]:
     if result.request_id != approval.request.request_id:
@@ -134,11 +138,11 @@ def build_approval_response(
             return {"permissions": {}}
         permissions = approval.params.get("permissions")
         if not isinstance(permissions, Mapping):
-            raise CodexAppServerProtocolError(
+            raise AppServerProtocolError(
                 "permissions approval request has no permissions object"
             )
         return {"permissions": dict(permissions), "scope": "turn"}
-    raise CodexAppServerProtocolError("unsupported approval response method")
+    raise AppServerProtocolError("unsupported approval response method")
 
 
 def approval_error(error: BaseException) -> Mapping[str, object]:
@@ -153,14 +157,14 @@ def approval_error(error: BaseException) -> Mapping[str, object]:
 def _require_text(params: Mapping[str, object], field_name: str) -> str:
     value = params.get(field_name)
     if not isinstance(value, str) or not value:
-        raise CodexAppServerProtocolError(
+        raise AppServerProtocolError(
             f"approval request {field_name} must be non-empty text"
         )
     return value
 
 
 __all__ = [
-    "CodexApprovalRequest",
+    "ApprovalEnvelope",
     "approval_error",
     "build_approval_response",
     "is_approval_method",