Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat: agent runtime protocol (#5000)
Eric Hayesc408f4bbb0b8
diff --git a/.config/hakari.toml b/.config/hakari.tomlindex 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.jsonindex 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.lockindex 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.tomlindex 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.tsindex 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.tomlnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.locknew file mode 100644index 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.rsindex 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),}