Polish community UI copy and cleanup

crates/crank-core/src/ext/protocol.rs

@@ -4,9 +4,13 @@ use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use crate::{
-    AgentId, ExecutionMode, InvocationSource, Protocol, StreamSession, Target, WorkspaceId,
-};
+use crate::{AgentId, InvocationSource, Protocol, Target, WorkspaceId};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ExecutionMode {
+    Unary,
+}
 
 #[derive(Clone, Debug, PartialEq, Eq, Default)]
 pub struct ResponseCacheScope {
@@ -95,10 +99,6 @@ pub struct PreparedRequest {
     #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
     pub headers: BTreeMap<String, String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub grpc: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub variables: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub body: Option<Value>,
     #[serde(default)]
     pub timeout_ms: u64,
@@ -113,17 +113,6 @@ pub struct AdapterResponse {
     pub data: Value,
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct WindowExecutionResult {
-    pub summary: Value,
-    pub items: Vec<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cursor: Option<Value>,
-    pub window_complete: bool,
-    pub truncated: bool,
-    pub has_more: bool,
-}
-
 #[derive(Debug, thiserror::Error, PartialEq, Eq)]
 pub enum ProtocolAdapterError {
     #[error("protocol {protocol:?} does not support execution mode {mode:?}")]
@@ -147,32 +136,6 @@ pub trait ProtocolAdapter: Send + Sync {
         prepared: &PreparedRequest,
         context: &RuntimeRequestContext,
     ) -> Result<AdapterResponse, ProtocolAdapterError>;
-
-    async fn invoke_window(
-        &self,
-        _target: &Target,
-        _prepared: &PreparedRequest,
-        _window_duration_ms: u64,
-        _max_items: Option<u32>,
-        _context: &RuntimeRequestContext,
-    ) -> Result<WindowExecutionResult, ProtocolAdapterError> {
-        Err(ProtocolAdapterError::UnsupportedMode {
-            protocol: self.protocol(),
-            mode: ExecutionMode::Window,
-        })
-    }
-
-    async fn open_session(
-        &self,
-        _target: &Target,
-        _prepared: &PreparedRequest,
-        _context: &RuntimeRequestContext,
-    ) -> Result<StreamSession, ProtocolAdapterError> {
-        Err(ProtocolAdapterError::UnsupportedMode {
-            protocol: self.protocol(),
-            mode: ExecutionMode::Session,
-        })
-    }
 }
 
 pub type SharedProtocolAdapter = Arc<dyn ProtocolAdapter>;
@@ -211,18 +174,16 @@ impl AdapterRegistry {
 
 #[cfg(test)]
 mod tests {
-    use std::{collections::BTreeMap, sync::Arc};
+    use std::sync::Arc;
 
     use async_trait::async_trait;
     use serde_json::json;
 
     use super::{
-        AdapterRegistry, AdapterResponse, PreparedRequest, ProtocolAdapter, ProtocolAdapterError,
-        RuntimeRequestContext,
-    };
-    use crate::{
-        ExecutionMode, HttpMethod, InvocationSource, Protocol, RestTarget, Target, WorkspaceId,
+        AdapterRegistry, AdapterResponse, ExecutionMode, PreparedRequest, ProtocolAdapter,
+        ProtocolAdapterError, RuntimeRequestContext,
     };
+    use crate::{InvocationSource, Protocol, RestTarget, Target, WorkspaceId};
 
     #[derive(Clone)]
     struct StubAdapter(Protocol);
@@ -245,25 +206,13 @@ mod tests {
         ) -> Result<AdapterResponse, ProtocolAdapterError> {
             Ok(AdapterResponse {
                 status_code: 200,
-                headers: BTreeMap::new(),
+                headers: Default::default(),
                 body: json!({"ok": true}),
                 data: json!({"ok": true}),
             })
         }
     }
 
-    #[test]
-    fn registry_returns_registered_protocols() {
-        let registry = AdapterRegistry::empty()
-            .register(Arc::new(StubAdapter(Protocol::Rest)))
-            .register(Arc::new(StubAdapter(Protocol::Graphql)));
-
-        assert_eq!(
-            registry.protocols(),
-            vec![Protocol::Rest, Protocol::Graphql]
-        );
-    }
-
     #[test]
     fn registry_replaces_adapter_for_same_protocol() {
         let registry = AdapterRegistry::empty()
@@ -271,46 +220,36 @@ mod tests {
             .register(Arc::new(StubAdapter(Protocol::Rest)));
 
         assert_eq!(registry.protocols(), vec![Protocol::Rest]);
-        assert!(registry.get(Protocol::Rest).is_some());
     }
 
     #[test]
-    fn request_context_attaches_response_cache_scope() {
-        let context = RuntimeRequestContext::from_request_id("req_123")
-            .with_response_cache_scope("ws_01", "agent_01");
-
-        let scope = context.response_cache_scope().unwrap();
-        assert_eq!(scope.workspace_key, "ws_01");
-        assert_eq!(scope.agent_key, "agent_01");
-    }
-
-    #[test]
-    fn request_context_attaches_metering_context() {
+    fn request_context_builds_headers_and_metering_context() {
         let context = RuntimeRequestContext::from_request_id("req_123").with_metering_context(
             WorkspaceId::new("ws_01"),
             None,
-            InvocationSource::AgentToolCall,
+            InvocationSource::AdminTestRun,
         );
 
-        let metering = context.metering_context().unwrap();
-        assert_eq!(metering.workspace_id, WorkspaceId::new("ws_01"));
-        assert_eq!(metering.agent_id, None);
-        assert_eq!(metering.source, InvocationSource::AgentToolCall);
+        assert_eq!(
+            context.outbound_headers().get("x-request-id"),
+            Some(&"req_123".to_owned())
+        );
+        assert!(context.metering_context().is_some());
     }
 
     #[tokio::test]
-    async fn registry_returns_registered_adapter() {
-        let registry = AdapterRegistry::empty().register(Arc::new(StubAdapter(Protocol::Rest)));
-        let adapter = registry.get(Protocol::Rest).unwrap();
+    async fn adapter_contract_invokes_unary() {
+        let adapter = StubAdapter(Protocol::Rest);
+        let target = Target::Rest(RestTarget {
+            base_url: "https://api.example.com".to_owned(),
+            method: crate::HttpMethod::Get,
+            path_template: "/health".to_owned(),
+            static_headers: Default::default(),
+        });
 
         let response = adapter
             .invoke_unary(
-                &Target::Rest(RestTarget {
-                    base_url: "https://example.test".to_owned(),
-                    method: HttpMethod::Get,
-                    path_template: "/health".to_owned(),
-                    static_headers: BTreeMap::new(),
-                }),
+                &target,
                 &PreparedRequest::default(),
                 &RuntimeRequestContext::from_request_id("req_1"),
             )