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#[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#[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#[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}
90pub 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}
111pub 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 #[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#[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}
138pub 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 #[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}
175pub 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#[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}
210pub 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}
241pub 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#[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}
289pub 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 #[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#[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}
354pub 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}
383pub 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}
473pub 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#[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#[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#[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#[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 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 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 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 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 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 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 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 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 pub fn as_str_name(&self) -> &'static str {
939 match self {
940 SupportedSourceCodeLanguages::Deno => "DENO",
941 SupportedSourceCodeLanguages::Starlark => "STARLARK",
942 }
943 }
944 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 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 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}
983pub 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 #[derive(Debug, Clone)]
990 pub struct ExecutionRuntimeClient<T> {
991 inner: tonic::client::Grpc<T>,
992 }
993 impl ExecutionRuntimeClient<tonic::transport::Channel> {
994 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 #[must_use]
1043 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1044 self.inner = self.inner.send_compressed(encoding);
1045 self
1046 }
1047 #[must_use]
1049 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1050 self.inner = self.inner.accept_compressed(encoding);
1051 self
1052 }
1053 #[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 #[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 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 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 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 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 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 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 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 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 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 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 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 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 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}
1542pub mod execution_runtime_server {
1544 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1545 use tonic::codegen::*;
1546 #[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 async fn merge(
1558 &self,
1559 request: tonic::Request<super::RequestFileMerge>,
1560 ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1561 async fn current_file_state(
1563 &self,
1564 request: tonic::Request<super::RequestOnlyId>,
1565 ) -> std::result::Result<tonic::Response<super::File>, tonic::Status>;
1566 async fn get_parquet_history(
1568 &self,
1569 request: tonic::Request<super::RequestOnlyId>,
1570 ) -> std::result::Result<tonic::Response<super::ParquetFile>, tonic::Status>;
1571 async fn play(
1573 &self,
1574 request: tonic::Request<super::RequestAtFrame>,
1575 ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1576 async fn pause(
1578 &self,
1579 request: tonic::Request<super::RequestAtFrame>,
1580 ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1581 async fn branch(
1583 &self,
1584 request: tonic::Request<super::RequestNewBranch>,
1585 ) -> std::result::Result<tonic::Response<super::ExecutionStatus>, tonic::Status>;
1586 async fn list_branches(
1588 &self,
1589 request: tonic::Request<super::RequestListBranches>,
1590 ) -> std::result::Result<tonic::Response<super::ListBranchesRes>, tonic::Status>;
1591 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 type ListInputProposalsStream: futures_core::Stream<
1601 Item = std::result::Result<super::InputProposal, tonic::Status>,
1602 >
1603 + Send
1604 + 'static;
1605 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 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 type ListChangeEventsStream: futures_core::Stream<
1620 Item = std::result::Result<super::ChangeValueWithCounter, tonic::Status>,
1621 >
1622 + Send
1623 + 'static;
1624 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 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 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 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 #[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 #[must_use]
1702 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1703 self.accept_compression_encodings.enable(encoding);
1704 self
1705 }
1706 #[must_use]
1708 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1709 self.send_compression_encodings.enable(encoding);
1710 self
1711 }
1712 #[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 #[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}