prompt_graph_core/generated_protobufs/
promptgraph.rs

1#[derive(serde::Deserialize, serde::Serialize)]
2#[allow(clippy::derive_partial_eq_without_eq)]
3#[derive(Clone, PartialEq, ::prost::Message)]
4pub struct Query {
5    #[prost(string, optional, tag = "1")]
6    pub query: ::core::option::Option<::prost::alloc::string::String>,
7}
8/// Processed version of the Query
9#[derive(serde::Deserialize, serde::Serialize)]
10#[allow(clippy::derive_partial_eq_without_eq)]
11#[derive(Clone, PartialEq, ::prost::Message)]
12pub struct QueryPaths {
13    #[prost(string, tag = "1")]
14    pub node: ::prost::alloc::string::String,
15    #[prost(message, repeated, tag = "2")]
16    pub path: ::prost::alloc::vec::Vec<Path>,
17}
18#[derive(serde::Deserialize, serde::Serialize)]
19#[allow(clippy::derive_partial_eq_without_eq)]
20#[derive(Clone, PartialEq, ::prost::Message)]
21pub struct OutputType {
22    #[prost(string, tag = "2")]
23    pub output: ::prost::alloc::string::String,
24}
25/// Processed version of the OutputType
26#[derive(serde::Deserialize, serde::Serialize)]
27#[allow(clippy::derive_partial_eq_without_eq)]
28#[derive(Clone, PartialEq, ::prost::Message)]
29pub struct OutputPaths {
30    #[prost(string, tag = "1")]
31    pub node: ::prost::alloc::string::String,
32    #[prost(message, repeated, tag = "2")]
33    pub path: ::prost::alloc::vec::Vec<Path>,
34}
35/// Alias is a reference to another node, any value set
36/// on this node will propagate for the alias as well
37#[derive(serde::Deserialize, serde::Serialize)]
38#[allow(clippy::derive_partial_eq_without_eq)]
39#[derive(Clone, PartialEq, ::prost::Message)]
40pub struct PromptGraphAlias {
41    #[prost(string, tag = "2")]
42    pub from: ::prost::alloc::string::String,
43    #[prost(string, tag = "3")]
44    pub to: ::prost::alloc::string::String,
45}
46#[derive(serde::Deserialize, serde::Serialize)]
47#[allow(clippy::derive_partial_eq_without_eq)]
48#[derive(Clone, PartialEq, ::prost::Message)]
49pub struct PromptGraphConstant {
50    #[prost(message, optional, tag = "2")]
51    pub value: ::core::option::Option<SerializedValue>,
52}
53#[derive(serde::Deserialize, serde::Serialize)]
54#[allow(clippy::derive_partial_eq_without_eq)]
55#[derive(Clone, PartialEq, ::prost::Message)]
56pub struct PromptGraphVar {}
57#[derive(serde::Deserialize, serde::Serialize)]
58#[allow(clippy::derive_partial_eq_without_eq)]
59#[derive(Clone, PartialEq, ::prost::Message)]
60pub struct PromptGraphOutputValue {}
61#[derive(serde::Deserialize, serde::Serialize)]
62#[allow(clippy::derive_partial_eq_without_eq)]
63#[derive(Clone, PartialEq, ::prost::Message)]
64pub struct PromptGraphNodeCodeSourceCode {
65    #[prost(enumeration = "SupportedSourceCodeLanguages", tag = "1")]
66    pub language: i32,
67    #[prost(string, tag = "2")]
68    pub source_code: ::prost::alloc::string::String,
69    #[prost(bool, tag = "3")]
70    pub template: bool,
71}
72#[derive(serde::Deserialize, serde::Serialize)]
73#[allow(clippy::derive_partial_eq_without_eq)]
74#[derive(Clone, PartialEq, ::prost::Message)]
75pub struct PromptGraphParameterNode {}
76#[derive(serde::Deserialize, serde::Serialize)]
77#[allow(clippy::derive_partial_eq_without_eq)]
78#[derive(Clone, PartialEq, ::prost::Message)]
79pub struct PromptGraphMap {
80    #[prost(string, tag = "4")]
81    pub path: ::prost::alloc::string::String,
82}
83#[derive(serde::Deserialize, serde::Serialize)]
84#[allow(clippy::derive_partial_eq_without_eq)]
85#[derive(Clone, PartialEq, ::prost::Message)]
86pub struct PromptGraphNodeCode {
87    #[prost(oneof = "prompt_graph_node_code::Source", tags = "6, 7, 8")]
88    pub source: ::core::option::Option<prompt_graph_node_code::Source>,
89}
90/// Nested message and enum types in `PromptGraphNodeCode`.
91pub mod prompt_graph_node_code {
92    #[derive(serde::Deserialize, serde::Serialize)]
93    #[allow(clippy::derive_partial_eq_without_eq)]
94    #[derive(Clone, PartialEq, ::prost::Oneof)]
95    pub enum Source {
96        #[prost(message, tag = "6")]
97        SourceCode(super::PromptGraphNodeCodeSourceCode),
98        #[prost(bytes, tag = "7")]
99        Zipfile(::prost::alloc::vec::Vec<u8>),
100        #[prost(string, tag = "8")]
101        S3Path(::prost::alloc::string::String),
102    }
103}
104#[derive(serde::Deserialize, serde::Serialize)]
105#[allow(clippy::derive_partial_eq_without_eq)]
106#[derive(Clone, PartialEq, ::prost::Message)]
107pub struct PromptGraphNodeLoader {
108    #[prost(oneof = "prompt_graph_node_loader::LoadFrom", tags = "1")]
109    pub load_from: ::core::option::Option<prompt_graph_node_loader::LoadFrom>,
110}
111/// Nested message and enum types in `PromptGraphNodeLoader`.
112pub mod prompt_graph_node_loader {
113    #[derive(serde::Deserialize, serde::Serialize)]
114    #[allow(clippy::derive_partial_eq_without_eq)]
115    #[derive(Clone, PartialEq, ::prost::Oneof)]
116    pub enum LoadFrom {
117        /// Load a zip file, decompress it, and make the paths available as keys
118        #[prost(bytes, tag = "1")]
119        ZipfileBytes(::prost::alloc::vec::Vec<u8>),
120    }
121}
122#[derive(serde::Deserialize, serde::Serialize)]
123#[allow(clippy::derive_partial_eq_without_eq)]
124#[derive(Clone, PartialEq, ::prost::Message)]
125pub struct PromptGraphNodeCustom {
126    #[prost(string, tag = "1")]
127    pub type_name: ::prost::alloc::string::String,
128}
129/// TODO: we should allow the user to freely manipulate wall-clock time
130/// Output value of this should just be the timestamp
131#[derive(serde::Deserialize, serde::Serialize)]
132#[allow(clippy::derive_partial_eq_without_eq)]
133#[derive(Clone, PartialEq, ::prost::Message)]
134pub struct PromptGraphNodeSchedule {
135    #[prost(oneof = "prompt_graph_node_schedule::Policy", tags = "1, 2, 3")]
136    pub policy: ::core::option::Option<prompt_graph_node_schedule::Policy>,
137}
138/// Nested message and enum types in `PromptGraphNodeSchedule`.
139pub mod prompt_graph_node_schedule {
140    #[derive(serde::Deserialize, serde::Serialize)]
141    #[allow(clippy::derive_partial_eq_without_eq)]
142    #[derive(Clone, PartialEq, ::prost::Oneof)]
143    pub enum Policy {
144        #[prost(string, tag = "1")]
145        Crontab(::prost::alloc::string::String),
146        #[prost(string, tag = "2")]
147        NaturalLanguage(::prost::alloc::string::String),
148        #[prost(string, tag = "3")]
149        EveryMs(::prost::alloc::string::String),
150    }
151}
152#[derive(serde::Deserialize, serde::Serialize)]
153#[allow(clippy::derive_partial_eq_without_eq)]
154#[derive(Clone, PartialEq, ::prost::Message)]
155pub struct PromptGraphNodePrompt {
156    #[prost(string, tag = "4")]
157    pub template: ::prost::alloc::string::String,
158    #[prost(float, tag = "7")]
159    pub temperature: f32,
160    #[prost(float, tag = "8")]
161    pub top_p: f32,
162    #[prost(int32, tag = "9")]
163    pub max_tokens: i32,
164    #[prost(float, tag = "10")]
165    pub presence_penalty: f32,
166    #[prost(float, tag = "11")]
167    pub frequency_penalty: f32,
168    /// TODO: set the user token
169    /// TODO: support logit bias
170    #[prost(string, repeated, tag = "12")]
171    pub stop: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
172    #[prost(oneof = "prompt_graph_node_prompt::Model", tags = "5, 6")]
173    pub model: ::core::option::Option<prompt_graph_node_prompt::Model>,
174}
175/// Nested message and enum types in `PromptGraphNodePrompt`.
176pub mod prompt_graph_node_prompt {
177    #[derive(serde::Deserialize, serde::Serialize)]
178    #[allow(clippy::derive_partial_eq_without_eq)]
179    #[derive(Clone, PartialEq, ::prost::Oneof)]
180    pub enum Model {
181        #[prost(enumeration = "super::SupportedChatModel", tag = "5")]
182        ChatModel(i32),
183        #[prost(enumeration = "super::SupportedCompletionModel", tag = "6")]
184        CompletionModel(i32),
185    }
186}
187/// TODO: this expects a selector for the query? - no its a template and you build that
188/// TODO: what about the output type? pre-defined
189/// TODO: what about the metadata?
190/// TODO: metadata could be an independent query, or it could instead be a template too
191#[derive(serde::Deserialize, serde::Serialize)]
192#[allow(clippy::derive_partial_eq_without_eq)]
193#[derive(Clone, PartialEq, ::prost::Message)]
194pub struct PromptGraphNodeMemory {
195    #[prost(string, tag = "3")]
196    pub collection_name: ::prost::alloc::string::String,
197    #[prost(string, tag = "4")]
198    pub template: ::prost::alloc::string::String,
199    #[prost(enumeration = "MemoryAction", tag = "7")]
200    pub action: i32,
201    #[prost(oneof = "prompt_graph_node_memory::EmbeddingModel", tags = "5")]
202    pub embedding_model: ::core::option::Option<
203        prompt_graph_node_memory::EmbeddingModel,
204    >,
205    #[prost(oneof = "prompt_graph_node_memory::VectorDbProvider", tags = "6")]
206    pub vector_db_provider: ::core::option::Option<
207        prompt_graph_node_memory::VectorDbProvider,
208    >,
209}
210/// Nested message and enum types in `PromptGraphNodeMemory`.
211pub mod prompt_graph_node_memory {
212    #[derive(serde::Deserialize, serde::Serialize)]
213    #[allow(clippy::derive_partial_eq_without_eq)]
214    #[derive(Clone, PartialEq, ::prost::Oneof)]
215    pub enum EmbeddingModel {
216        #[prost(enumeration = "super::SupportedEmebddingModel", tag = "5")]
217        Model(i32),
218    }
219    #[derive(serde::Deserialize, serde::Serialize)]
220    #[allow(clippy::derive_partial_eq_without_eq)]
221    #[derive(Clone, PartialEq, ::prost::Oneof)]
222    pub enum VectorDbProvider {
223        #[prost(enumeration = "super::SupportedVectorDatabase", tag = "6")]
224        Db(i32),
225    }
226}
227#[derive(serde::Deserialize, serde::Serialize)]
228#[allow(clippy::derive_partial_eq_without_eq)]
229#[derive(Clone, PartialEq, ::prost::Message)]
230pub struct PromptGraphNodeObservation {
231    #[prost(string, tag = "4")]
232    pub integration: ::prost::alloc::string::String,
233}
234#[derive(serde::Deserialize, serde::Serialize)]
235#[allow(clippy::derive_partial_eq_without_eq)]
236#[derive(Clone, PartialEq, ::prost::Message)]
237pub struct PromptGraphNodeComponent {
238    #[prost(oneof = "prompt_graph_node_component::Transclusion", tags = "4, 5, 6")]
239    pub transclusion: ::core::option::Option<prompt_graph_node_component::Transclusion>,
240}
241/// Nested message and enum types in `PromptGraphNodeComponent`.
242pub mod prompt_graph_node_component {
243    #[derive(serde::Deserialize, serde::Serialize)]
244    #[allow(clippy::derive_partial_eq_without_eq)]
245    #[derive(Clone, PartialEq, ::prost::Oneof)]
246    pub enum Transclusion {
247        #[prost(message, tag = "4")]
248        InlineFile(super::File),
249        #[prost(bytes, tag = "5")]
250        BytesReference(::prost::alloc::vec::Vec<u8>),
251        #[prost(string, tag = "6")]
252        S3PathReference(::prost::alloc::string::String),
253    }
254}
255#[derive(serde::Deserialize, serde::Serialize)]
256#[allow(clippy::derive_partial_eq_without_eq)]
257#[derive(Clone, PartialEq, ::prost::Message)]
258pub struct PromptGraphNodeEcho {}
259/// TODO: configure resolving joins
260#[derive(serde::Deserialize, serde::Serialize)]
261#[allow(clippy::derive_partial_eq_without_eq)]
262#[derive(Clone, PartialEq, ::prost::Message)]
263pub struct PromptGraphNodeJoin {}
264#[derive(serde::Deserialize, serde::Serialize)]
265#[allow(clippy::derive_partial_eq_without_eq)]
266#[derive(Clone, PartialEq, ::prost::Message)]
267pub struct ItemCore {
268    #[prost(string, tag = "1")]
269    pub name: ::prost::alloc::string::String,
270    #[prost(message, repeated, tag = "2")]
271    pub triggers: ::prost::alloc::vec::Vec<Query>,
272    #[prost(string, repeated, tag = "3")]
273    pub output_tables: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
274    #[prost(message, optional, tag = "4")]
275    pub output: ::core::option::Option<OutputType>,
276}
277#[derive(serde::Deserialize, serde::Serialize)]
278#[allow(clippy::derive_partial_eq_without_eq)]
279#[derive(Clone, PartialEq, ::prost::Message)]
280pub struct Item {
281    #[prost(message, optional, tag = "1")]
282    pub core: ::core::option::Option<ItemCore>,
283    #[prost(
284        oneof = "item::Item",
285        tags = "2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17"
286    )]
287    pub item: ::core::option::Option<item::Item>,
288}
289/// Nested message and enum types in `Item`.
290pub mod item {
291    #[derive(serde::Deserialize, serde::Serialize)]
292    #[allow(clippy::derive_partial_eq_without_eq)]
293    #[derive(Clone, PartialEq, ::prost::Oneof)]
294    pub enum Item {
295        #[prost(message, tag = "2")]
296        Alias(super::PromptGraphAlias),
297        #[prost(message, tag = "3")]
298        Map(super::PromptGraphMap),
299        #[prost(message, tag = "4")]
300        Constant(super::PromptGraphConstant),
301        #[prost(message, tag = "5")]
302        Variable(super::PromptGraphVar),
303        #[prost(message, tag = "6")]
304        Output(super::PromptGraphOutputValue),
305        /// TODO: delete above this line
306        #[prost(message, tag = "7")]
307        NodeCode(super::PromptGraphNodeCode),
308        #[prost(message, tag = "8")]
309        NodePrompt(super::PromptGraphNodePrompt),
310        #[prost(message, tag = "9")]
311        NodeMemory(super::PromptGraphNodeMemory),
312        #[prost(message, tag = "10")]
313        NodeComponent(super::PromptGraphNodeComponent),
314        #[prost(message, tag = "11")]
315        NodeObservation(super::PromptGraphNodeObservation),
316        #[prost(message, tag = "12")]
317        NodeParameter(super::PromptGraphParameterNode),
318        #[prost(message, tag = "13")]
319        NodeEcho(super::PromptGraphNodeEcho),
320        #[prost(message, tag = "14")]
321        NodeLoader(super::PromptGraphNodeLoader),
322        #[prost(message, tag = "15")]
323        NodeCustom(super::PromptGraphNodeCustom),
324        #[prost(message, tag = "16")]
325        NodeJoin(super::PromptGraphNodeJoin),
326        #[prost(message, tag = "17")]
327        NodeSchedule(super::PromptGraphNodeSchedule),
328    }
329}
330/// TODO: add a flag for 'Cleaned', 'Dirty', 'Validated'
331#[derive(serde::Deserialize, serde::Serialize)]
332#[allow(clippy::derive_partial_eq_without_eq)]
333#[derive(Clone, PartialEq, ::prost::Message)]
334pub struct File {
335    #[prost(string, tag = "1")]
336    pub id: ::prost::alloc::string::String,
337    #[prost(message, repeated, tag = "2")]
338    pub nodes: ::prost::alloc::vec::Vec<Item>,
339}
340#[derive(serde::Deserialize, serde::Serialize)]
341#[allow(clippy::derive_partial_eq_without_eq)]
342#[derive(Clone, PartialEq, ::prost::Message)]
343pub struct Path {
344    #[prost(string, repeated, tag = "1")]
345    pub address: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
346}
347#[derive(serde::Deserialize, serde::Serialize)]
348#[allow(clippy::derive_partial_eq_without_eq)]
349#[derive(Clone, PartialEq, ::prost::Message)]
350pub struct TypeDefinition {
351    #[prost(oneof = "type_definition::Type", tags = "1, 2, 3, 4, 5, 6, 7")]
352    pub r#type: ::core::option::Option<type_definition::Type>,
353}
354/// Nested message and enum types in `TypeDefinition`.
355pub mod type_definition {
356    #[derive(serde::Deserialize, serde::Serialize)]
357    #[allow(clippy::derive_partial_eq_without_eq)]
358    #[derive(Clone, PartialEq, ::prost::Oneof)]
359    pub enum Type {
360        #[prost(message, tag = "1")]
361        Primitive(super::PrimitiveType),
362        #[prost(message, tag = "2")]
363        Array(::prost::alloc::boxed::Box<super::ArrayType>),
364        #[prost(message, tag = "3")]
365        Object(super::ObjectType),
366        #[prost(message, tag = "4")]
367        Union(super::UnionType),
368        #[prost(message, tag = "5")]
369        Intersection(super::IntersectionType),
370        #[prost(message, tag = "6")]
371        Optional(::prost::alloc::boxed::Box<super::OptionalType>),
372        #[prost(message, tag = "7")]
373        Enum(super::EnumType),
374    }
375}
376#[derive(serde::Deserialize, serde::Serialize)]
377#[allow(clippy::derive_partial_eq_without_eq)]
378#[derive(Clone, PartialEq, ::prost::Message)]
379pub struct PrimitiveType {
380    #[prost(oneof = "primitive_type::Primitive", tags = "1, 2, 3, 4, 5")]
381    pub primitive: ::core::option::Option<primitive_type::Primitive>,
382}
383/// Nested message and enum types in `PrimitiveType`.
384pub mod primitive_type {
385    #[derive(serde::Deserialize, serde::Serialize)]
386    #[allow(clippy::derive_partial_eq_without_eq)]
387    #[derive(Clone, PartialEq, ::prost::Oneof)]
388    pub enum Primitive {
389        #[prost(bool, tag = "1")]
390        IsString(bool),
391        #[prost(bool, tag = "2")]
392        IsNumber(bool),
393        #[prost(bool, tag = "3")]
394        IsBoolean(bool),
395        #[prost(bool, tag = "4")]
396        IsNull(bool),
397        #[prost(bool, tag = "5")]
398        IsUndefined(bool),
399    }
400}
401#[derive(serde::Deserialize, serde::Serialize)]
402#[allow(clippy::derive_partial_eq_without_eq)]
403#[derive(Clone, PartialEq, ::prost::Message)]
404pub struct ArrayType {
405    #[prost(message, optional, boxed, tag = "1")]
406    pub r#type: ::core::option::Option<::prost::alloc::boxed::Box<TypeDefinition>>,
407}
408#[derive(serde::Deserialize, serde::Serialize)]
409#[allow(clippy::derive_partial_eq_without_eq)]
410#[derive(Clone, PartialEq, ::prost::Message)]
411pub struct ObjectType {
412    #[prost(map = "string, message", tag = "1")]
413    pub fields: ::std::collections::HashMap<
414        ::prost::alloc::string::String,
415        TypeDefinition,
416    >,
417}
418#[derive(serde::Deserialize, serde::Serialize)]
419#[allow(clippy::derive_partial_eq_without_eq)]
420#[derive(Clone, PartialEq, ::prost::Message)]
421pub struct UnionType {
422    #[prost(message, repeated, tag = "1")]
423    pub types: ::prost::alloc::vec::Vec<TypeDefinition>,
424}
425#[derive(serde::Deserialize, serde::Serialize)]
426#[allow(clippy::derive_partial_eq_without_eq)]
427#[derive(Clone, PartialEq, ::prost::Message)]
428pub struct IntersectionType {
429    #[prost(message, repeated, tag = "1")]
430    pub types: ::prost::alloc::vec::Vec<TypeDefinition>,
431}
432#[derive(serde::Deserialize, serde::Serialize)]
433#[allow(clippy::derive_partial_eq_without_eq)]
434#[derive(Clone, PartialEq, ::prost::Message)]
435pub struct OptionalType {
436    #[prost(message, optional, boxed, tag = "1")]
437    pub r#type: ::core::option::Option<::prost::alloc::boxed::Box<TypeDefinition>>,
438}
439#[derive(serde::Deserialize, serde::Serialize)]
440#[allow(clippy::derive_partial_eq_without_eq)]
441#[derive(Clone, PartialEq, ::prost::Message)]
442pub struct EnumType {
443    #[prost(map = "string, string", tag = "1")]
444    pub values: ::std::collections::HashMap<
445        ::prost::alloc::string::String,
446        ::prost::alloc::string::String,
447    >,
448}
449#[derive(serde::Deserialize, serde::Serialize)]
450#[allow(clippy::derive_partial_eq_without_eq)]
451#[derive(Clone, PartialEq, ::prost::Message)]
452pub struct SerializedValueArray {
453    #[prost(message, repeated, tag = "1")]
454    pub values: ::prost::alloc::vec::Vec<SerializedValue>,
455}
456#[derive(serde::Deserialize, serde::Serialize)]
457#[allow(clippy::derive_partial_eq_without_eq)]
458#[derive(Clone, PartialEq, ::prost::Message)]
459pub struct SerializedValueObject {
460    #[prost(map = "string, message", tag = "1")]
461    pub values: ::std::collections::HashMap<
462        ::prost::alloc::string::String,
463        SerializedValue,
464    >,
465}
466#[derive(serde::Deserialize, serde::Serialize)]
467#[allow(clippy::derive_partial_eq_without_eq)]
468#[derive(Clone, PartialEq, ::prost::Message)]
469pub struct SerializedValue {
470    #[prost(oneof = "serialized_value::Val", tags = "2, 3, 4, 5, 6, 7")]
471    pub val: ::core::option::Option<serialized_value::Val>,
472}
473/// Nested message and enum types in `SerializedValue`.
474pub mod serialized_value {
475    #[derive(serde::Deserialize, serde::Serialize)]
476    #[allow(clippy::derive_partial_eq_without_eq)]
477    #[derive(Clone, PartialEq, ::prost::Oneof)]
478    pub enum Val {
479        #[prost(float, tag = "2")]
480        Float(f32),
481        #[prost(int32, tag = "3")]
482        Number(i32),
483        #[prost(string, tag = "4")]
484        String(::prost::alloc::string::String),
485        #[prost(bool, tag = "5")]
486        Boolean(bool),
487        #[prost(message, tag = "6")]
488        Array(super::SerializedValueArray),
489        #[prost(message, tag = "7")]
490        Object(super::SerializedValueObject),
491    }
492}
493#[derive(serde::Deserialize, serde::Serialize)]
494#[allow(clippy::derive_partial_eq_without_eq)]
495#[derive(Clone, PartialEq, ::prost::Message)]
496pub struct ChangeValue {
497    #[prost(message, optional, tag = "1")]
498    pub path: ::core::option::Option<Path>,
499    #[prost(message, optional, tag = "2")]
500    pub value: ::core::option::Option<SerializedValue>,
501    #[prost(uint64, tag = "3")]
502    pub branch: u64,
503}
504#[derive(serde::Deserialize, serde::Serialize)]
505#[allow(clippy::derive_partial_eq_without_eq)]
506#[derive(Clone, PartialEq, ::prost::Message)]
507pub struct WrappedChangeValue {
508    #[prost(uint64, tag = "3")]
509    pub monotonic_counter: u64,
510    #[prost(message, optional, tag = "4")]
511    pub change_value: ::core::option::Option<ChangeValue>,
512}
513/// Computation of a node
514#[derive(serde::Deserialize, serde::Serialize)]
515#[allow(clippy::derive_partial_eq_without_eq)]
516#[derive(Clone, PartialEq, ::prost::Message)]
517pub struct NodeWillExecute {
518    #[prost(string, tag = "1")]
519    pub source_node: ::prost::alloc::string::String,
520    #[prost(message, repeated, tag = "2")]
521    pub change_values_used_in_execution: ::prost::alloc::vec::Vec<WrappedChangeValue>,
522    #[prost(uint64, tag = "3")]
523    pub matched_query_index: u64,
524}
525/// Group of node computations to run
526#[derive(serde::Deserialize, serde::Serialize)]
527#[allow(clippy::derive_partial_eq_without_eq)]
528#[derive(Clone, PartialEq, ::prost::Message)]
529pub struct DispatchResult {
530    #[prost(message, repeated, tag = "1")]
531    pub operations: ::prost::alloc::vec::Vec<NodeWillExecute>,
532}
533#[derive(serde::Deserialize, serde::Serialize)]
534#[allow(clippy::derive_partial_eq_without_eq)]
535#[derive(Clone, PartialEq, ::prost::Message)]
536pub struct NodeWillExecuteOnBranch {
537    #[prost(uint64, tag = "1")]
538    pub branch: u64,
539    #[prost(uint64, tag = "2")]
540    pub counter: u64,
541    #[prost(string, optional, tag = "3")]
542    pub custom_node_type_name: ::core::option::Option<::prost::alloc::string::String>,
543    #[prost(message, optional, tag = "4")]
544    pub node: ::core::option::Option<NodeWillExecute>,
545}
546#[derive(serde::Deserialize, serde::Serialize)]
547#[allow(clippy::derive_partial_eq_without_eq)]
548#[derive(Clone, PartialEq, ::prost::Message)]
549pub struct ChangeValueWithCounter {
550    #[prost(message, repeated, tag = "1")]
551    pub filled_values: ::prost::alloc::vec::Vec<ChangeValue>,
552    #[prost(uint64, repeated, tag = "2")]
553    pub parent_monotonic_counters: ::prost::alloc::vec::Vec<u64>,
554    #[prost(uint64, tag = "3")]
555    pub monotonic_counter: u64,
556    #[prost(uint64, tag = "4")]
557    pub branch: u64,
558    #[prost(string, tag = "5")]
559    pub source_node: ::prost::alloc::string::String,
560}
561#[derive(serde::Deserialize, serde::Serialize)]
562#[allow(clippy::derive_partial_eq_without_eq)]
563#[derive(Clone, PartialEq, ::prost::Message)]
564pub struct CounterWithPath {
565    #[prost(uint64, tag = "1")]
566    pub monotonic_counter: u64,
567    #[prost(message, optional, tag = "2")]
568    pub path: ::core::option::Option<Path>,
569}
570/// Input proposals
571#[derive(serde::Deserialize, serde::Serialize)]
572#[allow(clippy::derive_partial_eq_without_eq)]
573#[derive(Clone, PartialEq, ::prost::Message)]
574pub struct InputProposal {
575    #[prost(string, tag = "1")]
576    pub name: ::prost::alloc::string::String,
577    #[prost(message, optional, tag = "2")]
578    pub output: ::core::option::Option<OutputType>,
579    #[prost(uint64, tag = "3")]
580    pub counter: u64,
581    #[prost(uint64, tag = "4")]
582    pub branch: u64,
583}
584#[derive(serde::Deserialize, serde::Serialize)]
585#[allow(clippy::derive_partial_eq_without_eq)]
586#[derive(Clone, PartialEq, ::prost::Message)]
587pub struct RequestInputProposalResponse {
588    #[prost(string, tag = "1")]
589    pub id: ::prost::alloc::string::String,
590    #[prost(uint64, tag = "2")]
591    pub proposal_counter: u64,
592    #[prost(message, repeated, tag = "3")]
593    pub changes: ::prost::alloc::vec::Vec<ChangeValue>,
594    #[prost(uint64, tag = "4")]
595    pub branch: u64,
596}
597#[derive(serde::Deserialize, serde::Serialize)]
598#[allow(clippy::derive_partial_eq_without_eq)]
599#[derive(Clone, PartialEq, ::prost::Message)]
600pub struct DivergentBranch {
601    #[prost(uint64, tag = "1")]
602    pub branch: u64,
603    #[prost(uint64, tag = "2")]
604    pub diverges_at_counter: u64,
605}
606#[derive(serde::Deserialize, serde::Serialize)]
607#[allow(clippy::derive_partial_eq_without_eq)]
608#[derive(Clone, PartialEq, ::prost::Message)]
609pub struct Branch {
610    #[prost(uint64, tag = "1")]
611    pub id: u64,
612    #[prost(uint64, repeated, tag = "2")]
613    pub source_branch_ids: ::prost::alloc::vec::Vec<u64>,
614    #[prost(message, repeated, tag = "3")]
615    pub divergent_branches: ::prost::alloc::vec::Vec<DivergentBranch>,
616    #[prost(uint64, tag = "4")]
617    pub diverges_at_counter: u64,
618}
619#[derive(serde::Deserialize, serde::Serialize)]
620#[allow(clippy::derive_partial_eq_without_eq)]
621#[derive(Clone, PartialEq, ::prost::Message)]
622pub struct Empty {}
623/// This is the return value from api calls that reports the current counter and branch the operation
624/// was performed on.
625#[derive(serde::Deserialize, serde::Serialize)]
626#[derive(typescript_type_def::TypeDef)]
627#[allow(clippy::derive_partial_eq_without_eq)]
628#[derive(Clone, PartialEq, ::prost::Message)]
629pub struct ExecutionStatus {
630    #[prost(string, tag = "1")]
631    pub id: ::prost::alloc::string::String,
632    #[prost(uint64, tag = "2")]
633    pub monotonic_counter: u64,
634    #[prost(uint64, tag = "3")]
635    pub branch: u64,
636}
637#[derive(serde::Deserialize, serde::Serialize)]
638#[allow(clippy::derive_partial_eq_without_eq)]
639#[derive(Clone, PartialEq, ::prost::Message)]
640pub struct FileAddressedChangeValueWithCounter {
641    #[prost(string, tag = "1")]
642    pub id: ::prost::alloc::string::String,
643    #[prost(string, tag = "2")]
644    pub node_name: ::prost::alloc::string::String,
645    #[prost(uint64, tag = "3")]
646    pub branch: u64,
647    #[prost(uint64, tag = "4")]
648    pub counter: u64,
649    #[prost(message, optional, tag = "5")]
650    pub change: ::core::option::Option<ChangeValueWithCounter>,
651}
652#[derive(serde::Deserialize, serde::Serialize)]
653#[allow(clippy::derive_partial_eq_without_eq)]
654#[derive(Clone, PartialEq, ::prost::Message)]
655pub struct RequestOnlyId {
656    #[prost(string, tag = "1")]
657    pub id: ::prost::alloc::string::String,
658    #[prost(uint64, tag = "2")]
659    pub branch: u64,
660}
661#[derive(serde::Deserialize, serde::Serialize)]
662#[allow(clippy::derive_partial_eq_without_eq)]
663#[derive(Clone, PartialEq, ::prost::Message)]
664pub struct FilteredPollNodeWillExecuteEventsRequest {
665    #[prost(string, tag = "1")]
666    pub id: ::prost::alloc::string::String,
667}
668#[derive(serde::Deserialize, serde::Serialize)]
669#[allow(clippy::derive_partial_eq_without_eq)]
670#[derive(Clone, PartialEq, ::prost::Message)]
671pub struct RequestAtFrame {
672    #[prost(string, tag = "1")]
673    pub id: ::prost::alloc::string::String,
674    #[prost(uint64, tag = "2")]
675    pub frame: u64,
676    #[prost(uint64, tag = "3")]
677    pub branch: u64,
678}
679#[derive(serde::Deserialize, serde::Serialize)]
680#[allow(clippy::derive_partial_eq_without_eq)]
681#[derive(Clone, PartialEq, ::prost::Message)]
682pub struct RequestNewBranch {
683    #[prost(string, tag = "1")]
684    pub id: ::prost::alloc::string::String,
685    #[prost(uint64, tag = "2")]
686    pub source_branch_id: u64,
687    #[prost(uint64, tag = "3")]
688    pub diverges_at_counter: u64,
689}
690#[derive(serde::Deserialize, serde::Serialize)]
691#[allow(clippy::derive_partial_eq_without_eq)]
692#[derive(Clone, PartialEq, ::prost::Message)]
693pub struct RequestListBranches {
694    #[prost(string, tag = "1")]
695    pub id: ::prost::alloc::string::String,
696}
697#[derive(serde::Deserialize, serde::Serialize)]
698#[allow(clippy::derive_partial_eq_without_eq)]
699#[derive(Clone, PartialEq, ::prost::Message)]
700pub struct ListBranchesRes {
701    #[prost(string, tag = "1")]
702    pub id: ::prost::alloc::string::String,
703    #[prost(message, repeated, tag = "2")]
704    pub branches: ::prost::alloc::vec::Vec<Branch>,
705}
706#[derive(serde::Deserialize, serde::Serialize)]
707#[allow(clippy::derive_partial_eq_without_eq)]
708#[derive(Clone, PartialEq, ::prost::Message)]
709pub struct RequestFileMerge {
710    #[prost(string, tag = "1")]
711    pub id: ::prost::alloc::string::String,
712    #[prost(message, optional, tag = "2")]
713    pub file: ::core::option::Option<File>,
714    #[prost(uint64, tag = "3")]
715    pub branch: u64,
716}
717#[derive(serde::Deserialize, serde::Serialize)]
718#[allow(clippy::derive_partial_eq_without_eq)]
719#[derive(Clone, PartialEq, ::prost::Message)]
720pub struct ParquetFile {
721    #[prost(bytes = "vec", tag = "1")]
722    pub data: ::prost::alloc::vec::Vec<u8>,
723}
724#[derive(serde::Deserialize, serde::Serialize)]
725#[allow(clippy::derive_partial_eq_without_eq)]
726#[derive(Clone, PartialEq, ::prost::Message)]
727pub struct QueryAtFrame {
728    #[prost(string, tag = "1")]
729    pub id: ::prost::alloc::string::String,
730    #[prost(message, optional, tag = "2")]
731    pub query: ::core::option::Option<Query>,
732    #[prost(uint64, tag = "3")]
733    pub frame: u64,
734    #[prost(uint64, tag = "4")]
735    pub branch: u64,
736}
737#[derive(serde::Deserialize, serde::Serialize)]
738#[allow(clippy::derive_partial_eq_without_eq)]
739#[derive(Clone, PartialEq, ::prost::Message)]
740pub struct QueryAtFrameResponse {
741    #[prost(message, repeated, tag = "1")]
742    pub values: ::prost::alloc::vec::Vec<WrappedChangeValue>,
743}
744#[derive(serde::Deserialize, serde::Serialize)]
745#[allow(clippy::derive_partial_eq_without_eq)]
746#[derive(Clone, PartialEq, ::prost::Message)]
747pub struct RequestAckNodeWillExecuteEvent {
748    #[prost(string, tag = "1")]
749    pub id: ::prost::alloc::string::String,
750    #[prost(uint64, tag = "3")]
751    pub branch: u64,
752    #[prost(uint64, tag = "4")]
753    pub counter: u64,
754}
755#[derive(serde::Deserialize, serde::Serialize)]
756#[allow(clippy::derive_partial_eq_without_eq)]
757#[derive(Clone, PartialEq, ::prost::Message)]
758pub struct RespondPollNodeWillExecuteEvents {
759    #[prost(message, repeated, tag = "1")]
760    pub node_will_execute_events: ::prost::alloc::vec::Vec<NodeWillExecuteOnBranch>,
761}
762#[derive(serde::Deserialize, serde::Serialize)]
763#[allow(clippy::derive_partial_eq_without_eq)]
764#[derive(Clone, PartialEq, ::prost::Message)]
765pub struct PromptLibraryRecord {
766    #[prost(message, optional, tag = "1")]
767    pub record: ::core::option::Option<UpsertPromptLibraryRecord>,
768    #[prost(uint64, tag = "3")]
769    pub version_counter: u64,
770}
771#[derive(serde::Deserialize, serde::Serialize)]
772#[allow(clippy::derive_partial_eq_without_eq)]
773#[derive(Clone, PartialEq, ::prost::Message)]
774pub struct UpsertPromptLibraryRecord {
775    #[prost(string, tag = "1")]
776    pub template: ::prost::alloc::string::String,
777    #[prost(string, tag = "2")]
778    pub name: ::prost::alloc::string::String,
779    #[prost(string, tag = "3")]
780    pub id: ::prost::alloc::string::String,
781    #[prost(string, optional, tag = "4")]
782    pub description: ::core::option::Option<::prost::alloc::string::String>,
783}
784#[derive(serde::Deserialize, serde::Serialize)]
785#[allow(clippy::derive_partial_eq_without_eq)]
786#[derive(Clone, PartialEq, ::prost::Message)]
787pub struct ListRegisteredGraphsResponse {
788    #[prost(string, repeated, tag = "1")]
789    pub ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
790}
791#[derive(serde::Deserialize, serde::Serialize)]
792#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
793#[repr(i32)]
794pub enum SupportedChatModel {
795    Gpt4 = 0,
796    Gpt40314 = 1,
797    Gpt432k = 2,
798    Gpt432k0314 = 3,
799    Gpt35Turbo = 4,
800    Gpt35Turbo0301 = 5,
801}
802impl SupportedChatModel {
803    /// String value of the enum field names used in the ProtoBuf definition.
804    ///
805    /// The values are not transformed in any way and thus are considered stable
806    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
807    pub fn as_str_name(&self) -> &'static str {
808        match self {
809            SupportedChatModel::Gpt4 => "GPT_4",
810            SupportedChatModel::Gpt40314 => "GPT_4_0314",
811            SupportedChatModel::Gpt432k => "GPT_4_32K",
812            SupportedChatModel::Gpt432k0314 => "GPT_4_32K_0314",
813            SupportedChatModel::Gpt35Turbo => "GPT_3_5_TURBO",
814            SupportedChatModel::Gpt35Turbo0301 => "GPT_3_5_TURBO_0301",
815        }
816    }
817    /// Creates an enum from field names used in the ProtoBuf definition.
818    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
819        match value {
820            "GPT_4" => Some(Self::Gpt4),
821            "GPT_4_0314" => Some(Self::Gpt40314),
822            "GPT_4_32K" => Some(Self::Gpt432k),
823            "GPT_4_32K_0314" => Some(Self::Gpt432k0314),
824            "GPT_3_5_TURBO" => Some(Self::Gpt35Turbo),
825            "GPT_3_5_TURBO_0301" => Some(Self::Gpt35Turbo0301),
826            _ => None,
827        }
828    }
829}
830#[derive(serde::Deserialize, serde::Serialize)]
831#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
832#[repr(i32)]
833pub enum SupportedCompletionModel {
834    TextDavinci003 = 0,
835    TextDavinci002 = 1,
836    TextCurie001 = 2,
837    TextBabbage001 = 3,
838    TextAda00 = 4,
839}
840impl SupportedCompletionModel {
841    /// String value of the enum field names used in the ProtoBuf definition.
842    ///
843    /// The values are not transformed in any way and thus are considered stable
844    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
845    pub fn as_str_name(&self) -> &'static str {
846        match self {
847            SupportedCompletionModel::TextDavinci003 => "TEXT_DAVINCI_003",
848            SupportedCompletionModel::TextDavinci002 => "TEXT_DAVINCI_002",
849            SupportedCompletionModel::TextCurie001 => "TEXT_CURIE_001",
850            SupportedCompletionModel::TextBabbage001 => "TEXT_BABBAGE_001",
851            SupportedCompletionModel::TextAda00 => "TEXT_ADA_00",
852        }
853    }
854    /// Creates an enum from field names used in the ProtoBuf definition.
855    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
856        match value {
857            "TEXT_DAVINCI_003" => Some(Self::TextDavinci003),
858            "TEXT_DAVINCI_002" => Some(Self::TextDavinci002),
859            "TEXT_CURIE_001" => Some(Self::TextCurie001),
860            "TEXT_BABBAGE_001" => Some(Self::TextBabbage001),
861            "TEXT_ADA_00" => Some(Self::TextAda00),
862            _ => None,
863        }
864    }
865}
866#[derive(serde::Deserialize, serde::Serialize)]
867#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
868#[repr(i32)]
869pub enum SupportedEmebddingModel {
870    TextEmbeddingAda002 = 0,
871    TextSearchAdaDoc001 = 1,
872}
873impl SupportedEmebddingModel {
874    /// String value of the enum field names used in the ProtoBuf definition.
875    ///
876    /// The values are not transformed in any way and thus are considered stable
877    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
878    pub fn as_str_name(&self) -> &'static str {
879        match self {
880            SupportedEmebddingModel::TextEmbeddingAda002 => "TEXT_EMBEDDING_ADA_002",
881            SupportedEmebddingModel::TextSearchAdaDoc001 => "TEXT_SEARCH_ADA_DOC_001",
882        }
883    }
884    /// Creates an enum from field names used in the ProtoBuf definition.
885    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
886        match value {
887            "TEXT_EMBEDDING_ADA_002" => Some(Self::TextEmbeddingAda002),
888            "TEXT_SEARCH_ADA_DOC_001" => Some(Self::TextSearchAdaDoc001),
889            _ => None,
890        }
891    }
892}
893#[derive(serde::Deserialize, serde::Serialize)]
894#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
895#[repr(i32)]
896pub enum SupportedVectorDatabase {
897    InMemory = 0,
898    Chroma = 1,
899    Pineconedb = 2,
900    Qdrant = 3,
901}
902impl SupportedVectorDatabase {
903    /// String value of the enum field names used in the ProtoBuf definition.
904    ///
905    /// The values are not transformed in any way and thus are considered stable
906    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
907    pub fn as_str_name(&self) -> &'static str {
908        match self {
909            SupportedVectorDatabase::InMemory => "IN_MEMORY",
910            SupportedVectorDatabase::Chroma => "CHROMA",
911            SupportedVectorDatabase::Pineconedb => "PINECONEDB",
912            SupportedVectorDatabase::Qdrant => "QDRANT",
913        }
914    }
915    /// Creates an enum from field names used in the ProtoBuf definition.
916    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
917        match value {
918            "IN_MEMORY" => Some(Self::InMemory),
919            "CHROMA" => Some(Self::Chroma),
920            "PINECONEDB" => Some(Self::Pineconedb),
921            "QDRANT" => Some(Self::Qdrant),
922            _ => None,
923        }
924    }
925}
926#[derive(serde::Deserialize, serde::Serialize)]
927#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
928#[repr(i32)]
929pub enum SupportedSourceCodeLanguages {
930    Deno = 0,
931    Starlark = 1,
932}
933impl SupportedSourceCodeLanguages {
934    /// String value of the enum field names used in the ProtoBuf definition.
935    ///
936    /// The values are not transformed in any way and thus are considered stable
937    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
938    pub fn as_str_name(&self) -> &'static str {
939        match self {
940            SupportedSourceCodeLanguages::Deno => "DENO",
941            SupportedSourceCodeLanguages::Starlark => "STARLARK",
942        }
943    }
944    /// Creates an enum from field names used in the ProtoBuf definition.
945    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
946        match value {
947            "DENO" => Some(Self::Deno),
948            "STARLARK" => Some(Self::Starlark),
949            _ => None,
950        }
951    }
952}
953#[derive(serde::Deserialize, serde::Serialize)]
954#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
955#[repr(i32)]
956pub enum MemoryAction {
957    Read = 0,
958    Write = 1,
959    Delete = 2,
960}
961impl MemoryAction {
962    /// String value of the enum field names used in the ProtoBuf definition.
963    ///
964    /// The values are not transformed in any way and thus are considered stable
965    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
966    pub fn as_str_name(&self) -> &'static str {
967        match self {
968            MemoryAction::Read => "READ",
969            MemoryAction::Write => "WRITE",
970            MemoryAction::Delete => "DELETE",
971        }
972    }
973    /// Creates an enum from field names used in the ProtoBuf definition.
974    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
975        match value {
976            "READ" => Some(Self::Read),
977            "WRITE" => Some(Self::Write),
978            "DELETE" => Some(Self::Delete),
979            _ => None,
980        }
981    }
982}
983/// Generated client implementations.
984pub mod execution_runtime_client {
985    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
986    use tonic::codegen::*;
987    use tonic::codegen::http::Uri;
988    /// API:
989    #[derive(Debug, Clone)]
990    pub struct ExecutionRuntimeClient<T> {
991        inner: tonic::client::Grpc<T>,
992    }
993    impl ExecutionRuntimeClient<tonic::transport::Channel> {
994        /// Attempt to create a new client by connecting to a given endpoint.
995        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
996        where
997            D: TryInto<tonic::transport::Endpoint>,
998            D::Error: Into<StdError>,
999        {
1000            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1001            Ok(Self::new(conn))
1002        }
1003    }
1004    impl<T> ExecutionRuntimeClient<T>
1005    where
1006        T: tonic::client::GrpcService<tonic::body::BoxBody>,
1007        T::Error: Into<StdError>,
1008        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
1009        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
1010    {
1011        pub fn new(inner: T) -> Self {
1012            let inner = tonic::client::Grpc::new(inner);
1013            Self { inner }
1014        }
1015        pub fn with_origin(inner: T, origin: Uri) -> Self {
1016            let inner = tonic::client::Grpc::with_origin(inner, origin);
1017            Self { inner }
1018        }
1019        pub fn with_interceptor<F>(
1020            inner: T,
1021            interceptor: F,
1022        ) -> ExecutionRuntimeClient<InterceptedService<T, F>>
1023        where
1024            F: tonic::service::Interceptor,
1025            T::ResponseBody: Default,
1026            T: tonic::codegen::Service<
1027                http::Request<tonic::body::BoxBody>,
1028                Response = http::Response<
1029                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1030                >,
1031            >,
1032            <T as tonic::codegen::Service<
1033                http::Request<tonic::body::BoxBody>,
1034            >>::Error: Into<StdError> + Send + Sync,
1035        {
1036            ExecutionRuntimeClient::new(InterceptedService::new(inner, interceptor))
1037        }
1038        /// Compress requests with the given encoding.
1039        ///
1040        /// This requires the server to support it otherwise it might respond with an
1041        /// error.
1042        #[must_use]
1043        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1044            self.inner = self.inner.send_compressed(encoding);
1045            self
1046        }
1047        /// Enable decompressing responses.
1048        #[must_use]
1049        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1050            self.inner = self.inner.accept_compressed(encoding);
1051            self
1052        }
1053        /// Limits the maximum size of a decoded message.
1054        ///
1055        /// Default: `4MB`
1056        #[must_use]
1057        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1058            self.inner = self.inner.max_decoding_message_size(limit);
1059            self
1060        }
1061        /// Limits the maximum size of an encoded message.
1062        ///
1063        /// Default: `usize::MAX`
1064        #[must_use]
1065        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1066            self.inner = self.inner.max_encoding_message_size(limit);
1067            self
1068        }
1069        pub async fn run_query(
1070            &mut self,
1071            request: impl tonic::IntoRequest<super::QueryAtFrame>,
1072        ) -> std::result::Result<
1073            tonic::Response<super::QueryAtFrameResponse>,
1074            tonic::Status,
1075        > {
1076            self.inner
1077                .ready()
1078                .await
1079                .map_err(|e| {
1080                    tonic::Status::new(
1081                        tonic::Code::Unknown,
1082                        format!("Service was not ready: {}", e.into()),
1083                    )
1084                })?;
1085            let codec = tonic::codec::ProstCodec::default();
1086            let path = http::uri::PathAndQuery::from_static(
1087                "/promptgraph.ExecutionRuntime/RunQuery",
1088            );
1089            let mut req = request.into_request();
1090            req.extensions_mut()
1091                .insert(GrpcMethod::new("promptgraph.ExecutionRuntime", "RunQuery"));
1092            self.inner.unary(req, path, codec).await
1093        }
1094        /// * Merge a new file - if an existing file is available at the id, will merge the new file into the existing one
1095        pub async fn merge(
1096            &mut self,
1097            request: impl tonic::IntoRequest<super::RequestFileMerge>,
1098        ) -> std::result::Result<
1099            tonic::Response<super::ExecutionStatus>,
1100            tonic::Status,
1101        > {
1102            self.inner
1103                .ready()
1104                .await
1105                .map_err(|e| {
1106                    tonic::Status::new(
1107                        tonic::Code::Unknown,
1108                        format!("Service was not ready: {}", e.into()),
1109                    )
1110                })?;
1111            let codec = tonic::codec::ProstCodec::default();
1112            let path = http::uri::PathAndQuery::from_static(
1113                "/promptgraph.ExecutionRuntime/Merge",
1114            );
1115            let mut req = request.into_request();
1116            req.extensions_mut()
1117                .insert(GrpcMethod::new("promptgraph.ExecutionRuntime", "Merge"));
1118            self.inner.unary(req, path, codec).await
1119        }
1120        /// * Get the current graph state of a file at a branch and counter position
1121        pub async fn current_file_state(
1122            &mut self,
1123            request: impl tonic::IntoRequest<super::RequestOnlyId>,
1124        ) -> std::result::Result<tonic::Response<super::File>, tonic::Status> {
1125            self.inner
1126                .ready()
1127                .await
1128                .map_err(|e| {
1129                    tonic::Status::new(
1130                        tonic::Code::Unknown,
1131                        format!("Service was not ready: {}", e.into()),
1132                    )
1133                })?;
1134            let codec = tonic::codec::ProstCodec::default();
1135            let path = http::uri::PathAndQuery::from_static(
1136                "/promptgraph.ExecutionRuntime/CurrentFileState",
1137            );
1138            let mut req = request.into_request();
1139            req.extensions_mut()
1140                .insert(
1141                    GrpcMethod::new("promptgraph.ExecutionRuntime", "CurrentFileState"),
1142                );
1143            self.inner.unary(req, path, codec).await
1144        }
1145        /// * Get the parquet history for a specific branch and Id - returns bytes
1146        pub async fn get_parquet_history(
1147            &mut self,
1148            request: impl tonic::IntoRequest<super::RequestOnlyId>,
1149        ) -> std::result::Result<tonic::Response<super::ParquetFile>, tonic::Status> {
1150            self.inner
1151                .ready()
1152                .await
1153                .map_err(|e| {
1154                    tonic::Status::new(
1155                        tonic::Code::Unknown,
1156                        format!("Service was not ready: {}", e.into()),
1157                    )
1158                })?;
1159            let codec = tonic::codec::ProstCodec::default();
1160            let path = http::uri::PathAndQuery::from_static(
1161                "/promptgraph.ExecutionRuntime/GetParquetHistory",
1162            );
1163            let mut req = request.into_request();
1164            req.extensions_mut()
1165                .insert(
1166                    GrpcMethod::new("promptgraph.ExecutionRuntime", "GetParquetHistory"),
1167                );
1168            self.inner.unary(req, path, codec).await
1169        }
1170        /// * Resume execution
1171        pub async fn play(
1172            &mut self,
1173            request: impl tonic::IntoRequest<super::RequestAtFrame>,
1174        ) -> std::result::Result<
1175            tonic::Response<super::ExecutionStatus>,
1176            tonic::Status,
1177        > {
1178            self.inner
1179                .ready()
1180                .await
1181                .map_err(|e| {
1182                    tonic::Status::new(
1183                        tonic::Code::Unknown,
1184                        format!("Service was not ready: {}", e.into()),
1185                    )
1186                })?;
1187            let codec = tonic::codec::ProstCodec::default();
1188            let path = http::uri::PathAndQuery::from_static(
1189                "/promptgraph.ExecutionRuntime/Play",
1190            );
1191            let mut req = request.into_request();
1192            req.extensions_mut()
1193                .insert(GrpcMethod::new("promptgraph.ExecutionRuntime", "Play"));
1194            self.inner.unary(req, path, codec).await
1195        }
1196        /// * Pause execution
1197        pub async fn pause(
1198            &mut self,
1199            request: impl tonic::IntoRequest<super::RequestAtFrame>,
1200        ) -> std::result::Result<
1201            tonic::Response<super::ExecutionStatus>,
1202            tonic::Status,
1203        > {
1204            self.inner
1205                .ready()
1206                .await
1207                .map_err(|e| {
1208                    tonic::Status::new(
1209                        tonic::Code::Unknown,
1210                        format!("Service was not ready: {}", e.into()),
1211                    )
1212                })?;
1213            let codec = tonic::codec::ProstCodec::default();
1214            let path = http::uri::PathAndQuery::from_static(
1215                "/promptgraph.ExecutionRuntime/Pause",
1216            );
1217            let mut req = request.into_request();
1218            req.extensions_mut()
1219                .insert(GrpcMethod::new("promptgraph.ExecutionRuntime", "Pause"));
1220            self.inner.unary(req, path, codec).await
1221        }
1222        /// * Split history into a separate branch
1223        pub async fn branch(
1224            &mut self,
1225            request: impl tonic::IntoRequest<super::RequestNewBranch>,
1226        ) -> std::result::Result<
1227            tonic::Response<super::ExecutionStatus>,
1228            tonic::Status,
1229        > {
1230            self.inner
1231                .ready()
1232                .await
1233                .map_err(|e| {
1234                    tonic::Status::new(
1235                        tonic::Code::Unknown,
1236                        format!("Service was not ready: {}", e.into()),
1237                    )
1238                })?;
1239            let codec = tonic::codec::ProstCodec::default();
1240            let path = http::uri::PathAndQuery::from_static(
1241                "/promptgraph.ExecutionRuntime/Branch",
1242            );
1243            let mut req = request.into_request();
1244            req.extensions_mut()
1245                .insert(GrpcMethod::new("promptgraph.ExecutionRuntime", "Branch"));
1246            self.inner.unary(req, path, codec).await
1247        }
1248        /// * Get all branches
1249        pub async fn list_branches(
1250            &mut self,
1251            request: impl tonic::IntoRequest<super::RequestListBranches>,
1252        ) -> std::result::Result<
1253            tonic::Response<super::ListBranchesRes>,
1254            tonic::Status,
1255        > {
1256            self.inner
1257                .ready()
1258                .await
1259                .map_err(|e| {
1260                    tonic::Status::new(
1261                        tonic::Code::Unknown,
1262                        format!("Service was not ready: {}", e.into()),
1263                    )
1264                })?;
1265            let codec = tonic::codec::ProstCodec::default();
1266            let path = http::uri::PathAndQuery::from_static(
1267                "/promptgraph.ExecutionRuntime/ListBranches",
1268            );
1269            let mut req = request.into_request();
1270            req.extensions_mut()
1271                .insert(GrpcMethod::new("promptgraph.ExecutionRuntime", "ListBranches"));
1272            self.inner.unary(req, path, codec).await
1273        }
1274        /// * List all registered files
1275        pub async fn list_registered_graphs(
1276            &mut self,
1277            request: impl tonic::IntoRequest<super::Empty>,
1278        ) -> std::result::Result<
1279            tonic::Response<super::ListRegisteredGraphsResponse>,
1280            tonic::Status,
1281        > {
1282            self.inner
1283                .ready()
1284                .await
1285                .map_err(|e| {
1286                    tonic::Status::new(
1287                        tonic::Code::Unknown,
1288                        format!("Service was not ready: {}", e.into()),
1289                    )
1290                })?;
1291            let codec = tonic::codec::ProstCodec::default();
1292            let path = http::uri::PathAndQuery::from_static(
1293                "/promptgraph.ExecutionRuntime/ListRegisteredGraphs",
1294            );
1295            let mut req = request.into_request();
1296            req.extensions_mut()
1297                .insert(
1298                    GrpcMethod::new(
1299                        "promptgraph.ExecutionRuntime",
1300                        "ListRegisteredGraphs",
1301                    ),
1302                );
1303            self.inner.unary(req, path, codec).await
1304        }
1305        /// * Receive a stream of input proposals <- this is a server-side stream
1306        pub async fn list_input_proposals(
1307            &mut self,
1308            request: impl tonic::IntoRequest<super::RequestOnlyId>,
1309        ) -> std::result::Result<
1310            tonic::Response<tonic::codec::Streaming<super::InputProposal>>,
1311            tonic::Status,
1312        > {
1313            self.inner
1314                .ready()
1315                .await
1316                .map_err(|e| {
1317                    tonic::Status::new(
1318                        tonic::Code::Unknown,
1319                        format!("Service was not ready: {}", e.into()),
1320                    )
1321                })?;
1322            let codec = tonic::codec::ProstCodec::default();
1323            let path = http::uri::PathAndQuery::from_static(
1324                "/promptgraph.ExecutionRuntime/ListInputProposals",
1325            );
1326            let mut req = request.into_request();
1327            req.extensions_mut()
1328                .insert(
1329                    GrpcMethod::new("promptgraph.ExecutionRuntime", "ListInputProposals"),
1330                );
1331            self.inner.server_streaming(req, path, codec).await
1332        }
1333        /// * Push responses to input proposals (these wait for some input from a host until they're resolved) <- RPC client to server
1334        pub async fn respond_to_input_proposal(
1335            &mut self,
1336            request: impl tonic::IntoRequest<super::RequestInputProposalResponse>,
1337        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
1338            self.inner
1339                .ready()
1340                .await
1341                .map_err(|e| {
1342                    tonic::Status::new(
1343                        tonic::Code::Unknown,
1344                        format!("Service was not ready: {}", e.into()),
1345                    )
1346                })?;
1347            let codec = tonic::codec::ProstCodec::default();
1348            let path = http::uri::PathAndQuery::from_static(
1349                "/promptgraph.ExecutionRuntime/RespondToInputProposal",
1350            );
1351            let mut req = request.into_request();
1352            req.extensions_mut()
1353                .insert(
1354                    GrpcMethod::new(
1355                        "promptgraph.ExecutionRuntime",
1356                        "RespondToInputProposal",
1357                    ),
1358                );
1359            self.inner.unary(req, path, codec).await
1360        }
1361        /// * Observe the stream of execution events <- this is a server-side stream
1362        pub async fn list_change_events(
1363            &mut self,
1364            request: impl tonic::IntoRequest<super::RequestOnlyId>,
1365        ) -> std::result::Result<
1366            tonic::Response<tonic::codec::Streaming<super::ChangeValueWithCounter>>,
1367            tonic::Status,
1368        > {
1369            self.inner
1370                .ready()
1371                .await
1372                .map_err(|e| {
1373                    tonic::Status::new(
1374                        tonic::Code::Unknown,
1375                        format!("Service was not ready: {}", e.into()),
1376                    )
1377                })?;
1378            let codec = tonic::codec::ProstCodec::default();
1379            let path = http::uri::PathAndQuery::from_static(
1380                "/promptgraph.ExecutionRuntime/ListChangeEvents",
1381            );
1382            let mut req = request.into_request();
1383            req.extensions_mut()
1384                .insert(
1385                    GrpcMethod::new("promptgraph.ExecutionRuntime", "ListChangeEvents"),
1386                );
1387            self.inner.server_streaming(req, path, codec).await
1388        }
1389        pub async fn list_node_will_execute_events(
1390            &mut self,
1391            request: impl tonic::IntoRequest<super::RequestOnlyId>,
1392        ) -> std::result::Result<
1393            tonic::Response<tonic::codec::Streaming<super::NodeWillExecuteOnBranch>>,
1394            tonic::Status,
1395        > {
1396            self.inner
1397                .ready()
1398                .await
1399                .map_err(|e| {
1400                    tonic::Status::new(
1401                        tonic::Code::Unknown,
1402                        format!("Service was not ready: {}", e.into()),
1403                    )
1404                })?;
1405            let codec = tonic::codec::ProstCodec::default();
1406            let path = http::uri::PathAndQuery::from_static(
1407                "/promptgraph.ExecutionRuntime/ListNodeWillExecuteEvents",
1408            );
1409            let mut req = request.into_request();
1410            req.extensions_mut()
1411                .insert(
1412                    GrpcMethod::new(
1413                        "promptgraph.ExecutionRuntime",
1414                        "ListNodeWillExecuteEvents",
1415                    ),
1416                );
1417            self.inner.server_streaming(req, path, codec).await
1418        }
1419        /// * Observe when the server thinks our local node implementation should execute and with what changes
1420        pub async fn poll_custom_node_will_execute_events(
1421            &mut self,
1422            request: impl tonic::IntoRequest<
1423                super::FilteredPollNodeWillExecuteEventsRequest,
1424            >,
1425        ) -> std::result::Result<
1426            tonic::Response<super::RespondPollNodeWillExecuteEvents>,
1427            tonic::Status,
1428        > {
1429            self.inner
1430                .ready()
1431                .await
1432                .map_err(|e| {
1433                    tonic::Status::new(
1434                        tonic::Code::Unknown,
1435                        format!("Service was not ready: {}", e.into()),
1436                    )
1437                })?;
1438            let codec = tonic::codec::ProstCodec::default();
1439            let path = http::uri::PathAndQuery::from_static(
1440                "/promptgraph.ExecutionRuntime/PollCustomNodeWillExecuteEvents",
1441            );
1442            let mut req = request.into_request();
1443            req.extensions_mut()
1444                .insert(
1445                    GrpcMethod::new(
1446                        "promptgraph.ExecutionRuntime",
1447                        "PollCustomNodeWillExecuteEvents",
1448                    ),
1449                );
1450            self.inner.unary(req, path, codec).await
1451        }
1452        pub async fn ack_node_will_execute_event(
1453            &mut self,
1454            request: impl tonic::IntoRequest<super::RequestAckNodeWillExecuteEvent>,
1455        ) -> std::result::Result<
1456            tonic::Response<super::ExecutionStatus>,
1457            tonic::Status,
1458        > {
1459            self.inner
1460                .ready()
1461                .await
1462                .map_err(|e| {
1463                    tonic::Status::new(
1464                        tonic::Code::Unknown,
1465                        format!("Service was not ready: {}", e.into()),
1466                    )
1467                })?;
1468            let codec = tonic::codec::ProstCodec::default();
1469            let path = http::uri::PathAndQuery::from_static(
1470                "/promptgraph.ExecutionRuntime/AckNodeWillExecuteEvent",
1471            );
1472            let mut req = request.into_request();
1473            req.extensions_mut()
1474                .insert(
1475                    GrpcMethod::new(
1476                        "promptgraph.ExecutionRuntime",
1477                        "AckNodeWillExecuteEvent",
1478                    ),
1479                );
1480            self.inner.unary(req, path, codec).await
1481        }
1482        /// * Receive events from workers <- this is an RPC client to server, we don't need to wait for a response from the server
1483        pub async fn push_worker_event(
1484            &mut self,
1485            request: impl tonic::IntoRequest<super::FileAddressedChangeValueWithCounter>,
1486        ) -> std::result::Result<
1487            tonic::Response<super::ExecutionStatus>,
1488            tonic::Status,
1489        > {
1490            self.inner
1491                .ready()
1492                .await
1493                .map_err(|e| {
1494                    tonic::Status::new(
1495                        tonic::Code::Unknown,
1496                        format!("Service was not ready: {}", e.into()),
1497                    )
1498                })?;
1499            let codec = tonic::codec::ProstCodec::default();
1500            let path = http::uri::PathAndQuery::from_static(
1501                "/promptgraph.ExecutionRuntime/PushWorkerEvent",
1502            );
1503            let mut req = request.into_request();
1504            req.extensions_mut()
1505                .insert(
1506                    GrpcMethod::new("promptgraph.ExecutionRuntime", "PushWorkerEvent"),
1507                );
1508            self.inner.unary(req, path, codec).await
1509        }
1510        pub async fn push_template_partial(
1511            &mut self,
1512            request: impl tonic::IntoRequest<super::UpsertPromptLibraryRecord>,
1513        ) -> std::result::Result<
1514            tonic::Response<super::ExecutionStatus>,
1515            tonic::Status,
1516        > {
1517            self.inner
1518                .ready()
1519                .await
1520                .map_err(|e| {
1521                    tonic::Status::new(
1522                        tonic::Code::Unknown,
1523                        format!("Service was not ready: {}", e.into()),
1524                    )
1525                })?;
1526            let codec = tonic::codec::ProstCodec::default();
1527            let path = http::uri::PathAndQuery::from_static(
1528                "/promptgraph.ExecutionRuntime/PushTemplatePartial",
1529            );
1530            let mut req = request.into_request();
1531            req.extensions_mut()
1532                .insert(
1533                    GrpcMethod::new(
1534                        "promptgraph.ExecutionRuntime",
1535                        "PushTemplatePartial",
1536                    ),
1537                );
1538            self.inner.unary(req, path, codec).await
1539        }
1540    }
1541}
1542/// Generated server implementations.
1543pub mod execution_runtime_server {
1544    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1545    use tonic::codegen::*;
1546    /// Generated trait containing gRPC methods that should be implemented for use with ExecutionRuntimeServer.
1547    #[async_trait]
1548    pub trait ExecutionRuntime: Send + Sync + 'static {
1549        async fn run_query(
1550            &self,
1551            request: tonic::Request<super::QueryAtFrame>,
1552        ) -> std::result::Result<
1553            tonic::Response<super::QueryAtFrameResponse>,
1554            tonic::Status,
1555        >;
1556        /// * Merge a new file - if an existing file is available at the id, will merge the new file into the existing one
1557        async fn merge(
1558            &self,
1559            request: tonic::Request<super::RequestFileMerge>,
1560        ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1561        /// * Get the current graph state of a file at a branch and counter position
1562        async fn current_file_state(
1563            &self,
1564            request: tonic::Request<super::RequestOnlyId>,
1565        ) -> std::result::Result<tonic::Response<super::File>, tonic::Status>;
1566        /// * Get the parquet history for a specific branch and Id - returns bytes
1567        async fn get_parquet_history(
1568            &self,
1569            request: tonic::Request<super::RequestOnlyId>,
1570        ) -> std::result::Result<tonic::Response<super::ParquetFile>, tonic::Status>;
1571        /// * Resume execution
1572        async fn play(
1573            &self,
1574            request: tonic::Request<super::RequestAtFrame>,
1575        ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1576        /// * Pause execution
1577        async fn pause(
1578            &self,
1579            request: tonic::Request<super::RequestAtFrame>,
1580        ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1581        /// * Split history into a separate branch
1582        async fn branch(
1583            &self,
1584            request: tonic::Request<super::RequestNewBranch>,
1585        ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1586        /// * Get all branches
1587        async fn list_branches(
1588            &self,
1589            request: tonic::Request<super::RequestListBranches>,
1590        ) -> std::result::Result<tonic::Response<super::ListBranchesRes>, tonic::Status>;
1591        /// * List all registered files
1592        async fn list_registered_graphs(
1593            &self,
1594            request: tonic::Request<super::Empty>,
1595        ) -> std::result::Result<
1596            tonic::Response<super::ListRegisteredGraphsResponse>,
1597            tonic::Status,
1598        >;
1599        /// Server streaming response type for the ListInputProposals method.
1600        type ListInputProposalsStream: futures_core::Stream<
1601                Item = std::result::Result<super::InputProposal, tonic::Status>,
1602            >
1603            + Send
1604            + 'static;
1605        /// * Receive a stream of input proposals <- this is a server-side stream
1606        async fn list_input_proposals(
1607            &self,
1608            request: tonic::Request<super::RequestOnlyId>,
1609        ) -> std::result::Result<
1610            tonic::Response<Self::ListInputProposalsStream>,
1611            tonic::Status,
1612        >;
1613        /// * Push responses to input proposals (these wait for some input from a host until they're resolved) <- RPC client to server
1614        async fn respond_to_input_proposal(
1615            &self,
1616            request: tonic::Request<super::RequestInputProposalResponse>,
1617        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
1618        /// Server streaming response type for the ListChangeEvents method.
1619        type ListChangeEventsStream: futures_core::Stream<
1620                Item = std::result::Result<super::ChangeValueWithCounter, tonic::Status>,
1621            >
1622            + Send
1623            + 'static;
1624        /// * Observe the stream of execution events <- this is a server-side stream
1625        async fn list_change_events(
1626            &self,
1627            request: tonic::Request<super::RequestOnlyId>,
1628        ) -> std::result::Result<
1629            tonic::Response<Self::ListChangeEventsStream>,
1630            tonic::Status,
1631        >;
1632        /// Server streaming response type for the ListNodeWillExecuteEvents method.
1633        type ListNodeWillExecuteEventsStream: futures_core::Stream<
1634                Item = std::result::Result<super::NodeWillExecuteOnBranch, tonic::Status>,
1635            >
1636            + Send
1637            + 'static;
1638        async fn list_node_will_execute_events(
1639            &self,
1640            request: tonic::Request<super::RequestOnlyId>,
1641        ) -> std::result::Result<
1642            tonic::Response<Self::ListNodeWillExecuteEventsStream>,
1643            tonic::Status,
1644        >;
1645        /// * Observe when the server thinks our local node implementation should execute and with what changes
1646        async fn poll_custom_node_will_execute_events(
1647            &self,
1648            request: tonic::Request<super::FilteredPollNodeWillExecuteEventsRequest>,
1649        ) -> std::result::Result<
1650            tonic::Response<super::RespondPollNodeWillExecuteEvents>,
1651            tonic::Status,
1652        >;
1653        async fn ack_node_will_execute_event(
1654            &self,
1655            request: tonic::Request<super::RequestAckNodeWillExecuteEvent>,
1656        ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1657        /// * Receive events from workers <- this is an RPC client to server, we don't need to wait for a response from the server
1658        async fn push_worker_event(
1659            &self,
1660            request: tonic::Request<super::FileAddressedChangeValueWithCounter>,
1661        ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1662        async fn push_template_partial(
1663            &self,
1664            request: tonic::Request<super::UpsertPromptLibraryRecord>,
1665        ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1666    }
1667    /// API:
1668    #[derive(Debug)]
1669    pub struct ExecutionRuntimeServer<T: ExecutionRuntime> {
1670        inner: _Inner<T>,
1671        accept_compression_encodings: EnabledCompressionEncodings,
1672        send_compression_encodings: EnabledCompressionEncodings,
1673        max_decoding_message_size: Option<usize>,
1674        max_encoding_message_size: Option<usize>,
1675    }
1676    struct _Inner<T>(Arc<T>);
1677    impl<T: ExecutionRuntime> ExecutionRuntimeServer<T> {
1678        pub fn new(inner: T) -> Self {
1679            Self::from_arc(Arc::new(inner))
1680        }
1681        pub fn from_arc(inner: Arc<T>) -> Self {
1682            let inner = _Inner(inner);
1683            Self {
1684                inner,
1685                accept_compression_encodings: Default::default(),
1686                send_compression_encodings: Default::default(),
1687                max_decoding_message_size: None,
1688                max_encoding_message_size: None,
1689            }
1690        }
1691        pub fn with_interceptor<F>(
1692            inner: T,
1693            interceptor: F,
1694        ) -> InterceptedService<Self, F>
1695        where
1696            F: tonic::service::Interceptor,
1697        {
1698            InterceptedService::new(Self::new(inner), interceptor)
1699        }
1700        /// Enable decompressing requests with the given encoding.
1701        #[must_use]
1702        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1703            self.accept_compression_encodings.enable(encoding);
1704            self
1705        }
1706        /// Compress responses with the given encoding, if the client supports it.
1707        #[must_use]
1708        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1709            self.send_compression_encodings.enable(encoding);
1710            self
1711        }
1712        /// Limits the maximum size of a decoded message.
1713        ///
1714        /// Default: `4MB`
1715        #[must_use]
1716        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1717            self.max_decoding_message_size = Some(limit);
1718            self
1719        }
1720        /// Limits the maximum size of an encoded message.
1721        ///
1722        /// Default: `usize::MAX`
1723        #[must_use]
1724        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1725            self.max_encoding_message_size = Some(limit);
1726            self
1727        }
1728    }
1729    impl<T, B> tonic::codegen::Service<http::Request<B>> for ExecutionRuntimeServer<T>
1730    where
1731        T: ExecutionRuntime,
1732        B: Body + Send + 'static,
1733        B::Error: Into<StdError> + Send + 'static,
1734    {
1735        type Response = http::Response<tonic::body::BoxBody>;
1736        type Error = std::convert::Infallible;
1737        type Future = BoxFuture<Self::Response, Self::Error>;
1738        fn poll_ready(
1739            &mut self,
1740            _cx: &mut Context<'_>,
1741        ) -> Poll<std::result::Result<(), Self::Error>> {
1742            Poll::Ready(Ok(()))
1743        }
1744        fn call(&mut self, req: http::Request<B>) -> Self::Future {
1745            let inner = self.inner.clone();
1746            match req.uri().path() {
1747                "/promptgraph.ExecutionRuntime/RunQuery" => {
1748                    #[allow(non_camel_case_types)]
1749                    struct RunQuerySvc<T: ExecutionRuntime>(pub Arc<T>);
1750                    impl<
1751                        T: ExecutionRuntime,
1752                    > tonic::server::UnaryService<super::QueryAtFrame>
1753                    for RunQuerySvc<T> {
1754                        type Response = super::QueryAtFrameResponse;
1755                        type Future = BoxFuture<
1756                            tonic::Response<Self::Response>,
1757                            tonic::Status,
1758                        >;
1759                        fn call(
1760                            &mut self,
1761                            request: tonic::Request<super::QueryAtFrame>,
1762                        ) -> Self::Future {
1763                            let inner = Arc::clone(&self.0);
1764                            let fut = async move { (*inner).run_query(request).await };
1765                            Box::pin(fut)
1766                        }
1767                    }
1768                    let accept_compression_encodings = self.accept_compression_encodings;
1769                    let send_compression_encodings = self.send_compression_encodings;
1770                    let max_decoding_message_size = self.max_decoding_message_size;
1771                    let max_encoding_message_size = self.max_encoding_message_size;
1772                    let inner = self.inner.clone();
1773                    let fut = async move {
1774                        let inner = inner.0;
1775                        let method = RunQuerySvc(inner);
1776                        let codec = tonic::codec::ProstCodec::default();
1777                        let mut grpc = tonic::server::Grpc::new(codec)
1778                            .apply_compression_config(
1779                                accept_compression_encodings,
1780                                send_compression_encodings,
1781                            )
1782                            .apply_max_message_size_config(
1783                                max_decoding_message_size,
1784                                max_encoding_message_size,
1785                            );
1786                        let res = grpc.unary(method, req).await;
1787                        Ok(res)
1788                    };
1789                    Box::pin(fut)
1790                }
1791                "/promptgraph.ExecutionRuntime/Merge" => {
1792                    #[allow(non_camel_case_types)]
1793                    struct MergeSvc<T: ExecutionRuntime>(pub Arc<T>);
1794                    impl<
1795                        T: ExecutionRuntime,
1796                    > tonic::server::UnaryService<super::RequestFileMerge>
1797                    for MergeSvc<T> {
1798                        type Response = super::ExecutionStatus;
1799                        type Future = BoxFuture<
1800                            tonic::Response<Self::Response>,
1801                            tonic::Status,
1802                        >;
1803                        fn call(
1804                            &mut self,
1805                            request: tonic::Request<super::RequestFileMerge>,
1806                        ) -> Self::Future {
1807                            let inner = Arc::clone(&self.0);
1808                            let fut = async move { (*inner).merge(request).await };
1809                            Box::pin(fut)
1810                        }
1811                    }
1812                    let accept_compression_encodings = self.accept_compression_encodings;
1813                    let send_compression_encodings = self.send_compression_encodings;
1814                    let max_decoding_message_size = self.max_decoding_message_size;
1815                    let max_encoding_message_size = self.max_encoding_message_size;
1816                    let inner = self.inner.clone();
1817                    let fut = async move {
1818                        let inner = inner.0;
1819                        let method = MergeSvc(inner);
1820                        let codec = tonic::codec::ProstCodec::default();
1821                        let mut grpc = tonic::server::Grpc::new(codec)
1822                            .apply_compression_config(
1823                                accept_compression_encodings,
1824                                send_compression_encodings,
1825                            )
1826                            .apply_max_message_size_config(
1827                                max_decoding_message_size,
1828                                max_encoding_message_size,
1829                            );
1830                        let res = grpc.unary(method, req).await;
1831                        Ok(res)
1832                    };
1833                    Box::pin(fut)
1834                }
1835                "/promptgraph.ExecutionRuntime/CurrentFileState" => {
1836                    #[allow(non_camel_case_types)]
1837                    struct CurrentFileStateSvc<T: ExecutionRuntime>(pub Arc<T>);
1838                    impl<
1839                        T: ExecutionRuntime,
1840                    > tonic::server::UnaryService<super::RequestOnlyId>
1841                    for CurrentFileStateSvc<T> {
1842                        type Response = super::File;
1843                        type Future = BoxFuture<
1844                            tonic::Response<Self::Response>,
1845                            tonic::Status,
1846                        >;
1847                        fn call(
1848                            &mut self,
1849                            request: tonic::Request<super::RequestOnlyId>,
1850                        ) -> Self::Future {
1851                            let inner = Arc::clone(&self.0);
1852                            let fut = async move {
1853                                (*inner).current_file_state(request).await
1854                            };
1855                            Box::pin(fut)
1856                        }
1857                    }
1858                    let accept_compression_encodings = self.accept_compression_encodings;
1859                    let send_compression_encodings = self.send_compression_encodings;
1860                    let max_decoding_message_size = self.max_decoding_message_size;
1861                    let max_encoding_message_size = self.max_encoding_message_size;
1862                    let inner = self.inner.clone();
1863                    let fut = async move {
1864                        let inner = inner.0;
1865                        let method = CurrentFileStateSvc(inner);
1866                        let codec = tonic::codec::ProstCodec::default();
1867                        let mut grpc = tonic::server::Grpc::new(codec)
1868                            .apply_compression_config(
1869                                accept_compression_encodings,
1870                                send_compression_encodings,
1871                            )
1872                            .apply_max_message_size_config(
1873                                max_decoding_message_size,
1874                                max_encoding_message_size,
1875                            );
1876                        let res = grpc.unary(method, req).await;
1877                        Ok(res)
1878                    };
1879                    Box::pin(fut)
1880                }
1881                "/promptgraph.ExecutionRuntime/GetParquetHistory" => {
1882                    #[allow(non_camel_case_types)]
1883                    struct GetParquetHistorySvc<T: ExecutionRuntime>(pub Arc<T>);
1884                    impl<
1885                        T: ExecutionRuntime,
1886                    > tonic::server::UnaryService<super::RequestOnlyId>
1887                    for GetParquetHistorySvc<T> {
1888                        type Response = super::ParquetFile;
1889                        type Future = BoxFuture<
1890                            tonic::Response<Self::Response>,
1891                            tonic::Status,
1892                        >;
1893                        fn call(
1894                            &mut self,
1895                            request: tonic::Request<super::RequestOnlyId>,
1896                        ) -> Self::Future {
1897                            let inner = Arc::clone(&self.0);
1898                            let fut = async move {
1899                                (*inner).get_parquet_history(request).await
1900                            };
1901                            Box::pin(fut)
1902                        }
1903                    }
1904                    let accept_compression_encodings = self.accept_compression_encodings;
1905                    let send_compression_encodings = self.send_compression_encodings;
1906                    let max_decoding_message_size = self.max_decoding_message_size;
1907                    let max_encoding_message_size = self.max_encoding_message_size;
1908                    let inner = self.inner.clone();
1909                    let fut = async move {
1910                        let inner = inner.0;
1911                        let method = GetParquetHistorySvc(inner);
1912                        let codec = tonic::codec::ProstCodec::default();
1913                        let mut grpc = tonic::server::Grpc::new(codec)
1914                            .apply_compression_config(
1915                                accept_compression_encodings,
1916                                send_compression_encodings,
1917                            )
1918                            .apply_max_message_size_config(
1919                                max_decoding_message_size,
1920                                max_encoding_message_size,
1921                            );
1922                        let res = grpc.unary(method, req).await;
1923                        Ok(res)
1924                    };
1925                    Box::pin(fut)
1926                }
1927                "/promptgraph.ExecutionRuntime/Play" => {
1928                    #[allow(non_camel_case_types)]
1929                    struct PlaySvc<T: ExecutionRuntime>(pub Arc<T>);
1930                    impl<
1931                        T: ExecutionRuntime,
1932                    > tonic::server::UnaryService<super::RequestAtFrame> for PlaySvc<T> {
1933                        type Response = super::ExecutionStatus;
1934                        type Future = BoxFuture<
1935                            tonic::Response<Self::Response>,
1936                            tonic::Status,
1937                        >;
1938                        fn call(
1939                            &mut self,
1940                            request: tonic::Request<super::RequestAtFrame>,
1941                        ) -> Self::Future {
1942                            let inner = Arc::clone(&self.0);
1943                            let fut = async move { (*inner).play(request).await };
1944                            Box::pin(fut)
1945                        }
1946                    }
1947                    let accept_compression_encodings = self.accept_compression_encodings;
1948                    let send_compression_encodings = self.send_compression_encodings;
1949                    let max_decoding_message_size = self.max_decoding_message_size;
1950                    let max_encoding_message_size = self.max_encoding_message_size;
1951                    let inner = self.inner.clone();
1952                    let fut = async move {
1953                        let inner = inner.0;
1954                        let method = PlaySvc(inner);
1955                        let codec = tonic::codec::ProstCodec::default();
1956                        let mut grpc = tonic::server::Grpc::new(codec)
1957                            .apply_compression_config(
1958                                accept_compression_encodings,
1959                                send_compression_encodings,
1960                            )
1961                            .apply_max_message_size_config(
1962                                max_decoding_message_size,
1963                                max_encoding_message_size,
1964                            );
1965                        let res = grpc.unary(method, req).await;
1966                        Ok(res)
1967                    };
1968                    Box::pin(fut)
1969                }
1970                "/promptgraph.ExecutionRuntime/Pause" => {
1971                    #[allow(non_camel_case_types)]
1972                    struct PauseSvc<T: ExecutionRuntime>(pub Arc<T>);
1973                    impl<
1974                        T: ExecutionRuntime,
1975                    > tonic::server::UnaryService<super::RequestAtFrame>
1976                    for PauseSvc<T> {
1977                        type Response = super::ExecutionStatus;
1978                        type Future = BoxFuture<
1979                            tonic::Response<Self::Response>,
1980                            tonic::Status,
1981                        >;
1982                        fn call(
1983                            &mut self,
1984                            request: tonic::Request<super::RequestAtFrame>,
1985                        ) -> Self::Future {
1986                            let inner = Arc::clone(&self.0);
1987                            let fut = async move { (*inner).pause(request).await };
1988                            Box::pin(fut)
1989                        }
1990                    }
1991                    let accept_compression_encodings = self.accept_compression_encodings;
1992                    let send_compression_encodings = self.send_compression_encodings;
1993                    let max_decoding_message_size = self.max_decoding_message_size;
1994                    let max_encoding_message_size = self.max_encoding_message_size;
1995                    let inner = self.inner.clone();
1996                    let fut = async move {
1997                        let inner = inner.0;
1998                        let method = PauseSvc(inner);
1999                        let codec = tonic::codec::ProstCodec::default();
2000                        let mut grpc = tonic::server::Grpc::new(codec)
2001                            .apply_compression_config(
2002                                accept_compression_encodings,
2003                                send_compression_encodings,
2004                            )
2005                            .apply_max_message_size_config(
2006                                max_decoding_message_size,
2007                                max_encoding_message_size,
2008                            );
2009                        let res = grpc.unary(method, req).await;
2010                        Ok(res)
2011                    };
2012                    Box::pin(fut)
2013                }
2014                "/promptgraph.ExecutionRuntime/Branch" => {
2015                    #[allow(non_camel_case_types)]
2016                    struct BranchSvc<T: ExecutionRuntime>(pub Arc<T>);
2017                    impl<
2018                        T: ExecutionRuntime,
2019                    > tonic::server::UnaryService<super::RequestNewBranch>
2020                    for BranchSvc<T> {
2021                        type Response = super::ExecutionStatus;
2022                        type Future = BoxFuture<
2023                            tonic::Response<Self::Response>,
2024                            tonic::Status,
2025                        >;
2026                        fn call(
2027                            &mut self,
2028                            request: tonic::Request<super::RequestNewBranch>,
2029                        ) -> Self::Future {
2030                            let inner = Arc::clone(&self.0);
2031                            let fut = async move { (*inner).branch(request).await };
2032                            Box::pin(fut)
2033                        }
2034                    }
2035                    let accept_compression_encodings = self.accept_compression_encodings;
2036                    let send_compression_encodings = self.send_compression_encodings;
2037                    let max_decoding_message_size = self.max_decoding_message_size;
2038                    let max_encoding_message_size = self.max_encoding_message_size;
2039                    let inner = self.inner.clone();
2040                    let fut = async move {
2041                        let inner = inner.0;
2042                        let method = BranchSvc(inner);
2043                        let codec = tonic::codec::ProstCodec::default();
2044                        let mut grpc = tonic::server::Grpc::new(codec)
2045                            .apply_compression_config(
2046                                accept_compression_encodings,
2047                                send_compression_encodings,
2048                            )
2049                            .apply_max_message_size_config(
2050                                max_decoding_message_size,
2051                                max_encoding_message_size,
2052                            );
2053                        let res = grpc.unary(method, req).await;
2054                        Ok(res)
2055                    };
2056                    Box::pin(fut)
2057                }
2058                "/promptgraph.ExecutionRuntime/ListBranches" => {
2059                    #[allow(non_camel_case_types)]
2060                    struct ListBranchesSvc<T: ExecutionRuntime>(pub Arc<T>);
2061                    impl<
2062                        T: ExecutionRuntime,
2063                    > tonic::server::UnaryService<super::RequestListBranches>
2064                    for ListBranchesSvc<T> {
2065                        type Response = super::ListBranchesRes;
2066                        type Future = BoxFuture<
2067                            tonic::Response<Self::Response>,
2068                            tonic::Status,
2069                        >;
2070                        fn call(
2071                            &mut self,
2072                            request: tonic::Request<super::RequestListBranches>,
2073                        ) -> Self::Future {
2074                            let inner = Arc::clone(&self.0);
2075                            let fut = async move {
2076                                (*inner).list_branches(request).await
2077                            };
2078                            Box::pin(fut)
2079                        }
2080                    }
2081                    let accept_compression_encodings = self.accept_compression_encodings;
2082                    let send_compression_encodings = self.send_compression_encodings;
2083                    let max_decoding_message_size = self.max_decoding_message_size;
2084                    let max_encoding_message_size = self.max_encoding_message_size;
2085                    let inner = self.inner.clone();
2086                    let fut = async move {
2087                        let inner = inner.0;
2088                        let method = ListBranchesSvc(inner);
2089                        let codec = tonic::codec::ProstCodec::default();
2090                        let mut grpc = tonic::server::Grpc::new(codec)
2091                            .apply_compression_config(
2092                                accept_compression_encodings,
2093                                send_compression_encodings,
2094                            )
2095                            .apply_max_message_size_config(
2096                                max_decoding_message_size,
2097                                max_encoding_message_size,
2098                            );
2099                        let res = grpc.unary(method, req).await;
2100                        Ok(res)
2101                    };
2102                    Box::pin(fut)
2103                }
2104                "/promptgraph.ExecutionRuntime/ListRegisteredGraphs" => {
2105                    #[allow(non_camel_case_types)]
2106                    struct ListRegisteredGraphsSvc<T: ExecutionRuntime>(pub Arc<T>);
2107                    impl<T: ExecutionRuntime> tonic::server::UnaryService<super::Empty>
2108                    for ListRegisteredGraphsSvc<T> {
2109                        type Response = super::ListRegisteredGraphsResponse;
2110                        type Future = BoxFuture<
2111                            tonic::Response<Self::Response>,
2112                            tonic::Status,
2113                        >;
2114                        fn call(
2115                            &mut self,
2116                            request: tonic::Request<super::Empty>,
2117                        ) -> Self::Future {
2118                            let inner = Arc::clone(&self.0);
2119                            let fut = async move {
2120                                (*inner).list_registered_graphs(request).await
2121                            };
2122                            Box::pin(fut)
2123                        }
2124                    }
2125                    let accept_compression_encodings = self.accept_compression_encodings;
2126                    let send_compression_encodings = self.send_compression_encodings;
2127                    let max_decoding_message_size = self.max_decoding_message_size;
2128                    let max_encoding_message_size = self.max_encoding_message_size;
2129                    let inner = self.inner.clone();
2130                    let fut = async move {
2131                        let inner = inner.0;
2132                        let method = ListRegisteredGraphsSvc(inner);
2133                        let codec = tonic::codec::ProstCodec::default();
2134                        let mut grpc = tonic::server::Grpc::new(codec)
2135                            .apply_compression_config(
2136                                accept_compression_encodings,
2137                                send_compression_encodings,
2138                            )
2139                            .apply_max_message_size_config(
2140                                max_decoding_message_size,
2141                                max_encoding_message_size,
2142                            );
2143                        let res = grpc.unary(method, req).await;
2144                        Ok(res)
2145                    };
2146                    Box::pin(fut)
2147                }
2148                "/promptgraph.ExecutionRuntime/ListInputProposals" => {
2149                    #[allow(non_camel_case_types)]
2150                    struct ListInputProposalsSvc<T: ExecutionRuntime>(pub Arc<T>);
2151                    impl<
2152                        T: ExecutionRuntime,
2153                    > tonic::server::ServerStreamingService<super::RequestOnlyId>
2154                    for ListInputProposalsSvc<T> {
2155                        type Response = super::InputProposal;
2156                        type ResponseStream = T::ListInputProposalsStream;
2157                        type Future = BoxFuture<
2158                            tonic::Response<Self::ResponseStream>,
2159                            tonic::Status,
2160                        >;
2161                        fn call(
2162                            &mut self,
2163                            request: tonic::Request<super::RequestOnlyId>,
2164                        ) -> Self::Future {
2165                            let inner = Arc::clone(&self.0);
2166                            let fut = async move {
2167                                (*inner).list_input_proposals(request).await
2168                            };
2169                            Box::pin(fut)
2170                        }
2171                    }
2172                    let accept_compression_encodings = self.accept_compression_encodings;
2173                    let send_compression_encodings = self.send_compression_encodings;
2174                    let max_decoding_message_size = self.max_decoding_message_size;
2175                    let max_encoding_message_size = self.max_encoding_message_size;
2176                    let inner = self.inner.clone();
2177                    let fut = async move {
2178                        let inner = inner.0;
2179                        let method = ListInputProposalsSvc(inner);
2180                        let codec = tonic::codec::ProstCodec::default();
2181                        let mut grpc = tonic::server::Grpc::new(codec)
2182                            .apply_compression_config(
2183                                accept_compression_encodings,
2184                                send_compression_encodings,
2185                            )
2186                            .apply_max_message_size_config(
2187                                max_decoding_message_size,
2188                                max_encoding_message_size,
2189                            );
2190                        let res = grpc.server_streaming(method, req).await;
2191                        Ok(res)
2192                    };
2193                    Box::pin(fut)
2194                }
2195                "/promptgraph.ExecutionRuntime/RespondToInputProposal" => {
2196                    #[allow(non_camel_case_types)]
2197                    struct RespondToInputProposalSvc<T: ExecutionRuntime>(pub Arc<T>);
2198                    impl<
2199                        T: ExecutionRuntime,
2200                    > tonic::server::UnaryService<super::RequestInputProposalResponse>
2201                    for RespondToInputProposalSvc<T> {
2202                        type Response = super::Empty;
2203                        type Future = BoxFuture<
2204                            tonic::Response<Self::Response>,
2205                            tonic::Status,
2206                        >;
2207                        fn call(
2208                            &mut self,
2209                            request: tonic::Request<super::RequestInputProposalResponse>,
2210                        ) -> Self::Future {
2211                            let inner = Arc::clone(&self.0);
2212                            let fut = async move {
2213                                (*inner).respond_to_input_proposal(request).await
2214                            };
2215                            Box::pin(fut)
2216                        }
2217                    }
2218                    let accept_compression_encodings = self.accept_compression_encodings;
2219                    let send_compression_encodings = self.send_compression_encodings;
2220                    let max_decoding_message_size = self.max_decoding_message_size;
2221                    let max_encoding_message_size = self.max_encoding_message_size;
2222                    let inner = self.inner.clone();
2223                    let fut = async move {
2224                        let inner = inner.0;
2225                        let method = RespondToInputProposalSvc(inner);
2226                        let codec = tonic::codec::ProstCodec::default();
2227                        let mut grpc = tonic::server::Grpc::new(codec)
2228                            .apply_compression_config(
2229                                accept_compression_encodings,
2230                                send_compression_encodings,
2231                            )
2232                            .apply_max_message_size_config(
2233                                max_decoding_message_size,
2234                                max_encoding_message_size,
2235                            );
2236                        let res = grpc.unary(method, req).await;
2237                        Ok(res)
2238                    };
2239                    Box::pin(fut)
2240                }
2241                "/promptgraph.ExecutionRuntime/ListChangeEvents" => {
2242                    #[allow(non_camel_case_types)]
2243                    struct ListChangeEventsSvc<T: ExecutionRuntime>(pub Arc<T>);
2244                    impl<
2245                        T: ExecutionRuntime,
2246                    > tonic::server::ServerStreamingService<super::RequestOnlyId>
2247                    for ListChangeEventsSvc<T> {
2248                        type Response = super::ChangeValueWithCounter;
2249                        type ResponseStream = T::ListChangeEventsStream;
2250                        type Future = BoxFuture<
2251                            tonic::Response<Self::ResponseStream>,
2252                            tonic::Status,
2253                        >;
2254                        fn call(
2255                            &mut self,
2256                            request: tonic::Request<super::RequestOnlyId>,
2257                        ) -> Self::Future {
2258                            let inner = Arc::clone(&self.0);
2259                            let fut = async move {
2260                                (*inner).list_change_events(request).await
2261                            };
2262                            Box::pin(fut)
2263                        }
2264                    }
2265                    let accept_compression_encodings = self.accept_compression_encodings;
2266                    let send_compression_encodings = self.send_compression_encodings;
2267                    let max_decoding_message_size = self.max_decoding_message_size;
2268                    let max_encoding_message_size = self.max_encoding_message_size;
2269                    let inner = self.inner.clone();
2270                    let fut = async move {
2271                        let inner = inner.0;
2272                        let method = ListChangeEventsSvc(inner);
2273                        let codec = tonic::codec::ProstCodec::default();
2274                        let mut grpc = tonic::server::Grpc::new(codec)
2275                            .apply_compression_config(
2276                                accept_compression_encodings,
2277                                send_compression_encodings,
2278                            )
2279                            .apply_max_message_size_config(
2280                                max_decoding_message_size,
2281                                max_encoding_message_size,
2282                            );
2283                        let res = grpc.server_streaming(method, req).await;
2284                        Ok(res)
2285                    };
2286                    Box::pin(fut)
2287                }
2288                "/promptgraph.ExecutionRuntime/ListNodeWillExecuteEvents" => {
2289                    #[allow(non_camel_case_types)]
2290                    struct ListNodeWillExecuteEventsSvc<T: ExecutionRuntime>(pub Arc<T>);
2291                    impl<
2292                        T: ExecutionRuntime,
2293                    > tonic::server::ServerStreamingService<super::RequestOnlyId>
2294                    for ListNodeWillExecuteEventsSvc<T> {
2295                        type Response = super::NodeWillExecuteOnBranch;
2296                        type ResponseStream = T::ListNodeWillExecuteEventsStream;
2297                        type Future = BoxFuture<
2298                            tonic::Response<Self::ResponseStream>,
2299                            tonic::Status,
2300                        >;
2301                        fn call(
2302                            &mut self,
2303                            request: tonic::Request<super::RequestOnlyId>,
2304                        ) -> Self::Future {
2305                            let inner = Arc::clone(&self.0);
2306                            let fut = async move {
2307                                (*inner).list_node_will_execute_events(request).await
2308                            };
2309                            Box::pin(fut)
2310                        }
2311                    }
2312                    let accept_compression_encodings = self.accept_compression_encodings;
2313                    let send_compression_encodings = self.send_compression_encodings;
2314                    let max_decoding_message_size = self.max_decoding_message_size;
2315                    let max_encoding_message_size = self.max_encoding_message_size;
2316                    let inner = self.inner.clone();
2317                    let fut = async move {
2318                        let inner = inner.0;
2319                        let method = ListNodeWillExecuteEventsSvc(inner);
2320                        let codec = tonic::codec::ProstCodec::default();
2321                        let mut grpc = tonic::server::Grpc::new(codec)
2322                            .apply_compression_config(
2323                                accept_compression_encodings,
2324                                send_compression_encodings,
2325                            )
2326                            .apply_max_message_size_config(
2327                                max_decoding_message_size,
2328                                max_encoding_message_size,
2329                            );
2330                        let res = grpc.server_streaming(method, req).await;
2331                        Ok(res)
2332                    };
2333                    Box::pin(fut)
2334                }
2335                "/promptgraph.ExecutionRuntime/PollCustomNodeWillExecuteEvents" => {
2336                    #[allow(non_camel_case_types)]
2337                    struct PollCustomNodeWillExecuteEventsSvc<T: ExecutionRuntime>(
2338                        pub Arc<T>,
2339                    );
2340                    impl<
2341                        T: ExecutionRuntime,
2342                    > tonic::server::UnaryService<
2343                        super::FilteredPollNodeWillExecuteEventsRequest,
2344                    > for PollCustomNodeWillExecuteEventsSvc<T> {
2345                        type Response = super::RespondPollNodeWillExecuteEvents;
2346                        type Future = BoxFuture<
2347                            tonic::Response<Self::Response>,
2348                            tonic::Status,
2349                        >;
2350                        fn call(
2351                            &mut self,
2352                            request: tonic::Request<
2353                                super::FilteredPollNodeWillExecuteEventsRequest,
2354                            >,
2355                        ) -> Self::Future {
2356                            let inner = Arc::clone(&self.0);
2357                            let fut = async move {
2358                                (*inner).poll_custom_node_will_execute_events(request).await
2359                            };
2360                            Box::pin(fut)
2361                        }
2362                    }
2363                    let accept_compression_encodings = self.accept_compression_encodings;
2364                    let send_compression_encodings = self.send_compression_encodings;
2365                    let max_decoding_message_size = self.max_decoding_message_size;
2366                    let max_encoding_message_size = self.max_encoding_message_size;
2367                    let inner = self.inner.clone();
2368                    let fut = async move {
2369                        let inner = inner.0;
2370                        let method = PollCustomNodeWillExecuteEventsSvc(inner);
2371                        let codec = tonic::codec::ProstCodec::default();
2372                        let mut grpc = tonic::server::Grpc::new(codec)
2373                            .apply_compression_config(
2374                                accept_compression_encodings,
2375                                send_compression_encodings,
2376                            )
2377                            .apply_max_message_size_config(
2378                                max_decoding_message_size,
2379                                max_encoding_message_size,
2380                            );
2381                        let res = grpc.unary(method, req).await;
2382                        Ok(res)
2383                    };
2384                    Box::pin(fut)
2385                }
2386                "/promptgraph.ExecutionRuntime/AckNodeWillExecuteEvent" => {
2387                    #[allow(non_camel_case_types)]
2388                    struct AckNodeWillExecuteEventSvc<T: ExecutionRuntime>(pub Arc<T>);
2389                    impl<
2390                        T: ExecutionRuntime,
2391                    > tonic::server::UnaryService<super::RequestAckNodeWillExecuteEvent>
2392                    for AckNodeWillExecuteEventSvc<T> {
2393                        type Response = super::ExecutionStatus;
2394                        type Future = BoxFuture<
2395                            tonic::Response<Self::Response>,
2396                            tonic::Status,
2397                        >;
2398                        fn call(
2399                            &mut self,
2400                            request: tonic::Request<
2401                                super::RequestAckNodeWillExecuteEvent,
2402                            >,
2403                        ) -> Self::Future {
2404                            let inner = Arc::clone(&self.0);
2405                            let fut = async move {
2406                                (*inner).ack_node_will_execute_event(request).await
2407                            };
2408                            Box::pin(fut)
2409                        }
2410                    }
2411                    let accept_compression_encodings = self.accept_compression_encodings;
2412                    let send_compression_encodings = self.send_compression_encodings;
2413                    let max_decoding_message_size = self.max_decoding_message_size;
2414                    let max_encoding_message_size = self.max_encoding_message_size;
2415                    let inner = self.inner.clone();
2416                    let fut = async move {
2417                        let inner = inner.0;
2418                        let method = AckNodeWillExecuteEventSvc(inner);
2419                        let codec = tonic::codec::ProstCodec::default();
2420                        let mut grpc = tonic::server::Grpc::new(codec)
2421                            .apply_compression_config(
2422                                accept_compression_encodings,
2423                                send_compression_encodings,
2424                            )
2425                            .apply_max_message_size_config(
2426                                max_decoding_message_size,
2427                                max_encoding_message_size,
2428                            );
2429                        let res = grpc.unary(method, req).await;
2430                        Ok(res)
2431                    };
2432                    Box::pin(fut)
2433                }
2434                "/promptgraph.ExecutionRuntime/PushWorkerEvent" => {
2435                    #[allow(non_camel_case_types)]
2436                    struct PushWorkerEventSvc<T: ExecutionRuntime>(pub Arc<T>);
2437                    impl<
2438                        T: ExecutionRuntime,
2439                    > tonic::server::UnaryService<
2440                        super::FileAddressedChangeValueWithCounter,
2441                    > for PushWorkerEventSvc<T> {
2442                        type Response = super::ExecutionStatus;
2443                        type Future = BoxFuture<
2444                            tonic::Response<Self::Response>,
2445                            tonic::Status,
2446                        >;
2447                        fn call(
2448                            &mut self,
2449                            request: tonic::Request<
2450                                super::FileAddressedChangeValueWithCounter,
2451                            >,
2452                        ) -> Self::Future {
2453                            let inner = Arc::clone(&self.0);
2454                            let fut = async move {
2455                                (*inner).push_worker_event(request).await
2456                            };
2457                            Box::pin(fut)
2458                        }
2459                    }
2460                    let accept_compression_encodings = self.accept_compression_encodings;
2461                    let send_compression_encodings = self.send_compression_encodings;
2462                    let max_decoding_message_size = self.max_decoding_message_size;
2463                    let max_encoding_message_size = self.max_encoding_message_size;
2464                    let inner = self.inner.clone();
2465                    let fut = async move {
2466                        let inner = inner.0;
2467                        let method = PushWorkerEventSvc(inner);
2468                        let codec = tonic::codec::ProstCodec::default();
2469                        let mut grpc = tonic::server::Grpc::new(codec)
2470                            .apply_compression_config(
2471                                accept_compression_encodings,
2472                                send_compression_encodings,
2473                            )
2474                            .apply_max_message_size_config(
2475                                max_decoding_message_size,
2476                                max_encoding_message_size,
2477                            );
2478                        let res = grpc.unary(method, req).await;
2479                        Ok(res)
2480                    };
2481                    Box::pin(fut)
2482                }
2483                "/promptgraph.ExecutionRuntime/PushTemplatePartial" => {
2484                    #[allow(non_camel_case_types)]
2485                    struct PushTemplatePartialSvc<T: ExecutionRuntime>(pub Arc<T>);
2486                    impl<
2487                        T: ExecutionRuntime,
2488                    > tonic::server::UnaryService<super::UpsertPromptLibraryRecord>
2489                    for PushTemplatePartialSvc<T> {
2490                        type Response = super::ExecutionStatus;
2491                        type Future = BoxFuture<
2492                            tonic::Response<Self::Response>,
2493                            tonic::Status,
2494                        >;
2495                        fn call(
2496                            &mut self,
2497                            request: tonic::Request<super::UpsertPromptLibraryRecord>,
2498                        ) -> Self::Future {
2499                            let inner = Arc::clone(&self.0);
2500                            let fut = async move {
2501                                (*inner).push_template_partial(request).await
2502                            };
2503                            Box::pin(fut)
2504                        }
2505                    }
2506                    let accept_compression_encodings = self.accept_compression_encodings;
2507                    let send_compression_encodings = self.send_compression_encodings;
2508                    let max_decoding_message_size = self.max_decoding_message_size;
2509                    let max_encoding_message_size = self.max_encoding_message_size;
2510                    let inner = self.inner.clone();
2511                    let fut = async move {
2512                        let inner = inner.0;
2513                        let method = PushTemplatePartialSvc(inner);
2514                        let codec = tonic::codec::ProstCodec::default();
2515                        let mut grpc = tonic::server::Grpc::new(codec)
2516                            .apply_compression_config(
2517                                accept_compression_encodings,
2518                                send_compression_encodings,
2519                            )
2520                            .apply_max_message_size_config(
2521                                max_decoding_message_size,
2522                                max_encoding_message_size,
2523                            );
2524                        let res = grpc.unary(method, req).await;
2525                        Ok(res)
2526                    };
2527                    Box::pin(fut)
2528                }
2529                _ => {
2530                    Box::pin(async move {
2531                        Ok(
2532                            http::Response::builder()
2533                                .status(200)
2534                                .header("grpc-status", "12")
2535                                .header("content-type", "application/grpc")
2536                                .body(empty_body())
2537                                .unwrap(),
2538                        )
2539                    })
2540                }
2541            }
2542        }
2543    }
2544    impl<T: ExecutionRuntime> Clone for ExecutionRuntimeServer<T> {
2545        fn clone(&self) -> Self {
2546            let inner = self.inner.clone();
2547            Self {
2548                inner,
2549                accept_compression_encodings: self.accept_compression_encodings,
2550                send_compression_encodings: self.send_compression_encodings,
2551                max_decoding_message_size: self.max_decoding_message_size,
2552                max_encoding_message_size: self.max_encoding_message_size,
2553            }
2554        }
2555    }
2556    impl<T: ExecutionRuntime> Clone for _Inner<T> {
2557        fn clone(&self) -> Self {
2558            Self(Arc::clone(&self.0))
2559        }
2560    }
2561    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
2562        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2563            write!(f, "{:?}", self.0)
2564        }
2565    }
2566    impl<T: ExecutionRuntime> tonic::server::NamedService for ExecutionRuntimeServer<T> {
2567        const NAME: &'static str = "promptgraph.ExecutionRuntime";
2568    }
2569}
prompt_graph_core/generated_protobufs/promptgraph.rs

prompt_graph_core/generated_protobufs/
promptgraph.rs
