Skip to main content

hyprstream_rpc_derive/codegen/
dispatch.rs

1//! Transport-agnostic JSON dispatch generation.
2//!
3//! Generates a standalone `dispatch()` async function that routes method calls
4//! by name, serializing JSON → Cap'n Proto → send → Cap'n Proto → JSON.
5//! Works on all targets (native + wasm32) with any send function.
6
7use proc_macro2::TokenStream;
8use quote::{format_ident, quote};
9
10use crate::resolve::ResolvedSchema;
11use crate::schema::types::*;
12use crate::util::*;
13
14/// Generate a portable dispatch function for a service.
15///
16/// The generated function has signature:
17/// ```ignore
18/// pub async fn dispatch<F, Fut>(
19///     method: &str,
20///     args_json: &str,
21///     request_id: u64,
22///     send: F,
23/// ) -> Result<String, String>
24/// where
25///     F: FnOnce(Vec<u8>) -> Fut,
26///     Fut: std::future::Future<Output = Result<Vec<u8>, String>>,
27/// ```
28pub fn generate_portable_dispatch(
29    service_name: &str,
30    resolved: &ResolvedSchema,
31    types_crate: Option<&syn::Path>,
32) -> TokenStream {
33    let pascal = to_pascal_case(service_name);
34    let response_type = format_ident!("{}ResponseVariant", pascal);
35    let capnp_mod_ident = format_ident!("{}_capnp", service_name);
36    let capnp_mod: TokenStream = match types_crate {
37        Some(tc) => quote! { #tc::#capnp_mod_ident },
38        None => quote! { crate::#capnp_mod_ident },
39    };
40    let req_type = format_ident!("{}", to_snake_case(&format!("{pascal}Request")));
41
42    let scoped_names: Vec<&str> = resolved
43        .raw
44        .scoped_clients
45        .iter()
46        .map(|sc| sc.factory_name.as_str())
47        .collect();
48
49    // Identify which methods are streaming.
50    // Top-level: response variant is "{name}Result" with type StreamInfo
51    // Scoped: response variant matches request name directly (no "Result" suffix)
52    let is_streaming =
53        |v: &UnionVariant, resp_variants: &[UnionVariant], is_scoped: bool| -> bool {
54            let result_name = if is_scoped {
55                v.name.clone()
56            } else {
57                format!("{}Result", v.name)
58            };
59            resp_variants
60                .iter()
61                .any(|r| r.name == result_name && r.type_name == "StreamInfo")
62        };
63
64    // Generate match arms for non-streaming, non-scoped methods
65    let dispatch_arms: Vec<TokenStream> = resolved
66        .raw
67        .request_variants
68        .iter()
69        .filter(|v| !scoped_names.contains(&v.name.as_str()))
70        .filter(|v| !v.cli_hidden)
71        .filter(|v| !is_streaming(v, &resolved.raw.response_variants, false))
72        .map(|v| generate_dispatch_arm(v, resolved, &capnp_mod, &req_type, &response_type))
73        .collect();
74
75    // Generate streaming dispatch arms (top-level)
76    let streaming_arms: Vec<TokenStream> = resolved
77        .raw
78        .request_variants
79        .iter()
80        .filter(|v| !scoped_names.contains(&v.name.as_str()))
81        .filter(|v| !v.cli_hidden)
82        .filter(|v| is_streaming(v, &resolved.raw.response_variants, false))
83        .map(|v| {
84            generate_streaming_dispatch_arm(v, resolved, &capnp_mod, &req_type, &response_type)
85        })
86        .collect();
87
88    // Generate scoped dispatch arms (e.g., "ttt.init", "ttt.train")
89    // Only generates for direct scoped clients, not nested (3rd level).
90    let scoped_dispatch_arms: Vec<TokenStream> = resolved
91        .raw
92        .scoped_clients
93        .iter()
94        .filter(|sc| !sc.inner_request_variants.is_empty())
95        .flat_map(|sc| {
96            let scope_snake = to_snake_case(&sc.factory_name);
97            let scope_init = format_ident!("init_{}", to_snake_case(&sc.factory_name));
98
99            // Scope fields: extract from args JSON (before serialize_message closure)
100            let scope_field_extracts: Vec<TokenStream> = sc.scope_fields.iter().enumerate().map(|(i, f)| {
101                let field_snake = to_snake_case(&f.name);
102                let field_camel = &f.name;
103                let var_name = format_ident!("__scope_val_{}", i);
104                match f.type_name.as_str() {
105                    "Text" => quote! {
106                        let #var_name = args.get(#field_camel)
107                            .or_else(|| args.get(#field_snake))
108                            .and_then(|v| v.as_str())
109                            .ok_or_else(|| format!("missing scope field '{}' in args", #field_camel))?
110                            .to_owned();
111                    },
112                    _ => quote! {},
113                }
114            }).collect();
115            let scope_field_setters: Vec<TokenStream> = sc.scope_fields.iter().enumerate().map(|(i, f)| {
116                let setter = format_ident!("set_{}", to_snake_case(&f.name));
117                let var_name = format_ident!("__scope_val_{}", i);
118                match f.type_name.as_str() {
119                    "Text" => quote! { __scope.#setter(&#var_name); },
120                    _ => quote! {},
121                }
122            }).collect();
123
124            // Inner scoped response type — uses client_name from scoped client detection
125            let scoped_response_type = format_ident!("{}ResponseVariant", sc.client_name);
126
127            sc.inner_request_variants.iter()
128                .filter(|v| !v.cli_hidden)
129                .filter(|v| !is_streaming(v, &sc.inner_response_variants, true))
130                .map(|v| {
131                    let method_snake = to_snake_case(&v.name);
132                    let full_name = format!("{}.{}", scope_snake, method_snake);
133                    let inner_init = format_ident!("init_{}", to_snake_case(&v.name));
134                    let inner_set = format_ident!("set_{}", to_snake_case(&v.name));
135                    let ct = resolved.resolve_type(&v.type_name).capnp_type.clone();
136
137                    let inner_serialize = match ct {
138                        CapnpType::Void => quote! { __scope.#inner_set(()); },
139                        CapnpType::Text => quote! {
140                            let __val = args.get(#method_snake).or_else(|| args.get("value"))
141                                .and_then(|v| v.as_str()).unwrap_or_default();
142                            __scope.#inner_set(__val);
143                        },
144                        _ => {
145                            if let Some(sdef) = resolved.find_struct(&v.type_name) {
146                                let nuf: Vec<_> = sdef.non_union_fields().collect();
147                                let is_void_wrapper = nuf.is_empty()
148                                    || (nuf.len() == 1 && nuf[0].type_name == "Void");
149                                if is_void_wrapper {
150                                    quote! { __scope.#inner_init(); }
151                                } else {
152                                    // Deserialization happens OUTSIDE the closure
153                                    // The closure just uses the pre-deserialized value
154                                    quote! {
155                                        let mut __inner = __scope.#inner_init();
156                                        hyprstream_rpc::capnp::ToCapnp::write_to(&__scoped_req, &mut __inner);
157                                    }
158                                }
159                            } else {
160                                quote! { __scope.#inner_init(); }
161                            }
162                        }
163                    };
164
165                    // Pre-deserialize struct args outside the closure
166                    let pre_deserialize = match ct.clone() {
167                        CapnpType::Struct(_) | CapnpType::Unknown(_) => {
168                            if let Some(sdef) = resolved.find_struct(&v.type_name) {
169                                let nuf: Vec<_> = sdef.non_union_fields().collect();
170                                let is_void_wrapper = nuf.is_empty()
171                                    || (nuf.len() == 1 && nuf[0].type_name == "Void");
172                                if is_void_wrapper {
173                                    quote! {}
174                                } else {
175                                    let data_name = format_ident!("{}", v.type_name);
176                                    quote! {
177                                        let __scoped_req: #data_name = serde_json::from_value(args.clone())
178                                            .map_err(|e| format!("deserialize {}: {e}", #method_snake))?;
179                                    }
180                                }
181                            } else { quote! {} }
182                        }
183                        _ => quote! {},
184                    };
185
186                    quote! {
187                        #full_name => {
188                            #(#scope_field_extracts)*
189                            #pre_deserialize
190                            let payload = hyprstream_rpc::serialize_message(|msg| {
191                                let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
192                                req.set_id(request_id);
193                                let mut __scope = req.#scope_init();
194                                #(#scope_field_setters)*
195                                #inner_serialize
196                            }).map_err(|e| format!("serialize: {e}"))?;
197                            let response_bytes = send(payload).await?;
198                            let variant = #scoped_response_type::parse_scoped_response(&response_bytes)
199                                .map_err(|e| format!("parse response: {e}"))?;
200                            let json = serde_json::to_string(&variant)
201                                .map_err(|e| format!("serialize response: {e}"))?;
202                            Ok(DispatchResult::Response(json))
203                        }
204                    }
205                })
206                .collect::<Vec<_>>()
207        })
208        .collect();
209
210    // Scoped streaming dispatch arms (e.g., "ttt.train_stream", "infer.generate_stream")
211    let scoped_streaming_arms: Vec<TokenStream> = resolved
212        .raw
213        .scoped_clients
214        .iter()
215        .filter(|sc| !sc.inner_request_variants.is_empty())
216        .flat_map(|sc| {
217            let scope_snake = to_snake_case(&sc.factory_name);
218            let scope_init = format_ident!("init_{}", to_snake_case(&sc.factory_name));
219
220            let scope_field_extracts: Vec<TokenStream> = sc.scope_fields.iter().enumerate().map(|(i, f)| {
221                let field_snake = to_snake_case(&f.name);
222                let field_camel = &f.name;
223                let var_name = format_ident!("__scope_val_{}", i);
224                match f.type_name.as_str() {
225                    "Text" => quote! {
226                        let #var_name = args.get(#field_camel)
227                            .or_else(|| args.get(#field_snake))
228                            .and_then(|v| v.as_str())
229                            .ok_or_else(|| format!("missing scope field '{}' in args", #field_camel))?
230                            .to_owned();
231                    },
232                    _ => quote! {},
233                }
234            }).collect();
235            let scope_field_setters: Vec<TokenStream> = sc.scope_fields.iter().enumerate().map(|(i, f)| {
236                let setter = format_ident!("set_{}", to_snake_case(&f.name));
237                let var_name = format_ident!("__scope_val_{}", i);
238                match f.type_name.as_str() {
239                    "Text" => quote! { __scope.#setter(&#var_name); },
240                    _ => quote! {},
241                }
242            }).collect();
243
244            let scoped_response_type = format_ident!("{}ResponseVariant", sc.client_name);
245
246            sc.inner_request_variants.iter()
247                .filter(|v| !v.cli_hidden)
248                .filter(|v| is_streaming(v, &sc.inner_response_variants, true))
249                .map(|v| {
250                    let method_snake = to_snake_case(&v.name);
251                    let full_name = format!("{}.{}", scope_snake, method_snake);
252                    let inner_init = format_ident!("init_{}", to_snake_case(&v.name));
253                    let inner_set = format_ident!("set_{}", to_snake_case(&v.name));
254                    let ct = resolved.resolve_type(&v.type_name).capnp_type.clone();
255
256                    let inner_serialize = match ct.clone() {
257                        CapnpType::Void => quote! { __scope.#inner_set(()); },
258                        _ => {
259                            if let Some(sdef) = resolved.find_struct(&v.type_name) {
260                                let nuf: Vec<_> = sdef.non_union_fields().collect();
261                                let is_void_wrapper = nuf.is_empty()
262                                    || (nuf.len() == 1 && nuf[0].type_name == "Void");
263                                if is_void_wrapper {
264                                    quote! { __scope.#inner_init(); }
265                                } else {
266                                    quote! {
267                                        let mut __inner = __scope.#inner_init();
268                                        hyprstream_rpc::capnp::ToCapnp::write_to(&__scoped_req, &mut __inner);
269                                    }
270                                }
271                            } else {
272                                quote! { __scope.#inner_init(); }
273                            }
274                        }
275                    };
276
277                    let pre_deserialize = match ct {
278                        CapnpType::Struct(_) | CapnpType::Unknown(_) => {
279                            if let Some(sdef) = resolved.find_struct(&v.type_name) {
280                                let nuf: Vec<_> = sdef.non_union_fields().collect();
281                                let is_void_wrapper = nuf.is_empty()
282                                    || (nuf.len() == 1 && nuf[0].type_name == "Void");
283                                if is_void_wrapper { quote! {} } else {
284                                    let data_name = format_ident!("{}", v.type_name);
285                                    quote! {
286                                        let __scoped_req: #data_name = serde_json::from_value(args.clone())
287                                            .map_err(|e| format!("deserialize {}: {e}", #method_snake))?;
288                                    }
289                                }
290                            } else { quote! {} }
291                        }
292                        _ => quote! {},
293                    };
294
295                    // #468: scoped streaming result variant is `{name}(StreamInfo)`
296                    // (handler.rs:1793/2197) — extract the verified StreamInfo TYPED.
297                    let scoped_resp_variant_pascal = format_ident!("{}", to_pascal_case(&v.name));
298
299                    quote! {
300                        #full_name => {
301                            #(#scope_field_extracts)*
302                            #pre_deserialize
303                            let payload = hyprstream_rpc::serialize_message(|msg| {
304                                let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
305                                req.set_id(request_id);
306                                let mut __scope = req.#scope_init();
307                                #(#scope_field_setters)*
308                                #inner_serialize
309                            }).map_err(|e| format!("serialize: {e}"))?;
310                            let response_bytes = send(payload).await?;
311                            // #468: pull the verified StreamInfo out TYPED — no JSON round-trip.
312                            // Scoped result variant is `{name}(StreamInfo)`.
313                            let variant = #scoped_response_type::parse_scoped_response(&response_bytes)
314                                .map_err(|e| format!("parse streaming response: {e}"))?;
315                            match variant {
316                                #scoped_response_type::#scoped_resp_variant_pascal(stream_info) => Ok(DispatchResult::Stream(stream_info)),
317                                _ => Err(format!("expected StreamInfo streaming response for method '{}'", #full_name)),
318                            }
319                        }
320                    }
321                })
322                .collect::<Vec<_>>()
323        })
324        .collect();
325
326    let method_list: Vec<String> = resolved
327        .raw
328        .request_variants
329        .iter()
330        .filter(|v| !scoped_names.contains(&v.name.as_str()) && !v.cli_hidden)
331        .map(|v| to_snake_case(&v.name))
332        .collect();
333    let scoped_method_list: Vec<String> = resolved
334        .raw
335        .scoped_clients
336        .iter()
337        .flat_map(|sc| {
338            let scope_snake = to_snake_case(&sc.factory_name);
339            sc.inner_request_variants
340                .iter()
341                .filter(|v| !v.cli_hidden)
342                .map(move |v| format!("{}.{}", scope_snake, to_snake_case(&v.name)))
343        })
344        .collect();
345    let mut all_methods = method_list;
346    all_methods.extend(scoped_method_list);
347    let methods_str = all_methods.join(", ");
348
349    quote! {
350        /// Result of a dispatch call — either a JSON response or a streaming setup.
351        pub enum DispatchResult {
352            /// Normal response — serialized JSON string.
353            Response(String),
354            /// Streaming response — the VERIFIED-capnp `StreamInfo` library type
355            /// (decoded + COSE-verified inside `send`/`call_streaming`), carried
356            /// typed (NOT a JSON string the caller re-parses). The caller reads
357            /// endpoint/dhPublic/streamId off it directly to set up the subscription. (#468)
358            Stream(hyprstream_rpc::stream_info::StreamInfo),
359        }
360
361        /// Transport-agnostic JSON dispatch for this service.
362        ///
363        /// Routes method calls by name, handling serialization on both sides.
364        /// Scoped methods use dot notation: `"ttt.init"`, `"ttt.train"`.
365        /// Streaming methods return `DispatchResult::Stream` with raw StreamInfo bytes.
366        pub async fn dispatch<F, Fut>(
367            method: &str,
368            args_json: &str,
369            request_id: u64,
370            send: F,
371        ) -> ::core::result::Result<DispatchResult, String>
372        where
373            F: FnOnce(Vec<u8>) -> Fut,
374            Fut: ::core::future::Future<Output = ::core::result::Result<Vec<u8>, String>>,
375        {
376            let args: serde_json::Value = serde_json::from_str(args_json)
377                .map_err(|e| format!("invalid JSON: {e}"))?;
378
379            match method {
380                #(#dispatch_arms)*
381                #(#scoped_dispatch_arms)*
382                #(#streaming_arms)*
383                #(#scoped_streaming_arms)*
384                _ => Err(format!("unknown method '{}', available: {}", method, #methods_str)),
385            }
386        }
387    }
388}
389
390/// Generate a single dispatch arm for a method.
391fn generate_dispatch_arm(
392    v: &UnionVariant,
393    resolved: &ResolvedSchema,
394    capnp_mod: &TokenStream,
395    req_type: &proc_macro2::Ident,
396    response_type: &proc_macro2::Ident,
397) -> TokenStream {
398    let method_name_str = to_snake_case(&v.name);
399    let ct = resolved.resolve_type(&v.type_name).capnp_type.clone();
400    let set_method = format_ident!("set_{}", to_snake_case(&v.name));
401    let init_method = format_ident!("init_{}", to_snake_case(&v.name));
402
403    // Build the serialization code based on argument type
404    let serialize_body = match ct {
405        CapnpType::Void => {
406            quote! {
407                let payload = hyprstream_rpc::serialize_message(|msg| {
408                    let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
409                    req.set_id(request_id);
410                    req.#set_method(());
411                }).map_err(|e| format!("serialize: {e}"))?;
412            }
413        }
414        CapnpType::Text => {
415            quote! {
416                let value = args.as_str()
417                    .or_else(|| args[#method_name_str].as_str())
418                    .or_else(|| args["value"].as_str())
419                    .unwrap_or_default();
420                let payload = hyprstream_rpc::serialize_message(|msg| {
421                    let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
422                    req.set_id(request_id);
423                    req.#set_method(value);
424                }).map_err(|e| format!("serialize: {e}"))?;
425            }
426        }
427        CapnpType::Struct(_) | CapnpType::Unknown(_) => {
428            if let Some(sdef) = resolved.find_struct(&v.type_name) {
429                let nuf: Vec<_> = sdef.non_union_fields().collect();
430                let is_void_wrapper =
431                    nuf.is_empty() || (nuf.len() == 1 && nuf[0].type_name == "Void");
432
433                if is_void_wrapper {
434                    quote! {
435                        let payload = hyprstream_rpc::serialize_message(|msg| {
436                            let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
437                            req.set_id(request_id);
438                            req.#init_method();
439                        }).map_err(|e| format!("serialize: {e}"))?;
440                    }
441                } else {
442                    let data_name = format_ident!("{}", v.type_name);
443                    quote! {
444                        let __req: #data_name = serde_json::from_value(args.clone())
445                            .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
446                        let payload = hyprstream_rpc::serialize_message(|msg| {
447                            let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
448                            req.set_id(request_id);
449                            let mut __inner = req.#init_method();
450                            hyprstream_rpc::capnp::ToCapnp::write_to(&__req, &mut __inner);
451                        }).map_err(|e| format!("serialize: {e}"))?;
452                    }
453                }
454            } else {
455                let err = format!("struct type not found: {}", v.type_name);
456                return quote! { #method_name_str => Err(#err.to_owned()), };
457            }
458        }
459        CapnpType::Bool => {
460            quote! {
461                let __value = args
462                    .get(#method_name_str)
463                    .or_else(|| args.get("value"))
464                    .cloned()
465                    .ok_or_else(|| format!("missing argument for {}", #method_name_str))?;
466                let value: bool = serde_json::from_value(__value)
467                    .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
468                let payload = hyprstream_rpc::serialize_message(|msg| {
469                    let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
470                    req.set_id(request_id);
471                    req.#set_method(value);
472                }).map_err(|e| format!("serialize: {e}"))?;
473            }
474        }
475        _ if ct.is_numeric() => {
476            let rust_ty = rust_type_tokens(&ct.rust_owned_type());
477            quote! {
478                let __value = args
479                    .get(#method_name_str)
480                    .or_else(|| args.get("value"))
481                    .cloned()
482                    .ok_or_else(|| format!("missing argument for {}", #method_name_str))?;
483                let value: #rust_ty = serde_json::from_value(__value)
484                    .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
485                let payload = hyprstream_rpc::serialize_message(|msg| {
486                    let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
487                    req.set_id(request_id);
488                    req.#set_method(value);
489                }).map_err(|e| format!("serialize: {e}"))?;
490            }
491        }
492        _ => {
493            // Unsupported primitive shape — keep the diagnostic at runtime.
494            return quote! { #method_name_str => Err(format!("unsupported argument type for {}", #method_name_str)), };
495        }
496    };
497
498    quote! {
499        #method_name_str => {
500            #serialize_body
501            let response_bytes = send(payload).await?;
502            let variant = #response_type::parse_response(&response_bytes)
503                .map_err(|e| format!("parse response: {e}"))?;
504            let json = serde_json::to_string(&variant)
505                .map_err(|e| format!("serialize response: {e}"))?;
506            Ok(DispatchResult::Response(json))
507        }
508    }
509}
510
511/// Generate a streaming dispatch arm — returns raw response bytes as DispatchResult::Stream.
512fn generate_streaming_dispatch_arm(
513    v: &UnionVariant,
514    resolved: &ResolvedSchema,
515    capnp_mod: &TokenStream,
516    req_type: &proc_macro2::Ident,
517    response_type: &proc_macro2::Ident,
518) -> TokenStream {
519    let method_name_str = to_snake_case(&v.name);
520    let ct = resolved.resolve_type(&v.type_name).capnp_type.clone();
521    let set_method = format_ident!("set_{}", to_snake_case(&v.name));
522    let init_method = format_ident!("init_{}", to_snake_case(&v.name));
523
524    // Reuse same serialization patterns as non-streaming
525    let serialize_body = match ct {
526        CapnpType::Void => quote! {
527            let payload = hyprstream_rpc::serialize_message(|msg| {
528                let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
529                req.set_id(request_id);
530                req.#set_method(());
531            }).map_err(|e| format!("serialize: {e}"))?;
532        },
533        CapnpType::Bool => {
534            quote! {
535                let __value = args
536                    .get(#method_name_str)
537                    .or_else(|| args.get("value"))
538                    .cloned()
539                    .ok_or_else(|| format!("missing argument for {}", #method_name_str))?;
540                let value: bool = serde_json::from_value(__value)
541                    .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
542                let payload = hyprstream_rpc::serialize_message(|msg| {
543                    let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
544                    req.set_id(request_id);
545                    req.#set_method(value);
546                }).map_err(|e| format!("serialize: {e}"))?;
547            }
548        }
549        _ if ct.is_numeric() => {
550            let rust_ty = rust_type_tokens(&ct.rust_owned_type());
551            quote! {
552                let __value = args
553                    .get(#method_name_str)
554                    .or_else(|| args.get("value"))
555                    .cloned()
556                    .ok_or_else(|| format!("missing argument for {}", #method_name_str))?;
557                let value: #rust_ty = serde_json::from_value(__value)
558                    .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
559                let payload = hyprstream_rpc::serialize_message(|msg| {
560                    let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
561                    req.set_id(request_id);
562                    req.#set_method(value);
563                }).map_err(|e| format!("serialize: {e}"))?;
564            }
565        }
566        _ => {
567            if let Some(sdef) = resolved.find_struct(&v.type_name) {
568                let nuf: Vec<_> = sdef.non_union_fields().collect();
569                let is_void_wrapper =
570                    nuf.is_empty() || (nuf.len() == 1 && nuf[0].type_name == "Void");
571                if is_void_wrapper {
572                    quote! {
573                        let payload = hyprstream_rpc::serialize_message(|msg| {
574                            let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
575                            req.set_id(request_id);
576                            req.#init_method();
577                        }).map_err(|e| format!("serialize: {e}"))?;
578                    }
579                } else {
580                    let data_name = format_ident!("{}", v.type_name);
581                    quote! {
582                        let __req: #data_name = serde_json::from_value(args.clone())
583                            .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
584                        let payload = hyprstream_rpc::serialize_message(|msg| {
585                            let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
586                            req.set_id(request_id);
587                            let mut __inner = req.#init_method();
588                            hyprstream_rpc::capnp::ToCapnp::write_to(&__req, &mut __inner);
589                        }).map_err(|e| format!("serialize: {e}"))?;
590                    }
591                }
592            } else {
593                let err = format!("struct type not found: {}", v.type_name);
594                return quote! { #method_name_str => Err(#err.to_owned()), };
595            }
596        }
597    };
598
599    // #468: carry the verified StreamInfo TYPED out of the parsed response
600    // variant — no `serde_json::to_string` round-trip. The top-level result
601    // variant is `{name}Result(StreamInfo)` (mirrors handler.rs).
602    let resp_variant_pascal = format_ident!("{}", to_pascal_case(&format!("{}Result", v.name)));
603    quote! {
604        #method_name_str => {
605            #serialize_body
606            let response_bytes = send(payload).await?;
607            // Parse the (COSE-verified) response and pull the StreamInfo out typed.
608            let variant = #response_type::parse_response(&response_bytes)
609                .map_err(|e| format!("parse streaming response: {e}"))?;
610            match variant {
611                #response_type::#resp_variant_pascal(stream_info) => Ok(DispatchResult::Stream(stream_info)),
612                _ => Err(format!("expected StreamInfo streaming response for method '{}'", #method_name_str)),
613            }
614        }
615    }
616}