modelrelay 6.5.0

Rust SDK for the ModelRelay API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Workflow specification types.
//!
//! This module contains the types that define a workflow's structure:
//! - `WorkflowKind` - Version discriminator for workflow specs
//! - `WorkflowSpecV1` - The main workflow specification
//! - `NodeV1` - A node in the workflow DAG
//! - `EdgeV1` - An edge connecting nodes
//! - `ExecutionV1` - Execution configuration
//! - `OutputRefV1` - Reference to a workflow output
//! - `NodeTypeV1` - The type of a node

use serde::{Deserialize, Serialize};
use serde_json::Value;

use super::ids::NodeId;

/// Workflow specification version.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum WorkflowKind {
    #[serde(rename = "workflow.v1")]
    WorkflowV1,
}

/// Node type within a workflow.v1.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum NodeTypeV1 {
    #[serde(rename = "llm.responses")]
    LlmResponses,
    #[serde(rename = "route.switch")]
    RouteSwitch,
    #[serde(rename = "join.all")]
    JoinAll,
    #[serde(rename = "join.any")]
    JoinAny,
    #[serde(rename = "join.collect")]
    JoinCollect,
    #[serde(rename = "transform.json")]
    TransformJson,
    #[serde(rename = "map.fanout")]
    MapFanout,
}

/// Condition source for workflow.v1 edges.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ConditionSourceV1 {
    NodeOutput,
    NodeStatus,
}

/// Condition operator for workflow.v1 edges.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ConditionOpV1 {
    Equals,
    Matches,
    Exists,
}

/// Edge condition for workflow.v1.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ConditionV1 {
    pub source: ConditionSourceV1,
    pub op: ConditionOpV1,
    pub path: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub value: Option<Value>,
}

/// Workflow specification (v1).
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WorkflowSpecV1 {
    pub kind: WorkflowKind,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub execution: Option<ExecutionV1>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inputs: Option<Vec<InputDeclV1>>,
    pub nodes: Vec<NodeV1>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edges: Option<Vec<EdgeV1>>,
    pub outputs: Vec<OutputRefV1>,
}

/// Workflow input declaration (v1).
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct InputDeclV1 {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub required: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default: Option<Value>,
}

/// Execution configuration for a workflow.v1.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ExecutionV1 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_parallelism: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub node_timeout_ms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub run_timeout_ms: Option<i64>,
}

/// A node in the workflow.v1 DAG.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct NodeV1 {
    pub id: NodeId,
    #[serde(rename = "type")]
    pub node_type: NodeTypeV1,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input: Option<Value>,
}

/// An edge connecting two nodes in the workflow.v1 DAG.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct EdgeV1 {
    pub from: NodeId,
    pub to: NodeId,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub when: Option<ConditionV1>,
}

/// Reference to a workflow.v1 output.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OutputRefV1 {
    pub name: String,
    pub from: NodeId,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pointer: Option<String>,
}

// ============================================================================
// Clean type aliases (no Workflow prefix)
// ============================================================================
// These aliases allow users to import from the workflow module with cleaner names:
//   use modelrelay::workflow::{Kind, SpecV1};
//
// This matches the pattern used in the Go and TypeScript SDKs.

/// Type alias for `WorkflowKind` - allows `workflow::Kind` usage.
#[allow(dead_code)]
pub type Kind = WorkflowKind;

/// Type alias for `WorkflowSpecV1` - allows `workflow::SpecV1` usage.
#[allow(dead_code)]
pub type SpecV1 = WorkflowSpecV1;