Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat: agent runtime protocol (#5000)

Eric Hayesc408f4bbb0b8
diff --git a/.config/hakari.toml b/.config/hakari.toml
index d6cb13147d..f0b54a5ff9 100644
--- a/.config/hakari.toml
+++ b/.config/hakari.toml
@@ -40,6 +40,9 @@ platforms = [
# macro_sync_service_jwt and the sync-service packages must stay wasm-safe, so
# they must not gain the workspace-hack dep, which pulls native-only features.
workspace-members = [
+ # Standalone protocol library. Until a deployable service consumes it,
+ # ACP's schema features must not alter unrelated service build/codegen closures.
+ "agent_runtime_protocol",
"xtask",
# xtask command crates: dev-only automation split out of xtask so each
# `cargo x <cmd>` compiles only its own dependency set.
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index 2940f29dbe..d675257146 100644
--- a/.github/workspace-dep-closures.json
+++ b/.github/workspace-dep-closures.json
@@ -23,6 +23,9 @@
"crates/remote_env_var",
"crates/workspace-hack"
],
+ "agent_runtime_protocol": [
+ "crates/agent_runtime_protocol"
+ ],
"ai_projections": [
"crates/agent",
"crates/ai_projections",
diff --git a/Cargo.lock b/Cargo.lock
index 6c334a5526..2b9aacb995 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -71,7 +71,7 @@ dependencies = [
"schemars 1.2.1",
"serde",
"serde_json",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tokio-util",
@@ -80,6 +80,69 @@ dependencies = [
"workspace-hack",
]
+[[package]]
+name = "agent-client-protocol"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "882b815ffa67b023e1b40e7ea3bab3f05869654e8565d6811870c5545285e1d3"
+dependencies = [
+ "agent-client-protocol-derive",
+ "agent-client-protocol-schema",
+ "async-process",
+ "blocking",
+ "futures",
+ "futures-concurrency",
+ "rustc-hash 2.1.2",
+ "schemars 1.2.1",
+ "serde",
+ "serde_json",
+ "shell-words",
+ "tracing",
+ "uuid",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "agent-client-protocol-derive"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5ca63f112bd2459bcaf9eda0683b9ba95fc3b5e5fdd9036ca941c6a09345b1"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "agent-client-protocol-schema"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06679e1542356341f4550ccfb16338b64f37f6af70de2105446ef6fbb078234c"
+dependencies = [
+ "anyhow",
+ "derive_more 2.1.1",
+ "schemars 1.2.1",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "strum 0.28.0",
+ "tracing",
+]
+
+[[package]]
+name = "agent_runtime_protocol"
+version = "0.1.0"
+dependencies = [
+ "agent-client-protocol",
+ "axum",
+ "futures",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-tungstenite 0.28.0",
+ "tracing",
+]
+
[[package]]
name = "ahash"
version = "0.8.12"
@@ -240,7 +303,7 @@ dependencies = [
"soup",
"sqlx",
"sqs_client",
- "strum",
+ "strum 0.27.2",
"sync_service_client",
"system_properties",
"teams",
@@ -285,7 +348,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tracing",
@@ -614,6 +677,18 @@ dependencies = [
"futures-core",
]
+[[package]]
+name = "async-channel"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
+dependencies = [
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
[[package]]
name = "async-compression"
version = "0.4.42"
@@ -690,7 +765,7 @@ dependencies = [
"proc-macro-crate 3.5.0",
"proc-macro2",
"quote",
- "strum",
+ "strum 0.27.2",
"syn 2.0.117",
"thiserror 2.0.18",
]
@@ -787,6 +862,24 @@ dependencies = [
"syn 2.0.117",
]
+[[package]]
+name = "async-process"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
+dependencies = [
+ "async-channel 2.5.0",
+ "async-io",
+ "async-lock",
+ "async-signal",
+ "async-task",
+ "blocking",
+ "cfg-if",
+ "event-listener 5.4.1",
+ "futures-lite 2.6.1",
+ "rustix 1.1.4",
+]
+
[[package]]
name = "async-recursion"
version = "1.1.1"
@@ -798,6 +891,24 @@ dependencies = [
"syn 2.0.117",
]
+[[package]]
+name = "async-signal"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485"
+dependencies = [
+ "async-io",
+ "async-lock",
+ "atomic-waker",
+ "cfg-if",
+ "futures-core",
+ "futures-io",
+ "rustix 1.1.4",
+ "signal-hook-registry",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
[[package]]
name = "async-stream"
version = "0.3.6"
@@ -882,6 +993,12 @@ dependencies = [
"tracing",
]
+[[package]]
+name = "async-task"
+version = "4.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
+
[[package]]
name = "async-trait"
version = "0.1.89"
@@ -1039,7 +1156,7 @@ dependencies = [
"sha1 0.10.6",
"sqlx",
"sqs_client",
- "strum",
+ "strum 0.27.2",
"teams",
"thiserror 2.0.18",
"time",
@@ -2070,6 +2187,19 @@ dependencies = [
"objc2",
]
+[[package]]
+name = "blocking"
+version = "1.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+dependencies = [
+ "async-channel 2.5.0",
+ "async-task",
+ "futures-io",
+ "futures-lite 2.6.1",
+ "piper",
+]
+
[[package]]
name = "bollard"
version = "0.21.0"
@@ -2878,7 +3008,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"tracing",
"utoipa",
"uuid",
@@ -3025,8 +3155,8 @@ dependencies = [
"serde_json",
"sqlx",
"stream",
- "strum",
- "strum_macros",
+ "strum 0.27.2",
+ "strum_macros 0.27.2",
"tokio",
"tower 0.5.3",
"tower-http",
@@ -4211,7 +4341,7 @@ dependencies = [
"sqs_worker",
"static_file",
"stream",
- "strum",
+ "strum 0.27.2",
"sync_service_client",
"thiserror 2.0.18",
"time",
@@ -4386,7 +4516,7 @@ dependencies = [
"schemars 1.2.1",
"serde",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"utoipa",
"workspace-hack",
@@ -4665,7 +4795,7 @@ dependencies = [
"macro_aws_config",
"models_bulk_upload",
"s3_key",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tracing",
@@ -4792,7 +4922,7 @@ dependencies = [
"serde_json",
"serde_with",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tracing",
@@ -4989,7 +5119,7 @@ dependencies = [
"sqs_client",
"sqs_worker",
"static_file_service_client",
- "strum_macros",
+ "strum_macros 0.27.2",
"system_properties",
"thiserror 2.0.18",
"tokio",
@@ -5057,7 +5187,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"tokio",
"tracing",
"workspace-hack",
@@ -5607,7 +5737,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tracing",
@@ -5673,6 +5803,19 @@ dependencies = [
"futures-sink",
]
+[[package]]
+name = "futures-concurrency"
+version = "7.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175cd8cca9e1d45b87f18ffa75088f2099e3c4fe5e2f83e42de112560bea8ea6"
+dependencies = [
+ "fixedbitset 0.5.7",
+ "futures-core",
+ "futures-lite 2.6.1",
+ "pin-project",
+ "smallvec",
+]
+
[[package]]
name = "futures-core"
version = "0.3.32"
@@ -5728,7 +5871,10 @@ version = "2.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
dependencies = [
+ "fastrand 2.4.1",
"futures-core",
+ "futures-io",
+ "parking",
"pin-project-lite",
]
@@ -5929,7 +6075,7 @@ dependencies = [
"serde",
"serde_json",
"serde_yml",
- "strum_macros",
+ "strum_macros 0.27.2",
]
[[package]]
@@ -6752,7 +6898,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e9b187a72d63adbfba487f48095306ac823049cb504ee195541e91c7775f5ad"
dependencies = [
"anyhow",
- "async-channel",
+ "async-channel 1.9.0",
"base64 0.13.1",
"futures-lite 1.13.0",
"http 0.2.12",
@@ -7244,7 +7390,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tracing",
@@ -7475,7 +7621,7 @@ dependencies = [
"schemars 1.2.1",
"serde",
"serde_json",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"utoipa",
"uuid",
@@ -8505,7 +8651,7 @@ version = "0.1.0"
dependencies = [
"macro_env_var",
"serde",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tracing",
"workspace-hack",
@@ -9176,7 +9322,7 @@ dependencies = [
"serde_json",
"serde_repr",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tracing",
"utoipa",
@@ -9192,7 +9338,7 @@ dependencies = [
"cowlike",
"serde",
"serde_json",
- "strum",
+ "strum 0.27.2",
"utoipa",
"workspace-hack",
]
@@ -9212,7 +9358,7 @@ version = "0.1.0"
dependencies = [
"serde",
"serde_json",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"utoipa",
"workspace-hack",
@@ -9235,7 +9381,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"tracing",
"utoipa",
"uuid",
@@ -9266,7 +9412,7 @@ name = "models_bulk_upload"
version = "0.1.0"
dependencies = [
"serde",
- "strum",
+ "strum 0.27.2",
"utoipa",
"workspace-hack",
]
@@ -9296,7 +9442,7 @@ dependencies = [
"serde_json",
"serde_with",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"utoipa",
"uuid",
@@ -9327,7 +9473,7 @@ name = "models_opensearch"
version = "0.1.0"
dependencies = [
"serde",
- "strum",
+ "strum 0.27.2",
"workspace-hack",
]
@@ -9357,7 +9503,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"utoipa",
"workspace-hack",
]
@@ -9394,7 +9540,7 @@ dependencies = [
"schemars 1.2.1",
"serde",
"serde_json",
- "strum",
+ "strum 0.27.2",
"utoipa",
"uuid",
"workspace-hack",
@@ -9442,7 +9588,7 @@ dependencies = [
"models_properties",
"serde",
"serde_json",
- "strum",
+ "strum 0.27.2",
"utoipa",
"uuid",
"workspace-hack",
@@ -9456,7 +9602,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"utoipa",
"uuid",
"workspace-hack",
@@ -9581,7 +9727,7 @@ dependencies = [
"serde",
"serde_json",
"sha2 0.10.9",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tower 0.5.3",
@@ -9730,7 +9876,7 @@ dependencies = [
"serde_json",
"sha2 0.10.9",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tower 0.5.3",
@@ -10202,7 +10348,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tracing",
@@ -10272,7 +10418,7 @@ dependencies = [
"opensearch_query_builder",
"serde",
"serde_json",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tracing",
@@ -10902,6 +11048,17 @@ version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+[[package]]
+name = "piper"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
+dependencies = [
+ "atomic-waker",
+ "fastrand 2.4.1",
+ "futures-io",
+]
+
[[package]]
name = "piston-float"
version = "1.0.1"
@@ -12706,7 +12863,7 @@ dependencies = [
"sqlx",
"sqs_client",
"sqs_worker",
- "strum",
+ "strum 0.27.2",
"thiserror 2.0.18",
"tokio",
"tokio-util",
@@ -12759,7 +12916,7 @@ dependencies = [
"serde",
"serde_json",
"sqlx",
- "strum",
+ "strum 0.27.2",
"system_properties",
"thiserror 2.0.18",
"tokio",
@@ -13054,6 +13211,7 @@ version = "1.0.150"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
dependencies = [
+ "indexmap 2.14.0",
"itoa",
"memchr",
"serde",
@@ -13353,6 +13511,12 @@ dependencies = [
"workspace-hack",
]
+[[package]]
+name = "shell-words"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+
[[package]]
name = "shlex"
version = "1.3.0"
@@ -13869,7 +14033,7 @@ dependencies = [
"s3_key",
"serde",
"serde_json",
- "strum",
+ "strum 0.27.2",
"tracing",
"uuid",
"workspace-hack",
@@ -13961,7 +14125,7 @@ dependencies = [
"serde",
"serde_dynamo",
"serde_json",
- "strum_macros",
+ "strum_macros 0.27.2",
"thiserror 2.0.18",
"tokio",
"tower-http",
@@ -14099,7 +14263,16 @@ version = "0.27.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
dependencies = [
- "strum_macros",
+ "strum_macros 0.27.2",
+]
+
+[[package]]
+name = "strum"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
+dependencies = [
+ "strum_macros 0.28.0",
]
[[package]]
@@ -14114,6 +14287,18 @@ dependencies = [
"syn 2.0.117",
]
+[[package]]
+name = "strum_macros"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
[[package]]
name = "subtle"
version = "2.6.1"
@@ -16351,7 +16536,7 @@ dependencies = [
"async-trait",
"proc-macro2",
"quote",
- "strum",
+ "strum 0.27.2",
"syn 2.0.117",
"wasm-bindgen",
"wasm-bindgen-futures",
@@ -16633,7 +16818,7 @@ dependencies = [
"serde_json",
"serde_yaml",
"sha2 0.10.9",
- "strum",
+ "strum 0.27.2",
"tokio",
"xtask_paths",
]
diff --git a/Cargo.toml b/Cargo.toml
index 67178b708d..8c89ef3bf3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,6 +3,7 @@ resolver = "2"
members = [
"crates/agent",
+ "crates/agent_runtime_protocol",
"crates/ai_projections",
"crates/ai_usage",
"crates/bot_id",
@@ -98,6 +99,7 @@ members = [
anyhow = "1.0.100"
apollo-compiler = "1"
apollo-parser = "0.8"
+agent-client-protocol = "1.2.0"
askama = "0.14"
async-graphql = "7.2.1"
async-lock = "3"
diff --git a/apps/web/scripts/generate-dcs-tools.ts b/apps/web/scripts/generate-dcs-tools.ts
index a7ad98ff6f..0bcb049ad3 100644
--- a/apps/web/scripts/generate-dcs-tools.ts
+++ b/apps/web/scripts/generate-dcs-tools.ts
@@ -59,7 +59,7 @@ type FrontendSchemas = z.infer<typeof FrontendSchemasValidator>;
async function buildAndRunSchemaGenerator(): Promise<void> {
console.log('Building gen_tool_schemas binary...');
- await $`cd ${rustWorkspaceDir} && SQLX_OFFLINE=true cargo build --bin gen_tool_schemas`;
+ await $`cd ${rustWorkspaceDir} && SQLX_OFFLINE=true cargo build --package ai_tools --bin gen_tool_schemas`;
console.log('Build complete.');
await $`rm -rf ${path.join(aiToolsDir, 'schemas')}`.quiet();
diff --git a/crates/agent_runtime_protocol/Cargo.toml b/crates/agent_runtime_protocol/Cargo.toml
new file mode 100644
index 0000000000..e3f17806fc
--- /dev/null
+++ b/crates/agent_runtime_protocol/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+edition = "2024"
+name = "agent_runtime_protocol"
+publish = false
+version = "0.1.0"
+
+[features]
+test-utils = []
+
+[dependencies]
+agent-client-protocol = { workspace = true }
+axum = { workspace = true, features = ["ws"] }
+futures = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true, features = ["rt", "sync"] }
+tokio-tungstenite = { workspace = true }
+tracing = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["io-std", "io-util", "macros", "net", "rt", "rt-multi-thread", "time"] }
diff --git a/crates/agent_runtime_protocol/examples/acp.rs b/crates/agent_runtime_protocol/examples/acp.rs
new file mode 100644
index 0000000000..ed1c08374c
--- /dev/null
+++ b/crates/agent_runtime_protocol/examples/acp.rs
@@ -0,0 +1,52 @@
+//! Connect the official ACP Client and Agent through an Agent Runtime connection.
+//!
+//! Run with:
+//!
+//! ```text
+//! cargo run -p agent_runtime_protocol --example acp
+//! ```
+
+use agent_client_protocol::schema::ProtocolVersion;
+use agent_client_protocol::schema::v1::{InitializeRequest, InitializeResponse};
+use agent_client_protocol::{Agent, Client};
+use agent_runtime_protocol::domain::channel::Channel;
+use agent_runtime_protocol::domain::connection::{RuntimeConnection, ServerConnection};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+ let (service_channel, runtime_channel) = Channel::duplex();
+ let (_service, service_acp) = ServerConnection::connect(service_channel, ());
+ let (_runtime, runtime_acp) = RuntimeConnection::connect(runtime_channel);
+
+ // These are official agent_client_protocol::Channel values. No adapter API or
+ // string serialization is needed by either ACP component.
+ let agent = tokio::spawn(async move {
+ Agent
+ .builder()
+ .on_receive_request(
+ async move |request: InitializeRequest, responder, _connection| {
+ responder.respond(InitializeResponse::new(request.protocol_version))
+ },
+ agent_client_protocol::on_receive_request!(),
+ )
+ .connect_to(runtime_acp)
+ .await
+ });
+
+ let response = Client
+ .connect_with(service_acp, async |connection| {
+ connection
+ .send_request(InitializeRequest::new(ProtocolVersion::V1))
+ .block_task()
+ .await
+ })
+ .await?;
+ println!(
+ "official ACP initialize completed with {:?}",
+ response.protocol_version
+ );
+
+ agent.abort();
+ let _ = agent.await;
+ Ok(())
+}
diff --git a/crates/agent_runtime_protocol/examples/events.rs b/crates/agent_runtime_protocol/examples/events.rs
new file mode 100644
index 0000000000..4aadb0898b
--- /dev/null
+++ b/crates/agent_runtime_protocol/examples/events.rs
@@ -0,0 +1,41 @@
+//! Exchange a system event in memory.
+//!
+//! Run with:
+//!
+//! ```text
+//! cargo run -p agent_runtime_protocol --example events
+//! ```
+
+use agent_runtime_protocol::domain::channel::Channel;
+use agent_runtime_protocol::domain::connection::{
+ RuntimeConnection, ServerConnection, SystemEventHandler,
+};
+use agent_runtime_protocol::domain::schema::v0::SystemEvent;
+use tokio::sync::mpsc;
+
+struct ServiceEvents(mpsc::UnboundedSender<SystemEvent>);
+
+impl SystemEventHandler for ServiceEvents {
+ async fn handle(&self, event: SystemEvent) {
+ let _ = self.0.send(event);
+ }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+ let (service_channel, runtime_channel) = Channel::duplex();
+ let (event_sender, mut events) = mpsc::unbounded_channel();
+
+ let (_service, _service_acp) =
+ ServerConnection::connect(service_channel, ServiceEvents(event_sender));
+ let (runtime, _runtime_acp) = RuntimeConnection::connect(runtime_channel);
+
+ runtime.system_event(SystemEvent::Unknown("example/connected".to_owned()))?;
+ let event = events.recv().await.ok_or("event stream closed")?;
+ let SystemEvent::Unknown(name) = &event else {
+ unreachable!("SystemEvent has only one variant today");
+ };
+ println!("service received event: {name}");
+
+ Ok(())
+}
diff --git a/crates/agent_runtime_protocol/examples/mock_container.rs b/crates/agent_runtime_protocol/examples/mock_container.rs
new file mode 100644
index 0000000000..4f2c347ca3
--- /dev/null
+++ b/crates/agent_runtime_protocol/examples/mock_container.rs
@@ -0,0 +1,214 @@
+//! Interactive end-to-end example with a mock container and Claude Code.
+//!
+//! The process contains two sides:
+//!
+//! - the service accepts a runtime-initiated WebSocket, prints protocol events,
+//! and provides an interactive prompt on stdin;
+//! - a Tokio task stands in for a container, connects its runtime to the service,
+//! and starts Zed's Claude Code ACP adapter with `npx`.
+//!
+//! Prerequisites:
+//!
+//! - Node.js and `npx` must be installed;
+//! - `ANTHROPIC_API_KEY` must be available to the process;
+//! - the first run may take longer while `npx` downloads the adapter.
+//!
+//! Run with:
+//!
+//! ```text
+//! cargo run -p agent_runtime_protocol --example mock_container
+//! ```
+//!
+//! Enter prompts at `you>`. Enter `/quit` or send EOF to stop.
+
+use std::error::Error;
+use std::io::{self as stdio, Write};
+use std::sync::Arc;
+
+use agent_client_protocol::schema::ProtocolVersion;
+use agent_client_protocol::schema::v1::{
+ ContentBlock, InitializeRequest, NewSessionRequest, PromptRequest, RequestPermissionOutcome,
+ RequestPermissionRequest, RequestPermissionResponse, SessionNotification, TextContent,
+};
+use agent_client_protocol::{AcpAgent, Agent, Channel, Client, ConnectTo, ConnectionTo};
+use agent_runtime_protocol::domain::connection::{
+ RuntimeConnection, ServerChannel, ServerConnection,
+};
+use agent_runtime_protocol::domain::schema::v0::{ToRuntimeMessage, ToServerMessage};
+use agent_runtime_protocol::outbound::websocket::{ServerTransport, connect_runtime};
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::sync::Notify;
+
+#[cfg(test)]
+#[path = "mock_container/test.rs"]
+mod test;
+
+type AnyError = Box<dyn Error + Send + Sync>;
+
+const ZED_CLAUDE_CODE_ACP: &str = "@zed-industries/[email protected]";
+
+#[tokio::main]
+async fn main() -> Result<(), AnyError> {
+ let carrier: Arc<ServerTransport<ToRuntimeMessage, ToServerMessage>> =
+ Arc::new(ServerTransport::new());
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
+ let address = listener.local_addr()?;
+ let app = Arc::clone(&carrier).into_router();
+ let websocket_handle = tokio::spawn(async move { axum::serve(listener, app).await });
+ println!("service listening on ws://{address}");
+
+ let acp_ready = Arc::new(Notify::new());
+ let mut container = tokio::spawn(run_mock_container(
+ format!("ws://{address}"),
+ Arc::clone(&acp_ready),
+ ));
+ let incoming = accept_runtime(&carrier, &mut container).await?;
+ println!("service accepted runtime connection");
+
+ let (service, acp) = ServerConnection::connect(incoming, ());
+ wait_for_acp(&acp_ready, &mut container).await?;
+
+ let chat = run_interactive_client(acp);
+ tokio::pin!(chat);
+
+ let result = tokio::select! {
+ result = &mut chat => {
+ container.abort();
+ let _ = container.await;
+ result
+ }
+ container_result = &mut container => {
+ match container_result {
+ Ok(Ok(())) => Err("mock container exited unexpectedly".into()),
+ Ok(Err(error)) => Err(error),
+ Err(error) => Err(Box::new(error) as AnyError),
+ }
+ }
+ };
+
+ drop(service);
+ websocket_handle.abort();
+ result
+}
+
+async fn accept_runtime(
+ carrier: &ServerTransport<ToRuntimeMessage, ToServerMessage>,
+ container: &mut tokio::task::JoinHandle<Result<(), AnyError>>,
+) -> Result<ServerChannel, AnyError> {
+ tokio::select! {
+ incoming = carrier.accept() => incoming
+ .ok_or_else(|| "mock container disconnected before connecting".into()),
+ result = &mut *container => Err(container_startup_error(result)),
+ }
+}
+
+async fn wait_for_acp(
+ ready: &Notify,
+ container: &mut tokio::task::JoinHandle<Result<(), AnyError>>,
+) -> Result<(), AnyError> {
+ tokio::select! {
+ () = ready.notified() => Ok(()),
+ result = &mut *container => Err(container_startup_error(result)),
+ }
+}
+
+fn container_startup_error(
+ result: Result<Result<(), AnyError>, tokio::task::JoinError>,
+) -> AnyError {
+ match result {
+ Ok(Ok(())) => "mock container exited before startup completed".into(),
+ Ok(Err(error)) => error,
+ Err(error) => Box::new(error),
+ }
+}
+
+fn cancelled_permission_response() -> RequestPermissionResponse {
+ RequestPermissionResponse::new(RequestPermissionOutcome::Cancelled)
+}
+
+async fn run_mock_container(websocket_url: String, acp_ready: Arc<Notify>) -> Result<(), AnyError> {
+ let (stream, _response) = tokio_tungstenite::connect_async(websocket_url).await?;
+ let channel = connect_runtime::<ToServerMessage, ToRuntimeMessage, _>(stream);
+ let (_runtime, acp) = RuntimeConnection::connect(channel);
+ acp_ready.notify_one();
+
+ // Construct the command explicitly because the SDK's convenience helper now
+ // points at the renamed package. This example intentionally runs Zed's wrapper.
+ let claude_code = AcpAgent::from_args(["npx", "-y", ZED_CLAUDE_CODE_ACP])?;
+ ConnectTo::<Client>::connect_to(claude_code, acp)
+ .await
+ .map_err(Into::into)
+}
+
+async fn run_interactive_client(acp: Channel) -> Result<(), AnyError> {
+ Client
+ .builder()
+ .on_receive_notification(
+ async move |notification: SessionNotification, _connection| {
+ println!("\n[ACP session event] {:#?}", notification.update);
+ Ok(())
+ },
+ agent_client_protocol::on_receive_notification!(),
+ )
+ .on_receive_request(
+ async move |request: RequestPermissionRequest, responder, _connection| {
+ println!("\n[ACP permission request] {request:#?}");
+ println!("[ACP permission cancelled: this example does not prompt for approval]");
+ responder.respond(cancelled_permission_response())
+ },
+ agent_client_protocol::on_receive_request!(),
+ )
+ .connect_with(acp, |connection: ConnectionTo<Agent>| async move {
+ let initialized = connection
+ .send_request(InitializeRequest::new(ProtocolVersion::V1))
+ .block_task()
+ .await?;
+ println!("[ACP initialized] {initialized:#?}");
+
+ let cwd = std::env::current_dir().map_err(|error| {
+ agent_client_protocol::Error::internal_error()
+ .data(format!("cannot determine working directory: {error}"))
+ })?;
+ let session = connection
+ .send_request(NewSessionRequest::new(cwd))
+ .block_task()
+ .await?;
+ println!("[ACP session started] {}", session.session_id);
+ println!("type a prompt, or /quit to exit");
+
+ let mut lines = BufReader::new(tokio::io::stdin()).lines();
+ loop {
+ print!("you> ");
+ stdio::stdout()
+ .flush()
+ .map_err(agent_client_protocol::util::internal_error)?;
+ let Some(line) = lines
+ .next_line()
+ .await
+ .map_err(agent_client_protocol::util::internal_error)?
+ else {
+ break;
+ };
+ let line = line.trim();
+ if line == "/quit" {
+ break;
+ }
+ if line.is_empty() {
+ continue;
+ }
+
+ let response = connection
+ .send_request(PromptRequest::new(
+ session.session_id.clone(),
+ vec![ContentBlock::Text(TextContent::new(line))],
+ ))
+ .block_task()
+ .await?;
+ println!("\n[ACP prompt completed] {response:#?}");
+ }
+
+ Ok(())
+ })
+ .await?;
+ Ok(())
+}
diff --git a/crates/agent_runtime_protocol/examples/mock_container/test.rs b/crates/agent_runtime_protocol/examples/mock_container/test.rs
new file mode 100644
index 0000000000..ee3f5ab515
--- /dev/null
+++ b/crates/agent_runtime_protocol/examples/mock_container/test.rs
@@ -0,0 +1,42 @@
+use super::*;
+use tokio::time::{Duration, timeout};
+
+#[tokio::test]
+async fn startup_observes_container_failure_before_subscription() {
+ let carrier: ServerTransport<ToRuntimeMessage, ToServerMessage> = ServerTransport::new();
+ let mut container = tokio::spawn(async {
+ Err::<(), AnyError>(std::io::Error::other("container startup failed").into())
+ });
+
+ let error = timeout(
+ Duration::from_secs(1),
+ accept_runtime(&carrier, &mut container),
+ )
+ .await
+ .expect("container failure should be observed promptly")
+ .expect_err("startup should fail when the container exits");
+
+ assert!(error.to_string().contains("container startup failed"));
+}
+
+#[tokio::test]
+async fn startup_observes_container_failure_before_acp_is_ready() {
+ let ready = Notify::new();
+ let mut container = tokio::spawn(async {
+ Err::<(), AnyError>(std::io::Error::other("ACP startup failed").into())
+ });
+
+ let error = timeout(Duration::from_secs(1), wait_for_acp(&ready, &mut container))
+ .await
+ .expect("container failure should be observed promptly")
+ .expect_err("startup should fail when ACP never becomes ready");
+
+ assert!(error.to_string().contains("ACP startup failed"));
+}
+
+#[test]
+fn permission_requests_are_cancelled_without_user_confirmation() {
+ let response = cancelled_permission_response();
+
+ assert_eq!(response.outcome, RequestPermissionOutcome::Cancelled);
+}
diff --git a/crates/agent_runtime_protocol/examples/websocket.rs b/crates/agent_runtime_protocol/examples/websocket.rs
new file mode 100644
index 0000000000..9869d435b5
--- /dev/null
+++ b/crates/agent_runtime_protocol/examples/websocket.rs
@@ -0,0 +1,41 @@
+//! Run the logical protocol over a runtime-initiated plain WebSocket.
+//!
+//! Run with:
+//!
+//! ```text
+//! cargo run -p agent_runtime_protocol --example websocket
+//! ```
+
+use std::sync::Arc;
+
+use agent_runtime_protocol::domain::connection::{RuntimeConnection, ServerConnection};
+use agent_runtime_protocol::domain::schema::v0::{ToRuntimeMessage, ToServerMessage};
+use agent_runtime_protocol::outbound::websocket::{ServerTransport, connect_runtime};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+ let transport: Arc<ServerTransport<ToRuntimeMessage, ToServerMessage>> =
+ Arc::new(ServerTransport::new());
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
+ let address = listener.local_addr()?;
+ let app = Arc::clone(&transport).into_router();
+ let server_handle = tokio::spawn(async move { axum::serve(listener, app).await });
+
+ // The runtime initiates the WebSocket and can start sending messages
+ // immediately - there is no subscribe handshake to complete first.
+ let (stream, _response) = tokio_tungstenite::connect_async(format!("ws://{address}")).await?;
+ let runtime_channel = connect_runtime::<ToServerMessage, ToRuntimeMessage, _>(stream);
+ let service_channel = transport
+ .accept()
+ .await
+ .ok_or("runtime disconnected before acceptance")?;
+
+ let (service, _service_acp) = ServerConnection::connect(service_channel, ());
+ let (runtime, _runtime_acp) = RuntimeConnection::connect(runtime_channel);
+ println!("runtime and service connected over WebSocket");
+
+ drop(runtime);
+ drop(service);
+ server_handle.abort();
+ Ok(())
+}
diff --git a/crates/agent_runtime_protocol/src/domain/channel.rs b/crates/agent_runtime_protocol/src/domain/channel.rs
new file mode 100644
index 0000000000..d5f5d0b46d
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/domain/channel.rs
@@ -0,0 +1,93 @@
+//! A typed duplex channel over the logical protocol stream.
+
+use std::sync::Arc;
+
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
+
+use super::ports::Transport;
+
+/// One typed endpoint of a duplex channel: sends `Tx` messages, receives
+/// `Rx` messages.
+///
+/// This is the abstraction boundary physical transports adapt to. Unlike a
+/// physical WebSocket, a [`Channel`] depends on nothing but
+/// `tokio::sync::mpsc`, so it can be exposed to consumers outside this crate.
+pub struct Channel<Tx, Rx> {
+ /// Sends messages to the counterpart.
+ pub tx: UnboundedSender<Tx>,
+ /// Receives messages from the counterpart.
+ pub rx: UnboundedReceiver<Rx>,
+}
+
+// Written by hand rather than derived: tokio's channel halves implement
+// `Debug` regardless of `Tx`/`Rx`, so a derive would wrongly add `Tx: Debug,
+// Rx: Debug` bounds that aren't actually required.
+impl<Tx, Rx> std::fmt::Debug for Channel<Tx, Rx> {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter
+ .debug_struct("Channel")
+ .field("tx", &self.tx)
+ .field("rx", &self.rx)
+ .finish()
+ }
+}
+
+impl<Tx, Rx> Channel<Tx, Rx> {
+ /// Create a pair of connected channel endpoints.
+ ///
+ /// Messages sent via one endpoint's `tx` are received on the other
+ /// endpoint's `rx`, and vice versa.
+ #[must_use]
+ pub fn duplex() -> (Channel<Tx, Rx>, Channel<Rx, Tx>) {
+ let (tx_a, rx_a) = tokio::sync::mpsc::unbounded_channel();
+ let (tx_b, rx_b) = tokio::sync::mpsc::unbounded_channel();
+
+ (
+ Channel { tx: tx_a, rx: rx_b },
+ Channel { tx: tx_b, rx: rx_a },
+ )
+ }
+}
+
+/// Bridge a physical [`Transport`] into a [`Channel`] endpoint.
+///
+/// Spawns two independent tasks - one draining outgoing messages into
+/// `transport.send`, one looping on `transport.recv` - until either side
+/// closes or a transport operation fails. They run as separate tasks rather
+/// than arms of one `select!` specifically so that a `recv` future already
+/// mid-flight is always polled to completion instead of being raced against,
+/// and possibly cancelled by, an outgoing send becoming ready.
+///
+/// Not exposed outside this crate: outbound adapters adapt to [`Channel`],
+/// they don't hand pumps to callers.
+pub(crate) fn pump<T, Tx, Rx>(transport: Arc<T>) -> Channel<Tx, Rx>
+where
+ T: Transport<Tx, Rx> + Send + Sync + 'static,
+ Tx: Send + 'static,
+ Rx: Send + 'static,
+{
+ let (caller, worker) = Channel::duplex();
+ let Channel {
+ tx: worker_tx,
+ rx: mut worker_rx,
+ } = worker;
+
+ let send_transport = Arc::clone(&transport);
+ tokio::spawn(async move {
+ while let Some(outgoing) = worker_rx.recv().await {
+ if send_transport.send(outgoing).await.is_err() {
+ break;
+ }
+ }
+ });
+
+ tokio::spawn(async move {
+ while let Ok(Some(incoming)) = transport.recv().await {
+ if worker_tx.send(incoming).is_err() {
+ break;
+ }
+ }
+ });
+
+ caller
+}
diff --git a/crates/agent_runtime_protocol/src/domain/connection/mod.rs b/crates/agent_runtime_protocol/src/domain/connection/mod.rs
new file mode 100644
index 0000000000..a2987c07a9
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/domain/connection/mod.rs
@@ -0,0 +1,196 @@
+//! Role-oriented logical protocol connections.
+//!
+//! A connection hosts exactly one agent execution, so there is no routing
+//! table: the single [`agent_client_protocol::Channel`] handed back by
+//! [`ServerConnection::connect`] and [`RuntimeConnection::connect`] carries
+//! all of this connection's ACP traffic.
+
+use std::future::Future;
+
+use agent_client_protocol::Channel as AcpChannel;
+use futures::StreamExt;
+use tokio::sync::mpsc::UnboundedSender;
+
+use crate::domain::channel::Channel;
+use crate::domain::schema::v0::{AcpMessage, SystemEvent, ToRuntimeMessage, ToServerMessage};
+
+#[cfg(test)]
+mod test;
+
+/// The logical channel carried by an Agent Service's side of a connection.
+pub type ServerChannel = Channel<ToRuntimeMessage, ToServerMessage>;
+/// The logical channel carried by an Agent Runtime's side of a connection.
+pub type RuntimeChannel = Channel<ToServerMessage, ToRuntimeMessage>;
+
+/// Handles a system event delivered to an Agent Service.
+///
+/// Use `()` when the connection only carries ACP. It ignores any system event.
+pub trait SystemEventHandler: Send + Sync + 'static {
+ /// Observe a runtime or agent state transition.
+ fn handle(&self, event: SystemEvent) -> impl Future<Output = ()> + Send;
+}
+
+impl SystemEventHandler for () {
+ fn handle(&self, _event: SystemEvent) -> impl Future<Output = ()> + Send {
+ std::future::ready(())
+ }
+}
+
+/// A failure while using a logical protocol connection.
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum ConnectionError {
+ /// The logical connection has closed.
+ #[error("connection closed")]
+ Closed,
+}
+
+/// Agent Service-side access to one logical runtime connection.
+pub struct ServerConnection {
+ driver: tokio::task::AbortHandle,
+}
+
+impl ServerConnection {
+ /// Attach the service role to a logical message channel.
+ ///
+ /// Returns the connection handle alongside an official ACP
+ /// [`AcpChannel`] for the single agent execution this connection hosts.
+ #[must_use]
+ pub fn connect<H>(channel: ServerChannel, system_events: H) -> (Self, AcpChannel)
+ where
+ H: SystemEventHandler,
+ {
+ let Channel {
+ tx: outbound,
+ rx: inbound,
+ } = channel;
+ let (acp, acp_driver) = AcpChannel::duplex();
+ let driver =
+ tokio::spawn(run_server(inbound, outbound, system_events, acp_driver)).abort_handle();
+
+ (Self { driver }, acp)
+ }
+}
+
+impl Drop for ServerConnection {
+ fn drop(&mut self) {
+ self.driver.abort();
+ }
+}
+
+/// Agent Runtime-side access to one logical service connection.
+pub struct RuntimeConnection {
+ outbound: UnboundedSender<ToServerMessage>,
+ driver: tokio::task::AbortHandle,
+}
+
+impl RuntimeConnection {
+ /// Attach the runtime role to a logical message channel.
+ ///
+ /// Returns the connection handle alongside an official ACP
+ /// [`AcpChannel`] for the single agent execution this connection hosts.
+ #[must_use]
+ pub fn connect(channel: RuntimeChannel) -> (Self, AcpChannel) {
+ let Channel {
+ tx: outbound,
+ rx: inbound,
+ } = channel;
+ let (acp, acp_driver) = AcpChannel::duplex();
+ let driver =
+ tokio::spawn(run_runtime(inbound, outbound.clone(), acp_driver)).abort_handle();
+ (Self { outbound, driver }, acp)
+ }
+
+ /// Send a system event notification to the Agent Service.
+ pub fn system_event(&self, event: SystemEvent) -> Result<(), ConnectionError> {
+ self.outbound
+ .send(ToServerMessage::Event { event })
+ .map_err(|_| ConnectionError::Closed)
+ }
+}
+
+impl Drop for RuntimeConnection {
+ fn drop(&mut self) {
+ self.driver.abort();
+ }
+}
+
+async fn run_server<H>(
+ mut inbound: tokio::sync::mpsc::UnboundedReceiver<ToServerMessage>,
+ outbound: UnboundedSender<ToRuntimeMessage>,
+ system_events: H,
+ mut acp: AcpChannel,
+) where
+ H: SystemEventHandler,
+{
+ // Whether the caller's ACP channel is still open. A caller that only
+ // wants events is free to drop its ACP channel immediately; that must
+ // not tear down event handling, so once the ACP side closes we simply
+ // stop selecting on it instead of breaking the loop.
+ let mut acp_open = true;
+ loop {
+ tokio::select! {
+ message = inbound.recv() => {
+ let Some(message) = message else {
+ break;
+ };
+ match message {
+ ToServerMessage::Event { event } => {
+ system_events.handle(event).await;
+ }
+ ToServerMessage::Acp(AcpMessage(raw)) => {
+ if acp_open && acp.tx.unbounded_send(Ok(raw)).is_err() {
+ acp_open = false;
+ }
+ }
+ }
+ }
+ message = acp.rx.next(), if acp_open => {
+ match message {
+ Some(Ok(raw)) => {
+ if outbound.send(ToRuntimeMessage::Acp(AcpMessage(raw))).is_err() {
+ break;
+ }
+ }
+ _ => acp_open = false,
+ }
+ }
+ }
+ }
+}
+
+async fn run_runtime(
+ mut inbound: tokio::sync::mpsc::UnboundedReceiver<ToRuntimeMessage>,
+ outbound: UnboundedSender<ToServerMessage>,
+ mut acp: AcpChannel,
+) {
+ // See the matching comment in `run_server`: dropping the ACP channel must
+ // not tear down this connection - only an actual transport failure does.
+ let mut acp_open = true;
+ loop {
+ tokio::select! {
+ message = inbound.recv() => {
+ let Some(message) = message else {
+ break;
+ };
+ match message {
+ ToRuntimeMessage::Acp(AcpMessage(raw)) => {
+ if acp_open && acp.tx.unbounded_send(Ok(raw)).is_err() {
+ acp_open = false;
+ }
+ }
+ }
+ }
+ message = acp.rx.next(), if acp_open => {
+ match message {
+ Some(Ok(raw)) => {
+ if outbound.send(ToServerMessage::Acp(AcpMessage(raw))).is_err() {
+ break;
+ }
+ }
+ _ => acp_open = false,
+ }
+ }
+ }
+ }
+}
diff --git a/crates/agent_runtime_protocol/src/domain/connection/test.rs b/crates/agent_runtime_protocol/src/domain/connection/test.rs
new file mode 100644
index 0000000000..eaff96abbe
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/domain/connection/test.rs
@@ -0,0 +1,180 @@
+use std::sync::Arc;
+
+use agent_client_protocol::Channel as AcpChannel;
+use agent_client_protocol::RawJsonRpcMessage;
+use futures::StreamExt;
+use serde_json::json;
+use tokio::sync::Mutex;
+use tokio::time::{Duration, timeout};
+
+use super::*;
+
+#[derive(Clone, Default)]
+struct Events(Arc<Mutex<Vec<SystemEvent>>>);
+
+impl SystemEventHandler for Events {
+ async fn handle(&self, event: SystemEvent) {
+ self.0.lock().await.push(event);
+ }
+}
+
+/// Connect a server/runtime pair, discarding their ACP channels.
+fn connections() -> (ServerConnection, RuntimeConnection, Events) {
+ let (server_channel, runtime_channel) = Channel::duplex();
+ let events = Events::default();
+ let (server, _server_acp) = ServerConnection::connect(server_channel, events.clone());
+ let (runtime, _runtime_acp) = RuntimeConnection::connect(runtime_channel);
+ (server, runtime, events)
+}
+
+/// Connect a server/runtime pair, keeping both ACP channels.
+fn connections_with_acp() -> (
+ ServerConnection,
+ AcpChannel,
+ RuntimeConnection,
+ AcpChannel,
+ Events,
+) {
+ let (server_channel, runtime_channel) = Channel::duplex();
+ let events = Events::default();
+ let (server, server_acp) = ServerConnection::connect(server_channel, events.clone());
+ let (runtime, runtime_acp) = RuntimeConnection::connect(runtime_channel);
+ (server, server_acp, runtime, runtime_acp, events)
+}
+
+#[tokio::test]
+async fn unit_handlers_support_connections_that_only_use_acp() {
+ let (server_channel, runtime_channel) = Channel::duplex();
+ let (_server, _server_acp) = ServerConnection::connect(server_channel, ());
+ let (_runtime, _runtime_acp) = RuntimeConnection::connect(runtime_channel);
+}
+
+#[tokio::test]
+async fn system_event_is_dispatched_without_a_response() {
+ let (_server, runtime, events) = connections();
+ runtime
+ .system_event(SystemEvent::Unknown("runtime/ready".to_owned()))
+ .expect("event should send");
+
+ timeout(Duration::from_secs(1), async {
+ loop {
+ if events.0.lock().await.len() == 1 {
+ break;
+ }
+ tokio::task::yield_now().await;
+ }
+ })
+ .await
+ .expect("event should be dispatched");
+
+ assert_eq!(
+ events.0.lock().await[0],
+ SystemEvent::Unknown("runtime/ready".to_owned())
+ );
+}
+
+#[tokio::test]
+async fn acp_channels_carry_raw_sdk_messages_in_both_directions() {
+ let (_server, mut server_acp, _runtime, mut runtime_acp, _events) = connections_with_acp();
+
+ let initialize = RawJsonRpcMessage::request(
+ "initialize".to_owned(),
+ json!({ "protocolVersion": 1 }),
+ agent_client_protocol::schema::v1::RequestId::Number(1),
+ )
+ .unwrap();
+ server_acp.tx.unbounded_send(Ok(initialize)).unwrap();
+
+ let delivered = timeout(Duration::from_secs(1), runtime_acp.rx.next())
+ .await
+ .expect("ACP request should not hang")
+ .expect("ACP channel should remain open")
+ .expect("ACP request should be valid");
+ assert_eq!(
+ serde_json::to_value(delivered).unwrap(),
+ json!({
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "initialize",
+ "params": { "protocolVersion": 1 },
+ })
+ );
+
+ runtime_acp
+ .tx
+ .unbounded_send(Ok(RawJsonRpcMessage::response(
+ agent_client_protocol::schema::v1::RequestId::Number(1),
+ Ok(json!({ "protocolVersion": 1 })),
+ )))
+ .unwrap();
+ let response = timeout(Duration::from_secs(1), server_acp.rx.next())
+ .await
+ .expect("ACP response should not hang")
+ .expect("ACP channel should remain open")
+ .expect("ACP response should be valid");
+ assert_eq!(
+ serde_json::to_value(response).unwrap(),
+ json!({
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": { "protocolVersion": 1 },
+ })
+ );
+}
+
+#[tokio::test]
+async fn dropping_a_connection_closes_its_acp_channel() {
+ let (_server, mut server_acp, _runtime, _runtime_acp, _events) = connections_with_acp();
+
+ drop(_runtime);
+
+ let closed = timeout(Duration::from_secs(1), server_acp.rx.next())
+ .await
+ .expect("ACP channel should close promptly");
+ assert!(closed.is_none());
+}
+
+#[tokio::test]
+async fn official_acp_client_and_agent_connect_directly_to_exposed_channels() {
+ use agent_client_protocol::schema::ProtocolVersion;
+ use agent_client_protocol::schema::v1::{InitializeRequest, InitializeResponse};
+ use agent_client_protocol::{Agent, Client};
+
+ let (_server, server_acp, _runtime, runtime_acp, _events) = connections_with_acp();
+
+ let agent = tokio::spawn(async move {
+ Agent
+ .builder()
+ .on_receive_request(
+ async move |request: InitializeRequest, responder, _connection| {
+ responder.respond(InitializeResponse::new(request.protocol_version))
+ },
+ agent_client_protocol::on_receive_request!(),
+ )
+ .connect_to(runtime_acp)
+ .await
+ });
+
+ let response = timeout(
+ Duration::from_secs(1),
+ Client.connect_with(server_acp, async |connection| {
+ connection
+ .send_request(InitializeRequest::new(ProtocolVersion::V1))
+ .block_task()
+ .await
+ }),
+ )
+ .await
+ .expect("official ACP initialize should not hang")
+ .expect("official ACP initialize should succeed");
+ assert_eq!(response.protocol_version, ProtocolVersion::V1);
+
+ agent.abort();
+ assert!(
+ agent
+ .await
+ .expect_err("agent task should be cancelled")
+ .is_cancelled(),
+ "the long-lived agent driver should only be stopped explicitly"
+ );
+}
diff --git a/crates/agent_runtime_protocol/src/domain/mod.rs b/crates/agent_runtime_protocol/src/domain/mod.rs
new file mode 100644
index 0000000000..f24cd4e5d7
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/domain/mod.rs
@@ -0,0 +1,10 @@
+//! Domain layer: protocol schema, role-oriented connections, and the physical transport port.
+
+/// A typed duplex channel over the logical protocol stream.
+pub mod channel;
+/// Role-oriented connections over a logical Agent Runtime Protocol stream.
+pub mod connection;
+/// The physical transport port.
+pub mod ports;
+/// Versioned protocol message types.
+pub mod schema;
diff --git a/crates/agent_runtime_protocol/src/domain/ports.rs b/crates/agent_runtime_protocol/src/domain/ports.rs
new file mode 100644
index 0000000000..0243c1db09
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/domain/ports.rs
@@ -0,0 +1,28 @@
+//! The physical transport port.
+
+use std::future::Future;
+
+/// A failure while using a physical transport carrier.
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum TransportError {
+ /// A carrier client operation failed.
+ #[error("transport client failed: {0}")]
+ Client(String),
+}
+
+/// A physical carrier for one logical connection: sends `Tx` messages,
+/// receives `Rx` messages.
+///
+/// This is the port outbound adapters (a plain WebSocket, an in-memory test
+/// double, or any other physical carrier) implement. [`crate::domain::channel::pump`]
+/// bridges any [`Transport`] into a [`crate::domain::channel::Channel`].
+pub trait Transport<Tx, Rx> {
+ /// Send one logical message to the counterpart.
+ fn send(&self, message: Tx) -> impl Future<Output = Result<(), TransportError>> + Send;
+
+ /// Receive the next logical message from the counterpart.
+ ///
+ /// Returns `Ok(None)` once the counterpart has closed the connection.
+ fn recv(&self) -> impl Future<Output = Result<Option<Rx>, TransportError>> + Send;
+}
diff --git a/crates/agent_runtime_protocol/src/domain/schema/mod.rs b/crates/agent_runtime_protocol/src/domain/schema/mod.rs
new file mode 100644
index 0000000000..254adf0b75
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/domain/schema/mod.rs
@@ -0,0 +1,4 @@
+//! Agent Runtime Protocol schema types.
+
+/// Draft `agent-runtime.v0` schema types.
+pub mod v0;
diff --git a/crates/agent_runtime_protocol/src/domain/schema/v0/mod.rs b/crates/agent_runtime_protocol/src/domain/schema/v0/mod.rs
new file mode 100644
index 0000000000..0f403fc07b
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/domain/schema/v0/mod.rs
@@ -0,0 +1,86 @@
+//! Draft `agent-runtime.v0` message types.
+//!
+//! The logical protocol multiplexes two kinds of traffic over one stream:
+//! runtime/agent lifecycle events and ACP conversation traffic. Each
+//! direction has its own envelope - [`ToRuntimeMessage`] for Agent Service to
+//! Agent Runtime traffic and [`ToServerMessage`] for the reverse -
+//! discriminated by a `"type"` field. Only the wrapped ACP payload is itself
+//! a JSON-RPC message; the outer envelope is not.
+//!
+//! A connection hosts exactly one agent execution, so nothing on this schema
+//! needs an agent or agent-instance identifier: [`AcpMessage`] simply carries
+//! the agent's raw ACP traffic.
+
+use agent_client_protocol::RawJsonRpcMessage;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+#[cfg(test)]
+mod test;
+
+/// The kind of runtime or agent state transition reported to the Agent Service.
+///
+/// The protocol does not define an event-name catalog yet. This enum is
+/// non-exhaustive and currently contains only [`SystemEvent::Unknown`]. Every
+/// wire string round-trips through it unchanged.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum SystemEvent {
+ /// An application-defined event name.
+ Unknown(String),
+}
+
+impl SystemEvent {
+ /// Borrow the wire string for this event name.
+ #[must_use]
+ pub fn as_str(&self) -> &str {
+ match self {
+ Self::Unknown(name) => name,
+ }
+ }
+}
+
+impl Serialize for SystemEvent {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_str(self.as_str())
+ }
+}
+
+impl<'de> Deserialize<'de> for SystemEvent {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(Self::Unknown(String::deserialize(deserializer)?))
+ }
+}
+
+/// One complete ACP JSON-RPC message routed between the Agent Service and the
+/// single agent execution hosted by this connection.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AcpMessage(pub RawJsonRpcMessage);
+
+/// Agent Service to Agent Runtime traffic on the logical protocol stream.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+#[non_exhaustive]
+pub enum ToRuntimeMessage {
+ /// An ACP message routed to the hosted agent.
+ Acp(AcpMessage),
+}
+
+/// Agent Runtime to Agent Service traffic on the logical protocol stream.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+#[non_exhaustive]
+pub enum ToServerMessage {
+ /// An ACP message routed from the hosted agent.
+ Acp(AcpMessage),
+ /// A runtime or agent lifecycle event.
+ Event {
+ /// The event name.
+ event: SystemEvent,
+ },
+}
diff --git a/crates/agent_runtime_protocol/src/domain/schema/v0/test.rs b/crates/agent_runtime_protocol/src/domain/schema/v0/test.rs
new file mode 100644
index 0000000000..6840497635
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/domain/schema/v0/test.rs
@@ -0,0 +1,89 @@
+use agent_client_protocol::RawJsonRpcMessage;
+use agent_client_protocol::schema::v1::RequestId;
+use serde_json::json;
+
+use super::*;
+
+#[test]
+fn event_names_are_opaque_wire_strings() {
+ let event_names = [
+ SystemEvent::Unknown("runtime/ready".to_owned()),
+ SystemEvent::Unknown("agent/started".to_owned()),
+ SystemEvent::Unknown("vendor/custom-event".to_owned()),
+ ];
+ for name in event_names {
+ let wire_name = name.as_str();
+ assert_eq!(serde_json::to_value(&name).unwrap(), json!(wire_name));
+ assert_eq!(
+ serde_json::from_value::<SystemEvent>(json!(wire_name)).unwrap(),
+ name
+ );
+ }
+}
+
+#[test]
+fn unknown_event_names_round_trip_losslessly() {
+ let event = serde_json::from_value::<SystemEvent>(json!("vendor/custom-event")).unwrap();
+ assert_eq!(
+ event,
+ SystemEvent::Unknown("vendor/custom-event".to_owned())
+ );
+ assert_eq!(
+ serde_json::to_value(event).unwrap(),
+ json!("vendor/custom-event")
+ );
+}
+
+#[test]
+fn to_server_message_event_has_the_specified_wire_shape() {
+ let event = ToServerMessage::Event {
+ event: SystemEvent::Unknown("agent/stopped".to_owned()),
+ };
+
+ assert_eq!(
+ serde_json::to_value(event).unwrap(),
+ json!({
+ "type": "event",
+ "event": "agent/stopped",
+ })
+ );
+}
+
+#[test]
+fn acp_message_contains_an_acp_raw_jsonrpc_message() {
+ let nested = RawJsonRpcMessage::request(
+ "initialize".to_owned(),
+ json!({ "protocolVersion": 1 }),
+ RequestId::Number(1),
+ )
+ .unwrap();
+ let delivery = ToRuntimeMessage::Acp(AcpMessage(nested));
+
+ let message = serde_json::to_value(delivery).unwrap();
+ assert_eq!(
+ message,
+ json!({
+ "type": "acp",
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "initialize",
+ "params": {
+ "protocolVersion": 1,
+ },
+ })
+ );
+
+ let ToRuntimeMessage::Acp(AcpMessage(parsed)) =
+ serde_json::from_value::<ToRuntimeMessage>(message).unwrap();
+ assert_eq!(
+ serde_json::to_value(parsed).unwrap(),
+ json!({
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "initialize",
+ "params": {
+ "protocolVersion": 1,
+ },
+ })
+ );
+}
diff --git a/crates/agent_runtime_protocol/src/lib.rs b/crates/agent_runtime_protocol/src/lib.rs
new file mode 100644
index 0000000000..d27cd53578
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/lib.rs
@@ -0,0 +1,15 @@
+#![deny(missing_docs)]
+//! Agent Runtime Protocol wire types.
+//!
+//! The Agent Runtime Protocol is the outer protocol used to communicate with
+//! an agent runtime. It carries Agent Client Protocol (ACP) messages alongside
+//! runtime control messages without interpreting the wrapped ACP payloads.
+
+/// Protocol schema, role-oriented connections, and the runtime wire port.
+pub mod domain;
+/// Adapters implementing the domain wire port over physical transports.
+pub mod outbound;
+
+/// Utilities for asserting direction-labelled JSON messages at the wire boundary.
+#[cfg(any(test, feature = "test-utils"))]
+pub mod testing;
diff --git a/crates/agent_runtime_protocol/src/outbound/mod.rs b/crates/agent_runtime_protocol/src/outbound/mod.rs
new file mode 100644
index 0000000000..75486e6232
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/outbound/mod.rs
@@ -0,0 +1,4 @@
+//! Adapters implementing the domain wire port over physical transports.
+
+/// Plain WebSocket carrier for logical protocol messages.
+pub mod websocket;
diff --git a/crates/agent_runtime_protocol/src/outbound/websocket/mod.rs b/crates/agent_runtime_protocol/src/outbound/websocket/mod.rs
new file mode 100644
index 0000000000..31ba15bb7c
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/outbound/websocket/mod.rs
@@ -0,0 +1,269 @@
+//! Plain WebSocket carrier.
+//!
+//! Both peers of the WebSocket are symmetric: either side can push a logical
+//! message onto the wire the instant the socket exists, and the other side
+//! just reads it. There is no RPC session, no method dispatch, no request id,
+//! and no subscribe/unsubscribe handshake to establish first - a WebSocket
+//! frame is not itself JSON-RPC, unlike the ACP payload it can carry.
+//!
+//! One WebSocket text frame carries exactly one complete logical message -
+//! [`crate::domain::schema::v0::ToRuntimeMessage`] or
+//! [`crate::domain::schema::v0::ToServerMessage`], `"type"`-tagged as
+//! described in [`crate::domain::schema`]:
+//!
+//! ```json
+//! { "type": "event", "event": "agent/stopped" }
+//! ```
+
+use std::sync::Arc;
+
+use axum::Router;
+use axum::extract::State;
+use axum::extract::ws::{Message as AxumMessage, WebSocket, WebSocketUpgrade};
+use axum::response::Response;
+use axum::routing::get;
+use futures::{Sink, SinkExt, Stream, StreamExt};
+use serde::Serialize;
+use serde::de::DeserializeOwned;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::sync::Mutex as AsyncMutex;
+use tokio::sync::mpsc;
+use tokio_tungstenite::WebSocketStream;
+use tokio_tungstenite::tungstenite::Message as TungsteniteMessage;
+
+use crate::domain::channel::{Channel, pump};
+use crate::domain::ports::{Transport, TransportError};
+
+#[cfg(test)]
+mod test;
+
+/// A physical WebSocket frame type that can carry one JSON text payload.
+///
+/// Implemented for both `axum`'s and `tokio-tungstenite`'s message types so
+/// the pump loop below can drive either a server-accepted or a
+/// client-dialed socket without caring which library it came from.
+trait TextFrame: Sized {
+ /// Wrap a JSON payload as a text frame.
+ fn text(payload: String) -> Self;
+
+ /// Extract this frame's text payload, if it has one.
+ ///
+ /// Non-text frames (ping/pong/binary/close) are not part of the logical
+ /// protocol and are silently skipped by the pump loop.
+ fn into_text(self) -> Option<String>;
+}
+
+impl TextFrame for AxumMessage {
+ fn text(payload: String) -> Self {
+ Self::Text(payload.into())
+ }
+
+ fn into_text(self) -> Option<String> {
+ match self {
+ Self::Text(text) => Some(text.to_string()),
+ _ => None,
+ }
+ }
+}
+
+impl TextFrame for TungsteniteMessage {
+ fn text(payload: String) -> Self {
+ Self::Text(payload.into())
+ }
+
+ fn into_text(self) -> Option<String> {
+ match self {
+ Self::Text(text) => Some(text.to_string()),
+ _ => None,
+ }
+ }
+}
+
+/// Drive one physical WebSocket until it closes or fails: outgoing JSON text
+/// pulled from `outgoing` is written to the socket, and incoming text frames
+/// are decoded and pushed onto `incoming`.
+///
+/// A frame that fails to decode as `Rx` is dropped with a warning rather than
+/// closing the connection - the rest of the logical stream is unaffected by
+/// one malformed message.
+async fn run_pump<Rx, Socket, Frame, Error>(
+ socket: Socket,
+ mut outgoing: mpsc::UnboundedReceiver<String>,
+ incoming: mpsc::UnboundedSender<Rx>,
+) where
+ Rx: DeserializeOwned,
+ Frame: TextFrame,
+ Socket: Sink<Frame, Error = Error> + Stream<Item = Result<Frame, Error>> + Unpin,
+{
+ let (mut sink, mut stream) = socket.split();
+ loop {
+ tokio::select! {
+ next_outgoing = outgoing.recv() => {
+ let Some(payload) = next_outgoing else { break };
+ if sink.send(Frame::text(payload)).await.is_err() {
+ break;
+ }
+ }
+ next_incoming = stream.next() => {
+ match next_incoming {
+ Some(Ok(frame)) => {
+ let Some(text) = frame.into_text() else { continue };
+ match serde_json::from_str::<Rx>(&text) {
+ Ok(message) => {
+ if incoming.send(message).is_err() {
+ break;
+ }
+ }
+ Err(error) => {
+ tracing::warn!(error = ?error, "dropping malformed WebSocket frame");
+ }
+ }
+ }
+ Some(Err(_)) | None => break,
+ }
+ }
+ }
+ }
+}
+
+/// [`Transport`] adapter over one peer's plain WebSocket.
+///
+/// Sending serializes straight to a JSON string and hands it to the spawned
+/// pump task's write half; receiving drains the channel that pump feeds from
+/// the socket's read half.
+///
+/// Crate-visible rather than private so the interface-conformance tests in
+/// [`crate::testing::wire_conformance`] can exercise it directly through the
+/// [`Transport`] trait, the same way they exercise
+/// [`crate::testing::fake_wire::FakeTransport`].
+pub(crate) struct WebSocketWire<Rx> {
+ outgoing: mpsc::UnboundedSender<String>,
+ incoming: AsyncMutex<mpsc::UnboundedReceiver<Rx>>,
+}
+
+impl<Tx, Rx> Transport<Tx, Rx> for WebSocketWire<Rx>
+where
+ Tx: Serialize + Send + Sync + 'static,
+ Rx: Send + 'static,
+{
+ async fn send(&self, message: Tx) -> Result<(), TransportError> {
+ let payload = serde_json::to_string(&message)
+ .map_err(|error| TransportError::Client(error.to_string()))?;
+ self.outgoing
+ .send(payload)
+ .map_err(|_| TransportError::Client("WebSocket connection closed".to_owned()))
+ }
+
+ async fn recv(&self) -> Result<Option<Rx>, TransportError> {
+ Ok(self.incoming.lock().await.recv().await)
+ }
+}
+
+fn wire_channel<Tx, Rx>(
+ outgoing: mpsc::UnboundedSender<String>,
+ incoming: mpsc::UnboundedReceiver<Rx>,
+) -> Channel<Tx, Rx>
+where
+ Tx: Serialize + Send + Sync + 'static,
+ Rx: Send + 'static,
+{
+ pump(Arc::new(WebSocketWire {
+ outgoing,
+ incoming: AsyncMutex::new(incoming),
+ }))
+}
+
+/// An axum WebSocket acceptor and its stream of accepted runtime connections.
+///
+/// One accepted WebSocket is exactly one logical session: there is no
+/// caller-chosen identifier and no way to multiplex several logical sessions
+/// over one socket.
+pub struct ServerTransport<Tx, Rx> {
+ incoming_tx: mpsc::UnboundedSender<Channel<Tx, Rx>>,
+ incoming: AsyncMutex<mpsc::UnboundedReceiver<Channel<Tx, Rx>>>,
+}
+
+impl<Tx, Rx> ServerTransport<Tx, Rx> {
+ /// Construct an empty server carrier.
+ #[must_use]
+ pub fn new() -> Self {
+ let (incoming_tx, incoming) = mpsc::unbounded_channel();
+ Self {
+ incoming_tx,
+ incoming: AsyncMutex::new(incoming),
+ }
+ }
+
+ /// Wait for the next accepted runtime connection.
+ pub async fn accept(&self) -> Option<Channel<Tx, Rx>> {
+ self.incoming.lock().await.recv().await
+ }
+}
+
+impl<Tx, Rx> Default for ServerTransport<Tx, Rx> {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<Tx, Rx> ServerTransport<Tx, Rx>
+where
+ Tx: Serialize + Send + Sync + 'static,
+ Rx: DeserializeOwned + Send + Sync + 'static,
+{
+ /// Build a router with one route that upgrades an incoming WebSocket
+ /// into a runtime connection, delivered on [`ServerTransport::accept`].
+ pub fn into_router(self: Arc<Self>) -> Router {
+ Router::new()
+ .route("/", get(upgrade::<Tx, Rx>))
+ .with_state(self)
+ }
+}
+
+async fn upgrade<Tx, Rx>(
+ State(transport): State<Arc<ServerTransport<Tx, Rx>>>,
+ ws: WebSocketUpgrade,
+) -> Response
+where
+ Tx: Serialize + Send + Sync + 'static,
+ Rx: DeserializeOwned + Send + Sync + 'static,
+{
+ ws.on_upgrade(move |socket: WebSocket| async move {
+ let (outgoing_tx, outgoing_rx) = mpsc::unbounded_channel();
+ let (incoming_tx, incoming_rx) = mpsc::unbounded_channel();
+ let _ = transport
+ .incoming_tx
+ .send(wire_channel(outgoing_tx, incoming_rx));
+ run_pump(socket, outgoing_rx, incoming_tx).await;
+ })
+}
+
+/// Build the runtime-side wire over an already-connected WebSocket stream.
+///
+/// Unlike the service side, the runtime doesn't go through axum: it dials out
+/// and drives the socket itself, so this takes an already-connected
+/// [`WebSocketStream`] directly.
+pub(crate) fn client_wire<Rx, S>(stream: WebSocketStream<S>) -> WebSocketWire<Rx>
+where
+ Rx: DeserializeOwned + Send + Sync + 'static,
+ S: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+{
+ let (outgoing_tx, outgoing_rx) = mpsc::unbounded_channel();
+ let (incoming_tx, incoming_rx) = mpsc::unbounded_channel();
+ tokio::spawn(run_pump(stream, outgoing_rx, incoming_tx));
+
+ WebSocketWire {
+ outgoing: outgoing_tx,
+ incoming: AsyncMutex::new(incoming_rx),
+ }
+}
+
+/// Bridge a runtime-side WebSocket stream into its logical channel.
+pub fn connect_runtime<Tx, Rx, S>(stream: WebSocketStream<S>) -> Channel<Tx, Rx>
+where
+ Tx: Serialize + Send + Sync + 'static,
+ Rx: DeserializeOwned + Send + Sync + 'static,
+ S: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+{
+ pump(Arc::new(client_wire::<Rx, S>(stream)))
+}
diff --git a/crates/agent_runtime_protocol/src/outbound/websocket/test.rs b/crates/agent_runtime_protocol/src/outbound/websocket/test.rs
new file mode 100644
index 0000000000..f30d570cbe
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/outbound/websocket/test.rs
@@ -0,0 +1,241 @@
+use agent_client_protocol::RawJsonRpcMessage;
+use futures::{SinkExt, StreamExt};
+use serde_json::{Value, json};
+use tokio::time::{Duration, timeout};
+
+use super::*;
+use crate::domain::connection::{RuntimeConnection, ServerConnection, SystemEventHandler};
+use crate::domain::schema::v0::{AcpMessage, SystemEvent, ToRuntimeMessage, ToServerMessage};
+
+fn event() -> ToServerMessage {
+ ToServerMessage::Event {
+ event: SystemEvent::Unknown("runtime/ready".to_owned()),
+ }
+}
+
+fn acp_to_runtime() -> ToRuntimeMessage {
+ ToRuntimeMessage::Acp(AcpMessage(
+ RawJsonRpcMessage::notification("session/update".to_owned(), json!({ "foo": "bar" }))
+ .unwrap(),
+ ))
+}
+
+#[tokio::test]
+async fn sent_payload_is_exactly_the_serialized_envelope_with_no_rpc_wrapper() {
+ let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded_channel::<String>();
+ let wire: WebSocketWire<()> = WebSocketWire {
+ outgoing: outgoing_tx,
+ incoming: AsyncMutex::new(mpsc::unbounded_channel().1),
+ };
+
+ Transport::<ToRuntimeMessage, ()>::send(&wire, acp_to_runtime())
+ .await
+ .expect("send should succeed");
+
+ let sent = timeout(Duration::from_secs(1), outgoing_rx.recv())
+ .await
+ .expect("outbound payload should not hang")
+ .expect("outgoing channel should remain open");
+ let sent: Value = serde_json::from_str(&sent).unwrap();
+ assert_eq!(
+ sent,
+ json!({
+ "type": "acp",
+ "jsonrpc": "2.0",
+ "method": "session/update",
+ "params": { "foo": "bar" },
+ })
+ );
+ assert!(
+ sent.get("id").is_none(),
+ "the wire payload must be the bare envelope, not a JSON-RPC-wrapped message"
+ );
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn wire_frames_are_bare_json_with_no_outer_envelope() {
+ let transport: Arc<ServerTransport<ToRuntimeMessage, ToServerMessage>> =
+ Arc::new(ServerTransport::new());
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+ .await
+ .expect("listener should bind");
+ let address = listener.local_addr().expect("listener address");
+ let app = Arc::clone(&transport).into_router();
+ let server_handle = tokio::spawn(async move {
+ axum::serve(listener, app).await.expect("server should run");
+ });
+
+ let (stream, _response) = tokio_tungstenite::connect_async(format!("ws://{address}"))
+ .await
+ .expect("raw client should connect");
+ let (mut write, mut read) = stream.split();
+
+ let server_channel = timeout(Duration::from_secs(1), transport.accept())
+ .await
+ .expect("server accept should not hang")
+ .expect("server should accept the connection");
+ server_channel.tx.send(acp_to_runtime()).unwrap();
+
+ let frame = timeout(Duration::from_secs(1), read.next())
+ .await
+ .expect("frame should arrive promptly")
+ .expect("stream should remain open")
+ .expect("frame should not be an error");
+ let TungsteniteMessage::Text(text) = frame else {
+ panic!("expected a text frame");
+ };
+ let received: Value = serde_json::from_str(&text).unwrap();
+ assert_eq!(
+ received,
+ json!({
+ "type": "acp",
+ "jsonrpc": "2.0",
+ "method": "session/update",
+ "params": { "foo": "bar" },
+ })
+ );
+
+ let raw_reply = serde_json::to_string(&event()).unwrap();
+ write
+ .send(TungsteniteMessage::Text(raw_reply.into()))
+ .await
+ .unwrap();
+ drop(write);
+ server_handle.abort();
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn malformed_frame_is_dropped_without_closing_the_connection() {
+ let transport: Arc<ServerTransport<ToRuntimeMessage, ToServerMessage>> =
+ Arc::new(ServerTransport::new());
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+ .await
+ .expect("listener should bind");
+ let address = listener.local_addr().expect("listener address");
+ let app = Arc::clone(&transport).into_router();
+ let server_handle = tokio::spawn(async move {
+ axum::serve(listener, app).await.expect("server should run");
+ });
+
+ let (stream, _response) = tokio_tungstenite::connect_async(format!("ws://{address}"))
+ .await
+ .expect("raw client should connect");
+ let (mut write, _read) = stream.split();
+
+ let mut server_channel = timeout(Duration::from_secs(1), transport.accept())
+ .await
+ .expect("server accept should not hang")
+ .expect("server should accept the connection");
+
+ write
+ .send(TungsteniteMessage::Text("not json".into()))
+ .await
+ .unwrap();
+ write
+ .send(TungsteniteMessage::Text(
+ serde_json::to_string(&event()).unwrap().into(),
+ ))
+ .await
+ .unwrap();
+
+ let delivered = timeout(Duration::from_secs(1), server_channel.rx.recv())
+ .await
+ .expect("well-formed frame after a malformed one should still arrive")
+ .expect("channel should remain open");
+ assert_eq!(
+ serde_json::to_value(delivered).unwrap(),
+ serde_json::to_value(event()).unwrap()
+ );
+
+ server_handle.abort();
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn runtime_initiates_a_real_websocket_and_exchanges_bare_json_envelopes() {
+ let transport: Arc<ServerTransport<ToRuntimeMessage, ToServerMessage>> =
+ Arc::new(ServerTransport::new());
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+ .await
+ .expect("listener should bind");
+ let address = listener.local_addr().expect("listener address");
+ let app = Arc::clone(&transport).into_router();
+ let server_handle = tokio::spawn(async move {
+ axum::serve(listener, app).await.expect("server should run");
+ });
+
+ let (stream, _response) = tokio_tungstenite::connect_async(format!("ws://{address}"))
+ .await
+ .expect("runtime should connect");
+ let mut runtime = connect_runtime::<ToServerMessage, ToRuntimeMessage, _>(stream);
+ let mut server = timeout(Duration::from_secs(1), transport.accept())
+ .await
+ .expect("server accept should not hang")
+ .expect("server should accept runtime");
+
+ runtime.tx.send(event()).unwrap();
+ let delivered = timeout(Duration::from_secs(1), server.rx.recv())
+ .await
+ .expect("runtime-to-server should not hang")
+ .expect("server logical channel should remain open");
+ assert_eq!(
+ serde_json::to_value(delivered).unwrap(),
+ serde_json::to_value(event()).unwrap()
+ );
+
+ server.tx.send(acp_to_runtime()).unwrap();
+ let delivered = timeout(Duration::from_secs(1), runtime.rx.recv())
+ .await
+ .expect("server-to-runtime should not hang")
+ .expect("runtime logical channel should remain open");
+ assert_eq!(
+ serde_json::to_value(delivered).unwrap(),
+ serde_json::to_value(acp_to_runtime()).unwrap()
+ );
+
+ server_handle.abort();
+}
+
+struct Events(tokio::sync::mpsc::UnboundedSender<SystemEvent>);
+
+impl SystemEventHandler for Events {
+ async fn handle(&self, event: SystemEvent) {
+ self.0
+ .send(event)
+ .expect("event receiver should remain open");
+ }
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn role_connections_run_over_a_runtime_initiated_websocket() {
+ let transport: Arc<ServerTransport<ToRuntimeMessage, ToServerMessage>> =
+ Arc::new(ServerTransport::new());
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+ .await
+ .expect("listener should bind");
+ let address = listener.local_addr().expect("listener address");
+ let app = Arc::clone(&transport).into_router();
+ let server_handle = tokio::spawn(async move {
+ axum::serve(listener, app).await.expect("server should run");
+ });
+
+ let (stream, _response) = tokio_tungstenite::connect_async(format!("ws://{address}"))
+ .await
+ .expect("runtime should connect");
+ let runtime_channel = connect_runtime::<ToServerMessage, ToRuntimeMessage, _>(stream);
+ let server_channel = transport.accept().await.unwrap();
+ let (event_sender, mut event_receiver) = tokio::sync::mpsc::unbounded_channel();
+ let (_server_connection, _server_acp) =
+ ServerConnection::connect(server_channel, Events(event_sender));
+ let (runtime_connection, _runtime_acp) = RuntimeConnection::connect(runtime_channel);
+
+ runtime_connection
+ .system_event(SystemEvent::Unknown("runtime/ready".to_owned()))
+ .unwrap();
+ let received = timeout(Duration::from_secs(1), event_receiver.recv())
+ .await
+ .expect("event should not hang")
+ .expect("event channel should remain open");
+ assert_eq!(received, SystemEvent::Unknown("runtime/ready".to_owned()));
+
+ server_handle.abort();
+}
diff --git a/crates/agent_runtime_protocol/src/testing/fake_wire.rs b/crates/agent_runtime_protocol/src/testing/fake_wire.rs
new file mode 100644
index 0000000000..33bab4cc3f
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/testing/fake_wire.rs
@@ -0,0 +1,124 @@
+//! A deterministic [`Transport`] test double.
+
+use std::sync::{Arc, Mutex};
+
+use futures::StreamExt;
+use futures::channel::mpsc;
+
+use crate::domain::ports::{Transport, TransportError};
+
+#[cfg(test)]
+mod test;
+
+/// A deterministic [`Transport`] double for testing pump-loop behavior
+/// without a real socket.
+///
+/// Construct a transport and its [`FakeTransportProbe`] together with
+/// [`FakeTransport::new`].
+pub struct FakeTransport<Tx, Rx> {
+ fail_next_recv: Arc<Mutex<Option<String>>>,
+ fail_next_send: Arc<Mutex<Option<String>>>,
+ incoming: Arc<tokio::sync::Mutex<mpsc::UnboundedReceiver<Rx>>>,
+ sent: mpsc::UnboundedSender<Tx>,
+}
+
+/// Observes and controls a [`FakeTransport`] from outside the transport port.
+pub struct FakeTransportProbe<Tx, Rx> {
+ fail_next_recv: Arc<Mutex<Option<String>>>,
+ fail_next_send: Arc<Mutex<Option<String>>>,
+ sent: mpsc::UnboundedReceiver<Tx>,
+ incoming: mpsc::UnboundedSender<Rx>,
+}
+
+impl<Tx, Rx> FakeTransport<Tx, Rx> {
+ /// Construct a fake transport and the probe used to observe and control it.
+ #[must_use]
+ pub fn new() -> (Self, FakeTransportProbe<Tx, Rx>) {
+ let (sent_tx, sent_rx) = mpsc::unbounded();
+ let (incoming_tx, incoming_rx) = mpsc::unbounded();
+ let fail_next_recv = Arc::new(Mutex::new(None));
+ let fail_next_send = Arc::new(Mutex::new(None));
+ (
+ Self {
+ fail_next_recv: Arc::clone(&fail_next_recv),
+ fail_next_send: Arc::clone(&fail_next_send),
+ incoming: Arc::new(tokio::sync::Mutex::new(incoming_rx)),
+ sent: sent_tx,
+ },
+ FakeTransportProbe {
+ fail_next_recv,
+ fail_next_send,
+ sent: sent_rx,
+ incoming: incoming_tx,
+ },
+ )
+ }
+}
+
+impl<Tx, Rx> Transport<Tx, Rx> for FakeTransport<Tx, Rx>
+where
+ Tx: Send + 'static,
+ Rx: Send + 'static,
+{
+ async fn send(&self, message: Tx) -> Result<(), TransportError> {
+ let _ = self.sent.unbounded_send(message);
+ if let Some(reason) = self
+ .fail_next_send
+ .lock()
+ .expect("fake transport mutex poisoned")
+ .take()
+ {
+ return Err(TransportError::Client(reason));
+ }
+ Ok(())
+ }
+
+ async fn recv(&self) -> Result<Option<Rx>, TransportError> {
+ if let Some(reason) = self
+ .fail_next_recv
+ .lock()
+ .expect("fake transport mutex poisoned")
+ .take()
+ {
+ return Err(TransportError::Client(reason));
+ }
+ let mut incoming = self.incoming.lock().await;
+ Ok(incoming.next().await)
+ }
+}
+
+impl<Tx, Rx> FakeTransportProbe<Tx, Rx> {
+ /// Fail the next `recv` call with the given reason.
+ pub fn fail_next_recv(&mut self, reason: impl Into<String>) {
+ *self
+ .fail_next_recv
+ .lock()
+ .expect("fake transport mutex poisoned") = Some(reason.into());
+ }
+
+ /// Fail the next `send` call with the given reason.
+ ///
+ /// The attempted message is still recorded and observable through
+ /// [`FakeTransportProbe::next_send`].
+ pub fn fail_next_send(&mut self, reason: impl Into<String>) {
+ *self
+ .fail_next_send
+ .lock()
+ .expect("fake transport mutex poisoned") = Some(reason.into());
+ }
+
+ /// Wait for the next message attempted through `send`, regardless of outcome.
+ pub async fn next_send(&mut self) -> Tx {
+ self.sent
+ .next()
+ .await
+ .expect("fake transport should remain open")
+ }
+
+ /// Push one message for the transport's `recv` to yield.
+ pub fn push_incoming(&mut self, message: Rx) {
+ self.incoming
+ .unbounded_send(message)
+ .expect("fake transport should remain open");
+ }
+}
diff --git a/crates/agent_runtime_protocol/src/testing/fake_wire/test.rs b/crates/agent_runtime_protocol/src/testing/fake_wire/test.rs
new file mode 100644
index 0000000000..36f57278a0
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/testing/fake_wire/test.rs
@@ -0,0 +1,49 @@
+use tokio::time::{Duration, timeout};
+
+use super::*;
+
+#[tokio::test]
+async fn send_is_recorded_and_succeeds_by_default() {
+ let (transport, mut probe): (FakeTransport<String, String>, _) = FakeTransport::new();
+ transport.send("system_event".to_owned()).await.unwrap();
+
+ let message = timeout(Duration::from_secs(1), probe.next_send())
+ .await
+ .expect("send should be recorded promptly");
+ assert_eq!(message, "system_event");
+}
+
+#[tokio::test]
+async fn fail_next_send_fails_exactly_one_send() {
+ let (transport, mut probe): (FakeTransport<String, String>, _) = FakeTransport::new();
+ probe.fail_next_send("socket closed");
+
+ assert!(transport.send("system_event".to_owned()).await.is_err());
+ assert!(transport.send("system_event".to_owned()).await.is_ok());
+}
+
+#[tokio::test]
+async fn fail_next_recv_fails_exactly_one_recv() {
+ let (transport, mut probe): (FakeTransport<String, String>, _) = FakeTransport::new();
+ probe.fail_next_recv("no such connection");
+ probe.push_incoming("system_event".to_owned());
+
+ assert!(transport.recv().await.is_err());
+ assert_eq!(
+ transport.recv().await.unwrap(),
+ Some("system_event".to_owned())
+ );
+}
+
+#[tokio::test]
+async fn push_incoming_is_delivered_by_recv() {
+ let (transport, mut probe): (FakeTransport<String, String>, _) = FakeTransport::new();
+
+ probe.push_incoming("system_event".to_owned());
+
+ let delivered = timeout(Duration::from_secs(1), transport.recv())
+ .await
+ .expect("recv should return promptly")
+ .expect("recv should not fail");
+ assert_eq!(delivered, Some("system_event".to_owned()));
+}
diff --git a/crates/agent_runtime_protocol/src/testing/mod.rs b/crates/agent_runtime_protocol/src/testing/mod.rs
new file mode 100644
index 0000000000..eb2b571094
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/testing/mod.rs
@@ -0,0 +1,309 @@
+//! Reusable utilities for asserting protocol JSON at the wire boundary.
+//!
+//! A wire test is a direction-labelled transcript of complete JSON messages
+//! represented as [`serde_json::Value`]s. It does not deserialize the
+//! messages into protocol types before comparing them. Consequently, it can
+//! catch changes to field names and JSON shapes. There is no JSON-RPC
+//! envelope to account for: each message here is exactly what one WebSocket
+//! text frame carries, the logical envelope itself.
+//!
+//! When testing an Agent Runtime, messages directed to the runtime are
+//! injected and messages directed to the server are asserted. When testing an
+//! Agent Service, the same transcript is interpreted in the opposite way.
+//!
+//! A conversation is defined without choosing the peer under test:
+//!
+//! ```text
+//! WireTest::new([
+//! to_server(json!({
+//! "type": "event",
+//! "event": "runtime/stopping"
+//! })),
+//! ])
+//! ```
+
+use std::error::Error;
+use std::fmt::{self, Display, Formatter};
+use std::future::Future;
+
+use serde_json::Value;
+
+/// A deterministic [`crate::domain::ports::Transport`] test double.
+pub mod fake_wire;
+
+#[cfg(test)]
+mod test;
+#[cfg(test)]
+mod wire_conformance;
+
+/// The destination of a JSON message on the protocol wire.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Direction {
+ /// The message travels from the Agent Service to the Agent Runtime.
+ ToRuntime,
+ /// The message travels from the Agent Runtime to the Agent Service.
+ ToServer,
+}
+
+impl Display for Direction {
+ fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::ToRuntime => formatter.write_str("runtime"),
+ Self::ToServer => formatter.write_str("server"),
+ }
+ }
+}
+
+/// One complete JSON message and its destination on the protocol wire.
+#[derive(Clone, Debug, PartialEq)]
+pub struct WireMessage {
+ message: Value,
+ direction: Direction,
+}
+
+impl WireMessage {
+ /// Construct a direction-labelled wire message.
+ pub fn new(direction: Direction, message: Value) -> Self {
+ Self { message, direction }
+ }
+
+ /// Return this message's wire destination.
+ pub fn direction(&self) -> Direction {
+ self.direction
+ }
+
+ /// Borrow the complete JSON message.
+ pub fn message(&self) -> &Value {
+ &self.message
+ }
+
+ /// Consume the wrapper and return the complete JSON message.
+ pub fn into_message(self) -> Value {
+ self.message
+ }
+}
+
+/// Wrap a wire message sent from the Agent Service to the Agent Runtime.
+pub fn to_runtime(message: Value) -> WireMessage {
+ WireMessage::new(Direction::ToRuntime, message)
+}
+
+/// Wrap a wire message sent from the Agent Runtime to the Agent Service.
+pub fn to_server(message: Value) -> WireMessage {
+ WireMessage::new(Direction::ToServer, message)
+}
+
+/// The protocol peer exercised by a wire test.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PeerUnderTest {
+ /// Exercise an Agent Runtime implementation.
+ Runtime,
+ /// Exercise an Agent Service implementation.
+ Server,
+}
+
+impl PeerUnderTest {
+ fn receives(self, direction: Direction) -> bool {
+ matches!(
+ (self, direction),
+ (Self::Runtime, Direction::ToRuntime) | (Self::Server, Direction::ToServer)
+ )
+ }
+}
+
+/// An adapter between a wire test and the peer under test.
+///
+/// Implementations may drive an in-memory connection, a WebSocket, or a
+/// spawned process. They must expose complete, decoded JSON messages without
+/// translating them into typed protocol values. Sending and receiving are
+/// named relative to the subject under test, avoiding assumptions about which
+/// peer opened the connection.
+///
+/// Implementations SHOULD place a timeout around receive operations; the
+/// runner deliberately does not depend on a particular async executor.
+pub trait WireHarness: Send {
+ /// An error produced while communicating with the subject under test.
+ type Error: Error + Send + Sync + 'static;
+
+ /// Put a complete JSON message onto the wire toward the subject under test.
+ fn send_to_subject(
+ &mut self,
+ message: Value,
+ ) -> impl Future<Output = Result<(), Self::Error>> + Send;
+
+ /// Receive the next complete JSON message emitted onto the wire by the subject.
+ fn receive_from_subject(&mut self) -> impl Future<Output = Result<Value, Self::Error>> + Send;
+}
+
+/// A direction-labelled JSON transcript that can exercise either protocol peer.
+///
+/// Outbound messages are compared using [`serde_json::Value`] equality. This
+/// asserts the complete decoded JSON value, while intentionally ignoring
+/// insignificant textual differences such as whitespace and object-key order.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct WireTest {
+ messages: Vec<WireMessage>,
+}
+
+impl WireTest {
+ /// Construct a wire test from complete JSON messages in expected wire order.
+ pub fn new(messages: impl IntoIterator<Item = WireMessage>) -> Self {
+ Self {
+ messages: messages.into_iter().collect(),
+ }
+ }
+
+ /// Borrow the direction-labelled wire transcript.
+ pub fn messages(&self) -> &[WireMessage] {
+ &self.messages
+ }
+
+ /// Run this wire test against an Agent Runtime implementation.
+ pub async fn run_runtime<H>(&self, harness: &mut H) -> Result<(), WireTestFailure<H::Error>>
+ where
+ H: WireHarness,
+ {
+ self.run(PeerUnderTest::Runtime, harness).await
+ }
+
+ /// Run this wire test against an Agent Service implementation.
+ pub async fn run_server<H>(&self, harness: &mut H) -> Result<(), WireTestFailure<H::Error>>
+ where
+ H: WireHarness,
+ {
+ self.run(PeerUnderTest::Server, harness).await
+ }
+
+ /// Run this wire test against the selected protocol peer.
+ pub async fn run<H>(
+ &self,
+ peer: PeerUnderTest,
+ harness: &mut H,
+ ) -> Result<(), WireTestFailure<H::Error>>
+ where
+ H: WireHarness,
+ {
+ for (step, expected) in self.messages.iter().enumerate() {
+ if peer.receives(expected.direction) {
+ harness
+ .send_to_subject(expected.message.clone())
+ .await
+ .map_err(|source| WireTestFailure::Send {
+ step,
+ direction: expected.direction,
+ source,
+ })?;
+ continue;
+ }
+
+ let actual = harness.receive_from_subject().await.map_err(|source| {
+ WireTestFailure::Receive {
+ step,
+ direction: expected.direction,
+ source,
+ }
+ })?;
+
+ if actual != expected.message {
+ return Err(WireTestFailure::Mismatch {
+ step,
+ direction: expected.direction,
+ expected: expected.message.clone(),
+ actual,
+ });
+ }
+ }
+
+ Ok(())
+ }
+}
+
+impl FromIterator<WireMessage> for WireTest {
+ fn from_iter<T: IntoIterator<Item = WireMessage>>(messages: T) -> Self {
+ Self::new(messages)
+ }
+}
+
+/// A failure while running a direction-labelled wire test.
+#[derive(Debug)]
+pub enum WireTestFailure<E> {
+ /// An inbound wire message could not be delivered to the subject.
+ Send {
+ /// Zero-based wire-test step.
+ step: usize,
+ /// Intended wire destination.
+ direction: Direction,
+ /// Harness error.
+ source: E,
+ },
+ /// The next outbound wire message could not be received from the subject.
+ Receive {
+ /// Zero-based wire-test step.
+ step: usize,
+ /// Expected wire destination.
+ direction: Direction,
+ /// Harness error.
+ source: E,
+ },
+ /// The subject emitted a different JSON value than the wire test expected.
+ Mismatch {
+ /// Zero-based wire-test step.
+ step: usize,
+ /// Expected wire destination.
+ direction: Direction,
+ /// Expected complete JSON message.
+ expected: Value,
+ /// Actual complete JSON message.
+ actual: Value,
+ },
+}
+
+impl<E> Display for WireTestFailure<E>
+where
+ E: Display,
+{
+ fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Send {
+ step,
+ direction,
+ source,
+ } => write!(
+ formatter,
+ "wire step {}: failed to send JSON message to {direction}: {source}",
+ step + 1
+ ),
+ Self::Receive {
+ step,
+ direction,
+ source,
+ } => write!(
+ formatter,
+ "wire step {}: failed to receive JSON message to {direction}: {source}",
+ step + 1
+ ),
+ Self::Mismatch {
+ step,
+ direction,
+ expected,
+ actual,
+ } => write!(
+ formatter,
+ "wire step {}: JSON message to {direction} did not match\nexpected: {expected}\n actual: {actual}",
+ step + 1
+ ),
+ }
+ }
+}
+
+impl<E> Error for WireTestFailure<E>
+where
+ E: Error + 'static,
+{
+ fn source(&self) -> Option<&(dyn Error + 'static)> {
+ match self {
+ Self::Send { source, .. } | Self::Receive { source, .. } => Some(source),
+ Self::Mismatch { .. } => None,
+ }
+ }
+}
diff --git a/crates/agent_runtime_protocol/src/testing/test.rs b/crates/agent_runtime_protocol/src/testing/test.rs
new file mode 100644
index 0000000000..43d1734d71
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/testing/test.rs
@@ -0,0 +1,142 @@
+use std::collections::VecDeque;
+use std::error::Error;
+use std::fmt::{self, Display, Formatter};
+use std::future::{Future, ready};
+
+use serde_json::{Value, json};
+
+use super::*;
+
+#[derive(Default)]
+struct Harness {
+ sent_to_subject: Vec<Value>,
+ emitted_by_subject: VecDeque<Value>,
+}
+
+#[derive(Debug)]
+struct HarnessError;
+
+impl Display for HarnessError {
+ fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
+ formatter.write_str("test harness error")
+ }
+}
+
+impl Error for HarnessError {}
+
+impl Harness {
+ fn with_emitted(messages: impl IntoIterator<Item = Value>) -> Self {
+ Self {
+ sent_to_subject: Vec::new(),
+ emitted_by_subject: messages.into_iter().collect(),
+ }
+ }
+}
+
+impl WireHarness for Harness {
+ type Error = HarnessError;
+
+ fn send_to_subject(
+ &mut self,
+ message: Value,
+ ) -> impl Future<Output = Result<(), Self::Error>> + Send {
+ self.sent_to_subject.push(message);
+ ready(Ok(()))
+ }
+
+ fn receive_from_subject(&mut self) -> impl Future<Output = Result<Value, Self::Error>> + Send {
+ let message = self
+ .emitted_by_subject
+ .pop_front()
+ .expect("fixture should provide the next emitted message");
+ ready(Ok(message))
+ }
+}
+
+fn conversation() -> WireTest {
+ WireTest::new([
+ to_server(json!({
+ "type": "event",
+ "event": "runtime/ready"
+ })),
+ to_runtime(json!({
+ "type": "acp",
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "initialize",
+ "params": { "protocolVersion": 1 }
+ })),
+ to_server(json!({
+ "type": "acp",
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": { "protocolVersion": 1 }
+ })),
+ ])
+}
+
+#[tokio::test]
+async fn one_transcript_exercises_the_runtime_and_server() {
+ let test = conversation();
+
+ let mut runtime = Harness::with_emitted([
+ test.messages()[0].message().clone(),
+ test.messages()[2].message().clone(),
+ ]);
+ test.run_runtime(&mut runtime)
+ .await
+ .expect("runtime should satisfy transcript");
+ assert_eq!(
+ runtime.sent_to_subject,
+ [test.messages()[1].message().clone()]
+ );
+
+ let mut server = Harness::with_emitted([test.messages()[1].message().clone()]);
+ test.run_server(&mut server)
+ .await
+ .expect("server should satisfy transcript");
+ assert_eq!(
+ server.sent_to_subject,
+ [
+ test.messages()[0].message().clone(),
+ test.messages()[2].message().clone(),
+ ]
+ );
+}
+
+#[tokio::test]
+async fn mismatch_reports_step_direction_and_values() {
+ let test = WireTest::new([to_server(json!({
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": { "expected": true }
+ }))]);
+ let mut runtime = Harness::with_emitted([json!({"actual": true})]);
+
+ let failure = test
+ .run_runtime(&mut runtime)
+ .await
+ .expect_err("different JSON should fail");
+
+ let WireTestFailure::Mismatch {
+ step,
+ direction,
+ expected,
+ actual,
+ } = failure
+ else {
+ panic!("expected a mismatch failure");
+ };
+
+ assert_eq!(step, 0);
+ assert_eq!(direction, Direction::ToServer);
+ assert_eq!(
+ expected,
+ json!({
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": { "expected": true }
+ })
+ );
+ assert_eq!(actual, json!({"actual": true}));
+}
diff --git a/crates/agent_runtime_protocol/src/testing/wire_conformance.rs b/crates/agent_runtime_protocol/src/testing/wire_conformance.rs
new file mode 100644
index 0000000000..390712a5dc
--- /dev/null
+++ b/crates/agent_runtime_protocol/src/testing/wire_conformance.rs
@@ -0,0 +1,87 @@
+//! Interface-conformance tests shared across every [`Transport`] implementation.
+//!
+//! Each implementation is exercised through the same assertion body, run as
+//! an outer `#[test]` per implementation. This is the pattern the transport
+//! port exists to enable: swapping [`FakeTransport`] for
+//! [`crate::outbound::websocket::WebSocketWire`] costs nothing beyond
+//! supplying a different way to observe the transport's counterpart.
+
+use std::future::Future;
+use std::sync::Arc;
+
+use serde_json::{Value, json};
+use tokio::time::{Duration, timeout};
+
+use crate::domain::channel::pump;
+use crate::domain::ports::Transport;
+use crate::outbound::websocket::{ServerTransport, client_wire};
+use crate::testing::fake_wire::FakeTransport;
+
+/// Interface-conformance assertion shared by every [`Transport`] implementation:
+/// a message sent through the connected channel reaches the transport's
+/// counterpart. Each implementation supplies its own way to observe that
+/// counterpart, since that's the one part a transport port intentionally
+/// doesn't model.
+///
+/// The payload is a JSON object rather than a bare string: every real message
+/// on this protocol is a tagged enum or struct, so it is always an object in
+/// practice; there is no other reason to prefer an object here now that the
+/// wire carries the bare envelope with no outer framing.
+async fn asserts_runtime_to_server_delivery<T, F, Fut>(transport: Arc<T>, receive_from_transport: F)
+where
+ T: Transport<Value, Value> + Send + Sync + 'static,
+ F: FnOnce() -> Fut,
+ Fut: Future<Output = Value>,
+{
+ let channel = pump(transport);
+ let message = json!({ "event": "system_event" });
+ channel.tx.send(message.clone()).unwrap();
+
+ let received = timeout(Duration::from_secs(1), receive_from_transport())
+ .await
+ .expect("transport should receive the message promptly");
+ assert_eq!(received, message);
+}
+
+#[tokio::test]
+async fn fake_transport_delivers_runtime_to_server_messages() {
+ let (transport, mut probe) = FakeTransport::new();
+ asserts_runtime_to_server_delivery(
+ Arc::new(transport),
+ || async move { probe.next_send().await },
+ )
+ .await;
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn websocket_transport_delivers_runtime_to_server_messages() {
+ let transport: Arc<ServerTransport<Value, Value>> = Arc::new(ServerTransport::new());
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+ .await
+ .expect("listener should bind");
+ let address = listener.local_addr().expect("listener address");
+ let app = Arc::clone(&transport).into_router();
+ let server_handle = tokio::spawn(async move {
+ axum::serve(listener, app).await.expect("server should run");
+ });
+
+ let (stream, _response) = tokio_tungstenite::connect_async(format!("ws://{address}"))
+ .await
+ .expect("runtime should connect");
+ let wire = client_wire::<Value, _>(stream);
+
+ asserts_runtime_to_server_delivery(Arc::new(wire), || async {
+ let mut channel = timeout(Duration::from_secs(1), transport.accept())
+ .await
+ .expect("server accept should not hang")
+ .expect("server should accept runtime");
+ channel
+ .rx
+ .recv()
+ .await
+ .expect("server logical channel should remain open")
+ })
+ .await;
+
+ server_handle.abort();
+}
diff --git a/services/coding-agent-worker/bun.lock b/services/coding-agent-worker/bun.lock
new file mode 100644
index 0000000000..2982622d89
--- /dev/null
+++ b/services/coding-agent-worker/bun.lock
@@ -0,0 +1,504 @@
+{
+ "lockfileVersion": 1,
+ "configVersion": 1,
+ "workspaces": {
+ "": {
+ "name": "daytona-bun-hello",
+ "dependencies": {
+ "@daytona/sdk": "latest",
+ "@hono/zod-validator": "^0.9.0",
+ "@zed-industries/agent-client-protocol": "^0.4.5",
+ "envsafe": "^2.0.3",
+ "hono": "^4.12.30",
+ "ink": "^7.1.1",
+ "ink-text-input": "^6.0.0",
+ "react": "^19.2.7",
+ "websocketstream-polyfill": "^1.0.3",
+ "zod": "^4.4.3",
+ },
+ "devDependencies": {
+ "@types/bun": "^1.3.14",
+ "@types/react": "^19.2.17",
+ },
+ },
+ },
+ "packages": {
+ "@alcalzone/ansi-tokenize": ["@alcalzone/[email protected]", "", { "dependencies": { "ansi-styles": "^6.2.1", "is-fullwidth-code-point": "^5.0.0" } }, "sha512-p+CMKJ93HFmLkjXKlXiVGlMQEuRb6H0MokBSwUsX+S6BRX8eV5naFZpQJFfJHjRZY0Hmnqy1/r6UWl3x+19zYA=="],
+
+ "@aws-sdk/checksums": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-AcYTunavv8dqm9u2pbq/gIlFERUo+jQDKKLZpYOgMLLytoAJ/qoyuhWj97FB7UzpMFVJNzMEUylzKK/s/05org=="],
+
+ "@aws-sdk/client-s3": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/checksums": "^3.1000.21", "@aws-sdk/core": "^3.977.1", "@aws-sdk/credential-provider-node": "^3.972.73", "@aws-sdk/middleware-sdk-s3": "^3.972.67", "@aws-sdk/signature-v4-multi-region": "^3.996.42", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/fetch-http-handler": "^5.6.10", "@smithy/node-http-handler": "^4.9.10", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-sEx7KAEtkp1UqOoWQv2baM1rreClZG7o9YE8EfPvYpPBvGad1fQRG3sMHrOPMkIdZ9VjGRl25GiaG1MSeie2Mw=="],
+
+ "@aws-sdk/core": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/types": "^3.974.2", "@aws-sdk/xml-builder": "^3.972.37", "@aws/lambda-invoke-store": "^0.3.0", "@smithy/core": "^3.29.8", "@smithy/signature-v4": "^5.6.9", "@smithy/types": "^4.16.1", "bowser": "^2.11.0", "tslib": "^2.6.2" } }, "sha512-KVtQRtc00ES/y+Sc3vYXeP6pCIcNlBJCZOwvqSy8ZpVGmbM5+IG+AfhuTKQ2oXmIVqZJewaGMMpzPkywC6xg0w=="],
+
+ "@aws-sdk/credential-provider-env": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-BkDrk2cNjed31IKin/Oksb2ziF+gfuyRskFVuT4EU9Mep7M8Y/d8DJG4+anHme4Vuse7CwaEscwEfGyR6mzBhQ=="],
+
+ "@aws-sdk/credential-provider-http": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/fetch-http-handler": "^5.6.10", "@smithy/node-http-handler": "^4.9.10", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-Wj1FGK2IxY5EccQCvH+niTYhIvDoDujJf2CpRRgS3NpYNEgiFNVItNbJYQjINRlu7fG7jSsXkKV0UWKriEplrw=="],
+
+ "@aws-sdk/credential-provider-ini": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/credential-provider-env": "^3.972.62", "@aws-sdk/credential-provider-http": "^3.972.64", "@aws-sdk/credential-provider-login": "^3.972.69", "@aws-sdk/credential-provider-process": "^3.972.62", "@aws-sdk/credential-provider-sso": "^3.973.6", "@aws-sdk/credential-provider-web-identity": "^3.972.68", "@aws-sdk/nested-clients": "^3.997.36", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/credential-provider-imds": "^4.4.13", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-2CefB8cCxDu52P24B8Ay93/cTT199bcSvNHQ8e2f4BjSCF83yErBnTIZEBo0VeIgCfmw+PJKFUXnlQWxm2dkug=="],
+
+ "@aws-sdk/credential-provider-login": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/nested-clients": "^3.997.36", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-gM3j0Ie9+FoLNTYODY+QWbg3vCRBc7mR9cRdntxTMkFYIrwfRmuucfavP6HNBlYSuaYww54TNJGej4GFgoPZAg=="],
+
+ "@aws-sdk/credential-provider-node": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/credential-provider-env": "^3.972.62", "@aws-sdk/credential-provider-http": "^3.972.64", "@aws-sdk/credential-provider-ini": "^3.973.7", "@aws-sdk/credential-provider-process": "^3.972.62", "@aws-sdk/credential-provider-sso": "^3.973.6", "@aws-sdk/credential-provider-web-identity": "^3.972.68", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/credential-provider-imds": "^4.4.13", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-VTzdbf8Ukjdb9yUubZzRI678CWZvKovhE8Nv3qihwhC187sRMGls+r9N8Wuht5q1xjKx2nmpS48ar8ppupjkCA=="],
+
+ "@aws-sdk/credential-provider-process": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-zXYU9UWNL66gtMgNLhmxlrvEokuI7r6G2q7FRGu41Bya4iS30JLelUipJX9SV4zhyCPWJhI9Li54R1d9H8Tq6A=="],
+
+ "@aws-sdk/credential-provider-sso": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/nested-clients": "^3.997.36", "@aws-sdk/token-providers": "3.1096.0", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-DobZggy3K49xdCpjeyMou0FQhkoYbluVGNydL6D+lcxF8GoAsttFX0xnH5GmiQ89We5dB6TRpW+CD/VowBH6HQ=="],
+
+ "@aws-sdk/credential-provider-web-identity": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/nested-clients": "^3.997.36", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-bq+yTt+uWJx60VVp/OIAX5xqUAu/K2Uc3eknWnWl+KtfcU2CQe0uNw6lySrn2t5GKHq7jsV0Z63HiBGVtzr/lg=="],
+
+ "@aws-sdk/lib-storage": ["@aws-sdk/[email protected]", "", { "dependencies": { "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "buffer": "5.6.0", "events": "3.3.0", "stream-browserify": "3.0.0", "tslib": "^2.6.2" }, "peerDependencies": { "@aws-sdk/client-s3": "^3.1096.0" } }, "sha512-A9ZoQFUawEO2l7jVoBRtDbIJ3hPBnxMRy3oIGQREOsMfwQFvoiyyV0f1Fl5CuIfoovv508TuW+Pe6WZIfh7NOg=="],
+
+ "@aws-sdk/middleware-sdk-s3": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/signature-v4-multi-region": "^3.996.42", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-aB1ahF9z4J5r8YK1QodwNX/P8XSKBFtnjf7h72XCs0BP3rtThOiXeA3Lm+Z+8tiN9Iwl5otsGeHaXmQoQ5MVfA=="],
+
+ "@aws-sdk/nested-clients": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/signature-v4-multi-region": "^3.996.42", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/fetch-http-handler": "^5.6.10", "@smithy/node-http-handler": "^4.9.10", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-b71Suv7L+DnhM0MsQHU4WO42I32kxLZi96PbVhZbxMYIoKnEZz3v+LSrG8fupAoA4cBSshCk1Dl/PeRz49qUSg=="],
+
+ "@aws-sdk/signature-v4-multi-region": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/types": "^3.974.2", "@smithy/signature-v4": "^5.6.9", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-DBV4naZP6HYBlAvPpoQzOP12Wvfou/5rN8yJPXjBTBylU5qwCbh/tXr2MddHoIjgoRkEl/eS+IljiUqvmwey1Q=="],
+
+ "@aws-sdk/token-providers": ["@aws-sdk/[email protected]", "", { "dependencies": { "@aws-sdk/core": "^3.977.1", "@aws-sdk/nested-clients": "^3.997.36", "@aws-sdk/types": "^3.974.2", "@smithy/core": "^3.29.8", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-hdUS2hDppy3vkWeFl5y86RLNU6OWH2mQB09yOSsRefwhhGTSFPkaZvfLDD/9vFcvMzlr8QFQFw3fw2FtrurVQA=="],
+
+ "@aws-sdk/types": ["@aws-sdk/[email protected]", "", { "dependencies": { "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-3W6IUtSxFbH6X7Wb7DzGCV5QiFQsd0g8bOfntpmDxQlzBoKWUMBu/JPQR0DwkE+Hpnxd6db1tXbOwdeHddG6cA=="],
+
+ "@aws-sdk/xml-builder": ["@aws-sdk/[email protected]", "", { "dependencies": { "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-zKq4HQum8JwDyEuyfuI4bbiAcU0KxP6qy+9PR/IsR92IyE/DaBAikzAS50tjxip4bqIIANpCcG+Yyj6CVhXupg=="],
+
+ "@aws/lambda-invoke-store": ["@aws/[email protected]", "", {}, "sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ=="],
+
+ "@daytona/analytics-api-client": ["@daytona/[email protected]", "", { "dependencies": { "axios": "^1.6.1" } }, "sha512-dO6rNFoL24l0NsumnDqvWJH560tuaukYHXUJI1JIBH94P/4m3Ha4k87q61cwrwumWHtKWqlkJXvVk8a6iSlpnQ=="],
+
+ "@daytona/api-client": ["@daytona/[email protected]", "", { "dependencies": { "axios": "^1.6.1" } }, "sha512-Bmk+sXbLdUNNd1G41a0NTNKiKQeNLfeo2Of7WLu49MrmyxqSd0ECXKG3ND8jI+VEJAwuyfs3u/vj36Gd8i0Vjg=="],
+
+ "@daytona/sdk": ["@daytona/[email protected]", "", { "dependencies": { "@aws-sdk/client-s3": "^3.787.0", "@aws-sdk/lib-storage": "^3.798.0", "@daytona/analytics-api-client": "0.201.0", "@daytona/api-client": "0.201.0", "@daytona/toolbox-api-client": "0.201.0", "@iarna/toml": "^2.2.5", "@opentelemetry/api": "^1.9.1", "@opentelemetry/exporter-trace-otlp-http": "^0.220.0", "@opentelemetry/instrumentation-http": "^0.220.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-node": "^0.220.0", "@opentelemetry/sdk-trace-base": "^2.9.0", "@opentelemetry/semantic-conventions": "^1.43.0", "axios": "^1.18.0", "busboy": "^1.0.0", "dotenv": "^17.0.1", "expand-tilde": "^2.0.2", "fast-glob": "^3.3.0", "form-data": "^4.0.4", "isomorphic-ws": "^5.0.0", "pathe": "^2.0.3", "shell-quote": "^1.8.2", "socket.io-client": "^4.8.1", "tar": "^7.5.11", "tslib": "2.8.1", "ws": "^8.18.0" } }, "sha512-nldIlBhSTClWeZl8SCd+0Jhf1GqubA7++2pqru8oWsAiuPOKHSHAhvHc/VW3oYoEkSMFiKCIWMJkLH128xIT9w=="],
+
+ "@daytona/toolbox-api-client": ["@daytona/[email protected]", "", { "dependencies": { "axios": "^1.6.1" } }, "sha512-rNPi4e3D0bg5xAY13h1zG1YzrK6gdbk5qV+0ibT9HeSj7hvUuuEUVWKFvdk24+VqsYbbno8OmF8/2Z2V6ZIdwg=="],
+
+ "@grpc/grpc-js": ["@grpc/[email protected]", "", { "dependencies": { "@grpc/proto-loader": "^0.8.0", "@js-sdsl/ordered-map": "^4.4.2" } }, "sha512-k9Dj3DV/itK9D06Y8f190Qgop7/Ui+D0njFV3LHMPwPT75DpXLQohE9Wmz0QElrJnzsjB7KPWiKJbOl7IPDArQ=="],
+
+ "@grpc/proto-loader": ["@grpc/[email protected]", "", { "dependencies": { "lodash.camelcase": "^4.3.0", "long": "^5.0.0", "protobufjs": "^7.5.5", "yargs": "^17.7.2" }, "bin": { "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" } }, "sha512-wtF6h+DY6M3YaDBPAmvuuA6jV8Sif9MjtOI5euKFWRgCDl5PeDpPsHR9u2l6St5ceY8AZgoNDww5+HvEsXFsGg=="],
+
+ "@hono/zod-validator": ["@hono/[email protected]", "", { "peerDependencies": { "hono": ">=4.11.2", "zod": "^3.25.0 || ^4.0.0" } }, "sha512-n0ZSXmCiHVIp4Y5wlOOyZCeTd/rsawA/qW1cipB8QOYKZ9N8Tk0nZUZCXho9cu374AN4JpDNKioNKBJ/W+LBug=="],
+
+ "@iarna/toml": ["@iarna/[email protected]", "", {}, "sha512-trnsAYxU3xnS1gPHPyU961coFyLkh4gAD/0zQ5mymY4yOZ+CYvsPqUbOFSw0aDM4y0tV7tiFxL/1XfXPNC6IPg=="],
+
+ "@isaacs/fs-minipass": ["@isaacs/[email protected]", "", { "dependencies": { "minipass": "^7.0.4" } }, "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w=="],
+
+ "@js-sdsl/ordered-map": ["@js-sdsl/[email protected]", "", {}, "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw=="],
+
+ "@nodelib/fs.scandir": ["@nodelib/[email protected]", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
+
+ "@nodelib/fs.stat": ["@nodelib/[email protected]", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
+
+ "@nodelib/fs.walk": ["@nodelib/[email protected]", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="],
+
+ "@opentelemetry/api": ["@opentelemetry/[email protected]", "", {}, "sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q=="],
+
+ "@opentelemetry/api-logs": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-CmVa4ImJ+ynfrPMNaAXHET6Bhb44SwzmfyVJFq9ni2jgXJR/l7C6gfVFddNmHP+ZOkP9cf4f9DBe68qVLTHc9w=="],
+
+ "@opentelemetry/configuration": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "yaml": "^2.8.3" }, "peerDependencies": { "@opentelemetry/api": "^1.9.0" } }, "sha512-glfIVKnZevRin8fY/9uES/mhRtMT1lGINLHc9MIo5fTQZXswEEHamJtgjv4MTtzgnhHGC92mIS/0lzAUZMyE0w=="],
+
+ "@opentelemetry/context-async-hooks": ["@opentelemetry/[email protected]", "", { "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-OQ0vzvbZBiUhjqLnUaoNfYmP8553Crr3aggB4y0ZUi815mZ7idpdJXQmoKdeBKJelYttoBlLSSHubmyw3wvX4w=="],
+
+ "@opentelemetry/core": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-m2nckMT80NnmjTYSPjJQObBJ+8dgkoajEOUbznL8AHZ3T3yHRk2P7gI1PhEBc1+lOnrYE9UWrWHqJDsmqjmNbw=="],
+
+ "@opentelemetry/exporter-logs-otlp-grpc": ["@opentelemetry/[email protected]", "", { "dependencies": { "@grpc/grpc-js": "^1.14.3", "@opentelemetry/core": "2.9.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-grpc-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/sdk-logs": "0.220.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-s0sRPCSlXYqlgObOpCftomJllp3LfUL9FobQ5csg2172ydVhSEnu1ptpsVBJadazs5nUNp7vDuLE03FAFWTLOQ=="],
+
+ "@opentelemetry/exporter-logs-otlp-http": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/api-logs": "0.220.0", "@opentelemetry/core": "2.9.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/sdk-logs": "0.220.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-8186thl+pTw64iz/qEEen5oJZoZ/gO73XruChdaGlYdWOdBIQ42r+vHLf6a7vIDqTD4b8ZOoMlyxptanECaI9A=="],
+
+ "@opentelemetry/exporter-logs-otlp-proto": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/sdk-logs": "0.220.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-8LZAxdJ0ENDAFwr4j0oY35mHBltiSzvlhdQAPGiC7p9VnxtuSq4SW1gfBAdW6t6hiQG6OwUl8w7KHaOdJPKHWg=="],
+
+ "@opentelemetry/exporter-metrics-otlp-grpc": ["@opentelemetry/[email protected]", "", { "dependencies": { "@grpc/grpc-js": "^1.14.3", "@opentelemetry/core": "2.9.0", "@opentelemetry/exporter-metrics-otlp-http": "0.220.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-grpc-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-metrics": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-U128izvJfX/dW9jRGP0gIfadR1Hg7ft3UEGIeRxLFK70m2BWw6AtNCOnsUygpw2zCgR/ygdWbGpcL6TmhW0ZGw=="],
+
+ "@opentelemetry/exporter-metrics-otlp-http": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-metrics": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Yqt3RBw/bRVncaE9qIIhk4WfjbAQqXuP9FgAaU+IKPndnLEp/cUqZlSC324+bpmduRz7DoTjig8Ub0PeILWXUA=="],
+
+ "@opentelemetry/exporter-metrics-otlp-proto": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/exporter-metrics-otlp-http": "0.220.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-metrics": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-lyO+IQBdSvqHN/ZOW/OzrSWemtfD+HgWngn+HBNLhjy0YrCQQTz0OE/kSekH2Pl340dn9DWzhqHdz5Eftr+HLA=="],
+
+ "@opentelemetry/exporter-prometheus": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-metrics": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-JZD5DL/NBpVd2BHefvYosm3G40UZ/KzExLv5tc0eZe0CtrsHHtcOk3YPUxR2EINmUeBf8+w5UReTV8fFPn95lA=="],
+
+ "@opentelemetry/exporter-trace-otlp-grpc": ["@opentelemetry/[email protected]", "", { "dependencies": { "@grpc/grpc-js": "^1.14.3", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-grpc-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/sdk-trace": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-bv1xmNhmNwIM6MdUBw4yYuJeVcEViVLk3uD69vOQMwueHBnfyl/u0HnBlB1FNY/Te0UOzJzvcbyR8wN6b+iGbA=="],
+
+ "@opentelemetry/exporter-trace-otlp-http": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-trace": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-/+ExB3lRkf+erv4PnoywyL7RHKITidxtUpUTS55k7OQ0dB42S7gEF1gry7swb9MSm1hYLUhJg4QQh9W8SpwwqA=="],
+
+ "@opentelemetry/exporter-trace-otlp-proto": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-trace": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-voTAD8XgJxlK7zLkXh8EzMB09zrQr3tyY/BsnDTlDiQU/UdK58MZ63A3mUjdEDrxMjCVmBHU3WQJhRmQe+Dvzg=="],
+
+ "@opentelemetry/exporter-zipkin": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-trace": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.0.0" } }, "sha512-RwINoce2BH8T4obT5pMcAla2sWma1YZvYuaktWmTluQ0PkQdvv5D060rWI1+kawX+J2qBRcMbwrZJJNcMJUauQ=="],
+
+ "@opentelemetry/instrumentation": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/api-logs": "0.220.0", "import-in-the-middle": "^3.0.0", "require-in-the-middle": "^8.0.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-xQx3E2WxP1mDvKzxLxX+CTCtNLa560YJZ3087qYHerl2YmiKpv7AH+dAy7vmx+eVrZ5BwhfWUAVoKOoxCNHcpw=="],
+
+ "@opentelemetry/instrumentation-http": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/instrumentation": "0.220.0", "@opentelemetry/semantic-conventions": "^1.29.0", "forwarded-parse": "2.1.2" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Szt4dO2Boz2CDr38DaSw/lnqwhwKl+IAdgNGEGgSm2Anb+fwPtIAGmIwkhsLLN69QQZQE96JxjMKYY4rlRkYKw=="],
+
+ "@opentelemetry/otlp-exporter-base": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/otlp-transformer": "0.220.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-CXYo8UD5Mn9YbgebO2EL4wejtA+gxLmLiu6HCk2KH2BR7XhFN6/6p1UlCb23DYCjeYkndevLHuejCCN1yx4+OQ=="],
+
+ "@opentelemetry/otlp-grpc-exporter-base": ["@opentelemetry/[email protected]", "", { "dependencies": { "@grpc/grpc-js": "^1.14.3", "@opentelemetry/core": "2.9.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-transformer": "0.220.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-/eIkBPMBTIvM3x/0mDX4aJeSkYifYClnBPr68PL1h5LV4VQv4+SV6CGrpiZ4fIWDnobVmhTWCm1J/QRdAWUfvA=="],
+
+ "@opentelemetry/otlp-transformer": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/api-logs": "0.220.0", "@opentelemetry/core": "2.9.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-logs": "0.220.0", "@opentelemetry/sdk-metrics": "2.9.0", "@opentelemetry/sdk-trace": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-lXGrv7KXZ0gNH9SVNUaa6vv6phVYGvJxfXAlMbzbakiXru75f5MZl8Z7oqiMMQD77riVHJCFlQvbZs/VVN2/4A=="],
+
+ "@opentelemetry/propagator-b3": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-WrOT1WsOUG+B7hstD2RYoMPIOK76G8E9AQHhMjUvrQaGx/oA7rPWQvvr1Rqv7+yy4R0ZMVwWLC4vW2xnkgWPAQ=="],
+
+ "@opentelemetry/propagator-jaeger": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-4mYGty27rYvSM0jtp1ZUOqd3LfVRCYg9H5G9OFzSx5HViYToU21MFhWfco7x1HwXr7ER8yGOiCIHZUwjPksc0Q=="],
+
+ "@opentelemetry/resources": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-jyA5MBLQ+Dkl3+JsZkUoUvL7yHvU64kLsvpXKarWm6347Sl1t1bXFTFykUePNpT5WH5pm9a2Qtt03iIYQhZ1Fg=="],
+
+ "@opentelemetry/sdk-logs": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/api-logs": "0.220.0", "@opentelemetry/core": "2.9.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-WywcTkQtv2iNmt+6y5Kcd4rzvx9bLVsBa2Nwcmg01IUaBTkTow3W4d9KE5vNBpEDtb9tp21WcRBY/lANRrApYA=="],
+
+ "@opentelemetry/sdk-metrics": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/resources": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.9.0 <1.10.0" } }, "sha512-Xx8RGS4H5XEBl01WuCreMIpiah9cCXMbSkeuIePPdD2cUpq/vUzYmj8E/MK1OsbOc93FuAD4jfn2WOacKwLn7Q=="],
+
+ "@opentelemetry/sdk-node": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/api-logs": "0.220.0", "@opentelemetry/configuration": "0.220.0", "@opentelemetry/context-async-hooks": "2.9.0", "@opentelemetry/core": "2.9.0", "@opentelemetry/exporter-logs-otlp-grpc": "0.220.0", "@opentelemetry/exporter-logs-otlp-http": "0.220.0", "@opentelemetry/exporter-logs-otlp-proto": "0.220.0", "@opentelemetry/exporter-metrics-otlp-grpc": "0.220.0", "@opentelemetry/exporter-metrics-otlp-http": "0.220.0", "@opentelemetry/exporter-metrics-otlp-proto": "0.220.0", "@opentelemetry/exporter-prometheus": "0.220.0", "@opentelemetry/exporter-trace-otlp-grpc": "0.220.0", "@opentelemetry/exporter-trace-otlp-http": "0.220.0", "@opentelemetry/exporter-trace-otlp-proto": "0.220.0", "@opentelemetry/exporter-zipkin": "2.9.0", "@opentelemetry/instrumentation": "0.220.0", "@opentelemetry/otlp-exporter-base": "0.220.0", "@opentelemetry/otlp-grpc-exporter-base": "0.220.0", "@opentelemetry/propagator-b3": "2.9.0", "@opentelemetry/propagator-jaeger": "2.9.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-logs": "0.220.0", "@opentelemetry/sdk-metrics": "2.9.0", "@opentelemetry/sdk-trace": "2.9.0", "@opentelemetry/sdk-trace-base": "2.9.0", "@opentelemetry/sdk-trace-node": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-wHtGyHhSKHNH3fym33xRu4Ef/HXTFvX8eQ42xdQdEO9LYx9Y2qNyBDJytyqVlvmo6abWZlNYTUthuAGUMYqYnQ=="],
+
+ "@opentelemetry/sdk-trace": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-sGA19HvtrrSKYsseHphluH6j3p6Xa3fqc7c7y8f/7mYWejc1lyDFcpSdD1kYa50HCLUeEo4zA5bW0pniaPszuw=="],
+
+ "@opentelemetry/sdk-trace-base": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.10.0", "@opentelemetry/resources": "2.10.0", "@opentelemetry/sdk-trace": "2.10.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-GuYQQT7QD2EeO8lcZLRQzcbOyhqAzL+6WWTKTU9mSUBYBazkEDl+VrQcXQhbB08OWM9anD1aHleVadzulpOaUQ=="],
+
+ "@opentelemetry/sdk-trace-node": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/context-async-hooks": "2.9.0", "@opentelemetry/core": "2.9.0", "@opentelemetry/sdk-trace-base": "2.9.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-ec9a7ps37huy5itYk0MalaZdSLlM6AXWp/FhtEjgMpp5leEGojBDvAl/UWttQnkMZOvFHKzRESn8TD3yKTF5nQ=="],
+
+ "@opentelemetry/semantic-conventions": ["@opentelemetry/[email protected]", "", {}, "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg=="],
+
+ "@protobufjs/aspromise": ["@protobufjs/[email protected]", "", {}, "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="],
+
+ "@protobufjs/base64": ["@protobufjs/[email protected]", "", {}, "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg=="],
+
+ "@protobufjs/codegen": ["@protobufjs/[email protected]", "", {}, "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g=="],
+
+ "@protobufjs/eventemitter": ["@protobufjs/[email protected]", "", {}, "sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg=="],
+
+ "@protobufjs/fetch": ["@protobufjs/[email protected]", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.1" } }, "sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw=="],
+
+ "@protobufjs/float": ["@protobufjs/[email protected]", "", {}, "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ=="],
+
+ "@protobufjs/path": ["@protobufjs/[email protected]", "", {}, "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA=="],
+
+ "@protobufjs/pool": ["@protobufjs/[email protected]", "", {}, "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw=="],
+
+ "@protobufjs/utf8": ["@protobufjs/[email protected]", "", {}, "sha512-b1UQwcEZ4yCnMCD8DAL1VlbvBJE9/IX4FTIp7BG1xYpf29SLazLSrqUkj4w7Y5y7cCVP6E5tcqqcI0xemPkHug=="],
+
+ "@smithy/core": ["@smithy/[email protected]", "", { "dependencies": { "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-sylYk2l9d7CmRv8ts8p0SDQUr3VO+HMeS1nrjL6+UtbO8ktJHTOeQ1McX+aAyvGGccp5aZX9eNtdcXrSwzoZaw=="],
+
+ "@smithy/credential-provider-imds": ["@smithy/[email protected]", "", { "dependencies": { "@smithy/core": "^3.31.0", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-xYVGrisQqTJWhOnScUhbx8s9H63TMtoxzuUoxG6mP8J+B/YbX3vZxVsgV0xDf43abJnJP0fjP7BkQh7OESwuRA=="],
+
+ "@smithy/fetch-http-handler": ["@smithy/[email protected]", "", { "dependencies": { "@smithy/core": "^3.31.0", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-OpQgP6IGH4j0NJ2zjfYZLjQL85ai+Wi/q51EmZJovXsEwKSvu89qiXUq77Q6EmwZ/hSl7fKpn2Z9mhiDN6OM+Q=="],
+
+ "@smithy/node-http-handler": ["@smithy/[email protected]", "", { "dependencies": { "@smithy/core": "^3.31.0", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-dWW5KRt4mnEvjNzbGqGeCuAvgum85Y9ZoyuMQqcTEfapndyVJ1k9BEHK7kdXJZ32enyRmmwcFjMwlB/KgLKI3Q=="],
+
+ "@smithy/signature-v4": ["@smithy/[email protected]", "", { "dependencies": { "@smithy/core": "^3.31.0", "@smithy/types": "^4.16.1", "tslib": "^2.6.2" } }, "sha512-7HsspeiNCZvZHEJ22vV5L/QYuJdTyJvPJvMrYD3AgkM3IJB0pkln4jkjPvtpTWRMkHXbO8WKwNjoVdVlBFwHmw=="],
+
+ "@smithy/types": ["@smithy/[email protected]", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-0JFs3V2y2M9tKW5na/qxe69Zv+uxLMO7QBbhxF/FHu/Gp2NFZAAL9tWl9PU02xxo07pb3G9FTyjNc6D5uZrJIg=="],
+
+ "@socket.io/component-emitter": ["@socket.io/[email protected]", "", {}, "sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA=="],
+
+ "@types/bun": ["@types/[email protected]", "", { "dependencies": { "bun-types": "1.3.14" } }, "sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw=="],
+
+ "@types/node": ["@types/[email protected]", "", { "dependencies": { "undici-types": "~8.3.0" } }, "sha512-Vu4a5UFA9rIIFJ7rB/Vaafh9lrCQszopTCx6KjFboXTGQbPNasehVR5TEiithSDGyd1DEiUByggTZsg8jukeIg=="],
+
+ "@types/react": ["@types/[email protected]", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw=="],
+
+ "@zed-industries/agent-client-protocol": ["@zed-industries/[email protected]", "", { "dependencies": { "zod": "^3.0.0" } }, "sha512-OwHKfu5AiKul/GSJilHg36+kOSV9eOl2eYnjR6tenAQDdraSnt22WFk0SDFTeuAANz1Gxkv+DTf7Hq32rvX7FQ=="],
+
+ "agent-base": ["[email protected]", "", { "dependencies": { "debug": "4" } }, "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ=="],
+
+ "ansi-escapes": ["[email protected]", "", { "dependencies": { "environment": "^1.0.0" } }, "sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg=="],
+
+ "ansi-regex": ["[email protected]", "", {}, "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="],
+
+ "ansi-styles": ["[email protected]", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+
+ "asynckit": ["[email protected]", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],
+
+ "auto-bind": ["[email protected]", "", {}, "sha512-ooviqdwwgfIfNmDwo94wlshcdzfO64XV0Cg6oDsDYBJfITDz1EngD2z7DkbvCWn+XIMsIqW27sEVF6qcpJrRcg=="],
+
+ "axios": ["[email protected]", "", { "dependencies": { "follow-redirects": "^1.16.0", "form-data": "^4.0.5", "https-proxy-agent": "^5.0.1", "proxy-from-env": "^2.1.0" } }, "sha512-3nTvFlvpn9Zu/RkHUqtc7/+al4UpRW5az71ap5zccp6e8RAYEzhMTecX8Dz1wWDYrPpUoB1HAQEGEAEvUr7S9g=="],
+
+ "base64-js": ["[email protected]", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
+
+ "bowser": ["[email protected]", "", {}, "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg=="],
+
+ "braces": ["[email protected]", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
+
+ "buffer": ["[email protected]", "", { "dependencies": { "base64-js": "^1.0.2", "ieee754": "^1.1.4" } }, "sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw=="],
+
+ "bun-types": ["[email protected]", "", { "dependencies": { "@types/node": "*" } }, "sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ=="],
+
+ "busboy": ["[email protected]", "", { "dependencies": { "streamsearch": "^1.1.0" } }, "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA=="],
+
+ "call-bind-apply-helpers": ["[email protected]", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
+
+ "chalk": ["[email protected]", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
+
+ "chownr": ["[email protected]", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="],
+
+ "cjs-module-lexer": ["[email protected]", "", {}, "sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ=="],
+
+ "cli-boxes": ["[email protected]", "", {}, "sha512-5IOn+jcCEHEraYolBPs/sT4BxYCe2nHg374OPiItB1O96KZFseS2gthU4twyYzeDcFew4DaUM/xwc5BQf08JJw=="],
+
+ "cli-cursor": ["[email protected]", "", { "dependencies": { "restore-cursor": "^4.0.0" } }, "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg=="],
+
+ "cli-truncate": ["[email protected]", "", { "dependencies": { "slice-ansi": "^9.0.0", "string-width": "^8.2.0" } }, "sha512-06p9vyLahLa4zkGcgsGxU6iEkSOiuI4fhCH6Emhe2lPAcoUv73n72DnODsnHA+5wwXGnV0n9M9/qOQJSjYhFhw=="],
+
+ "cliui": ["[email protected]", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="],
+
+ "code-excerpt": ["[email protected]", "", { "dependencies": { "convert-to-spaces": "^2.0.1" } }, "sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA=="],
+
+ "color-convert": ["[email protected]", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+ "color-name": ["[email protected]", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+ "combined-stream": ["[email protected]", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="],
+
+ "convert-to-spaces": ["[email protected]", "", {}, "sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ=="],
+
+ "csstype": ["[email protected]", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
+
+ "debug": ["[email protected]", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+ "delayed-stream": ["[email protected]", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],
+
+ "dotenv": ["[email protected]", "", {}, "sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw=="],
+
+ "dunder-proto": ["[email protected]", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
+
+ "emoji-regex": ["[email protected]", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+ "engine.io-client": ["[email protected]", "", { "dependencies": { "@socket.io/component-emitter": "~3.1.0", "debug": "~4.4.1", "engine.io-parser": "~5.2.1", "ws": "~8.21.0", "xmlhttprequest-ssl": "~2.1.1" } }, "sha512-iY6QdftLQ9pyiPoX082bpf/u1UewnOaJrtJIF9T0++QB34lZrj0uP+Q/bj8AlUsAxqhnkTV2BS8SBZSxOmoV5Q=="],
+
+ "engine.io-parser": ["[email protected]", "", {}, "sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q=="],
+
+ "environment": ["[email protected]", "", {}, "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q=="],
+
+ "envsafe": ["[email protected]", "", {}, "sha512-51lek8h5btjXhXUDW//Pno7HPydM1WQzltOb1/ONRKdwB2QkfAURnN4Qn0cJ5LzGvX2Km1ReR2O3K3Bqq9sBMg=="],
+
+ "es-define-property": ["[email protected]", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
+
+ "es-errors": ["[email protected]", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
+
+ "es-module-lexer": ["[email protected]", "", {}, "sha512-shc1dbU90Yl/xq1QrC7QRtfcwURZuVRfPhZbDoldJ1cn1gzDvBaBWlv0eFolj5+0znnPJz5TXLxsN77X/12KTA=="],
+
+ "es-object-atoms": ["[email protected]", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw=="],
+
+ "es-set-tostringtag": ["[email protected]", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="],
+
+ "es-toolkit": ["[email protected]", "", {}, "sha512-OyZKhUVvEep9ITEiwHn8GKnMRQIVqoSIX7WnRbkWgJkllCujilqP2rD0u979tkl8wqyc8ICwlc1UBVv/Sl1G6w=="],
+
+ "escalade": ["[email protected]", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="],
+
+ "escape-string-regexp": ["[email protected]", "", {}, "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w=="],
+
+ "events": ["[email protected]", "", {}, "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q=="],
+
+ "expand-tilde": ["[email protected]", "", { "dependencies": { "homedir-polyfill": "^1.0.1" } }, "sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw=="],
+
+ "fast-glob": ["[email protected]", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="],
+
+ "fastq": ["[email protected]", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw=="],
+
+ "fill-range": ["[email protected]", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],
+
+ "follow-redirects": ["[email protected]", "", {}, "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw=="],
+
+ "form-data": ["[email protected]", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.4", "mime-types": "^2.1.35" } }, "sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ=="],
+
+ "forwarded-parse": ["[email protected]", "", {}, "sha512-alTFZZQDKMporBH77856pXgzhEzaUVmLCDk+egLgIgHst3Tpndzz8MnKe+GzRJRfvVdn69HhpW7cmXzvtLvJAw=="],
+
+ "function-bind": ["[email protected]", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
+
+ "get-caller-file": ["[email protected]", "", {}, "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="],
+
+ "get-east-asian-width": ["[email protected]", "", {}, "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA=="],
+
+ "get-intrinsic": ["[email protected]", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
+
+ "get-proto": ["[email protected]", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
+
+ "glob-parent": ["[email protected]", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
+
+ "gopd": ["[email protected]", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
+
+ "has-symbols": ["[email protected]", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
+
+ "has-tostringtag": ["[email protected]", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
+
+ "hasown": ["[email protected]", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A=="],
+
+ "homedir-polyfill": ["[email protected]", "", { "dependencies": { "parse-passwd": "^1.0.0" } }, "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA=="],
+
+ "hono": ["[email protected]", "", {}, "sha512-XcuyW9qE2kJn07PkecMOBd5Vq/hMy7mmGw+idz1yblbg9N17ijJODrvPkn7/dwL3Kulj8LcRJ69DLOWf91dRUg=="],
+
+ "https-proxy-agent": ["[email protected]", "", { "dependencies": { "agent-base": "6", "debug": "4" } }, "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA=="],
+
+ "ieee754": ["[email protected]", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],
+
+ "import-in-the-middle": ["[email protected]", "", { "dependencies": { "cjs-module-lexer": "^2.2.0", "es-module-lexer": "^2.2.0", "module-details-from-path": "^1.0.4" } }, "sha512-jTd2FfOgOWOdgjkHuk/1Ms8VKFXkPs15ymYBETw1sAOrO/dY3XeGVRWir9qBbw7pXr0T2eTFwfCZ+N02HmiNGA=="],
+
+ "indent-string": ["[email protected]", "", {}, "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg=="],
+
+ "inherits": ["[email protected]", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
+
+ "ink": ["[email protected]", "", { "dependencies": { "@alcalzone/ansi-tokenize": "^0.3.0", "ansi-escapes": "^7.3.0", "ansi-styles": "^6.2.3", "auto-bind": "^5.0.1", "chalk": "^5.6.2", "cli-boxes": "^4.0.1", "cli-cursor": "^4.0.0", "cli-truncate": "^6.0.0", "code-excerpt": "^4.0.0", "es-toolkit": "^1.45.1", "indent-string": "^5.0.0", "is-in-ci": "^2.0.0", "patch-console": "^2.0.0", "react-reconciler": "^0.33.0", "scheduler": "^0.27.0", "signal-exit": "^3.0.7", "slice-ansi": "^9.0.0", "stack-utils": "^2.0.6", "string-width": "^8.2.0", "terminal-size": "^4.0.1", "type-fest": "^5.5.0", "widest-line": "^6.0.0", "wrap-ansi": "^10.0.0", "ws": "^8.20.0", "yoga-layout": "~3.2.1" }, "peerDependencies": { "@types/react": ">=19.2.0", "react": ">=19.2.0", "react-devtools-core": ">=6.1.2" }, "optionalPeers": ["@types/react", "react-devtools-core"] }, "sha512-Y43xxa1ZSPvpmfLHcN5o+OdP8Rf8ykkNJEuKYOUNZKT8wXVNLFTtEm1nSDMQkfBH+YANF4Xuu0hhZ4ejqAtN2w=="],
+
+ "ink-text-input": ["[email protected]", "", { "dependencies": { "chalk": "^5.3.0", "type-fest": "^4.18.2" }, "peerDependencies": { "ink": ">=5", "react": ">=18" } }, "sha512-Fw64n7Yha5deb1rHY137zHTAbSTNelUKuB5Kkk2HACXEtwIHBCf9OH2tP/LQ9fRYTl1F0dZgbW0zPnZk6FA9Lw=="],
+
+ "is-extglob": ["[email protected]", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
+
+ "is-fullwidth-code-point": ["[email protected]", "", { "dependencies": { "get-east-asian-width": "^1.3.1" } }, "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ=="],
+
+ "is-glob": ["[email protected]", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
+
+ "is-in-ci": ["[email protected]", "", { "bin": { "is-in-ci": "cli.js" } }, "sha512-cFeerHriAnhrQSbpAxL37W1wcJKUUX07HyLWZCW1URJT/ra3GyUTzBgUnh24TMVfNTV2Hij2HLxkPHFZfOZy5w=="],
+
+ "is-number": ["[email protected]", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
+
+ "isomorphic-ws": ["[email protected]", "", { "peerDependencies": { "ws": "*" } }, "sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw=="],
+
+ "lodash.camelcase": ["[email protected]", "", {}, "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA=="],
+
+ "long": ["[email protected]", "", {}, "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA=="],
+
+ "math-intrinsics": ["[email protected]", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
+
+ "merge2": ["[email protected]", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
+
+ "micromatch": ["[email protected]", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="],
+
+ "mime-db": ["[email protected]", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
+
+ "mime-types": ["[email protected]", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
+
+ "mimic-fn": ["[email protected]", "", {}, "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg=="],
+
+ "minipass": ["[email protected]", "", {}, "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A=="],
+
+ "minizlib": ["[email protected]", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw=="],
+
+ "module-details-from-path": ["[email protected]", "", {}, "sha512-EGWKgxALGMgzvxYF1UyGTy0HXX/2vHLkw6+NvDKW2jypWbHpjQuj4UMcqQWXHERJhVGKikolT06G3bcKe4fi7w=="],
+
+ "ms": ["[email protected]", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+ "onetime": ["[email protected]", "", { "dependencies": { "mimic-fn": "^2.1.0" } }, "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg=="],
+
+ "parse-passwd": ["[email protected]", "", {}, "sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q=="],
+
+ "patch-console": ["[email protected]", "", {}, "sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA=="],
+
+ "pathe": ["[email protected]", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+ "picomatch": ["[email protected]", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
+
+ "protobufjs": ["[email protected]", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.2", "@protobufjs/base64": "^1.1.2", "@protobufjs/codegen": "^2.0.5", "@protobufjs/eventemitter": "^1.1.1", "@protobufjs/fetch": "^1.1.1", "@protobufjs/float": "^1.0.2", "@protobufjs/path": "^1.1.2", "@protobufjs/pool": "^1.1.0", "@protobufjs/utf8": "^1.1.1", "@types/node": ">=13.7.0", "long": "^5.3.2" } }, "sha512-/FPD0nUc9jH6rfFjji9IBqOz4pcSE3CsT1m7Ep6Mdb0LxSUMj8hgl6GomOvZzpNpAqqGaXA0P3VSrZLFzIhQrw=="],
+
+ "proxy-from-env": ["[email protected]", "", {}, "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA=="],
+
+ "queue-microtask": ["[email protected]", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
+
+ "react": ["[email protected]", "", {}, "sha512-PWaYA1L/q9u2u7xYQi+Y3L3Yfnie7XyLeaJICV1MGD6LprsBxcAqGjYyr0eY3p+QdsA+x/Irkt4Qif8D63+Sbw=="],
+
+ "react-reconciler": ["[email protected]", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.0" } }, "sha512-KetWRytFv1epdpJc3J4G75I4WrplZE5jOL7Yq0p34+OVOKF4Se7WrdIdVC45XsSSmUTlht2FM/fM1FZb1mfQeA=="],
+
+ "readable-stream": ["[email protected]", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
+
+ "require-directory": ["[email protected]", "", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="],
+
+ "require-in-the-middle": ["[email protected]", "", { "dependencies": { "debug": "^4.3.5", "module-details-from-path": "^1.0.3" } }, "sha512-QT7FVMXfWOYFbeRBF6nu+I6tr2Tf3u0q8RIEjNob/heKY/nh7drD/k7eeMFmSQgnTtCzLDcCu/XEnpW2wk4xCQ=="],
+
+ "restore-cursor": ["[email protected]", "", { "dependencies": { "onetime": "^5.1.0", "signal-exit": "^3.0.2" } }, "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg=="],
+
+ "reusify": ["[email protected]", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
+
+ "run-parallel": ["[email protected]", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
+
+ "safe-buffer": ["[email protected]", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
+
+ "scheduler": ["[email protected]", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
+
+ "shell-quote": ["[email protected]", "", {}, "sha512-w1aiOKwKuRgtwAReIIj89puqg+I7GvX4IbLrvmhXbzQsj1+Zwi4VO3+fa6ZF91TWSjIxoEkKnMeHcLEODK5ZXA=="],
+
+ "signal-exit": ["[email protected]", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+
+ "slice-ansi": ["[email protected]", "", { "dependencies": { "ansi-styles": "^6.2.3", "is-fullwidth-code-point": "^5.1.0" } }, "sha512-SO/3iYL5S3W57LLEniscOGPZgOqZUPCx6d3dB+52B80yJ0XstzsC/eV8gnA4tM3MHDrKz+OCFSLNjswdSC+/bA=="],
+
+ "socket.io-client": ["[email protected]", "", { "dependencies": { "@socket.io/component-emitter": "~3.1.0", "debug": "~4.4.1", "engine.io-client": "~6.6.1", "socket.io-parser": "~4.2.4" } }, "sha512-uP0bpjWrjQmUt5DTHq9RuoCBdFJF10cdX9X+a368j/Ft0wmaVgxlrjvK3kjvgCODOMMOz9lcaRzxmso0bTWZ/g=="],
+
+ "socket.io-parser": ["[email protected]", "", { "dependencies": { "@socket.io/component-emitter": "~3.1.0", "debug": "~4.4.1" } }, "sha512-IH/iSeO9T6gz1KkFleGDWkG9N3dl4jXVYUtMhIqH10Md0ttMer8nUNWiP1DKuNrybD2xBrixLJdCC9J6ECoYkg=="],
+
+ "stack-utils": ["[email protected]", "", { "dependencies": { "escape-string-regexp": "^2.0.0" } }, "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ=="],
+
+ "stream-browserify": ["[email protected]", "", { "dependencies": { "inherits": "~2.0.4", "readable-stream": "^3.5.0" } }, "sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA=="],
+
+ "streamsearch": ["[email protected]", "", {}, "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg=="],
+
+ "string-width": ["[email protected]", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg=="],
+
+ "string_decoder": ["[email protected]", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
+
+ "strip-ansi": ["[email protected]", "", { "dependencies": { "ansi-regex": "^6.2.2" } }, "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w=="],
+
+ "tagged-tag": ["[email protected]", "", {}, "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng=="],
+
+ "tar": ["[email protected]", "", { "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.1.0", "yallist": "^5.0.0" } }, "sha512-MFO/QzvtAOmJbkhOaCTvbGcFN9L9b+JunIsDwaKljSOdcLMea3NJ1k9Usz/rjdfSXTq4dfzfeS7W4p4YOAAHeA=="],
+
+ "terminal-size": ["[email protected]", "", {}, "sha512-avMLDQpUI9I5XFrklECw1ZEUPJhqzcwSWsyyI8blhRLT+8N1jLJWLWWYQpB2q2xthq8xDvjZPISVh53T/+CLYQ=="],
+
+ "to-regex-range": ["[email protected]", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
+
+ "tslib": ["[email protected]", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+ "type-fest": ["[email protected]", "", { "dependencies": { "tagged-tag": "^1.0.0" } }, "sha512-YGYEVz3Fm5iy/AybuA0oyNFq7H4CgQNfRp/qfe8nurE1kuCeNm3/vfm9X4Mtl+qLyaKJUh5xrFZwogr41SMjYA=="],
+
+ "undici-types": ["[email protected]", "", {}, "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ=="],
+
+ "util-deprecate": ["[email protected]", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
+
+ "websocketstream-polyfill": ["[email protected]", "", {}, "sha512-fi4WLE0jZQgZ57k6gUPt5zOZtc3EjgfNgcDugS4z9KEOJiDpE2hWIAlaNwPzmTs9nfz6nvVOhx7e60W98Fm9dQ=="],
+
+ "widest-line": ["[email protected]", "", { "dependencies": { "string-width": "^8.1.0" } }, "sha512-U89AsyEeAsyoF0zVJBkG9zBgekjgjK7yk9sje3F4IQpXBJ10TF6ByLlIfjMhcmHMJgHZI4KHt4rdNfktzxIAMA=="],
+
+ "wrap-ansi": ["[email protected]", "", { "dependencies": { "ansi-styles": "^6.2.3", "string-width": "^8.2.0", "strip-ansi": "^7.1.2" } }, "sha512-SGcvg80f0wUy2/fXES19feHMz8E0JoXv2uNgHOu4Dgi2OrCy1lqwFYEJz1BLbDI0exjPMe/ZdzZ/YpGECBG/aQ=="],
+
+ "ws": ["[email protected]", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-+0NTnW77fFN/DjQi6k/Sq/Yvk4Sgajw7urW8V+asjXnRgDs9gyGkdb7EzgfhA4goXsRIZKE28fzIXBHEzhuiWw=="],
+
+ "xmlhttprequest-ssl": ["[email protected]", "", {}, "sha512-TEU+nJVUUnA4CYJFLvK5X9AOeH4KvDvhIfm0vV1GaQRtchnG0hgK5p8hw/xjv8cunWYCsiPCSDzObPyhEwq3KQ=="],
+
+ "y18n": ["[email protected]", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="],
+
+ "yallist": ["[email protected]", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="],
+
+ "yaml": ["[email protected]", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA=="],
+
+ "yargs": ["[email protected]", "", { "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" } }, "sha512-GZtjxm/J/4TSxuL3FNYjCmLktBTnIw/rVmKSIyKeYAZpmJB2ig9VauCC5xsa82GNKVKDAqpOn3KVzNt0zmrU0g=="],
+
+ "yargs-parser": ["[email protected]", "", {}, "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="],
+
+ "yoga-layout": ["[email protected]", "", {}, "sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ=="],
+
+ "zod": ["[email protected]", "", {}, "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ=="],
+
+ "@opentelemetry/sdk-node/@opentelemetry/sdk-trace-base": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-trace": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-cp9zmTl62R8PJrpvFcmc8N2JQU/xfa0S+61q511Nji+QxCfZ8Ifvg7H27G8cANe4crg4RTrWsVvanHiXjSp6ag=="],
+
+ "@opentelemetry/sdk-trace-base/@opentelemetry/core": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-/wNZ8twnEQQA4HoHu22+vcsdru6pWPWxW+7w+FlxT6Id7PE/WIbZmVKkte+PF72e0F2dnImFeHD2syyE1Mw6MQ=="],
+
+ "@opentelemetry/sdk-trace-base/@opentelemetry/resources": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.10.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-q6MMm2zhggzsHVNbabYwut+a6nbuQQe3URUoxaojM/8K1IBfwwPzvxIjNi2/lI1TFe+fMHMW9MWhrtDLEXEnkA=="],
+
+ "@opentelemetry/sdk-trace-base/@opentelemetry/sdk-trace": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.10.0", "@opentelemetry/resources": "2.10.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-MfQGq3GRmTh5fM/y+OjaO0vj6+luCB1XO2gfXCalKCfgKw0eHL++sm75DNweC6ohlp+aFvACqeE0fYayqdRaoQ=="],
+
+ "@opentelemetry/sdk-trace-node/@opentelemetry/sdk-trace-base": ["@opentelemetry/[email protected]", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/resources": "2.9.0", "@opentelemetry/sdk-trace": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-cp9zmTl62R8PJrpvFcmc8N2JQU/xfa0S+61q511Nji+QxCfZ8Ifvg7H27G8cANe4crg4RTrWsVvanHiXjSp6ag=="],
+
+ "@zed-industries/agent-client-protocol/zod": ["[email protected]", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+ "cliui/string-width": ["[email protected]", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+ "cliui/strip-ansi": ["[email protected]", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+ "cliui/wrap-ansi": ["[email protected]", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
+
+ "ink-text-input/type-fest": ["[email protected]", "", {}, "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA=="],
+
+ "yargs/string-width": ["[email protected]", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+ "cliui/string-width/is-fullwidth-code-point": ["[email protected]", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
+
+ "cliui/strip-ansi/ansi-regex": ["[email protected]", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+ "cliui/wrap-ansi/ansi-styles": ["[email protected]", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+ "yargs/string-width/is-fullwidth-code-point": ["[email protected]", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
+
+ "yargs/string-width/strip-ansi": ["[email protected]", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+ "yargs/string-width/strip-ansi/ansi-regex": ["[email protected]", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+ }
+}
diff --git a/services/document_text_extractor/src/model/mod.rs b/services/document_text_extractor/src/model/mod.rs
index 0873ff0a41..25634dc083 100644
--- a/services/document_text_extractor/src/model/mod.rs
+++ b/services/document_text_extractor/src/model/mod.rs
@@ -6,6 +6,6 @@ pub mod key;
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum IncomingEvent {
- EventBridgeEvent(EventBridgeEvent),
+ EventBridgeEvent(Box<EventBridgeEvent>),
SqsEvent(SqsEvent),
}