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"),
             )

crates/crank-core/src/ids.rs

@@ -57,8 +57,6 @@ define_id!(PlatformApiKeyId);
 define_id!(InvocationLogId);
 define_id!(AuditEventId);
 define_id!(SecretId);
-define_id!(StreamSessionId);
-define_id!(AsyncJobId);
 
 #[cfg(test)]
 mod tests {

crates/crank-core/src/lib.rs

@@ -9,9 +9,6 @@ pub mod observability;
 pub mod operation;
 pub mod protocol;
 pub mod secret;
-pub mod soap;
-pub mod stream_session;
-pub mod streaming;
 pub mod workspace;
 
 pub use access::{
@@ -53,36 +50,26 @@ pub use ext::billing::{
 pub use ext::capability::{CapabilityProfile, CommunityCapabilityProfile};
 pub use ext::metering::{MeteringEvent, MeteringSink, NoopMeteringSink, SharedMeteringSink};
 pub use ext::protocol::{
-    AdapterRegistry, AdapterResponse, MeteringContext, PreparedRequest, ProtocolAdapter,
-    ProtocolAdapterError, ResponseCacheScope, RuntimeRequestContext, SharedProtocolAdapter,
-    WindowExecutionResult,
+    AdapterRegistry, AdapterResponse, ExecutionMode, MeteringContext, PreparedRequest,
+    ProtocolAdapter, ProtocolAdapterError, ResponseCacheScope, RuntimeRequestContext,
+    SharedProtocolAdapter,
 };
 pub use ext::tenancy::{
     SharedTenantController, SingleTenantController, TenancyError, TenantController,
     TenantResolutionContext,
 };
 pub use ids::{
-    AgentId, AsyncJobId, AuditEventId, AuthProfileId, DescriptorId, InvitationId, InvocationLogId,
-    OperationId, PlatformApiKeyId, SampleId, SecretId, StreamSessionId, TenantId, ToolId, UserId,
-    UserSessionId, WorkspaceId,
+    AgentId, AuditEventId, AuthProfileId, DescriptorId, InvitationId, InvocationLogId, OperationId,
+    PlatformApiKeyId, SampleId, SecretId, TenantId, ToolId, UserId, UserSessionId, WorkspaceId,
 };
 pub use observability::{
     InvocationLevel, InvocationLog, InvocationSource, InvocationStatus, UsagePeriod, UsageRollup,
 };
 pub use operation::{
-    ConfigExport, ExecutionConfig, GeneratedDraft, GeneratedDraftStatus, GraphqlTarget,
-    GrpcProtocolOptions, GrpcTarget, Operation, OperationStatus, ProtocolOptions,
-    ResponseCachePolicy, RestTarget, RetryPolicy, Samples, SoapProtocolOptions, SoapTarget, Target,
-    ToolDescription, ToolExample, WebsocketProtocolOptions, WebsocketTarget, WizardState,
+    ConfigExport, ExecutionConfig, GeneratedDraft, GeneratedDraftStatus, Operation,
+    OperationStatus, ResponseCachePolicy, RestTarget, RetryPolicy, Samples, Target,
+    ToolDescription, ToolExample, WizardState,
 };
-pub use protocol::{AuthKind, ExportMode, GraphqlOperationType, HttpMethod, Protocol};
+pub use protocol::{AuthKind, ExportMode, HttpMethod, Protocol};
 pub use secret::{Secret, SecretKind, SecretStatus, SecretVersion};
-pub use soap::{
-    SoapBindingStyle, SoapFaultContract, SoapHeaderConfig, SoapOperationMetadata, SoapVersion,
-};
-pub use stream_session::{AsyncJobHandle, JobStatus, StreamSession, StreamStatus};
-pub use streaming::{
-    AggregationMode, ExecutionMode, StreamingConfig, StreamingConfigError, ToolFamilyConfig,
-    TransportBehavior,
-};
 pub use workspace::{Workspace, WorkspaceStatus};

crates/crank-core/src/operation.rs

@@ -6,12 +6,8 @@ use time::OffsetDateTime;
 
 use crate::{
     edition::OperationSecurityLevel,
-    ids::{AuthProfileId, DescriptorId, OperationId, SampleId},
-    protocol::{ExportMode, GraphqlOperationType, HttpMethod, Protocol},
-    soap::{
-        SoapBindingStyle, SoapFaultContract, SoapHeaderConfig, SoapOperationMetadata, SoapVersion,
-    },
-    streaming::StreamingConfig,
+    ids::{AuthProfileId, OperationId, SampleId},
+    protocol::{ExportMode, HttpMethod, Protocol},
 };
 
 fn default_operation_category() -> String {
@@ -40,68 +36,10 @@ pub struct RestTarget {
     pub static_headers: BTreeMap<String, String>,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct GraphqlTarget {
-    pub endpoint: String,
-    pub operation_type: GraphqlOperationType,
-    pub operation_name: String,
-    pub query_template: String,
-    pub response_path: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct GrpcTarget {
-    pub server_addr: String,
-    pub package: String,
-    pub service: String,
-    pub method: String,
-    #[serde(default)]
-    pub read_only: bool,
-    pub descriptor_ref: DescriptorId,
-    pub descriptor_set_b64: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct WebsocketTarget {
-    pub url: String,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub subprotocols: Vec<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub subscribe_message_template: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub unsubscribe_message_template: Option<Value>,
-    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
-    pub static_headers: BTreeMap<String, String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SoapTarget {
-    pub wsdl_ref: SampleId,
-    pub service_name: String,
-    pub port_name: String,
-    pub operation_name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub endpoint_override: Option<String>,
-    pub soap_version: SoapVersion,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub soap_action: Option<String>,
-    pub binding_style: SoapBindingStyle,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub headers: Vec<SoapHeaderConfig>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub fault_contract: Option<SoapFaultContract>,
-    #[serde(default)]
-    pub metadata: SoapOperationMetadata,
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(tag = "kind", rename_all = "snake_case")]
 pub enum Target {
     Rest(RestTarget),
-    Graphql(GraphqlTarget),
-    Grpc(GrpcTarget),
-    Websocket(WebsocketTarget),
-    Soap(SoapTarget),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
@@ -114,41 +52,6 @@ pub struct ResponseCachePolicy {
     pub ttl_ms: u64,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct GrpcProtocolOptions {
-    pub use_tls: bool,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct WebsocketProtocolOptions {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub heartbeat_interval_ms: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub reconnect_max_attempts: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub reconnect_backoff_ms: Option<u64>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct SoapProtocolOptions {
-    #[serde(default)]
-    pub use_tls: bool,
-    #[serde(default)]
-    pub validate_certificate: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ws_security_profile: Option<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct ProtocolOptions {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub grpc: Option<GrpcProtocolOptions>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub websocket: Option<WebsocketProtocolOptions>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub soap: Option<SoapProtocolOptions>,
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ExecutionConfig {
     pub timeout_ms: u64,
@@ -160,10 +63,6 @@ pub struct ExecutionConfig {
     pub auth_profile_ref: Option<AuthProfileId>,
     #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
     pub headers: BTreeMap<String, String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub protocol_options: Option<ProtocolOptions>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub streaming: Option<StreamingConfig>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -187,10 +86,6 @@ pub struct Samples {
     pub input_json_sample_ref: Option<SampleId>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub output_json_sample_ref: Option<SampleId>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub proto_file_ref: Option<SampleId>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub descriptor_ref: Option<DescriptorId>,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -301,17 +196,12 @@ mod tests {
     use crate::{
         auth::{AuthConfig, AuthProfile, BearerAuthConfig},
         edition::OperationSecurityLevel,
-        ids::{AuthProfileId, OperationId, SampleId},
+        ids::{AuthProfileId, OperationId},
         operation::{
-            ConfigExport, ExecutionConfig, GraphqlTarget, Operation, OperationStatus,
-            ProtocolOptions, RestTarget, Samples, SoapProtocolOptions, SoapTarget, Target,
-            ToolDescription, ToolExample, WebsocketProtocolOptions, WebsocketTarget,
-        },
-        protocol::{AuthKind, ExportMode, GraphqlOperationType, HttpMethod, Protocol},
-        soap::{
-            SoapBindingStyle, SoapFaultContract, SoapHeaderConfig, SoapOperationMetadata,
-            SoapVersion,
+            ConfigExport, ExecutionConfig, Operation, OperationStatus, RestTarget, Samples, Target,
+            ToolDescription, ToolExample,
         },
+        protocol::{AuthKind, ExportMode, HttpMethod, Protocol},
     };
 
     fn timestamp(value: &str) -> OffsetDateTime {
@@ -333,132 +223,9 @@ mod tests {
         assert_eq!(value["method"], "POST");
     }
 
-    #[test]
-    fn graphql_target_serializes_response_path() {
-        let target = Target::Graphql(GraphqlTarget {
-            endpoint: "https://api.example.com/graphql".to_owned(),
-            operation_type: GraphqlOperationType::Mutation,
-            operation_name: "CreateLead".to_owned(),
-            query_template: "mutation {}".to_owned(),
-            response_path: "$.response.body.data.createLead".to_owned(),
-        });
-
-        let value = serde_json::to_value(target).unwrap();
-
-        assert_eq!(value["kind"], "graphql");
-        assert_eq!(value["operation_type"], "mutation");
-    }
-
-    #[test]
-    fn websocket_target_serializes_templates() {
-        let target = Target::Websocket(WebsocketTarget {
-            url: "wss://events.example.com/stream".to_owned(),
-            subprotocols: vec!["graphql-transport-ws".to_owned()],
-            subscribe_message_template: Some(json!({ "type": "subscribe" })),
-            unsubscribe_message_template: Some(json!({ "type": "unsubscribe" })),
-            static_headers: BTreeMap::from([("x-env".to_owned(), "test".to_owned())]),
-        });
-
-        let value = serde_json::to_value(target).unwrap();
-
-        assert_eq!(value["kind"], "websocket");
-        assert_eq!(value["subprotocols"][0], "graphql-transport-ws");
-        assert_eq!(value["subscribe_message_template"]["type"], "subscribe");
-    }
-
-    #[test]
-    fn soap_target_serializes_binding_metadata() {
-        let target = Target::Soap(SoapTarget {
-            wsdl_ref: SampleId::new("sample_wsdl_01"),
-            service_name: "LeadService".to_owned(),
-            port_name: "LeadPort".to_owned(),
-            operation_name: "CreateLead".to_owned(),
-            endpoint_override: Some("https://soap.example.com/lead".to_owned()),
-            soap_version: SoapVersion::Soap12,
-            soap_action: Some("urn:createLead".to_owned()),
-            binding_style: SoapBindingStyle::DocumentLiteral,
-            headers: vec![SoapHeaderConfig {
-                name: "CorrelationId".to_owned(),
-                namespace_uri: Some("urn:crm".to_owned()),
-                required: true,
-                value_path: Some("$.mcp.correlation_id".to_owned()),
-            }],
-            fault_contract: Some(SoapFaultContract {
-                code_path: Some("$.Envelope.Body.Fault.Code.Value".to_owned()),
-                message_path: Some("$.Envelope.Body.Fault.Reason.Text".to_owned()),
-                detail_path: Some("$.Envelope.Body.Fault.Detail".to_owned()),
-            }),
-            metadata: SoapOperationMetadata {
-                input_part_names: vec!["LeadRequest".to_owned()],
-                output_part_names: vec!["LeadResponse".to_owned()],
-                namespaces: vec!["urn:crm".to_owned()],
-            },
-        });
-
-        let value = serde_json::to_value(target).unwrap();
-
-        assert_eq!(value["kind"], "soap");
-        assert_eq!(value["soap_version"], "soap_12");
-        assert_eq!(value["binding_style"], "document_literal");
-        assert_eq!(value["metadata"]["input_part_names"][0], "LeadRequest");
-    }
-
     #[test]
     fn operation_exposes_local_domain_helpers() {
-        let operation = Operation {
-            id: OperationId::new("op_01"),
-            name: "crm_create_lead".to_owned(),
-            display_name: "Create Lead".to_owned(),
-            category: "sales".to_owned(),
-            protocol: Protocol::Rest,
-            security_level: OperationSecurityLevel::Standard,
-            status: OperationStatus::Draft,
-            version: 1,
-            target: Target::Rest(RestTarget {
-                base_url: "https://api.example.com".to_owned(),
-                method: HttpMethod::Post,
-                path_template: "/v1/leads".to_owned(),
-                static_headers: BTreeMap::new(),
-            }),
-            input_schema: json!({"type":"object"}),
-            output_schema: json!({"type":"object"}),
-            input_mapping: json!({"rules":[]}),
-            output_mapping: json!({"rules":[]}),
-            execution_config: ExecutionConfig {
-                timeout_ms: 10_000,
-                retry_policy: None,
-                response_cache: None,
-                auth_profile_ref: Some(AuthProfileId::new("auth_01")),
-                headers: BTreeMap::new(),
-                protocol_options: Some(ProtocolOptions {
-                    grpc: None,
-                    websocket: Some(WebsocketProtocolOptions {
-                        heartbeat_interval_ms: Some(5_000),
-                        reconnect_max_attempts: Some(3),
-                        reconnect_backoff_ms: Some(250),
-                    }),
-                    soap: Some(SoapProtocolOptions {
-                        use_tls: true,
-                        validate_certificate: true,
-                        ws_security_profile: Some("username_token".to_owned()),
-                    }),
-                }),
-                streaming: None,
-            },
-            tool_description: ToolDescription {
-                title: "Create CRM lead".to_owned(),
-                description: "Creates a new lead.".to_owned(),
-                tags: Vec::new(),
-                examples: Vec::new(),
-            },
-            samples: Some(Samples::default()),
-            generated_draft: None,
-            config_export: None,
-            wizard_state: None,
-            created_at: timestamp("2026-03-25T08:00:00Z"),
-            updated_at: timestamp("2026-03-25T08:00:00Z"),
-            published_at: None,
-        };
+        let operation = test_operation(OperationStatus::Draft);
 
         assert_eq!(operation.tool_name(), "crm_create_lead");
         assert!(operation.is_draft());
@@ -497,51 +264,14 @@ mod tests {
     #[test]
     fn operation_roundtrips_through_yaml() {
         let operation = Operation {
-            id: OperationId::new("op_01"),
-            name: "crm_create_lead".to_owned(),
-            display_name: "Create Lead".to_owned(),
-            category: "sales".to_owned(),
-            protocol: Protocol::Rest,
-            security_level: OperationSecurityLevel::Standard,
             status: OperationStatus::Published,
             version: 3,
-            target: Target::Rest(RestTarget {
-                base_url: "https://api.example.com".to_owned(),
-                method: HttpMethod::Post,
-                path_template: "/v1/leads".to_owned(),
-                static_headers: BTreeMap::from([("X-App-Source".to_owned(), "crank".to_owned())]),
-            }),
-            input_schema: json!({"type":"object","fields":{"email":{"type":"string","required":true}}}),
-            output_schema: json!({"type":"object","fields":{"id":{"type":"string","required":true}}}),
-            input_mapping: json!({"rules":[{"source":"$.mcp.email","target":"$.request.body.email"}]}),
-            output_mapping: json!({"rules":[{"source":"$.response.body.id","target":"$.output.id"}]}),
-            execution_config: ExecutionConfig {
-                timeout_ms: 10_000,
-                retry_policy: None,
-                response_cache: None,
-                auth_profile_ref: Some(AuthProfileId::new("auth_01")),
-                headers: BTreeMap::new(),
-                protocol_options: Some(ProtocolOptions::default()),
-                streaming: None,
-            },
-            tool_description: ToolDescription {
-                title: "Create CRM lead".to_owned(),
-                description: "Creates a new lead.".to_owned(),
-                tags: vec!["crm".to_owned()],
-                examples: vec![ToolExample {
-                    input: json!({"email":"user@example.com"}),
-                }],
-            },
-            samples: Some(Samples::default()),
-            generated_draft: None,
             config_export: Some(ConfigExport {
                 format_version: "1".to_owned(),
                 export_mode: ExportMode::Portable,
             }),
-            wizard_state: None,
-            created_at: timestamp("2026-03-25T08:00:00Z"),
-            updated_at: timestamp("2026-03-25T08:10:00Z"),
             published_at: Some(timestamp("2026-03-25T08:15:00Z")),
+            ..test_operation(OperationStatus::Draft)
         };
 
         let yaml = serde_yaml::to_string(&operation).unwrap();
@@ -597,4 +327,49 @@ updated_at: 2026-03-25T08:10:00Z
         assert_eq!(restored.security_level, OperationSecurityLevel::Standard);
         assert_eq!(restored.published_at, None);
     }
+
+    fn test_operation(status: OperationStatus) -> Operation<serde_json::Value, serde_json::Value> {
+        Operation {
+            id: OperationId::new("op_01"),
+            name: "crm_create_lead".to_owned(),
+            display_name: "Create Lead".to_owned(),
+            category: "sales".to_owned(),
+            protocol: Protocol::Rest,
+            security_level: OperationSecurityLevel::Standard,
+            status,
+            version: 1,
+            target: Target::Rest(RestTarget {
+                base_url: "https://api.example.com".to_owned(),
+                method: HttpMethod::Post,
+                path_template: "/v1/leads".to_owned(),
+                static_headers: BTreeMap::new(),
+            }),
+            input_schema: json!({"type":"object","fields":{"email":{"type":"string","required":true}}}),
+            output_schema: json!({"type":"object","fields":{"id":{"type":"string","required":true}}}),
+            input_mapping: json!({"rules":[{"source":"$.mcp.email","target":"$.request.body.email"}]}),
+            output_mapping: json!({"rules":[{"source":"$.response.body.id","target":"$.output.id"}]}),
+            execution_config: ExecutionConfig {
+                timeout_ms: 10_000,
+                retry_policy: None,
+                response_cache: None,
+                auth_profile_ref: Some(AuthProfileId::new("auth_01")),
+                headers: BTreeMap::new(),
+            },
+            tool_description: ToolDescription {
+                title: "Create CRM lead".to_owned(),
+                description: "Creates a new lead.".to_owned(),
+                tags: vec!["crm".to_owned()],
+                examples: vec![ToolExample {
+                    input: json!({"email":"user@example.com"}),
+                }],
+            },
+            samples: Some(Samples::default()),
+            generated_draft: None,
+            config_export: None,
+            wizard_state: None,
+            created_at: timestamp("2026-03-25T08:00:00Z"),
+            updated_at: timestamp("2026-03-25T08:10:00Z"),
+            published_at: None,
+        }
+    }
 }

crates/crank-core/src/protocol.rs

@@ -1,15 +1,9 @@
 use serde::{Deserialize, Serialize};
 
-use crate::streaming::{ExecutionMode, TransportBehavior};
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum Protocol {
     Rest,
-    Graphql,
-    Grpc,
-    Websocket,
-    Soap,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -22,13 +16,6 @@ pub enum HttpMethod {
     Delete,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum GraphqlOperationType {
-    Query,
-    Mutation,
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum AuthKind {
@@ -44,73 +31,3 @@ pub enum ExportMode {
     Portable,
     Bundle,
 }
-
-impl Protocol {
-    pub fn supports_execution_mode(self, mode: ExecutionMode) -> bool {
-        match self {
-            Self::Rest => true,
-            Self::Graphql => matches!(mode, ExecutionMode::Unary),
-            Self::Grpc => true,
-            Self::Websocket => !matches!(mode, ExecutionMode::Unary),
-            Self::Soap => matches!(mode, ExecutionMode::Unary | ExecutionMode::AsyncJob),
-        }
-    }
-
-    pub fn supports_transport_behavior(self, behavior: TransportBehavior) -> bool {
-        match self {
-            Self::Rest => true,
-            Self::Graphql => matches!(behavior, TransportBehavior::RequestResponse),
-            Self::Grpc => !matches!(behavior, TransportBehavior::DeferredResult),
-            Self::Websocket => !matches!(behavior, TransportBehavior::RequestResponse),
-            Self::Soap => !matches!(behavior, TransportBehavior::StatefulSession),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Protocol;
-    use crate::streaming::{ExecutionMode, TransportBehavior};
-
-    #[test]
-    fn graphql_support_matrix_is_restricted() {
-        assert!(Protocol::Graphql.supports_execution_mode(ExecutionMode::Unary));
-        assert!(!Protocol::Graphql.supports_execution_mode(ExecutionMode::Window));
-        assert!(!Protocol::Graphql.supports_execution_mode(ExecutionMode::Session));
-        assert!(!Protocol::Graphql.supports_transport_behavior(TransportBehavior::ServerStream));
-    }
-
-    #[test]
-    fn grpc_supports_session_but_not_deferred_result() {
-        assert!(Protocol::Grpc.supports_execution_mode(ExecutionMode::Session));
-        assert!(!Protocol::Grpc.supports_transport_behavior(TransportBehavior::DeferredResult));
-    }
-
-    #[test]
-    fn websocket_requires_streaming_modes() {
-        assert!(!Protocol::Websocket.supports_execution_mode(ExecutionMode::Unary));
-        assert!(Protocol::Websocket.supports_execution_mode(ExecutionMode::Window));
-        assert!(Protocol::Websocket.supports_execution_mode(ExecutionMode::Session));
-        assert!(Protocol::Websocket.supports_execution_mode(ExecutionMode::AsyncJob));
-        assert!(
-            !Protocol::Websocket.supports_transport_behavior(TransportBehavior::RequestResponse)
-        );
-        assert!(Protocol::Websocket.supports_transport_behavior(TransportBehavior::ServerStream));
-        assert!(
-            Protocol::Websocket.supports_transport_behavior(TransportBehavior::StatefulSession)
-        );
-        assert!(Protocol::Websocket.supports_transport_behavior(TransportBehavior::DeferredResult));
-    }
-
-    #[test]
-    fn soap_is_request_response_first_with_async_job_support() {
-        assert!(Protocol::Soap.supports_execution_mode(ExecutionMode::Unary));
-        assert!(!Protocol::Soap.supports_execution_mode(ExecutionMode::Window));
-        assert!(!Protocol::Soap.supports_execution_mode(ExecutionMode::Session));
-        assert!(Protocol::Soap.supports_execution_mode(ExecutionMode::AsyncJob));
-        assert!(Protocol::Soap.supports_transport_behavior(TransportBehavior::RequestResponse));
-        assert!(Protocol::Soap.supports_transport_behavior(TransportBehavior::ServerStream));
-        assert!(!Protocol::Soap.supports_transport_behavior(TransportBehavior::StatefulSession));
-        assert!(Protocol::Soap.supports_transport_behavior(TransportBehavior::DeferredResult));
-    }
-}

crates/crank-core/src/soap.rs

@@ -1,101 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub enum SoapVersion {
-    #[serde(rename = "soap_11")]
-    Soap11,
-    #[serde(rename = "soap_12")]
-    Soap12,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum SoapBindingStyle {
-    DocumentLiteral,
-    RpcLiteral,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SoapHeaderConfig {
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub namespace_uri: Option<String>,
-    pub required: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub value_path: Option<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SoapFaultContract {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub code_path: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub message_path: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub detail_path: Option<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct SoapOperationMetadata {
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub input_part_names: Vec<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub output_part_names: Vec<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub namespaces: Vec<String>,
-}
-
-#[cfg(test)]
-mod tests {
-    use serde_json::json;
-
-    use super::{
-        SoapBindingStyle, SoapFaultContract, SoapHeaderConfig, SoapOperationMetadata, SoapVersion,
-    };
-
-    #[test]
-    fn soap_metadata_serializes_compactly() {
-        let value = serde_json::to_value(SoapOperationMetadata {
-            input_part_names: vec!["LeadRequest".to_owned()],
-            output_part_names: vec!["LeadResponse".to_owned()],
-            namespaces: vec!["urn:crm".to_owned()],
-        })
-        .unwrap();
-
-        assert_eq!(value["input_part_names"][0], "LeadRequest");
-        assert_eq!(value["output_part_names"][0], "LeadResponse");
-        assert_eq!(value["namespaces"][0], "urn:crm");
-    }
-
-    #[test]
-    fn soap_supporting_types_roundtrip() {
-        let value = json!({
-            "version": "soap_12",
-            "style": "document_literal",
-            "header": {
-                "name": "CorrelationId",
-                "namespace_uri": "urn:crm",
-                "required": true,
-                "value_path": "$.mcp.correlation_id"
-            },
-            "fault": {
-                "code_path": "$.Envelope.Body.Fault.Code.Value",
-                "message_path": "$.Envelope.Body.Fault.Reason.Text",
-                "detail_path": "$.Envelope.Body.Fault.Detail"
-            }
-        });
-
-        let version: SoapVersion = serde_json::from_value(value["version"].clone()).unwrap();
-        let style: SoapBindingStyle = serde_json::from_value(value["style"].clone()).unwrap();
-        let header: SoapHeaderConfig = serde_json::from_value(value["header"].clone()).unwrap();
-        let fault: SoapFaultContract = serde_json::from_value(value["fault"].clone()).unwrap();
-
-        assert_eq!(version, SoapVersion::Soap12);
-        assert_eq!(style, SoapBindingStyle::DocumentLiteral);
-        assert_eq!(header.name, "CorrelationId");
-        assert_eq!(
-            fault.detail_path.as_deref(),
-            Some("$.Envelope.Body.Fault.Detail")
-        );
-    }
-}

crates/crank-core/src/stream_session.rs

@@ -1,318 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use time::OffsetDateTime;
-
-use crate::{
-    ids::{AgentId, AsyncJobId, OperationId, StreamSessionId, WorkspaceId},
-    protocol::Protocol,
-    streaming::ExecutionMode,
-};
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum StreamStatus {
-    Created,
-    Running,
-    Stopped,
-    Failed,
-    Expired,
-}
-
-impl StreamStatus {
-    pub fn is_terminal(self) -> bool {
-        matches!(self, Self::Stopped | Self::Failed | Self::Expired)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct StreamSession {
-    pub id: StreamSessionId,
-    pub workspace_id: WorkspaceId,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub agent_id: Option<AgentId>,
-    pub operation_id: OperationId,
-    pub protocol: Protocol,
-    pub mode: ExecutionMode,
-    pub status: StreamStatus,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cursor: Option<Value>,
-    pub state: Value,
-    #[serde(with = "time::serde::rfc3339")]
-    pub expires_at: OffsetDateTime,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(with = "time::serde::rfc3339::option")]
-    pub last_poll_at: Option<OffsetDateTime>,
-    #[serde(with = "time::serde::rfc3339")]
-    pub created_at: OffsetDateTime,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(with = "time::serde::rfc3339::option")]
-    pub closed_at: Option<OffsetDateTime>,
-}
-
-impl StreamSession {
-    pub fn is_expired(&self, now: OffsetDateTime) -> bool {
-        self.expires_at <= now
-    }
-
-    pub fn can_poll(&self, now: OffsetDateTime) -> bool {
-        !self.status.is_terminal() && !self.is_expired(now)
-    }
-
-    pub fn remaining_poll_delay_ms(&self, now: OffsetDateTime, poll_interval_ms: u64) -> u64 {
-        let Some(last_poll_at) = self.last_poll_at else {
-            return 0;
-        };
-
-        let elapsed_ms = (now - last_poll_at).whole_milliseconds().max(0) as u64;
-        poll_interval_ms.saturating_sub(elapsed_ms)
-    }
-
-    pub fn mark_polled(&mut self, now: OffsetDateTime) {
-        self.last_poll_at = Some(now);
-    }
-
-    pub fn mark_closed(&mut self, now: OffsetDateTime) {
-        self.status = StreamStatus::Stopped;
-        self.last_poll_at = Some(now);
-        self.closed_at = Some(now);
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum JobStatus {
-    Created,
-    Running,
-    Completed,
-    Failed,
-    Cancelled,
-    Expired,
-}
-
-impl JobStatus {
-    pub fn is_terminal(self) -> bool {
-        matches!(
-            self,
-            Self::Completed | Self::Failed | Self::Cancelled | Self::Expired
-        )
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct AsyncJobHandle {
-    pub id: AsyncJobId,
-    pub workspace_id: WorkspaceId,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub agent_id: Option<AgentId>,
-    pub operation_id: OperationId,
-    pub status: JobStatus,
-    pub progress: Value,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub result: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(with = "time::serde::rfc3339::option")]
-    pub expires_at: Option<OffsetDateTime>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(with = "time::serde::rfc3339::option")]
-    pub last_poll_at: Option<OffsetDateTime>,
-    #[serde(with = "time::serde::rfc3339")]
-    pub created_at: OffsetDateTime,
-    #[serde(with = "time::serde::rfc3339")]
-    pub updated_at: OffsetDateTime,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(with = "time::serde::rfc3339::option")]
-    pub finished_at: Option<OffsetDateTime>,
-}
-
-impl AsyncJobHandle {
-    pub fn is_finished(&self) -> bool {
-        self.status.is_terminal()
-    }
-
-    pub fn can_cancel(&self) -> bool {
-        matches!(self.status, JobStatus::Created | JobStatus::Running)
-    }
-
-    pub fn remaining_poll_delay_ms(&self, now: OffsetDateTime, poll_interval_ms: u64) -> u64 {
-        let Some(last_poll_at) = self.last_poll_at else {
-            return 0;
-        };
-
-        let elapsed_ms = (now - last_poll_at).whole_milliseconds().max(0) as u64;
-        poll_interval_ms.saturating_sub(elapsed_ms)
-    }
-
-    pub fn mark_finished(&mut self, now: OffsetDateTime, result: Value) {
-        self.status = JobStatus::Completed;
-        self.result = Some(result);
-        self.error = None;
-        self.updated_at = now;
-        self.finished_at = Some(now);
-    }
-
-    pub fn mark_failed(&mut self, now: OffsetDateTime, error: Value) {
-        self.status = JobStatus::Failed;
-        self.error = Some(error);
-        self.updated_at = now;
-        self.finished_at = Some(now);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use serde_json::json;
-    use time::{OffsetDateTime, format_description::well_known::Rfc3339};
-
-    use super::{AsyncJobHandle, JobStatus, StreamSession, StreamStatus};
-    use crate::{
-        ids::{AsyncJobId, OperationId, StreamSessionId, WorkspaceId},
-        protocol::Protocol,
-        streaming::ExecutionMode,
-    };
-
-    fn timestamp(value: &str) -> OffsetDateTime {
-        OffsetDateTime::parse(value, &Rfc3339).unwrap()
-    }
-
-    #[test]
-    fn stream_session_tracks_poll_and_close_transitions() {
-        let mut session = StreamSession {
-            id: StreamSessionId::new("stream_01"),
-            workspace_id: WorkspaceId::new("ws_01"),
-            agent_id: None,
-            operation_id: OperationId::new("op_01"),
-            protocol: Protocol::Rest,
-            mode: ExecutionMode::Session,
-            status: StreamStatus::Running,
-            cursor: None,
-            state: json!({"cursor":"abc"}),
-            expires_at: timestamp("2026-04-06T12:05:00Z"),
-            last_poll_at: None,
-            created_at: timestamp("2026-04-06T12:00:00Z"),
-            closed_at: None,
-        };
-
-        assert!(session.can_poll(timestamp("2026-04-06T12:01:00Z")));
-
-        session.mark_polled(timestamp("2026-04-06T12:01:00Z"));
-        session.mark_closed(timestamp("2026-04-06T12:02:00Z"));
-
-        assert_eq!(session.status, StreamStatus::Stopped);
-        assert_eq!(session.closed_at, Some(timestamp("2026-04-06T12:02:00Z")));
-        assert!(!session.can_poll(timestamp("2026-04-06T12:03:00Z")));
-    }
-
-    #[test]
-    fn first_poll_has_no_required_delay() {
-        let session = StreamSession {
-            id: StreamSessionId::new("stream_01"),
-            workspace_id: WorkspaceId::new("ws_01"),
-            agent_id: None,
-            operation_id: OperationId::new("op_01"),
-            protocol: Protocol::Rest,
-            mode: ExecutionMode::Session,
-            status: StreamStatus::Running,
-            cursor: None,
-            state: json!({"cursor":"abc"}),
-            expires_at: timestamp("2026-04-06T12:05:00Z"),
-            last_poll_at: None,
-            created_at: timestamp("2026-04-06T12:00:00Z"),
-            closed_at: None,
-        };
-
-        assert_eq!(
-            session.remaining_poll_delay_ms(timestamp("2026-04-06T12:00:00.100Z"), 250),
-            0
-        );
-    }
-
-    #[test]
-    fn rapid_repeat_poll_reports_remaining_delay() {
-        let session = StreamSession {
-            id: StreamSessionId::new("stream_01"),
-            workspace_id: WorkspaceId::new("ws_01"),
-            agent_id: None,
-            operation_id: OperationId::new("op_01"),
-            protocol: Protocol::Rest,
-            mode: ExecutionMode::Session,
-            status: StreamStatus::Running,
-            cursor: None,
-            state: json!({"cursor":"abc"}),
-            expires_at: timestamp("2026-04-06T12:05:00Z"),
-            last_poll_at: Some(timestamp("2026-04-06T12:01:00Z")),
-            created_at: timestamp("2026-04-06T12:00:00Z"),
-            closed_at: None,
-        };
-
-        assert_eq!(
-            session.remaining_poll_delay_ms(timestamp("2026-04-06T12:01:00.100Z"), 250),
-            150
-        );
-    }
-
-    #[test]
-    fn async_job_tracks_finish_and_failure() {
-        let mut job = AsyncJobHandle {
-            id: AsyncJobId::new("job_01"),
-            workspace_id: WorkspaceId::new("ws_01"),
-            agent_id: None,
-            operation_id: OperationId::new("op_01"),
-            status: JobStatus::Running,
-            progress: json!({"percent": 60}),
-            result: None,
-            error: None,
-            expires_at: Some(timestamp("2026-04-06T12:05:00Z")),
-            last_poll_at: None,
-            created_at: timestamp("2026-04-06T12:00:00Z"),
-            updated_at: timestamp("2026-04-06T12:00:00Z"),
-            finished_at: None,
-        };
-
-        assert!(job.can_cancel());
-
-        job.mark_finished(timestamp("2026-04-06T12:01:00Z"), json!({"ok": true}));
-        assert!(job.is_finished());
-        assert_eq!(job.status, JobStatus::Completed);
-
-        let mut failed_job = job.clone();
-        failed_job.status = JobStatus::Running;
-        failed_job.result = None;
-        failed_job.finished_at = None;
-
-        failed_job.mark_failed(
-            timestamp("2026-04-06T12:02:00Z"),
-            json!({"message": "boom"}),
-        );
-        assert_eq!(failed_job.status, JobStatus::Failed);
-        assert_eq!(
-            failed_job.finished_at,
-            Some(timestamp("2026-04-06T12:02:00Z"))
-        );
-    }
-
-    #[test]
-    fn async_job_reports_remaining_poll_delay() {
-        let job = AsyncJobHandle {
-            id: AsyncJobId::new("job_01"),
-            workspace_id: WorkspaceId::new("ws_01"),
-            agent_id: None,
-            operation_id: OperationId::new("op_01"),
-            status: JobStatus::Running,
-            progress: json!({"percent": 60}),
-            result: None,
-            error: None,
-            expires_at: Some(timestamp("2026-04-06T12:05:00Z")),
-            last_poll_at: Some(timestamp("2026-04-06T12:01:00Z")),
-            created_at: timestamp("2026-04-06T12:00:00Z"),
-            updated_at: timestamp("2026-04-06T12:00:00Z"),
-            finished_at: None,
-        };
-
-        assert_eq!(
-            job.remaining_poll_delay_ms(timestamp("2026-04-06T12:01:00.100Z"), 250),
-            150
-        );
-    }
-}

crates/crank-core/src/streaming.rs

@@ -1,364 +0,0 @@
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-use crate::protocol::Protocol;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum ExecutionMode {
-    Unary,
-    Window,
-    Session,
-    AsyncJob,
-}
-
-impl ExecutionMode {
-    pub fn is_stateful(self) -> bool {
-        matches!(self, Self::Session | Self::AsyncJob)
-    }
-
-    pub fn requires_tool_family(self) -> bool {
-        self.is_stateful()
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum AggregationMode {
-    RawItems,
-    SummaryOnly,
-    SummaryPlusSamples,
-    Stats,
-    LatestState,
-}
-
-impl AggregationMode {
-    pub fn needs_items(self) -> bool {
-        matches!(self, Self::RawItems | Self::SummaryPlusSamples)
-    }
-
-    pub fn needs_summary(self) -> bool {
-        !matches!(self, Self::RawItems)
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum TransportBehavior {
-    RequestResponse,
-    ServerStream,
-    StatefulSession,
-    DeferredResult,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct ToolFamilyConfig {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub start_tool_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub poll_tool_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stop_tool_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub status_tool_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub result_tool_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cancel_tool_name: Option<String>,
-}
-
-impl ToolFamilyConfig {
-    pub fn validate_for_mode(&self, mode: ExecutionMode) -> Result<(), StreamingConfigError> {
-        match mode {
-            ExecutionMode::Unary | ExecutionMode::Window => {
-                if self.start_tool_name.is_some()
-                    || self.poll_tool_name.is_some()
-                    || self.stop_tool_name.is_some()
-                    || self.status_tool_name.is_some()
-                    || self.result_tool_name.is_some()
-                    || self.cancel_tool_name.is_some()
-                {
-                    return Err(StreamingConfigError::UnexpectedToolFamily(mode));
-                }
-            }
-            ExecutionMode::Session => {
-                if self.start_tool_name.is_none()
-                    || self.poll_tool_name.is_none()
-                    || self.stop_tool_name.is_none()
-                {
-                    return Err(StreamingConfigError::MissingSessionToolNames);
-                }
-            }
-            ExecutionMode::AsyncJob => {
-                if self.start_tool_name.is_none()
-                    || self.status_tool_name.is_none()
-                    || self.result_tool_name.is_none()
-                    || self.cancel_tool_name.is_none()
-                {
-                    return Err(StreamingConfigError::MissingAsyncJobToolNames);
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct StreamingConfig {
-    pub mode: ExecutionMode,
-    pub transport_behavior: TransportBehavior,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_duration_ms: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub poll_interval_ms: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub upstream_timeout_ms: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub idle_timeout_ms: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_session_lifetime_ms: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_items: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_bytes: Option<u32>,
-    pub aggregation_mode: AggregationMode,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub summary_path: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub items_path: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cursor_path: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub status_path: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub done_path: Option<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub redacted_paths: Vec<String>,
-    #[serde(default)]
-    pub truncate_item_fields: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_field_length: Option<u32>,
-    #[serde(default)]
-    pub drop_duplicates: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sampling_rate: Option<f64>,
-    #[serde(default)]
-    pub tool_family: ToolFamilyConfig,
-}
-
-impl StreamingConfig {
-    pub fn validate_common(&self) -> Result<(), StreamingConfigError> {
-        self.tool_family.validate_for_mode(self.mode)?;
-
-        if self.max_items.is_some_and(|value| value == 0) {
-            return Err(StreamingConfigError::InvalidMaxItems);
-        }
-
-        if self.max_bytes.is_some_and(|value| value == 0) {
-            return Err(StreamingConfigError::InvalidMaxBytes);
-        }
-
-        if self.max_field_length.is_some_and(|value| value == 0) {
-            return Err(StreamingConfigError::InvalidMaxFieldLength);
-        }
-
-        if self
-            .sampling_rate
-            .is_some_and(|value| value <= 0.0 || value > 1.0)
-        {
-            return Err(StreamingConfigError::InvalidSamplingRate);
-        }
-
-        match self.mode {
-            ExecutionMode::Unary => {
-                if self.window_duration_ms.is_some()
-                    || self.poll_interval_ms.is_some()
-                    || self.idle_timeout_ms.is_some()
-                    || self.max_session_lifetime_ms.is_some()
-                {
-                    return Err(StreamingConfigError::UnexpectedStatefulLimits(
-                        ExecutionMode::Unary,
-                    ));
-                }
-            }
-            ExecutionMode::Window => {
-                if self.window_duration_ms.is_none() {
-                    return Err(StreamingConfigError::MissingWindowDuration);
-                }
-            }
-            ExecutionMode::Session => {
-                if self.poll_interval_ms.is_none() || self.max_session_lifetime_ms.is_none() {
-                    return Err(StreamingConfigError::MissingSessionLimits);
-                }
-            }
-            ExecutionMode::AsyncJob => {}
-        }
-
-        Ok(())
-    }
-
-    pub fn validate_for_protocol(&self, protocol: Protocol) -> Result<(), StreamingConfigError> {
-        self.validate_common()?;
-
-        if !protocol.supports_execution_mode(self.mode) {
-            return Err(StreamingConfigError::UnsupportedExecutionMode {
-                protocol,
-                mode: self.mode,
-            });
-        }
-
-        if !protocol.supports_transport_behavior(self.transport_behavior) {
-            return Err(StreamingConfigError::UnsupportedTransportBehavior {
-                protocol,
-                behavior: self.transport_behavior,
-            });
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Clone, Debug, Error, PartialEq)]
-pub enum StreamingConfigError {
-    #[error("window mode requires window_duration_ms")]
-    MissingWindowDuration,
-    #[error("session mode requires poll_interval_ms and max_session_lifetime_ms")]
-    MissingSessionLimits,
-    #[error("max_items must be greater than zero")]
-    InvalidMaxItems,
-    #[error("max_bytes must be greater than zero")]
-    InvalidMaxBytes,
-    #[error("max_field_length must be greater than zero")]
-    InvalidMaxFieldLength,
-    #[error("sampling_rate must be in range (0, 1]")]
-    InvalidSamplingRate,
-    #[error("{0:?} mode cannot use session/window-only limits")]
-    UnexpectedStatefulLimits(ExecutionMode),
-    #[error("{mode:?} is not supported for protocol {protocol:?}")]
-    UnsupportedExecutionMode {
-        protocol: Protocol,
-        mode: ExecutionMode,
-    },
-    #[error("{behavior:?} is not supported for protocol {protocol:?}")]
-    UnsupportedTransportBehavior {
-        protocol: Protocol,
-        behavior: TransportBehavior,
-    },
-    #[error("session mode requires start, poll and stop tool names")]
-    MissingSessionToolNames,
-    #[error("async_job mode requires start, status, result and cancel tool names")]
-    MissingAsyncJobToolNames,
-    #[error("{0:?} mode cannot define tool-family names")]
-    UnexpectedToolFamily(ExecutionMode),
-}
-
-#[cfg(test)]
-mod tests {
-    use serde_json::json;
-
-    use super::{
-        AggregationMode, ExecutionMode, StreamingConfig, StreamingConfigError, ToolFamilyConfig,
-        TransportBehavior,
-    };
-    use crate::protocol::Protocol;
-
-    fn session_config() -> StreamingConfig {
-        StreamingConfig {
-            mode: ExecutionMode::Session,
-            transport_behavior: TransportBehavior::StatefulSession,
-            window_duration_ms: None,
-            poll_interval_ms: Some(1_000),
-            upstream_timeout_ms: Some(5_000),
-            idle_timeout_ms: Some(15_000),
-            max_session_lifetime_ms: Some(60_000),
-            max_items: Some(100),
-            max_bytes: Some(65_536),
-            aggregation_mode: AggregationMode::SummaryPlusSamples,
-            summary_path: Some("$.summary".to_owned()),
-            items_path: Some("$.items".to_owned()),
-            cursor_path: Some("$.cursor".to_owned()),
-            status_path: Some("$.status".to_owned()),
-            done_path: Some("$.done".to_owned()),
-            redacted_paths: vec!["$.items[*].token".to_owned()],
-            truncate_item_fields: true,
-            max_field_length: Some(256),
-            drop_duplicates: true,
-            sampling_rate: Some(0.5),
-            tool_family: ToolFamilyConfig {
-                start_tool_name: Some("logs_start".to_owned()),
-                poll_tool_name: Some("logs_poll".to_owned()),
-                stop_tool_name: Some("logs_stop".to_owned()),
-                status_tool_name: None,
-                result_tool_name: None,
-                cancel_tool_name: None,
-            },
-        }
-    }
-
-    #[test]
-    fn streaming_config_roundtrips_through_json() {
-        let config = session_config();
-
-        let value = serde_json::to_value(&config).unwrap();
-        let decoded: StreamingConfig = serde_json::from_value(value.clone()).unwrap();
-
-        assert_eq!(decoded, config);
-        assert_eq!(value["mode"], json!("session"));
-        assert_eq!(value["tool_family"]["start_tool_name"], json!("logs_start"));
-    }
-
-    #[test]
-    fn unary_mode_rejects_session_specific_fields() {
-        let config = StreamingConfig {
-            mode: ExecutionMode::Unary,
-            transport_behavior: TransportBehavior::RequestResponse,
-            window_duration_ms: None,
-            poll_interval_ms: Some(1_000),
-            upstream_timeout_ms: None,
-            idle_timeout_ms: None,
-            max_session_lifetime_ms: None,
-            max_items: None,
-            max_bytes: None,
-            aggregation_mode: AggregationMode::SummaryOnly,
-            summary_path: None,
-            items_path: None,
-            cursor_path: None,
-            status_path: None,
-            done_path: None,
-            redacted_paths: Vec::new(),
-            truncate_item_fields: false,
-            max_field_length: None,
-            drop_duplicates: false,
-            sampling_rate: None,
-            tool_family: ToolFamilyConfig::default(),
-        };
-
-        assert_eq!(
-            config.validate_common(),
-            Err(StreamingConfigError::UnexpectedStatefulLimits(
-                ExecutionMode::Unary
-            ))
-        );
-    }
-
-    #[test]
-    fn protocol_validation_rejects_graphql_session() {
-        let config = session_config();
-
-        assert_eq!(
-            config.validate_for_protocol(Protocol::Graphql),
-            Err(StreamingConfigError::UnsupportedExecutionMode {
-                protocol: Protocol::Graphql,
-                mode: ExecutionMode::Session,
-            })
-        );
-    }
-
-    #[test]
-    fn protocol_validation_accepts_rest_session() {
-        let config = session_config();
-
-        assert!(config.validate_for_protocol(Protocol::Rest).is_ok());
-    }
-}