feat: add grpc server streaming adapter

crates/crank-runtime/src/executor.rs

@@ -1,7 +1,7 @@
 use std::collections::BTreeMap;
 
 use crank_adapter_graphql::{GraphqlAdapter, GraphqlRequest};
-use crank_adapter_grpc::{GrpcAdapter, GrpcRequest};
+use crank_adapter_grpc::{GrpcAdapter, GrpcRequest, GrpcWindowRequest};
 use crank_adapter_rest::{RestAdapter, RestRequest, RestWindowRequest};
 use crank_core::{ExecutionMode, Target, TransportBehavior};
 use serde_json::{Map, Value, json};
@@ -63,7 +63,7 @@ impl RuntimeExecutor {
         let adapter_response = if matches!(
             streaming.transport_behavior,
             TransportBehavior::ServerStream
-        ) && matches!(operation.target, Target::Rest(_))
+        ) && matches!(operation.target, Target::Rest(_) | Target::Grpc(_))
         {
             self.execute_window_adapter(operation, prepared_request)
                 .await?
@@ -207,6 +207,39 @@ impl RuntimeExecutor {
                     data: Value::Null,
                 })
             }
+            Target::Grpc(target) => {
+                let Some(streaming) = operation.execution_config.streaming.as_ref() else {
+                    return Err(RuntimeError::MissingStreamingConfig {
+                        operation_id: operation.operation_id.as_str().to_owned(),
+                    });
+                };
+                let request = GrpcWindowRequest {
+                    request: GrpcRequest {
+                        headers: merge_headers(
+                            &BTreeMap::new(),
+                            &operation.execution_config.headers,
+                            &prepared_request.headers,
+                        ),
+                        body: prepared_request
+                            .grpc
+                            .clone()
+                            .unwrap_or(Value::Object(Map::new())),
+                        timeout_ms: streaming
+                            .upstream_timeout_ms
+                            .unwrap_or(operation.execution_config.timeout_ms),
+                    },
+                    window_duration_ms: streaming.window_duration_ms.unwrap_or_default(),
+                    max_items: streaming.max_items.map(|value| value.saturating_add(1)),
+                };
+                let response = self.grpc_adapter.execute_window(target, &request).await?;
+
+                Ok(AdapterResponse {
+                    status_code: response.status_code,
+                    headers: response.headers,
+                    body: response.body,
+                    data: Value::Null,
+                })
+            }
             _ => self.execute_adapter(operation, prepared_request).await,
         }
     }
@@ -377,6 +410,26 @@ mod tests {
         assert_eq!(output, json!({ "message": "hello" }));
     }
 
+    #[tokio::test]
+    async fn executes_grpc_window_mode_with_server_stream() {
+        let server_addr = grpc_test_support::spawn_unary_echo_server().await;
+        let executor = RuntimeExecutor::new();
+        let operation =
+            test_grpc_window_operation(&server_addr, AggregationMode::RawItems, Some(2));
+
+        let result = executor
+            .execute_window(&operation, &json!({ "message": "hello" }))
+            .await
+            .unwrap();
+
+        assert_eq!(result.summary, Value::Null);
+        assert_eq!(result.items.len(), 2);
+        assert_eq!(result.items[0], json!({ "message": "hello-one" }));
+        assert!(result.truncated);
+        assert!(result.has_more);
+        assert!(!result.window_complete);
+    }
+
     #[tokio::test]
     async fn rejects_invalid_input_shape() {
         let base_url = spawn_runtime_server().await;
@@ -898,6 +951,88 @@ mod tests {
         })
     }
 
+    fn test_grpc_window_operation(
+        server_addr: &str,
+        aggregation_mode: AggregationMode,
+        max_items: Option<u32>,
+    ) -> RuntimeOperation {
+        RuntimeOperation::from(Operation {
+            id: OperationId::new("op_grpc_window_runtime"),
+            name: "echo_stream_grpc".to_owned(),
+            display_name: "Server Stream Echo gRPC".to_owned(),
+            category: "support".to_owned(),
+            protocol: Protocol::Grpc,
+            status: OperationStatus::Published,
+            version: 1,
+            target: Target::Grpc(GrpcTarget {
+                server_addr: server_addr.to_owned(),
+                package: "echo".to_owned(),
+                service: "EchoService".to_owned(),
+                method: "ServerEcho".to_owned(),
+                descriptor_ref: DescriptorId::new("desc_echo"),
+                descriptor_set_b64: grpc_test_support::descriptor_set_b64(),
+            }),
+            input_schema: object_schema("message", SchemaKind::String),
+            output_schema: object_schema("ignored", SchemaKind::String),
+            input_mapping: MappingSet {
+                rules: vec![MappingRule {
+                    source: "$.mcp.message".to_owned(),
+                    target: "$.request.grpc.message".to_owned(),
+                    required: true,
+                    default_value: None,
+                    transform: None,
+                    condition: None,
+                    notes: None,
+                }],
+            },
+            output_mapping: MappingSet { rules: Vec::new() },
+            execution_config: ExecutionConfig {
+                timeout_ms: 1_000,
+                retry_policy: None,
+                auth_profile_ref: None,
+                headers: BTreeMap::new(),
+                protocol_options: None,
+                streaming: Some(StreamingConfig {
+                    mode: ExecutionMode::Window,
+                    transport_behavior: TransportBehavior::ServerStream,
+                    window_duration_ms: Some(3_000),
+                    poll_interval_ms: None,
+                    upstream_timeout_ms: Some(1_000),
+                    idle_timeout_ms: None,
+                    max_session_lifetime_ms: None,
+                    max_items,
+                    max_bytes: None,
+                    aggregation_mode,
+                    summary_path: None,
+                    items_path: Some("$.items".to_owned()),
+                    cursor_path: None,
+                    status_path: None,
+                    done_path: Some("$.done".to_owned()),
+                    redacted_paths: Vec::new(),
+                    truncate_item_fields: false,
+                    max_field_length: None,
+                    drop_duplicates: false,
+                    sampling_rate: None,
+                    tool_family: ToolFamilyConfig::default(),
+                }),
+            },
+            tool_description: ToolDescription {
+                title: "Server Stream Echo gRPC".to_owned(),
+                description: "Collects bounded gRPC stream messages.".to_owned(),
+                tags: vec!["grpc".to_owned(), "stream".to_owned()],
+                examples: vec![ToolExample {
+                    input: json!({ "message": "hello" }),
+                }],
+            },
+            samples: None,
+            generated_draft: None,
+            config_export: None,
+            created_at: "2026-04-06T12:00:00Z".to_owned(),
+            updated_at: "2026-04-06T12:00:00Z".to_owned(),
+            published_at: Some("2026-04-06T12:00:00Z".to_owned()),
+        })
+    }
+
     fn test_window_snapshot_operation(
         base_url: &str,
         aggregation_mode: AggregationMode,