cyberdesk 2.2.36 → 2.2.38
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client/client/client.gen.d.ts +2 -0
- package/dist/client/client/client.gen.js +217 -0
- package/dist/client/client/index.d.ts +8 -0
- package/dist/client/client/index.js +17 -0
- package/dist/client/client/types.gen.d.ts +117 -0
- package/dist/client/client/types.gen.js +3 -0
- package/dist/client/client/utils.gen.d.ts +33 -0
- package/dist/client/client/utils.gen.js +247 -0
- package/dist/client/client.gen.d.ts +4 -4
- package/dist/client/client.gen.js +2 -4
- package/dist/client/core/auth.gen.d.ts +18 -0
- package/dist/client/core/auth.gen.js +27 -0
- package/dist/client/core/bodySerializer.gen.d.ts +25 -0
- package/dist/client/core/bodySerializer.gen.js +60 -0
- package/dist/client/core/params.gen.d.ts +43 -0
- package/dist/client/core/params.gen.js +104 -0
- package/dist/client/core/pathSerializer.gen.d.ts +33 -0
- package/dist/client/core/pathSerializer.gen.js +115 -0
- package/dist/client/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/client/core/queryKeySerializer.gen.js +98 -0
- package/dist/client/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/client/core/serverSentEvents.gen.js +160 -0
- package/dist/client/core/types.gen.d.ts +78 -0
- package/dist/client/core/types.gen.js +3 -0
- package/dist/client/core/utils.gen.d.ts +19 -0
- package/dist/client/core/utils.gen.js +93 -0
- package/dist/client/index.d.ts +2 -2
- package/dist/client/index.js +113 -17
- package/dist/client/sdk.gen.d.ts +217 -141
- package/dist/client/sdk.gen.js +217 -665
- package/dist/client/types.gen.d.ts +2588 -132
- package/dist/index.d.ts +217 -249
- package/dist/index.js +18 -43
- package/package.json +5 -5
|
@@ -1,142 +1,259 @@
|
|
|
1
|
+
export type ClientOptions = {
|
|
2
|
+
baseUrl: string;
|
|
3
|
+
};
|
|
4
|
+
export type Webhooks = RunCompleteWebhookrunCompletePostWebhookRequest;
|
|
1
5
|
/**
|
|
6
|
+
* AddTagsRequest
|
|
7
|
+
*
|
|
2
8
|
* Schema for adding tags to a workflow
|
|
3
9
|
*/
|
|
4
10
|
export type AddTagsRequest = {
|
|
5
11
|
/**
|
|
12
|
+
* Tag Ids
|
|
13
|
+
*
|
|
6
14
|
* List of tag IDs to add
|
|
7
15
|
*/
|
|
8
16
|
tag_ids: Array<string>;
|
|
9
17
|
};
|
|
18
|
+
/**
|
|
19
|
+
* AttachmentType
|
|
20
|
+
*/
|
|
10
21
|
export type AttachmentType = 'input' | 'output';
|
|
22
|
+
/**
|
|
23
|
+
* Body_upload_workflow_prompt_image_v1_workflows_prompt_image_post
|
|
24
|
+
*/
|
|
11
25
|
export type BodyUploadWorkflowPromptImageV1WorkflowsPromptImagePost = {
|
|
12
26
|
/**
|
|
27
|
+
* File
|
|
28
|
+
*
|
|
13
29
|
* The image file to upload
|
|
14
30
|
*/
|
|
15
31
|
file: Blob | File;
|
|
16
32
|
};
|
|
17
33
|
/**
|
|
34
|
+
* BulkAddTagsRequest
|
|
35
|
+
*
|
|
18
36
|
* Schema for bulk adding tags to workflows
|
|
19
37
|
*/
|
|
20
38
|
export type BulkAddTagsRequest = {
|
|
21
39
|
/**
|
|
40
|
+
* Workflow Ids
|
|
41
|
+
*
|
|
22
42
|
* List of workflow IDs to add tags to
|
|
23
43
|
*/
|
|
24
44
|
workflow_ids: Array<string>;
|
|
25
45
|
/**
|
|
46
|
+
* Tag Ids
|
|
47
|
+
*
|
|
26
48
|
* List of tag IDs to add
|
|
27
49
|
*/
|
|
28
50
|
tag_ids: Array<string>;
|
|
29
51
|
};
|
|
30
52
|
/**
|
|
53
|
+
* ChainStep
|
|
54
|
+
*
|
|
31
55
|
* One step within a chain
|
|
32
56
|
*/
|
|
33
57
|
export type ChainStep = {
|
|
58
|
+
/**
|
|
59
|
+
* Workflow Id
|
|
60
|
+
*/
|
|
34
61
|
workflow_id: string;
|
|
35
62
|
/**
|
|
63
|
+
* Session Alias
|
|
64
|
+
*
|
|
36
65
|
* Alias to persist this step's outputs within the session
|
|
37
66
|
*/
|
|
38
67
|
session_alias?: string | null;
|
|
39
68
|
/**
|
|
69
|
+
* Inputs
|
|
70
|
+
*
|
|
40
71
|
* Step-specific inputs; values can be strings, objects, arrays, or {$ref: 'alias.outputs.path'} references
|
|
41
72
|
*/
|
|
42
73
|
inputs?: {
|
|
43
74
|
[key: string]: unknown;
|
|
44
75
|
} | null;
|
|
45
76
|
/**
|
|
77
|
+
* Sensitive Inputs
|
|
78
|
+
*
|
|
46
79
|
* Step-specific sensitive inputs (supports nested objects) that override or extend shared_sensitive_inputs
|
|
47
80
|
*/
|
|
48
81
|
sensitive_inputs?: {
|
|
49
82
|
[key: string]: unknown;
|
|
50
83
|
} | null;
|
|
51
84
|
};
|
|
52
|
-
export type ComputerTaskAcceptedResponse = {
|
|
53
|
-
task_id: string;
|
|
54
|
-
machine_id: string;
|
|
55
|
-
status?: string;
|
|
56
|
-
};
|
|
57
|
-
export type ComputerTaskObjectRequest = {
|
|
58
|
-
task: string;
|
|
59
|
-
};
|
|
60
85
|
/**
|
|
86
|
+
* ConnectionCreate
|
|
87
|
+
*
|
|
61
88
|
* Schema for creating a connection
|
|
62
89
|
*/
|
|
63
90
|
export type ConnectionCreate = {
|
|
91
|
+
/**
|
|
92
|
+
* Websocket Id
|
|
93
|
+
*/
|
|
64
94
|
websocket_id: string;
|
|
95
|
+
/**
|
|
96
|
+
* Ip Address
|
|
97
|
+
*/
|
|
65
98
|
ip_address?: string | null;
|
|
99
|
+
/**
|
|
100
|
+
* User Agent
|
|
101
|
+
*/
|
|
66
102
|
user_agent?: string | null;
|
|
103
|
+
/**
|
|
104
|
+
* Machine Id
|
|
105
|
+
*/
|
|
67
106
|
machine_id: string;
|
|
68
107
|
};
|
|
69
108
|
/**
|
|
109
|
+
* ConnectionResponse
|
|
110
|
+
*
|
|
70
111
|
* Connection response schema
|
|
71
112
|
*/
|
|
72
113
|
export type ConnectionResponse = {
|
|
114
|
+
/**
|
|
115
|
+
* Websocket Id
|
|
116
|
+
*/
|
|
73
117
|
websocket_id: string;
|
|
118
|
+
/**
|
|
119
|
+
* Ip Address
|
|
120
|
+
*/
|
|
74
121
|
ip_address?: string | null;
|
|
122
|
+
/**
|
|
123
|
+
* User Agent
|
|
124
|
+
*/
|
|
75
125
|
user_agent?: string | null;
|
|
126
|
+
/**
|
|
127
|
+
* Id
|
|
128
|
+
*/
|
|
76
129
|
id: string;
|
|
130
|
+
/**
|
|
131
|
+
* Machine Id
|
|
132
|
+
*/
|
|
77
133
|
machine_id: string;
|
|
134
|
+
/**
|
|
135
|
+
* Connected At
|
|
136
|
+
*/
|
|
78
137
|
connected_at: string;
|
|
138
|
+
/**
|
|
139
|
+
* Disconnected At
|
|
140
|
+
*/
|
|
79
141
|
disconnected_at: string | null;
|
|
142
|
+
/**
|
|
143
|
+
* Last Ping
|
|
144
|
+
*/
|
|
80
145
|
last_ping: string;
|
|
81
146
|
status: ConnectionStatus;
|
|
82
147
|
};
|
|
148
|
+
/**
|
|
149
|
+
* ConnectionStatus
|
|
150
|
+
*/
|
|
83
151
|
export type ConnectionStatus = 'connected' | 'disconnected' | 'error';
|
|
152
|
+
/**
|
|
153
|
+
* CopyToClipboardRequest
|
|
154
|
+
*/
|
|
84
155
|
export type CopyToClipboardRequest = {
|
|
85
156
|
/**
|
|
157
|
+
* Text
|
|
158
|
+
*
|
|
86
159
|
* Key name for the copied data
|
|
87
160
|
*/
|
|
88
161
|
text: string;
|
|
89
162
|
};
|
|
163
|
+
/**
|
|
164
|
+
* CyberdriverShutdownRequest
|
|
165
|
+
*/
|
|
90
166
|
export type CyberdriverShutdownRequest = {
|
|
91
167
|
/**
|
|
168
|
+
* Source
|
|
169
|
+
*
|
|
92
170
|
* Caller identifier for shutdown auditing
|
|
93
171
|
*/
|
|
94
172
|
source?: string;
|
|
95
173
|
/**
|
|
174
|
+
* Reason
|
|
175
|
+
*
|
|
96
176
|
* Reason for shutting down the CyberDriver process
|
|
97
177
|
*/
|
|
98
178
|
reason?: string | null;
|
|
99
179
|
};
|
|
180
|
+
/**
|
|
181
|
+
* DisplayDimensions
|
|
182
|
+
*/
|
|
100
183
|
export type DisplayDimensions = {
|
|
184
|
+
/**
|
|
185
|
+
* Width
|
|
186
|
+
*/
|
|
101
187
|
width: number;
|
|
188
|
+
/**
|
|
189
|
+
* Height
|
|
190
|
+
*/
|
|
102
191
|
height: number;
|
|
103
192
|
};
|
|
104
193
|
/**
|
|
194
|
+
* FileInput
|
|
195
|
+
*
|
|
105
196
|
* File input for run creation
|
|
106
197
|
*/
|
|
107
198
|
export type FileInput = {
|
|
199
|
+
/**
|
|
200
|
+
* Filename
|
|
201
|
+
*/
|
|
108
202
|
filename: string;
|
|
109
203
|
/**
|
|
204
|
+
* Content
|
|
205
|
+
*
|
|
110
206
|
* Base64 encoded file content
|
|
111
207
|
*/
|
|
112
208
|
content: string;
|
|
113
209
|
/**
|
|
210
|
+
* Target Path
|
|
211
|
+
*
|
|
114
212
|
* Optional path on machine, defaults to ~/CyberdeskTransfers/
|
|
115
213
|
*/
|
|
116
214
|
target_path?: string | null;
|
|
117
215
|
/**
|
|
216
|
+
* Cleanup Imports After Run
|
|
217
|
+
*
|
|
118
218
|
* Delete from machine after run completes
|
|
119
219
|
*/
|
|
120
220
|
cleanup_imports_after_run?: boolean;
|
|
121
221
|
};
|
|
222
|
+
/**
|
|
223
|
+
* FileWriteRequest
|
|
224
|
+
*/
|
|
122
225
|
export type FileWriteRequest = {
|
|
123
226
|
/**
|
|
227
|
+
* Path
|
|
228
|
+
*
|
|
124
229
|
* Target file path
|
|
125
230
|
*/
|
|
126
231
|
path: string;
|
|
127
232
|
/**
|
|
233
|
+
* Content
|
|
234
|
+
*
|
|
128
235
|
* Base64 encoded file content
|
|
129
236
|
*/
|
|
130
237
|
content: string;
|
|
131
238
|
/**
|
|
239
|
+
* Mode
|
|
240
|
+
*
|
|
132
241
|
* Write mode - 'write' or 'append'
|
|
133
242
|
*/
|
|
134
243
|
mode?: string;
|
|
135
244
|
};
|
|
245
|
+
/**
|
|
246
|
+
* HTTPValidationError
|
|
247
|
+
*/
|
|
136
248
|
export type HttpValidationError = {
|
|
249
|
+
/**
|
|
250
|
+
* Detail
|
|
251
|
+
*/
|
|
137
252
|
detail?: Array<ValidationError>;
|
|
138
253
|
};
|
|
139
254
|
/**
|
|
255
|
+
* IncludedResource
|
|
256
|
+
*
|
|
140
257
|
* A resource in the JSON:API-style included array.
|
|
141
258
|
*
|
|
142
259
|
* Each included resource has a `type` field indicating what kind of resource it is
|
|
@@ -154,775 +271,1937 @@ export type HttpValidationError = {
|
|
|
154
271
|
*/
|
|
155
272
|
export type IncludedResource = {
|
|
156
273
|
/**
|
|
274
|
+
* Type
|
|
275
|
+
*
|
|
157
276
|
* Resource type (e.g., 'workflow', 'machine', 'pool')
|
|
158
277
|
*/
|
|
159
278
|
type: string;
|
|
160
279
|
/**
|
|
280
|
+
* Id
|
|
281
|
+
*
|
|
161
282
|
* Resource UUID
|
|
162
283
|
*/
|
|
163
284
|
id: string;
|
|
164
|
-
[key: string]: unknown
|
|
285
|
+
[key: string]: unknown;
|
|
165
286
|
};
|
|
287
|
+
/**
|
|
288
|
+
* KeyboardKeyRequest
|
|
289
|
+
*/
|
|
166
290
|
export type KeyboardKeyRequest = {
|
|
291
|
+
/**
|
|
292
|
+
* Text
|
|
293
|
+
*/
|
|
167
294
|
text: string;
|
|
168
295
|
};
|
|
296
|
+
/**
|
|
297
|
+
* KeyboardTypeRequest
|
|
298
|
+
*/
|
|
169
299
|
export type KeyboardTypeRequest = {
|
|
300
|
+
/**
|
|
301
|
+
* Text
|
|
302
|
+
*/
|
|
170
303
|
text: string;
|
|
171
304
|
};
|
|
172
305
|
/**
|
|
306
|
+
* MachineCreate
|
|
307
|
+
*
|
|
173
308
|
* Schema for creating a machine
|
|
174
309
|
*/
|
|
175
310
|
export type MachineCreate = {
|
|
311
|
+
/**
|
|
312
|
+
* Name
|
|
313
|
+
*/
|
|
176
314
|
name?: string | null;
|
|
315
|
+
/**
|
|
316
|
+
* Fingerprint
|
|
317
|
+
*/
|
|
177
318
|
fingerprint: string;
|
|
319
|
+
/**
|
|
320
|
+
* Version
|
|
321
|
+
*/
|
|
178
322
|
version?: string | null;
|
|
323
|
+
/**
|
|
324
|
+
* Hostname
|
|
325
|
+
*/
|
|
179
326
|
hostname?: string | null;
|
|
327
|
+
/**
|
|
328
|
+
* Os Info
|
|
329
|
+
*/
|
|
180
330
|
os_info?: string | null;
|
|
181
331
|
/**
|
|
332
|
+
* Machine Parameters
|
|
333
|
+
*
|
|
182
334
|
* Machine-specific input values that auto-populate runs
|
|
183
335
|
*/
|
|
184
336
|
machine_parameters?: {
|
|
185
337
|
[key: string]: unknown;
|
|
186
338
|
} | null;
|
|
187
339
|
/**
|
|
340
|
+
* Machine Sensitive Parameters
|
|
341
|
+
*
|
|
188
342
|
* Machine-specific sensitive input aliases (stored in Basis Theory)
|
|
189
343
|
*/
|
|
190
344
|
machine_sensitive_parameters?: {
|
|
191
345
|
[key: string]: string;
|
|
192
346
|
} | null;
|
|
347
|
+
/**
|
|
348
|
+
* Unkey Key Id
|
|
349
|
+
*/
|
|
193
350
|
unkey_key_id: string;
|
|
194
351
|
};
|
|
352
|
+
/**
|
|
353
|
+
* MachineHealthCheckError
|
|
354
|
+
*/
|
|
195
355
|
export type MachineHealthCheckError = {
|
|
356
|
+
/**
|
|
357
|
+
* Machine Id
|
|
358
|
+
*/
|
|
196
359
|
machine_id: string;
|
|
360
|
+
/**
|
|
361
|
+
* Organization Id
|
|
362
|
+
*/
|
|
197
363
|
organization_id?: string | null;
|
|
364
|
+
/**
|
|
365
|
+
* Machine Name
|
|
366
|
+
*/
|
|
198
367
|
machine_name?: string | null;
|
|
368
|
+
/**
|
|
369
|
+
* Status Code
|
|
370
|
+
*/
|
|
199
371
|
status_code?: number | null;
|
|
372
|
+
/**
|
|
373
|
+
* Error
|
|
374
|
+
*/
|
|
200
375
|
error: string;
|
|
201
376
|
};
|
|
202
377
|
/**
|
|
378
|
+
* MachinePoolAssignment
|
|
379
|
+
*
|
|
203
380
|
* Schema for assigning machines to pools
|
|
204
381
|
*/
|
|
205
382
|
export type MachinePoolAssignment = {
|
|
206
383
|
/**
|
|
384
|
+
* Machine Ids
|
|
385
|
+
*
|
|
207
386
|
* List of machine IDs to assign to the pool
|
|
208
387
|
*/
|
|
209
388
|
machine_ids: Array<string>;
|
|
210
389
|
};
|
|
211
390
|
/**
|
|
391
|
+
* MachinePoolUpdate
|
|
392
|
+
*
|
|
212
393
|
* Schema for updating a machine's pool assignments
|
|
213
394
|
*/
|
|
214
395
|
export type MachinePoolUpdate = {
|
|
215
396
|
/**
|
|
397
|
+
* Pool Ids
|
|
398
|
+
*
|
|
216
399
|
* List of pool IDs to assign the machine to
|
|
217
400
|
*/
|
|
218
401
|
pool_ids: Array<string>;
|
|
219
402
|
};
|
|
220
403
|
/**
|
|
404
|
+
* MachineResponse
|
|
405
|
+
*
|
|
221
406
|
* Machine response schema
|
|
222
407
|
*/
|
|
223
408
|
export type MachineResponse = {
|
|
409
|
+
/**
|
|
410
|
+
* Name
|
|
411
|
+
*/
|
|
224
412
|
name?: string | null;
|
|
413
|
+
/**
|
|
414
|
+
* Fingerprint
|
|
415
|
+
*/
|
|
225
416
|
fingerprint: string;
|
|
417
|
+
/**
|
|
418
|
+
* Version
|
|
419
|
+
*/
|
|
226
420
|
version?: string | null;
|
|
421
|
+
/**
|
|
422
|
+
* Hostname
|
|
423
|
+
*/
|
|
227
424
|
hostname?: string | null;
|
|
425
|
+
/**
|
|
426
|
+
* Os Info
|
|
427
|
+
*/
|
|
228
428
|
os_info?: string | null;
|
|
229
429
|
/**
|
|
430
|
+
* Machine Parameters
|
|
431
|
+
*
|
|
230
432
|
* Machine-specific input values that auto-populate runs
|
|
231
433
|
*/
|
|
232
434
|
machine_parameters?: {
|
|
233
435
|
[key: string]: unknown;
|
|
234
436
|
} | null;
|
|
235
437
|
/**
|
|
438
|
+
* Machine Sensitive Parameters
|
|
439
|
+
*
|
|
236
440
|
* Machine-specific sensitive input aliases (stored in Basis Theory)
|
|
237
441
|
*/
|
|
238
442
|
machine_sensitive_parameters?: {
|
|
239
443
|
[key: string]: string;
|
|
240
444
|
} | null;
|
|
445
|
+
/**
|
|
446
|
+
* Id
|
|
447
|
+
*/
|
|
241
448
|
id: string;
|
|
449
|
+
/**
|
|
450
|
+
* User Id
|
|
451
|
+
*/
|
|
242
452
|
user_id?: string | null;
|
|
453
|
+
/**
|
|
454
|
+
* Organization Id
|
|
455
|
+
*/
|
|
243
456
|
organization_id?: string | null;
|
|
457
|
+
/**
|
|
458
|
+
* Unkey Key Id
|
|
459
|
+
*/
|
|
244
460
|
unkey_key_id: string;
|
|
245
461
|
status: MachineStatus;
|
|
462
|
+
/**
|
|
463
|
+
* Is Available
|
|
464
|
+
*/
|
|
246
465
|
is_available: boolean;
|
|
466
|
+
/**
|
|
467
|
+
* Reserved Session Id
|
|
468
|
+
*/
|
|
247
469
|
reserved_session_id?: string | null;
|
|
470
|
+
/**
|
|
471
|
+
* Linked Keepalive Machine Id
|
|
472
|
+
*/
|
|
248
473
|
linked_keepalive_machine_id?: string | null;
|
|
249
474
|
/**
|
|
475
|
+
* Physical Server Id
|
|
476
|
+
*
|
|
250
477
|
* Fly machine ID hosting the WebSocket connection
|
|
251
478
|
*/
|
|
252
479
|
physical_server_id?: string | null;
|
|
480
|
+
/**
|
|
481
|
+
* Created At
|
|
482
|
+
*/
|
|
253
483
|
created_at: string;
|
|
484
|
+
/**
|
|
485
|
+
* Last Seen
|
|
486
|
+
*/
|
|
254
487
|
last_seen: string;
|
|
488
|
+
/**
|
|
489
|
+
* Pools
|
|
490
|
+
*/
|
|
255
491
|
pools?: Array<PoolResponse> | null;
|
|
256
492
|
};
|
|
257
493
|
/**
|
|
494
|
+
* MachineResponseWithIncludes
|
|
495
|
+
*
|
|
258
496
|
* Machine response with optional included related resources.
|
|
259
497
|
*/
|
|
260
498
|
export type MachineResponseWithIncludes = {
|
|
499
|
+
/**
|
|
500
|
+
* Id
|
|
501
|
+
*/
|
|
261
502
|
id: string;
|
|
503
|
+
/**
|
|
504
|
+
* User Id
|
|
505
|
+
*/
|
|
262
506
|
user_id?: string | null;
|
|
507
|
+
/**
|
|
508
|
+
* Organization Id
|
|
509
|
+
*/
|
|
263
510
|
organization_id?: string | null;
|
|
511
|
+
/**
|
|
512
|
+
* Name
|
|
513
|
+
*/
|
|
264
514
|
name?: string | null;
|
|
515
|
+
/**
|
|
516
|
+
* Fingerprint
|
|
517
|
+
*/
|
|
265
518
|
fingerprint: string;
|
|
519
|
+
/**
|
|
520
|
+
* Unkey Key Id
|
|
521
|
+
*/
|
|
266
522
|
unkey_key_id: string;
|
|
523
|
+
/**
|
|
524
|
+
* Version
|
|
525
|
+
*/
|
|
267
526
|
version?: string | null;
|
|
527
|
+
/**
|
|
528
|
+
* Hostname
|
|
529
|
+
*/
|
|
268
530
|
hostname?: string | null;
|
|
531
|
+
/**
|
|
532
|
+
* Os Info
|
|
533
|
+
*/
|
|
269
534
|
os_info?: string | null;
|
|
535
|
+
/**
|
|
536
|
+
* Machine Parameters
|
|
537
|
+
*/
|
|
270
538
|
machine_parameters?: {
|
|
271
539
|
[key: string]: unknown;
|
|
272
540
|
} | null;
|
|
541
|
+
/**
|
|
542
|
+
* Machine Sensitive Parameters
|
|
543
|
+
*/
|
|
273
544
|
machine_sensitive_parameters?: {
|
|
274
545
|
[key: string]: string;
|
|
275
546
|
} | null;
|
|
276
547
|
status: MachineStatus;
|
|
548
|
+
/**
|
|
549
|
+
* Is Available
|
|
550
|
+
*/
|
|
277
551
|
is_available: boolean;
|
|
552
|
+
/**
|
|
553
|
+
* Reserved Session Id
|
|
554
|
+
*/
|
|
278
555
|
reserved_session_id?: string | null;
|
|
556
|
+
/**
|
|
557
|
+
* Linked Keepalive Machine Id
|
|
558
|
+
*/
|
|
279
559
|
linked_keepalive_machine_id?: string | null;
|
|
560
|
+
/**
|
|
561
|
+
* Physical Server Id
|
|
562
|
+
*/
|
|
280
563
|
physical_server_id?: string | null;
|
|
564
|
+
/**
|
|
565
|
+
* Created At
|
|
566
|
+
*/
|
|
281
567
|
created_at: string;
|
|
568
|
+
/**
|
|
569
|
+
* Last Seen
|
|
570
|
+
*/
|
|
282
571
|
last_seen: string;
|
|
572
|
+
/**
|
|
573
|
+
* Pools
|
|
574
|
+
*/
|
|
283
575
|
pools?: Array<PoolResponse> | null;
|
|
284
576
|
/**
|
|
577
|
+
* Included
|
|
578
|
+
*
|
|
285
579
|
* Related resources requested via the `include` query parameter
|
|
286
580
|
*/
|
|
287
581
|
included?: Array<IncludedResource> | null;
|
|
288
582
|
};
|
|
583
|
+
/**
|
|
584
|
+
* MachineStatus
|
|
585
|
+
*/
|
|
289
586
|
export type MachineStatus = 'connected' | 'disconnected' | 'error';
|
|
290
587
|
/**
|
|
588
|
+
* MachineUpdate
|
|
589
|
+
*
|
|
291
590
|
* Schema for updating a machine
|
|
292
591
|
*/
|
|
293
592
|
export type MachineUpdate = {
|
|
593
|
+
/**
|
|
594
|
+
* Name
|
|
595
|
+
*/
|
|
294
596
|
name?: string | null;
|
|
597
|
+
/**
|
|
598
|
+
* Version
|
|
599
|
+
*/
|
|
295
600
|
version?: string | null;
|
|
601
|
+
/**
|
|
602
|
+
* Hostname
|
|
603
|
+
*/
|
|
296
604
|
hostname?: string | null;
|
|
605
|
+
/**
|
|
606
|
+
* Os Info
|
|
607
|
+
*/
|
|
297
608
|
os_info?: string | null;
|
|
298
609
|
status?: MachineStatus | null;
|
|
610
|
+
/**
|
|
611
|
+
* Is Available
|
|
612
|
+
*/
|
|
299
613
|
is_available?: boolean | null;
|
|
614
|
+
/**
|
|
615
|
+
* Last Seen
|
|
616
|
+
*/
|
|
300
617
|
last_seen?: string | null;
|
|
301
618
|
/**
|
|
619
|
+
* Reserved Session Id
|
|
620
|
+
*
|
|
302
621
|
* Set to null to clear reservation; server will cancel any scheduling/running run on this machine, clear reservation, mark machine available, and trigger matching
|
|
303
622
|
*/
|
|
304
623
|
reserved_session_id?: string | null;
|
|
305
624
|
/**
|
|
625
|
+
* Machine Parameters
|
|
626
|
+
*
|
|
306
627
|
* Machine-specific input values. Provide empty dict {} to clear all.
|
|
307
628
|
*/
|
|
308
629
|
machine_parameters?: {
|
|
309
630
|
[key: string]: unknown;
|
|
310
631
|
} | null;
|
|
311
632
|
/**
|
|
633
|
+
* Machine Sensitive Parameters
|
|
634
|
+
*
|
|
312
635
|
* Machine-specific sensitive input values (will be stored in Basis Theory). Provide empty dict {} to clear all.
|
|
313
636
|
*/
|
|
314
637
|
machine_sensitive_parameters?: {
|
|
315
638
|
[key: string]: string;
|
|
316
639
|
} | null;
|
|
317
640
|
};
|
|
641
|
+
/**
|
|
642
|
+
* MachinesHealthCheckResponse
|
|
643
|
+
*/
|
|
318
644
|
export type MachinesHealthCheckResponse = {
|
|
645
|
+
/**
|
|
646
|
+
* Status
|
|
647
|
+
*/
|
|
319
648
|
status: 'ok' | 'error';
|
|
649
|
+
/**
|
|
650
|
+
* Scope
|
|
651
|
+
*/
|
|
320
652
|
scope: 'organization' | 'all_organizations';
|
|
653
|
+
/**
|
|
654
|
+
* Checked Machines
|
|
655
|
+
*/
|
|
321
656
|
checked_machines: number;
|
|
657
|
+
/**
|
|
658
|
+
* Healthy Machines
|
|
659
|
+
*/
|
|
322
660
|
healthy_machines: number;
|
|
661
|
+
/**
|
|
662
|
+
* Errored Machines
|
|
663
|
+
*/
|
|
323
664
|
errored_machines: Array<MachineHealthCheckError>;
|
|
665
|
+
/**
|
|
666
|
+
* Message
|
|
667
|
+
*/
|
|
324
668
|
message: string;
|
|
325
669
|
};
|
|
326
670
|
/**
|
|
671
|
+
* ModelConfigurationCreate
|
|
672
|
+
*
|
|
327
673
|
* Create a model configuration.
|
|
328
674
|
*
|
|
329
675
|
* `api_key` is the raw secret material; it will be stored in Basis Theory and only the alias is persisted.
|
|
330
676
|
* For providers that Cyberdesk does not provide keys for, `api_key` is required.
|
|
331
677
|
*/
|
|
332
678
|
export type ModelConfigurationCreate = {
|
|
679
|
+
/**
|
|
680
|
+
* Name
|
|
681
|
+
*/
|
|
333
682
|
name: string;
|
|
683
|
+
/**
|
|
684
|
+
* Description
|
|
685
|
+
*/
|
|
334
686
|
description?: string | null;
|
|
335
687
|
/**
|
|
688
|
+
* Provider
|
|
689
|
+
*
|
|
336
690
|
* LangChain provider name (e.g. 'anthropic', 'openai').
|
|
337
691
|
*/
|
|
338
692
|
provider: string;
|
|
339
693
|
/**
|
|
694
|
+
* Model
|
|
695
|
+
*
|
|
340
696
|
* Provider model identifier (e.g. 'claude-sonnet-4-5-20250929').
|
|
341
697
|
*/
|
|
342
698
|
model: string;
|
|
699
|
+
/**
|
|
700
|
+
* Temperature
|
|
701
|
+
*/
|
|
343
702
|
temperature?: number | null;
|
|
703
|
+
/**
|
|
704
|
+
* Max Tokens
|
|
705
|
+
*/
|
|
344
706
|
max_tokens?: number | null;
|
|
707
|
+
/**
|
|
708
|
+
* Timeout Seconds
|
|
709
|
+
*/
|
|
345
710
|
timeout_seconds?: number | null;
|
|
711
|
+
/**
|
|
712
|
+
* Max Retries
|
|
713
|
+
*/
|
|
346
714
|
max_retries?: number | null;
|
|
347
715
|
/**
|
|
716
|
+
* Additional Params
|
|
717
|
+
*
|
|
348
718
|
* Provider-specific kwargs passed through to LangChain.
|
|
349
719
|
*/
|
|
350
720
|
additional_params?: {
|
|
351
721
|
[key: string]: unknown;
|
|
352
722
|
} | null;
|
|
353
723
|
/**
|
|
724
|
+
* Agent Harness Version String
|
|
725
|
+
*
|
|
354
726
|
* Agent harness version string used by Cyberdesk workers for prompt/tool selection.
|
|
355
727
|
*/
|
|
356
728
|
agent_harness_version_string?: string | null;
|
|
357
729
|
/**
|
|
730
|
+
* Is Computer Use Model
|
|
731
|
+
*
|
|
358
732
|
* True if this model has native computer use capabilities. If True, can be used for main agent, focused actions, and fallbacks for those agents.
|
|
359
733
|
*/
|
|
360
734
|
is_computer_use_model?: boolean;
|
|
361
735
|
/**
|
|
736
|
+
* Is Archived
|
|
737
|
+
*
|
|
362
738
|
* Whether this model configuration is archived and should generally be hidden behind archived-model UI affordances.
|
|
363
739
|
*/
|
|
364
740
|
is_archived?: boolean;
|
|
365
741
|
/**
|
|
742
|
+
* Api Key
|
|
743
|
+
*
|
|
366
744
|
* Raw API key (stored in Basis Theory; never persisted directly).
|
|
367
745
|
*/
|
|
368
746
|
api_key?: string | null;
|
|
369
747
|
};
|
|
370
748
|
/**
|
|
749
|
+
* ModelConfigurationResponse
|
|
750
|
+
*
|
|
371
751
|
* API response schema for model configurations.
|
|
372
752
|
*/
|
|
373
753
|
export type ModelConfigurationResponse = {
|
|
754
|
+
/**
|
|
755
|
+
* Name
|
|
756
|
+
*/
|
|
374
757
|
name: string;
|
|
758
|
+
/**
|
|
759
|
+
* Description
|
|
760
|
+
*/
|
|
375
761
|
description?: string | null;
|
|
376
762
|
/**
|
|
763
|
+
* Provider
|
|
764
|
+
*
|
|
377
765
|
* LangChain provider name (e.g. 'anthropic', 'openai').
|
|
378
766
|
*/
|
|
379
767
|
provider: string;
|
|
380
768
|
/**
|
|
769
|
+
* Model
|
|
770
|
+
*
|
|
381
771
|
* Provider model identifier (e.g. 'claude-sonnet-4-5-20250929').
|
|
382
772
|
*/
|
|
383
773
|
model: string;
|
|
774
|
+
/**
|
|
775
|
+
* Temperature
|
|
776
|
+
*/
|
|
384
777
|
temperature?: number | null;
|
|
778
|
+
/**
|
|
779
|
+
* Max Tokens
|
|
780
|
+
*/
|
|
385
781
|
max_tokens?: number | null;
|
|
782
|
+
/**
|
|
783
|
+
* Timeout Seconds
|
|
784
|
+
*/
|
|
386
785
|
timeout_seconds?: number | null;
|
|
786
|
+
/**
|
|
787
|
+
* Max Retries
|
|
788
|
+
*/
|
|
387
789
|
max_retries?: number | null;
|
|
388
790
|
/**
|
|
791
|
+
* Additional Params
|
|
792
|
+
*
|
|
389
793
|
* Provider-specific kwargs passed through to LangChain.
|
|
390
794
|
*/
|
|
391
795
|
additional_params?: {
|
|
392
796
|
[key: string]: unknown;
|
|
393
797
|
} | null;
|
|
394
798
|
/**
|
|
799
|
+
* Agent Harness Version String
|
|
800
|
+
*
|
|
395
801
|
* Agent harness version string used by Cyberdesk workers for prompt/tool selection.
|
|
396
802
|
*/
|
|
397
803
|
agent_harness_version_string?: string | null;
|
|
398
804
|
/**
|
|
805
|
+
* Is Computer Use Model
|
|
806
|
+
*
|
|
399
807
|
* True if this model has native computer use capabilities. If True, can be used for main agent, focused actions, and fallbacks for those agents.
|
|
400
808
|
*/
|
|
401
809
|
is_computer_use_model?: boolean;
|
|
402
810
|
/**
|
|
811
|
+
* Is Archived
|
|
812
|
+
*
|
|
403
813
|
* Whether this model configuration is archived and should generally be hidden behind archived-model UI affordances.
|
|
404
814
|
*/
|
|
405
815
|
is_archived?: boolean;
|
|
816
|
+
/**
|
|
817
|
+
* Id
|
|
818
|
+
*/
|
|
406
819
|
id: string;
|
|
820
|
+
/**
|
|
821
|
+
* Organization Id
|
|
822
|
+
*/
|
|
407
823
|
organization_id?: string | null;
|
|
408
824
|
/**
|
|
825
|
+
* Api Key Alias
|
|
826
|
+
*
|
|
409
827
|
* Basis Theory token id (alias) used to resolve api_key at runtime.
|
|
410
828
|
*/
|
|
411
829
|
api_key_alias?: string | null;
|
|
830
|
+
/**
|
|
831
|
+
* Is System Default
|
|
832
|
+
*/
|
|
412
833
|
is_system_default: boolean;
|
|
834
|
+
/**
|
|
835
|
+
* Created At
|
|
836
|
+
*/
|
|
413
837
|
created_at: string;
|
|
838
|
+
/**
|
|
839
|
+
* Updated At
|
|
840
|
+
*/
|
|
414
841
|
updated_at: string;
|
|
415
842
|
};
|
|
416
843
|
/**
|
|
844
|
+
* ModelConfigurationUpdate
|
|
845
|
+
*
|
|
417
846
|
* Update a model configuration (organization-owned only).
|
|
418
847
|
*/
|
|
419
848
|
export type ModelConfigurationUpdate = {
|
|
849
|
+
/**
|
|
850
|
+
* Name
|
|
851
|
+
*/
|
|
420
852
|
name?: string | null;
|
|
853
|
+
/**
|
|
854
|
+
* Description
|
|
855
|
+
*/
|
|
421
856
|
description?: string | null;
|
|
857
|
+
/**
|
|
858
|
+
* Provider
|
|
859
|
+
*/
|
|
422
860
|
provider?: string | null;
|
|
861
|
+
/**
|
|
862
|
+
* Model
|
|
863
|
+
*/
|
|
423
864
|
model?: string | null;
|
|
424
865
|
/**
|
|
866
|
+
* Api Key
|
|
867
|
+
*
|
|
425
868
|
* Raw API key; if provided, replaces the stored alias.
|
|
426
869
|
*/
|
|
427
870
|
api_key?: string | null;
|
|
428
871
|
/**
|
|
872
|
+
* Clear Api Key
|
|
873
|
+
*
|
|
429
874
|
* If true, clears any stored api_key_alias (reverts to Cyberdesk-provided key if supported).
|
|
430
875
|
*/
|
|
431
876
|
clear_api_key?: boolean | null;
|
|
877
|
+
/**
|
|
878
|
+
* Temperature
|
|
879
|
+
*/
|
|
432
880
|
temperature?: number | null;
|
|
881
|
+
/**
|
|
882
|
+
* Max Tokens
|
|
883
|
+
*/
|
|
433
884
|
max_tokens?: number | null;
|
|
885
|
+
/**
|
|
886
|
+
* Timeout Seconds
|
|
887
|
+
*/
|
|
434
888
|
timeout_seconds?: number | null;
|
|
889
|
+
/**
|
|
890
|
+
* Max Retries
|
|
891
|
+
*/
|
|
435
892
|
max_retries?: number | null;
|
|
893
|
+
/**
|
|
894
|
+
* Additional Params
|
|
895
|
+
*/
|
|
436
896
|
additional_params?: {
|
|
437
897
|
[key: string]: unknown;
|
|
438
898
|
} | null;
|
|
899
|
+
/**
|
|
900
|
+
* Agent Harness Version String
|
|
901
|
+
*/
|
|
439
902
|
agent_harness_version_string?: string | null;
|
|
903
|
+
/**
|
|
904
|
+
* Is Computer Use Model
|
|
905
|
+
*/
|
|
440
906
|
is_computer_use_model?: boolean | null;
|
|
907
|
+
/**
|
|
908
|
+
* Is Archived
|
|
909
|
+
*/
|
|
441
910
|
is_archived?: boolean | null;
|
|
442
911
|
};
|
|
443
|
-
|
|
912
|
+
/**
|
|
913
|
+
* MouseClickRequest
|
|
914
|
+
*/
|
|
915
|
+
export type MouseClickRequest = {
|
|
916
|
+
/**
|
|
917
|
+
* X
|
|
918
|
+
*/
|
|
444
919
|
x?: number | null;
|
|
920
|
+
/**
|
|
921
|
+
* Y
|
|
922
|
+
*/
|
|
445
923
|
y?: number | null;
|
|
924
|
+
/**
|
|
925
|
+
* Button
|
|
926
|
+
*/
|
|
446
927
|
button?: string;
|
|
447
928
|
/**
|
|
929
|
+
* Down
|
|
930
|
+
*
|
|
448
931
|
* None = full click, True = mouse down, False = mouse up
|
|
449
932
|
*/
|
|
450
933
|
down?: boolean | null;
|
|
451
934
|
/**
|
|
935
|
+
* Clicks
|
|
936
|
+
*
|
|
452
937
|
* Number of clicks (1=single, 2=double, 3=triple)
|
|
453
938
|
*/
|
|
454
939
|
clicks?: number;
|
|
455
940
|
};
|
|
941
|
+
/**
|
|
942
|
+
* MouseDragRequest
|
|
943
|
+
*/
|
|
456
944
|
export type MouseDragRequest = {
|
|
945
|
+
/**
|
|
946
|
+
* To X
|
|
947
|
+
*/
|
|
457
948
|
to_x: number;
|
|
949
|
+
/**
|
|
950
|
+
* To Y
|
|
951
|
+
*/
|
|
458
952
|
to_y: number;
|
|
953
|
+
/**
|
|
954
|
+
* Start X
|
|
955
|
+
*/
|
|
459
956
|
start_x: number;
|
|
957
|
+
/**
|
|
958
|
+
* Start Y
|
|
959
|
+
*/
|
|
460
960
|
start_y: number;
|
|
961
|
+
/**
|
|
962
|
+
* Duration
|
|
963
|
+
*/
|
|
461
964
|
duration?: number | null;
|
|
462
965
|
/**
|
|
966
|
+
* Button
|
|
967
|
+
*
|
|
463
968
|
* 'left' | 'right' | 'middle'
|
|
464
969
|
*/
|
|
465
970
|
button?: string | null;
|
|
466
971
|
};
|
|
972
|
+
/**
|
|
973
|
+
* MouseMoveRequest
|
|
974
|
+
*/
|
|
467
975
|
export type MouseMoveRequest = {
|
|
976
|
+
/**
|
|
977
|
+
* X
|
|
978
|
+
*/
|
|
468
979
|
x: number;
|
|
980
|
+
/**
|
|
981
|
+
* Y
|
|
982
|
+
*/
|
|
469
983
|
y: number;
|
|
470
984
|
};
|
|
985
|
+
/**
|
|
986
|
+
* MousePosition
|
|
987
|
+
*/
|
|
471
988
|
export type MousePosition = {
|
|
989
|
+
/**
|
|
990
|
+
* X
|
|
991
|
+
*/
|
|
472
992
|
x: number;
|
|
993
|
+
/**
|
|
994
|
+
* Y
|
|
995
|
+
*/
|
|
473
996
|
y: number;
|
|
474
997
|
};
|
|
998
|
+
/**
|
|
999
|
+
* MouseScrollRequest
|
|
1000
|
+
*/
|
|
475
1001
|
export type MouseScrollRequest = {
|
|
476
1002
|
/**
|
|
1003
|
+
* Direction
|
|
1004
|
+
*
|
|
477
1005
|
* Scroll direction: 'up', 'down', 'left', or 'right'
|
|
478
1006
|
*/
|
|
479
1007
|
direction: string;
|
|
480
1008
|
/**
|
|
1009
|
+
* Amount
|
|
1010
|
+
*
|
|
481
1011
|
* Number of scroll steps (clicks); non-negative integer
|
|
482
1012
|
*/
|
|
483
1013
|
amount: number;
|
|
1014
|
+
/**
|
|
1015
|
+
* X
|
|
1016
|
+
*/
|
|
484
1017
|
x?: number | null;
|
|
1018
|
+
/**
|
|
1019
|
+
* Y
|
|
1020
|
+
*/
|
|
485
1021
|
y?: number | null;
|
|
486
1022
|
};
|
|
487
1023
|
/**
|
|
1024
|
+
* PaginatedResponse
|
|
1025
|
+
*
|
|
488
1026
|
* Paginated response wrapper
|
|
489
1027
|
*/
|
|
490
1028
|
export type PaginatedResponse = {
|
|
1029
|
+
/**
|
|
1030
|
+
* Items
|
|
1031
|
+
*/
|
|
491
1032
|
items: Array<unknown>;
|
|
1033
|
+
/**
|
|
1034
|
+
* Total
|
|
1035
|
+
*/
|
|
492
1036
|
total: number;
|
|
1037
|
+
/**
|
|
1038
|
+
* Skip
|
|
1039
|
+
*/
|
|
493
1040
|
skip: number;
|
|
1041
|
+
/**
|
|
1042
|
+
* Limit
|
|
1043
|
+
*/
|
|
494
1044
|
limit: number;
|
|
495
1045
|
};
|
|
1046
|
+
/**
|
|
1047
|
+
* PaginatedResponseWithIncludes[MachineResponse]
|
|
1048
|
+
*/
|
|
496
1049
|
export type PaginatedResponseWithIncludesMachineResponse = {
|
|
1050
|
+
/**
|
|
1051
|
+
* Items
|
|
1052
|
+
*/
|
|
497
1053
|
items: Array<MachineResponse>;
|
|
1054
|
+
/**
|
|
1055
|
+
* Total
|
|
1056
|
+
*/
|
|
498
1057
|
total: number;
|
|
1058
|
+
/**
|
|
1059
|
+
* Skip
|
|
1060
|
+
*/
|
|
499
1061
|
skip: number;
|
|
1062
|
+
/**
|
|
1063
|
+
* Limit
|
|
1064
|
+
*/
|
|
500
1065
|
limit: number;
|
|
501
1066
|
/**
|
|
1067
|
+
* Included
|
|
1068
|
+
*
|
|
502
1069
|
* Related resources requested via the `include` query parameter
|
|
503
1070
|
*/
|
|
504
1071
|
included?: Array<IncludedResource> | null;
|
|
505
1072
|
};
|
|
1073
|
+
/**
|
|
1074
|
+
* PaginatedResponseWithIncludes[PoolResponse]
|
|
1075
|
+
*/
|
|
506
1076
|
export type PaginatedResponseWithIncludesPoolResponse = {
|
|
1077
|
+
/**
|
|
1078
|
+
* Items
|
|
1079
|
+
*/
|
|
507
1080
|
items: Array<PoolResponse>;
|
|
1081
|
+
/**
|
|
1082
|
+
* Total
|
|
1083
|
+
*/
|
|
508
1084
|
total: number;
|
|
1085
|
+
/**
|
|
1086
|
+
* Skip
|
|
1087
|
+
*/
|
|
509
1088
|
skip: number;
|
|
1089
|
+
/**
|
|
1090
|
+
* Limit
|
|
1091
|
+
*/
|
|
510
1092
|
limit: number;
|
|
511
1093
|
/**
|
|
1094
|
+
* Included
|
|
1095
|
+
*
|
|
512
1096
|
* Related resources requested via the `include` query parameter
|
|
513
1097
|
*/
|
|
514
1098
|
included?: Array<IncludedResource> | null;
|
|
515
1099
|
};
|
|
1100
|
+
/**
|
|
1101
|
+
* PaginatedResponseWithIncludes[RunResponse]
|
|
1102
|
+
*/
|
|
516
1103
|
export type PaginatedResponseWithIncludesRunResponse = {
|
|
517
|
-
|
|
1104
|
+
/**
|
|
1105
|
+
* Items
|
|
1106
|
+
*/
|
|
1107
|
+
items: Array<RunResponseOutput>;
|
|
1108
|
+
/**
|
|
1109
|
+
* Total
|
|
1110
|
+
*/
|
|
518
1111
|
total: number;
|
|
1112
|
+
/**
|
|
1113
|
+
* Skip
|
|
1114
|
+
*/
|
|
519
1115
|
skip: number;
|
|
1116
|
+
/**
|
|
1117
|
+
* Limit
|
|
1118
|
+
*/
|
|
520
1119
|
limit: number;
|
|
521
1120
|
/**
|
|
1121
|
+
* Included
|
|
1122
|
+
*
|
|
522
1123
|
* Related resources requested via the `include` query parameter
|
|
523
1124
|
*/
|
|
524
1125
|
included?: Array<IncludedResource> | null;
|
|
525
1126
|
};
|
|
1127
|
+
/**
|
|
1128
|
+
* PaginatedResponseWithIncludes[TrajectoryResponse]
|
|
1129
|
+
*/
|
|
526
1130
|
export type PaginatedResponseWithIncludesTrajectoryResponse = {
|
|
1131
|
+
/**
|
|
1132
|
+
* Items
|
|
1133
|
+
*/
|
|
527
1134
|
items: Array<TrajectoryResponse>;
|
|
1135
|
+
/**
|
|
1136
|
+
* Total
|
|
1137
|
+
*/
|
|
528
1138
|
total: number;
|
|
1139
|
+
/**
|
|
1140
|
+
* Skip
|
|
1141
|
+
*/
|
|
529
1142
|
skip: number;
|
|
1143
|
+
/**
|
|
1144
|
+
* Limit
|
|
1145
|
+
*/
|
|
530
1146
|
limit: number;
|
|
531
1147
|
/**
|
|
1148
|
+
* Included
|
|
1149
|
+
*
|
|
532
1150
|
* Related resources requested via the `include` query parameter
|
|
533
1151
|
*/
|
|
534
1152
|
included?: Array<IncludedResource> | null;
|
|
535
1153
|
};
|
|
536
|
-
|
|
537
|
-
|
|
1154
|
+
/**
|
|
1155
|
+
* PaginatedResponseWithIncludes[WorkflowResponse]
|
|
1156
|
+
*/
|
|
1157
|
+
export type PaginatedResponseWithIncludesWorkflowResponse = {
|
|
1158
|
+
/**
|
|
1159
|
+
* Items
|
|
1160
|
+
*/
|
|
1161
|
+
items: Array<WorkflowResponse>;
|
|
1162
|
+
/**
|
|
1163
|
+
* Total
|
|
1164
|
+
*/
|
|
538
1165
|
total: number;
|
|
1166
|
+
/**
|
|
1167
|
+
* Skip
|
|
1168
|
+
*/
|
|
539
1169
|
skip: number;
|
|
1170
|
+
/**
|
|
1171
|
+
* Limit
|
|
1172
|
+
*/
|
|
540
1173
|
limit: number;
|
|
1174
|
+
/**
|
|
1175
|
+
* Included
|
|
1176
|
+
*
|
|
1177
|
+
* Related resources requested via the `include` query parameter
|
|
1178
|
+
*/
|
|
1179
|
+
included?: Array<IncludedResource> | null;
|
|
541
1180
|
};
|
|
542
|
-
|
|
543
|
-
|
|
1181
|
+
/**
|
|
1182
|
+
* PaginatedResponse[ConnectionResponse]
|
|
1183
|
+
*/
|
|
1184
|
+
export type PaginatedResponseConnectionResponse = {
|
|
1185
|
+
/**
|
|
1186
|
+
* Items
|
|
1187
|
+
*/
|
|
1188
|
+
items: Array<ConnectionResponse>;
|
|
1189
|
+
/**
|
|
1190
|
+
* Total
|
|
1191
|
+
*/
|
|
544
1192
|
total: number;
|
|
1193
|
+
/**
|
|
1194
|
+
* Skip
|
|
1195
|
+
*/
|
|
545
1196
|
skip: number;
|
|
1197
|
+
/**
|
|
1198
|
+
* Limit
|
|
1199
|
+
*/
|
|
546
1200
|
limit: number;
|
|
547
1201
|
};
|
|
548
|
-
|
|
549
|
-
|
|
1202
|
+
/**
|
|
1203
|
+
* PaginatedResponse[RunAttachmentResponse]
|
|
1204
|
+
*/
|
|
1205
|
+
export type PaginatedResponseRunAttachmentResponse = {
|
|
1206
|
+
/**
|
|
1207
|
+
* Items
|
|
1208
|
+
*/
|
|
1209
|
+
items: Array<RunAttachmentResponse>;
|
|
1210
|
+
/**
|
|
1211
|
+
* Total
|
|
1212
|
+
*/
|
|
550
1213
|
total: number;
|
|
1214
|
+
/**
|
|
1215
|
+
* Skip
|
|
1216
|
+
*/
|
|
551
1217
|
skip: number;
|
|
1218
|
+
/**
|
|
1219
|
+
* Limit
|
|
1220
|
+
*/
|
|
552
1221
|
limit: number;
|
|
553
1222
|
};
|
|
554
1223
|
/**
|
|
1224
|
+
* PoolCreate
|
|
1225
|
+
*
|
|
555
1226
|
* Schema for creating a pool
|
|
556
1227
|
*/
|
|
557
1228
|
export type PoolCreate = {
|
|
1229
|
+
/**
|
|
1230
|
+
* Name
|
|
1231
|
+
*/
|
|
558
1232
|
name: string;
|
|
1233
|
+
/**
|
|
1234
|
+
* Description
|
|
1235
|
+
*/
|
|
559
1236
|
description?: string | null;
|
|
560
1237
|
};
|
|
561
1238
|
/**
|
|
1239
|
+
* PoolResponse
|
|
1240
|
+
*
|
|
562
1241
|
* Pool response schema
|
|
563
1242
|
*/
|
|
564
1243
|
export type PoolResponse = {
|
|
1244
|
+
/**
|
|
1245
|
+
* Name
|
|
1246
|
+
*/
|
|
565
1247
|
name: string;
|
|
1248
|
+
/**
|
|
1249
|
+
* Description
|
|
1250
|
+
*/
|
|
566
1251
|
description?: string | null;
|
|
1252
|
+
/**
|
|
1253
|
+
* Id
|
|
1254
|
+
*/
|
|
567
1255
|
id: string;
|
|
1256
|
+
/**
|
|
1257
|
+
* Organization Id
|
|
1258
|
+
*/
|
|
568
1259
|
organization_id: string;
|
|
1260
|
+
/**
|
|
1261
|
+
* Created At
|
|
1262
|
+
*/
|
|
569
1263
|
created_at: string;
|
|
1264
|
+
/**
|
|
1265
|
+
* Updated At
|
|
1266
|
+
*/
|
|
570
1267
|
updated_at: string;
|
|
571
1268
|
/**
|
|
1269
|
+
* Machine Count
|
|
1270
|
+
*
|
|
572
1271
|
* Number of machines in this pool
|
|
573
1272
|
*/
|
|
574
1273
|
machine_count?: number | null;
|
|
575
1274
|
};
|
|
576
1275
|
/**
|
|
1276
|
+
* PoolResponseWithIncludes
|
|
1277
|
+
*
|
|
577
1278
|
* Pool response with optional included related resources.
|
|
578
1279
|
*/
|
|
579
1280
|
export type PoolResponseWithIncludes = {
|
|
1281
|
+
/**
|
|
1282
|
+
* Id
|
|
1283
|
+
*/
|
|
580
1284
|
id: string;
|
|
1285
|
+
/**
|
|
1286
|
+
* Organization Id
|
|
1287
|
+
*/
|
|
581
1288
|
organization_id: string;
|
|
1289
|
+
/**
|
|
1290
|
+
* Name
|
|
1291
|
+
*/
|
|
582
1292
|
name: string;
|
|
1293
|
+
/**
|
|
1294
|
+
* Description
|
|
1295
|
+
*/
|
|
583
1296
|
description?: string | null;
|
|
1297
|
+
/**
|
|
1298
|
+
* Created At
|
|
1299
|
+
*/
|
|
584
1300
|
created_at: string;
|
|
1301
|
+
/**
|
|
1302
|
+
* Updated At
|
|
1303
|
+
*/
|
|
585
1304
|
updated_at: string;
|
|
586
1305
|
/**
|
|
1306
|
+
* Machine Count
|
|
1307
|
+
*
|
|
587
1308
|
* Number of machines in this pool
|
|
588
1309
|
*/
|
|
589
1310
|
machine_count?: number | null;
|
|
590
1311
|
/**
|
|
1312
|
+
* Machines
|
|
1313
|
+
*
|
|
591
1314
|
* [Deprecated] Machines in this pool. Use `included` array instead.
|
|
592
1315
|
*/
|
|
593
1316
|
machines?: Array<MachineResponse> | null;
|
|
594
1317
|
/**
|
|
1318
|
+
* Included
|
|
1319
|
+
*
|
|
595
1320
|
* Related resources requested via the `include` query parameter
|
|
596
1321
|
*/
|
|
597
1322
|
included?: Array<IncludedResource> | null;
|
|
598
1323
|
};
|
|
599
1324
|
/**
|
|
1325
|
+
* PoolUpdate
|
|
1326
|
+
*
|
|
600
1327
|
* Schema for updating a pool
|
|
601
1328
|
*/
|
|
602
1329
|
export type PoolUpdate = {
|
|
1330
|
+
/**
|
|
1331
|
+
* Name
|
|
1332
|
+
*/
|
|
603
1333
|
name?: string | null;
|
|
1334
|
+
/**
|
|
1335
|
+
* Description
|
|
1336
|
+
*/
|
|
604
1337
|
description?: string | null;
|
|
605
1338
|
};
|
|
606
1339
|
/**
|
|
1340
|
+
* PoolWithMachines
|
|
1341
|
+
*
|
|
607
1342
|
* Pool response with machines included
|
|
608
1343
|
*/
|
|
609
1344
|
export type PoolWithMachines = {
|
|
1345
|
+
/**
|
|
1346
|
+
* Name
|
|
1347
|
+
*/
|
|
610
1348
|
name: string;
|
|
1349
|
+
/**
|
|
1350
|
+
* Description
|
|
1351
|
+
*/
|
|
611
1352
|
description?: string | null;
|
|
1353
|
+
/**
|
|
1354
|
+
* Id
|
|
1355
|
+
*/
|
|
612
1356
|
id: string;
|
|
1357
|
+
/**
|
|
1358
|
+
* Organization Id
|
|
1359
|
+
*/
|
|
613
1360
|
organization_id: string;
|
|
1361
|
+
/**
|
|
1362
|
+
* Created At
|
|
1363
|
+
*/
|
|
614
1364
|
created_at: string;
|
|
1365
|
+
/**
|
|
1366
|
+
* Updated At
|
|
1367
|
+
*/
|
|
615
1368
|
updated_at: string;
|
|
616
1369
|
/**
|
|
1370
|
+
* Machine Count
|
|
1371
|
+
*
|
|
617
1372
|
* Number of machines in this pool
|
|
618
1373
|
*/
|
|
619
1374
|
machine_count?: number | null;
|
|
1375
|
+
/**
|
|
1376
|
+
* Machines
|
|
1377
|
+
*/
|
|
620
1378
|
machines?: Array<MachineResponse>;
|
|
621
1379
|
};
|
|
1380
|
+
/**
|
|
1381
|
+
* PostRunCheckFileTargetMode
|
|
1382
|
+
*/
|
|
1383
|
+
export type PostRunCheckFileTargetMode = 'exact' | 'regex' | 'loop_items';
|
|
1384
|
+
/**
|
|
1385
|
+
* PostRunCheckStatus
|
|
1386
|
+
*/
|
|
1387
|
+
export type PostRunCheckStatus = 'pending' | 'running' | 'success' | 'failed' | 'infra_error' | 'cancelled';
|
|
1388
|
+
/**
|
|
1389
|
+
* PostRunCheckType
|
|
1390
|
+
*/
|
|
1391
|
+
export type PostRunCheckType = 'run_attachment_exists' | 'run_attachment_image_check' | 'output_data_passes_schema_validation' | 'output_data_agentic_check';
|
|
1392
|
+
/**
|
|
1393
|
+
* PowerShellExecRequest
|
|
1394
|
+
*/
|
|
622
1395
|
export type PowerShellExecRequest = {
|
|
623
1396
|
/**
|
|
1397
|
+
* Command
|
|
1398
|
+
*
|
|
624
1399
|
* PowerShell command to execute
|
|
625
1400
|
*/
|
|
626
1401
|
command: string;
|
|
627
1402
|
/**
|
|
1403
|
+
* Same Session
|
|
1404
|
+
*
|
|
628
1405
|
* Use persistent session
|
|
629
1406
|
*/
|
|
630
1407
|
same_session?: boolean;
|
|
631
1408
|
/**
|
|
1409
|
+
* Working Directory
|
|
1410
|
+
*
|
|
632
1411
|
* Working directory for new session
|
|
633
1412
|
*/
|
|
634
1413
|
working_directory?: string | null;
|
|
635
1414
|
/**
|
|
1415
|
+
* Session Id
|
|
1416
|
+
*
|
|
636
1417
|
* Session ID to use
|
|
637
1418
|
*/
|
|
638
1419
|
session_id?: string | null;
|
|
639
1420
|
/**
|
|
1421
|
+
* Timeout
|
|
1422
|
+
*
|
|
640
1423
|
* Maximum time in seconds to wait for command completion before continuing. The command will continue running in the background after timeout (default: 30.0)
|
|
641
1424
|
*/
|
|
642
1425
|
timeout?: number | null;
|
|
643
1426
|
};
|
|
1427
|
+
/**
|
|
1428
|
+
* PowerShellSessionRequest
|
|
1429
|
+
*/
|
|
644
1430
|
export type PowerShellSessionRequest = {
|
|
645
1431
|
/**
|
|
1432
|
+
* Action
|
|
1433
|
+
*
|
|
646
1434
|
* Action to perform - 'create' or 'destroy'
|
|
647
1435
|
*/
|
|
648
1436
|
action: string;
|
|
649
1437
|
/**
|
|
1438
|
+
* Session Id
|
|
1439
|
+
*
|
|
650
1440
|
* Session ID for destroy action
|
|
651
1441
|
*/
|
|
652
1442
|
session_id?: string | null;
|
|
653
1443
|
};
|
|
654
1444
|
/**
|
|
1445
|
+
* ReorderRequest
|
|
1446
|
+
*
|
|
655
1447
|
* Schema for reordering tags or groups
|
|
656
1448
|
*/
|
|
657
1449
|
export type ReorderRequest = {
|
|
658
1450
|
/**
|
|
1451
|
+
* Ids
|
|
1452
|
+
*
|
|
659
1453
|
* List of IDs in desired order
|
|
660
1454
|
*/
|
|
661
1455
|
ids: Array<string>;
|
|
662
1456
|
};
|
|
663
1457
|
/**
|
|
1458
|
+
* RequestLogCreate
|
|
1459
|
+
*
|
|
664
1460
|
* Schema for creating a request log
|
|
665
1461
|
*/
|
|
666
1462
|
export type RequestLogCreate = {
|
|
1463
|
+
/**
|
|
1464
|
+
* Request Id
|
|
1465
|
+
*/
|
|
667
1466
|
request_id: string;
|
|
1467
|
+
/**
|
|
1468
|
+
* Method
|
|
1469
|
+
*/
|
|
668
1470
|
method: string;
|
|
1471
|
+
/**
|
|
1472
|
+
* Path
|
|
1473
|
+
*/
|
|
669
1474
|
path: string;
|
|
1475
|
+
/**
|
|
1476
|
+
* Status Code
|
|
1477
|
+
*/
|
|
670
1478
|
status_code?: number | null;
|
|
1479
|
+
/**
|
|
1480
|
+
* Request Size Bytes
|
|
1481
|
+
*/
|
|
671
1482
|
request_size_bytes?: number | null;
|
|
1483
|
+
/**
|
|
1484
|
+
* Response Size Bytes
|
|
1485
|
+
*/
|
|
672
1486
|
response_size_bytes?: number | null;
|
|
1487
|
+
/**
|
|
1488
|
+
* Duration Ms
|
|
1489
|
+
*/
|
|
673
1490
|
duration_ms?: number | null;
|
|
1491
|
+
/**
|
|
1492
|
+
* Error Message
|
|
1493
|
+
*/
|
|
674
1494
|
error_message?: string | null;
|
|
1495
|
+
/**
|
|
1496
|
+
* Machine Id
|
|
1497
|
+
*/
|
|
675
1498
|
machine_id: string;
|
|
676
1499
|
};
|
|
677
1500
|
/**
|
|
1501
|
+
* RequestLogResponse
|
|
1502
|
+
*
|
|
678
1503
|
* Request log response schema
|
|
679
1504
|
*/
|
|
680
1505
|
export type RequestLogResponse = {
|
|
1506
|
+
/**
|
|
1507
|
+
* Request Id
|
|
1508
|
+
*/
|
|
681
1509
|
request_id: string;
|
|
1510
|
+
/**
|
|
1511
|
+
* Method
|
|
1512
|
+
*/
|
|
682
1513
|
method: string;
|
|
1514
|
+
/**
|
|
1515
|
+
* Path
|
|
1516
|
+
*/
|
|
683
1517
|
path: string;
|
|
1518
|
+
/**
|
|
1519
|
+
* Status Code
|
|
1520
|
+
*/
|
|
684
1521
|
status_code?: number | null;
|
|
1522
|
+
/**
|
|
1523
|
+
* Request Size Bytes
|
|
1524
|
+
*/
|
|
685
1525
|
request_size_bytes?: number | null;
|
|
1526
|
+
/**
|
|
1527
|
+
* Response Size Bytes
|
|
1528
|
+
*/
|
|
686
1529
|
response_size_bytes?: number | null;
|
|
1530
|
+
/**
|
|
1531
|
+
* Duration Ms
|
|
1532
|
+
*/
|
|
687
1533
|
duration_ms?: number | null;
|
|
1534
|
+
/**
|
|
1535
|
+
* Error Message
|
|
1536
|
+
*/
|
|
688
1537
|
error_message?: string | null;
|
|
1538
|
+
/**
|
|
1539
|
+
* Id
|
|
1540
|
+
*/
|
|
689
1541
|
id: string;
|
|
1542
|
+
/**
|
|
1543
|
+
* Machine Id
|
|
1544
|
+
*/
|
|
690
1545
|
machine_id: string;
|
|
1546
|
+
/**
|
|
1547
|
+
* Organization Id
|
|
1548
|
+
*/
|
|
691
1549
|
organization_id?: string | null;
|
|
1550
|
+
/**
|
|
1551
|
+
* Created At
|
|
1552
|
+
*/
|
|
692
1553
|
created_at: string;
|
|
1554
|
+
/**
|
|
1555
|
+
* Completed At
|
|
1556
|
+
*/
|
|
693
1557
|
completed_at: string | null;
|
|
694
1558
|
};
|
|
695
1559
|
/**
|
|
1560
|
+
* RequestLogUpdate
|
|
1561
|
+
*
|
|
696
1562
|
* Schema for updating a request log
|
|
697
1563
|
*/
|
|
698
1564
|
export type RequestLogUpdate = {
|
|
1565
|
+
/**
|
|
1566
|
+
* Status Code
|
|
1567
|
+
*/
|
|
699
1568
|
status_code?: number | null;
|
|
1569
|
+
/**
|
|
1570
|
+
* Response Size Bytes
|
|
1571
|
+
*/
|
|
700
1572
|
response_size_bytes?: number | null;
|
|
1573
|
+
/**
|
|
1574
|
+
* Completed At
|
|
1575
|
+
*/
|
|
701
1576
|
completed_at?: string | null;
|
|
1577
|
+
/**
|
|
1578
|
+
* Duration Ms
|
|
1579
|
+
*/
|
|
702
1580
|
duration_ms?: number | null;
|
|
1581
|
+
/**
|
|
1582
|
+
* Error Message
|
|
1583
|
+
*/
|
|
703
1584
|
error_message?: string | null;
|
|
704
1585
|
};
|
|
705
1586
|
/**
|
|
1587
|
+
* RunAttachmentCreate
|
|
1588
|
+
*
|
|
706
1589
|
* Schema for creating a run attachment
|
|
707
1590
|
*/
|
|
708
1591
|
export type RunAttachmentCreate = {
|
|
1592
|
+
/**
|
|
1593
|
+
* Run Id
|
|
1594
|
+
*/
|
|
709
1595
|
run_id: string;
|
|
1596
|
+
/**
|
|
1597
|
+
* Filename
|
|
1598
|
+
*/
|
|
710
1599
|
filename: string;
|
|
711
1600
|
/**
|
|
1601
|
+
* Content
|
|
1602
|
+
*
|
|
712
1603
|
* Base64 encoded file content
|
|
713
1604
|
*/
|
|
714
1605
|
content: string;
|
|
1606
|
+
/**
|
|
1607
|
+
* Content Type
|
|
1608
|
+
*/
|
|
715
1609
|
content_type: string;
|
|
716
1610
|
attachment_type: AttachmentType;
|
|
1611
|
+
/**
|
|
1612
|
+
* Target Path
|
|
1613
|
+
*/
|
|
717
1614
|
target_path?: string | null;
|
|
1615
|
+
/**
|
|
1616
|
+
* Cleanup Imports After Run
|
|
1617
|
+
*/
|
|
718
1618
|
cleanup_imports_after_run?: boolean;
|
|
1619
|
+
/**
|
|
1620
|
+
* Expires At
|
|
1621
|
+
*/
|
|
719
1622
|
expires_at?: string | null;
|
|
720
1623
|
};
|
|
721
1624
|
/**
|
|
1625
|
+
* RunAttachmentDownloadUrlResponse
|
|
1626
|
+
*
|
|
722
1627
|
* Response schema for run attachment download URL
|
|
723
1628
|
*/
|
|
724
1629
|
export type RunAttachmentDownloadUrlResponse = {
|
|
725
1630
|
/**
|
|
1631
|
+
* Url
|
|
1632
|
+
*
|
|
726
1633
|
* Signed URL for downloading the attachment
|
|
727
1634
|
*/
|
|
728
1635
|
url: string;
|
|
729
1636
|
/**
|
|
1637
|
+
* Expires In
|
|
1638
|
+
*
|
|
730
1639
|
* Seconds until the URL expires
|
|
731
1640
|
*/
|
|
732
1641
|
expires_in: number;
|
|
733
1642
|
};
|
|
734
1643
|
/**
|
|
1644
|
+
* RunAttachmentResponse
|
|
1645
|
+
*
|
|
735
1646
|
* Run attachment response schema
|
|
736
1647
|
*/
|
|
737
1648
|
export type RunAttachmentResponse = {
|
|
1649
|
+
/**
|
|
1650
|
+
* Filename
|
|
1651
|
+
*/
|
|
738
1652
|
filename: string;
|
|
1653
|
+
/**
|
|
1654
|
+
* Content Type
|
|
1655
|
+
*/
|
|
739
1656
|
content_type: string;
|
|
740
1657
|
attachment_type: AttachmentType;
|
|
1658
|
+
/**
|
|
1659
|
+
* Target Path
|
|
1660
|
+
*/
|
|
741
1661
|
target_path?: string | null;
|
|
1662
|
+
/**
|
|
1663
|
+
* Cleanup Imports After Run
|
|
1664
|
+
*/
|
|
742
1665
|
cleanup_imports_after_run?: boolean;
|
|
1666
|
+
/**
|
|
1667
|
+
* Id
|
|
1668
|
+
*/
|
|
743
1669
|
id: string;
|
|
1670
|
+
/**
|
|
1671
|
+
* User Id
|
|
1672
|
+
*/
|
|
744
1673
|
user_id?: string | null;
|
|
1674
|
+
/**
|
|
1675
|
+
* Organization Id
|
|
1676
|
+
*/
|
|
745
1677
|
organization_id?: string | null;
|
|
1678
|
+
/**
|
|
1679
|
+
* Run Id
|
|
1680
|
+
*/
|
|
746
1681
|
run_id: string;
|
|
1682
|
+
/**
|
|
1683
|
+
* Size Bytes
|
|
1684
|
+
*/
|
|
747
1685
|
size_bytes: number;
|
|
1686
|
+
/**
|
|
1687
|
+
* Storage Path
|
|
1688
|
+
*/
|
|
748
1689
|
storage_path: string;
|
|
1690
|
+
/**
|
|
1691
|
+
* Expires At
|
|
1692
|
+
*/
|
|
749
1693
|
expires_at?: string | null;
|
|
1694
|
+
/**
|
|
1695
|
+
* Created At
|
|
1696
|
+
*/
|
|
750
1697
|
created_at: string;
|
|
751
1698
|
};
|
|
752
1699
|
/**
|
|
1700
|
+
* RunAttachmentUpdate
|
|
1701
|
+
*
|
|
753
1702
|
* Schema for updating a run attachment
|
|
754
1703
|
*/
|
|
755
1704
|
export type RunAttachmentUpdate = {
|
|
1705
|
+
/**
|
|
1706
|
+
* Expires At
|
|
1707
|
+
*/
|
|
756
1708
|
expires_at?: string | null;
|
|
757
1709
|
};
|
|
758
1710
|
/**
|
|
1711
|
+
* RunBulkCreate
|
|
1712
|
+
*
|
|
759
1713
|
* Schema for bulk creating runs
|
|
760
1714
|
*/
|
|
761
1715
|
export type RunBulkCreate = {
|
|
1716
|
+
/**
|
|
1717
|
+
* Workflow Id
|
|
1718
|
+
*/
|
|
762
1719
|
workflow_id: string;
|
|
763
1720
|
/**
|
|
1721
|
+
* Machine Id
|
|
1722
|
+
*
|
|
764
1723
|
* Machine ID. If not provided, an available machine will be automatically selected.
|
|
765
1724
|
*/
|
|
766
1725
|
machine_id?: string | null;
|
|
767
1726
|
/**
|
|
1727
|
+
* Pool Ids
|
|
1728
|
+
*
|
|
768
1729
|
* Pool IDs to filter available machines. Machine must belong to all of these pools (intersection). Ignored when machine_id is provided.
|
|
769
1730
|
*/
|
|
770
1731
|
pool_ids?: Array<string> | null;
|
|
771
1732
|
/**
|
|
1733
|
+
* Input Values
|
|
1734
|
+
*
|
|
772
1735
|
* Input values for workflow variables
|
|
773
1736
|
*/
|
|
774
1737
|
input_values?: {
|
|
775
1738
|
[key: string]: unknown;
|
|
776
1739
|
} | null;
|
|
777
1740
|
/**
|
|
1741
|
+
* File Inputs
|
|
1742
|
+
*
|
|
778
1743
|
* Files to upload to the machine
|
|
779
1744
|
*/
|
|
780
1745
|
file_inputs?: Array<FileInput> | null;
|
|
781
1746
|
/**
|
|
1747
|
+
* Count
|
|
1748
|
+
*
|
|
782
1749
|
* Number of runs to create (max 1000)
|
|
783
1750
|
*/
|
|
784
1751
|
count: number;
|
|
785
1752
|
/**
|
|
1753
|
+
* Sensitive Input Values
|
|
1754
|
+
*
|
|
786
1755
|
* Sensitive input values (supports nested objects) to store in the secure vault per run. Not persisted in our database. In workflow input_schema, sensitive root keys are validated under a '$' prefixed key.
|
|
787
1756
|
*/
|
|
788
1757
|
sensitive_input_values?: {
|
|
789
1758
|
[key: string]: unknown;
|
|
790
1759
|
} | null;
|
|
791
1760
|
/**
|
|
1761
|
+
* Session Id
|
|
1762
|
+
*
|
|
792
1763
|
* Join an existing session; overrides machine_id/pool_ids for all runs
|
|
793
1764
|
*/
|
|
794
1765
|
session_id?: string | null;
|
|
795
1766
|
/**
|
|
1767
|
+
* Start Session
|
|
1768
|
+
*
|
|
796
1769
|
* Start a new session for these runs; a new UUID will be generated and set on all runs. The first run will attempt to reserve a machine.
|
|
797
1770
|
*/
|
|
798
1771
|
start_session?: boolean | null;
|
|
799
1772
|
};
|
|
800
1773
|
/**
|
|
1774
|
+
* RunBulkCreateResponse
|
|
1775
|
+
*
|
|
801
1776
|
* Response for bulk run creation
|
|
802
1777
|
*/
|
|
803
1778
|
export type RunBulkCreateResponse = {
|
|
804
|
-
|
|
1779
|
+
/**
|
|
1780
|
+
* Created Runs
|
|
1781
|
+
*/
|
|
1782
|
+
created_runs: Array<RunResponseOutput>;
|
|
1783
|
+
/**
|
|
1784
|
+
* Failed Count
|
|
1785
|
+
*/
|
|
805
1786
|
failed_count?: number;
|
|
1787
|
+
/**
|
|
1788
|
+
* Errors
|
|
1789
|
+
*/
|
|
806
1790
|
errors?: Array<string>;
|
|
807
1791
|
};
|
|
808
1792
|
/**
|
|
1793
|
+
* RunCompletedEvent
|
|
1794
|
+
*
|
|
809
1795
|
* Payload sent for the run_complete webhook event.
|
|
810
1796
|
*/
|
|
811
1797
|
export type RunCompletedEvent = {
|
|
812
1798
|
/**
|
|
1799
|
+
* Event Id
|
|
1800
|
+
*
|
|
813
1801
|
* Unique event identifier for idempotency
|
|
814
1802
|
*/
|
|
815
1803
|
event_id?: string;
|
|
816
1804
|
/**
|
|
1805
|
+
* Event Type
|
|
1806
|
+
*
|
|
817
1807
|
* Event type key
|
|
818
1808
|
*/
|
|
819
1809
|
event_type?: string;
|
|
820
1810
|
/**
|
|
1811
|
+
* Occurred At
|
|
1812
|
+
*
|
|
821
1813
|
* Time the event occurred (UTC)
|
|
822
1814
|
*/
|
|
823
|
-
occurred_at?: string;
|
|
1815
|
+
occurred_at?: string;
|
|
1816
|
+
/**
|
|
1817
|
+
* The completed run data
|
|
1818
|
+
*/
|
|
1819
|
+
run: RunResponseInput;
|
|
1820
|
+
};
|
|
1821
|
+
/**
|
|
1822
|
+
* RunCreate
|
|
1823
|
+
*
|
|
1824
|
+
* Schema for creating a run
|
|
1825
|
+
*/
|
|
1826
|
+
export type RunCreate = {
|
|
1827
|
+
/**
|
|
1828
|
+
* Workflow Id
|
|
1829
|
+
*/
|
|
1830
|
+
workflow_id: string;
|
|
1831
|
+
/**
|
|
1832
|
+
* Machine Id
|
|
1833
|
+
*
|
|
1834
|
+
* Machine ID. If not provided, an available machine will be automatically selected.
|
|
1835
|
+
*/
|
|
1836
|
+
machine_id?: string | null;
|
|
1837
|
+
/**
|
|
1838
|
+
* Pool Ids
|
|
1839
|
+
*
|
|
1840
|
+
* Pool IDs to filter available machines. Machine must belong to all of these pools (intersection). Ignored when machine_id is provided.
|
|
1841
|
+
*/
|
|
1842
|
+
pool_ids?: Array<string> | null;
|
|
1843
|
+
/**
|
|
1844
|
+
* Input Values
|
|
1845
|
+
*
|
|
1846
|
+
* Input values for workflow variables
|
|
1847
|
+
*/
|
|
1848
|
+
input_values?: {
|
|
1849
|
+
[key: string]: unknown;
|
|
1850
|
+
} | null;
|
|
1851
|
+
/**
|
|
1852
|
+
* File Inputs
|
|
1853
|
+
*
|
|
1854
|
+
* Files to upload to the machine
|
|
1855
|
+
*/
|
|
1856
|
+
file_inputs?: Array<FileInput> | null;
|
|
1857
|
+
/**
|
|
1858
|
+
* Sensitive Input Values
|
|
1859
|
+
*
|
|
1860
|
+
* Sensitive input values (supports nested objects). These are not stored and will be written to a secure vault and referenced by alias only. In workflow input_schema, sensitive root keys are validated under a '$' prefixed key (for example input key 'api_key' is '$api_key').
|
|
1861
|
+
*/
|
|
1862
|
+
sensitive_input_values?: {
|
|
1863
|
+
[key: string]: unknown;
|
|
1864
|
+
} | null;
|
|
1865
|
+
/**
|
|
1866
|
+
* Session Id
|
|
1867
|
+
*
|
|
1868
|
+
* Join an existing session; overrides machine_id/pool_ids
|
|
1869
|
+
*/
|
|
1870
|
+
session_id?: string | null;
|
|
1871
|
+
/**
|
|
1872
|
+
* Start Session
|
|
1873
|
+
*
|
|
1874
|
+
* Start a new session on the machine used by this run. Session ID will be this run's ID.
|
|
1875
|
+
*/
|
|
1876
|
+
start_session?: boolean | null;
|
|
1877
|
+
/**
|
|
1878
|
+
* Session Alias
|
|
1879
|
+
*
|
|
1880
|
+
* Persist outputs under this alias for $ref in this session
|
|
1881
|
+
*/
|
|
1882
|
+
session_alias?: string | null;
|
|
1883
|
+
/**
|
|
1884
|
+
* Release Session After
|
|
1885
|
+
*
|
|
1886
|
+
* Release the session after this run completes successfully
|
|
1887
|
+
*/
|
|
1888
|
+
release_session_after?: boolean | null;
|
|
1889
|
+
};
|
|
1890
|
+
/**
|
|
1891
|
+
* RunField
|
|
1892
|
+
*
|
|
1893
|
+
* Selectable run fields for projection in list endpoints.
|
|
1894
|
+
*
|
|
1895
|
+
* These are optional fields beyond the essential identifiers that are always returned
|
|
1896
|
+
* (id, workflow_id, machine_id, status, created_at).
|
|
1897
|
+
*/
|
|
1898
|
+
export type RunField = 'user_id' | 'organization_id' | 'error' | 'output_data' | 'input_attachment_ids' | 'output_attachment_ids' | 'run_message_history' | 'input_values' | 'pool_ids' | 'sensitive_input_aliases' | 'usage_metadata' | 'session_id' | 'session_alias' | 'release_session_after' | 'started_at' | 'ended_at' | 'post_run_checks' | 'machine_id';
|
|
1899
|
+
/**
|
|
1900
|
+
* RunListSortMode
|
|
1901
|
+
*/
|
|
1902
|
+
export type RunListSortMode = 'activity' | 'created_at_desc';
|
|
1903
|
+
/**
|
|
1904
|
+
* RunPostRunCheckSnapshot
|
|
1905
|
+
*
|
|
1906
|
+
* Version-tolerant run-level snapshot/result for one post-run check invocation.
|
|
1907
|
+
*/
|
|
1908
|
+
export type RunPostRunCheckSnapshot = {
|
|
1909
|
+
/**
|
|
1910
|
+
* Id
|
|
1911
|
+
*/
|
|
1912
|
+
id?: string | null;
|
|
1913
|
+
/**
|
|
1914
|
+
* Post Run Check Id
|
|
1915
|
+
*/
|
|
1916
|
+
post_run_check_id?: string | null;
|
|
1917
|
+
/**
|
|
1918
|
+
* Snapshot Version
|
|
1919
|
+
*/
|
|
1920
|
+
snapshot_version?: number | null;
|
|
1921
|
+
/**
|
|
1922
|
+
* Name
|
|
1923
|
+
*/
|
|
1924
|
+
name?: string | null;
|
|
1925
|
+
/**
|
|
1926
|
+
* Description
|
|
1927
|
+
*/
|
|
1928
|
+
description?: string | null;
|
|
1929
|
+
type?: PostRunCheckType | null;
|
|
1930
|
+
/**
|
|
1931
|
+
* Order
|
|
1932
|
+
*/
|
|
1933
|
+
order?: number | null;
|
|
1934
|
+
file_target_mode?: PostRunCheckFileTargetMode | null;
|
|
1935
|
+
/**
|
|
1936
|
+
* File Names
|
|
1937
|
+
*/
|
|
1938
|
+
file_names?: Array<string> | null;
|
|
1939
|
+
/**
|
|
1940
|
+
* File Name Regex
|
|
1941
|
+
*/
|
|
1942
|
+
file_name_regex?: string | null;
|
|
1943
|
+
/**
|
|
1944
|
+
* Expected Match Count
|
|
1945
|
+
*/
|
|
1946
|
+
expected_match_count?: number | null;
|
|
1947
|
+
/**
|
|
1948
|
+
* Expected Match Count Ref
|
|
1949
|
+
*/
|
|
1950
|
+
expected_match_count_ref?: string | null;
|
|
1951
|
+
/**
|
|
1952
|
+
* Loop Input
|
|
1953
|
+
*/
|
|
1954
|
+
loop_input?: string | null;
|
|
1955
|
+
/**
|
|
1956
|
+
* Loop Item Filename Template
|
|
1957
|
+
*/
|
|
1958
|
+
loop_item_filename_template?: string | null;
|
|
1959
|
+
/**
|
|
1960
|
+
* Check Prompt
|
|
1961
|
+
*/
|
|
1962
|
+
check_prompt?: string | null;
|
|
1963
|
+
/**
|
|
1964
|
+
* Model
|
|
1965
|
+
*/
|
|
1966
|
+
model?: string | null;
|
|
1967
|
+
status: PostRunCheckStatus;
|
|
1968
|
+
/**
|
|
1969
|
+
* Started At
|
|
1970
|
+
*/
|
|
1971
|
+
started_at?: string | null;
|
|
1972
|
+
/**
|
|
1973
|
+
* Ended At
|
|
1974
|
+
*/
|
|
1975
|
+
ended_at?: string | null;
|
|
1976
|
+
/**
|
|
1977
|
+
* Error Message
|
|
1978
|
+
*/
|
|
1979
|
+
error_message?: string | null;
|
|
1980
|
+
/**
|
|
1981
|
+
* Messages
|
|
1982
|
+
*/
|
|
1983
|
+
messages?: Array<string> | null;
|
|
1984
|
+
/**
|
|
1985
|
+
* Matched Filenames
|
|
1986
|
+
*/
|
|
1987
|
+
matched_filenames?: Array<string> | null;
|
|
1988
|
+
[key: string]: unknown;
|
|
1989
|
+
};
|
|
1990
|
+
/**
|
|
1991
|
+
* RunResponse
|
|
1992
|
+
*
|
|
1993
|
+
* Run response schema
|
|
1994
|
+
*/
|
|
1995
|
+
export type RunResponseInput = {
|
|
1996
|
+
/**
|
|
1997
|
+
* Workflow Id
|
|
1998
|
+
*/
|
|
1999
|
+
workflow_id: string;
|
|
2000
|
+
/**
|
|
2001
|
+
* Machine Id
|
|
2002
|
+
*/
|
|
2003
|
+
machine_id: string | null;
|
|
2004
|
+
/**
|
|
2005
|
+
* Id
|
|
2006
|
+
*/
|
|
2007
|
+
id: string;
|
|
2008
|
+
/**
|
|
2009
|
+
* User Id
|
|
2010
|
+
*/
|
|
2011
|
+
user_id?: string | null;
|
|
2012
|
+
/**
|
|
2013
|
+
* Organization Id
|
|
2014
|
+
*/
|
|
2015
|
+
organization_id?: string | null;
|
|
2016
|
+
status: RunStatus;
|
|
2017
|
+
/**
|
|
2018
|
+
* Error
|
|
2019
|
+
*/
|
|
2020
|
+
error?: Array<string> | null;
|
|
2021
|
+
/**
|
|
2022
|
+
* Output Data
|
|
2023
|
+
*/
|
|
2024
|
+
output_data?: {
|
|
2025
|
+
[key: string]: unknown;
|
|
2026
|
+
} | null;
|
|
824
2027
|
/**
|
|
825
|
-
*
|
|
2028
|
+
* Input Attachment Ids
|
|
826
2029
|
*/
|
|
827
|
-
|
|
828
|
-
};
|
|
829
|
-
/**
|
|
830
|
-
* Schema for creating a run
|
|
831
|
-
*/
|
|
832
|
-
export type RunCreate = {
|
|
833
|
-
workflow_id: string;
|
|
2030
|
+
input_attachment_ids?: Array<string> | null;
|
|
834
2031
|
/**
|
|
835
|
-
*
|
|
2032
|
+
* Output Attachment Ids
|
|
836
2033
|
*/
|
|
837
|
-
|
|
2034
|
+
output_attachment_ids?: Array<string> | null;
|
|
838
2035
|
/**
|
|
839
|
-
*
|
|
2036
|
+
* Run Message History
|
|
840
2037
|
*/
|
|
841
|
-
|
|
2038
|
+
run_message_history?: Array<{
|
|
2039
|
+
[key: string]: unknown;
|
|
2040
|
+
}> | null;
|
|
842
2041
|
/**
|
|
843
|
-
* Input
|
|
2042
|
+
* Input Values
|
|
844
2043
|
*/
|
|
845
2044
|
input_values?: {
|
|
846
2045
|
[key: string]: unknown;
|
|
847
2046
|
} | null;
|
|
848
2047
|
/**
|
|
849
|
-
*
|
|
2048
|
+
* Pool Ids
|
|
850
2049
|
*/
|
|
851
|
-
|
|
2050
|
+
pool_ids?: Array<string> | null;
|
|
852
2051
|
/**
|
|
853
|
-
* Sensitive
|
|
2052
|
+
* Sensitive Input Aliases
|
|
854
2053
|
*/
|
|
855
|
-
|
|
2054
|
+
sensitive_input_aliases?: {
|
|
2055
|
+
[key: string]: string;
|
|
2056
|
+
} | null;
|
|
2057
|
+
/**
|
|
2058
|
+
* Usage Metadata
|
|
2059
|
+
*
|
|
2060
|
+
* Arbitrary usage/billing metadata captured during a run (schema is flexible)
|
|
2061
|
+
*/
|
|
2062
|
+
usage_metadata?: {
|
|
856
2063
|
[key: string]: unknown;
|
|
857
2064
|
} | null;
|
|
858
2065
|
/**
|
|
859
|
-
*
|
|
2066
|
+
* Post Run Checks
|
|
2067
|
+
*
|
|
2068
|
+
* Version-tolerant snapshot/results for the run's post-run checks.
|
|
860
2069
|
*/
|
|
861
|
-
|
|
2070
|
+
post_run_checks?: Array<RunPostRunCheckSnapshot> | null;
|
|
862
2071
|
/**
|
|
863
|
-
*
|
|
2072
|
+
* Session Id
|
|
864
2073
|
*/
|
|
865
|
-
|
|
2074
|
+
session_id?: string | null;
|
|
866
2075
|
/**
|
|
867
|
-
*
|
|
2076
|
+
* Session Alias
|
|
868
2077
|
*/
|
|
869
2078
|
session_alias?: string | null;
|
|
870
2079
|
/**
|
|
871
|
-
* Release
|
|
2080
|
+
* Release Session After
|
|
872
2081
|
*/
|
|
873
2082
|
release_session_after?: boolean | null;
|
|
2083
|
+
/**
|
|
2084
|
+
* Created At
|
|
2085
|
+
*/
|
|
2086
|
+
created_at: string;
|
|
2087
|
+
/**
|
|
2088
|
+
* Started At
|
|
2089
|
+
*/
|
|
2090
|
+
started_at?: string | null;
|
|
2091
|
+
/**
|
|
2092
|
+
* Ended At
|
|
2093
|
+
*/
|
|
2094
|
+
ended_at?: string | null;
|
|
874
2095
|
};
|
|
875
2096
|
/**
|
|
876
|
-
*
|
|
2097
|
+
* RunResponse
|
|
877
2098
|
*
|
|
878
|
-
* These are optional fields beyond the essential identifiers that are always returned
|
|
879
|
-
* (id, workflow_id, machine_id, status, created_at).
|
|
880
|
-
*/
|
|
881
|
-
export type RunField = 'user_id' | 'organization_id' | 'run_kind' | 'ad_hoc_task' | 'error' | 'output_data' | 'input_attachment_ids' | 'output_attachment_ids' | 'run_message_history' | 'input_values' | 'pool_ids' | 'sensitive_input_aliases' | 'usage_metadata' | 'session_id' | 'session_alias' | 'release_session_after' | 'started_at' | 'ended_at' | 'machine_id';
|
|
882
|
-
export type RunKind = 'workflow' | 'ad_hoc';
|
|
883
|
-
export type RunListSortMode = 'activity' | 'created_at_desc';
|
|
884
|
-
/**
|
|
885
2099
|
* Run response schema
|
|
886
2100
|
*/
|
|
887
|
-
export type
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
2101
|
+
export type RunResponseOutput = {
|
|
2102
|
+
/**
|
|
2103
|
+
* Workflow Id
|
|
2104
|
+
*/
|
|
2105
|
+
workflow_id: string;
|
|
2106
|
+
/**
|
|
2107
|
+
* Machine Id
|
|
2108
|
+
*/
|
|
891
2109
|
machine_id: string | null;
|
|
2110
|
+
/**
|
|
2111
|
+
* Id
|
|
2112
|
+
*/
|
|
892
2113
|
id: string;
|
|
2114
|
+
/**
|
|
2115
|
+
* User Id
|
|
2116
|
+
*/
|
|
893
2117
|
user_id?: string | null;
|
|
2118
|
+
/**
|
|
2119
|
+
* Organization Id
|
|
2120
|
+
*/
|
|
894
2121
|
organization_id?: string | null;
|
|
895
2122
|
status: RunStatus;
|
|
2123
|
+
/**
|
|
2124
|
+
* Error
|
|
2125
|
+
*/
|
|
896
2126
|
error?: Array<string> | null;
|
|
2127
|
+
/**
|
|
2128
|
+
* Output Data
|
|
2129
|
+
*/
|
|
897
2130
|
output_data?: {
|
|
898
2131
|
[key: string]: unknown;
|
|
899
2132
|
} | null;
|
|
2133
|
+
/**
|
|
2134
|
+
* Input Attachment Ids
|
|
2135
|
+
*/
|
|
900
2136
|
input_attachment_ids?: Array<string> | null;
|
|
2137
|
+
/**
|
|
2138
|
+
* Output Attachment Ids
|
|
2139
|
+
*/
|
|
901
2140
|
output_attachment_ids?: Array<string> | null;
|
|
2141
|
+
/**
|
|
2142
|
+
* Run Message History
|
|
2143
|
+
*/
|
|
902
2144
|
run_message_history?: Array<{
|
|
903
2145
|
[key: string]: unknown;
|
|
904
2146
|
}> | null;
|
|
2147
|
+
/**
|
|
2148
|
+
* Input Values
|
|
2149
|
+
*/
|
|
905
2150
|
input_values?: {
|
|
906
2151
|
[key: string]: unknown;
|
|
907
2152
|
} | null;
|
|
2153
|
+
/**
|
|
2154
|
+
* Pool Ids
|
|
2155
|
+
*/
|
|
908
2156
|
pool_ids?: Array<string> | null;
|
|
2157
|
+
/**
|
|
2158
|
+
* Sensitive Input Aliases
|
|
2159
|
+
*/
|
|
909
2160
|
sensitive_input_aliases?: {
|
|
910
2161
|
[key: string]: string;
|
|
911
2162
|
} | null;
|
|
912
2163
|
/**
|
|
2164
|
+
* Usage Metadata
|
|
2165
|
+
*
|
|
913
2166
|
* Arbitrary usage/billing metadata captured during a run (schema is flexible)
|
|
914
2167
|
*/
|
|
915
2168
|
usage_metadata?: {
|
|
916
2169
|
[key: string]: unknown;
|
|
917
2170
|
} | null;
|
|
2171
|
+
/**
|
|
2172
|
+
* Post Run Checks
|
|
2173
|
+
*
|
|
2174
|
+
* Version-tolerant snapshot/results for the run's post-run checks.
|
|
2175
|
+
*/
|
|
2176
|
+
post_run_checks?: Array<RunPostRunCheckSnapshot> | null;
|
|
2177
|
+
/**
|
|
2178
|
+
* Session Id
|
|
2179
|
+
*/
|
|
918
2180
|
session_id?: string | null;
|
|
2181
|
+
/**
|
|
2182
|
+
* Session Alias
|
|
2183
|
+
*/
|
|
919
2184
|
session_alias?: string | null;
|
|
2185
|
+
/**
|
|
2186
|
+
* Release Session After
|
|
2187
|
+
*/
|
|
920
2188
|
release_session_after?: boolean | null;
|
|
2189
|
+
/**
|
|
2190
|
+
* Created At
|
|
2191
|
+
*/
|
|
921
2192
|
created_at: string;
|
|
2193
|
+
/**
|
|
2194
|
+
* Started At
|
|
2195
|
+
*/
|
|
922
2196
|
started_at?: string | null;
|
|
2197
|
+
/**
|
|
2198
|
+
* Ended At
|
|
2199
|
+
*/
|
|
923
2200
|
ended_at?: string | null;
|
|
924
2201
|
};
|
|
925
2202
|
/**
|
|
2203
|
+
* RunResponseWithIncludes
|
|
2204
|
+
*
|
|
926
2205
|
* Run response with optional included related resources.
|
|
927
2206
|
*
|
|
928
2207
|
* When the `include` query parameter is used, related resources are returned
|
|
@@ -931,48 +2210,115 @@ export type RunResponse = {
|
|
|
931
2210
|
* Example request: GET /v1/runs/123?include=workflow,machine
|
|
932
2211
|
*/
|
|
933
2212
|
export type RunResponseWithIncludes = {
|
|
2213
|
+
/**
|
|
2214
|
+
* Id
|
|
2215
|
+
*/
|
|
934
2216
|
id: string;
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
|
|
2217
|
+
/**
|
|
2218
|
+
* Workflow Id
|
|
2219
|
+
*/
|
|
2220
|
+
workflow_id: string;
|
|
2221
|
+
/**
|
|
2222
|
+
* Machine Id
|
|
2223
|
+
*/
|
|
938
2224
|
machine_id?: string | null;
|
|
2225
|
+
/**
|
|
2226
|
+
* User Id
|
|
2227
|
+
*/
|
|
939
2228
|
user_id?: string | null;
|
|
2229
|
+
/**
|
|
2230
|
+
* Organization Id
|
|
2231
|
+
*/
|
|
940
2232
|
organization_id?: string | null;
|
|
941
2233
|
status: RunStatus;
|
|
2234
|
+
/**
|
|
2235
|
+
* Error
|
|
2236
|
+
*/
|
|
942
2237
|
error?: Array<string> | null;
|
|
2238
|
+
/**
|
|
2239
|
+
* Output Data
|
|
2240
|
+
*/
|
|
943
2241
|
output_data?: {
|
|
944
2242
|
[key: string]: unknown;
|
|
945
2243
|
} | null;
|
|
2244
|
+
/**
|
|
2245
|
+
* Input Attachment Ids
|
|
2246
|
+
*/
|
|
946
2247
|
input_attachment_ids?: Array<string> | null;
|
|
2248
|
+
/**
|
|
2249
|
+
* Output Attachment Ids
|
|
2250
|
+
*/
|
|
947
2251
|
output_attachment_ids?: Array<string> | null;
|
|
2252
|
+
/**
|
|
2253
|
+
* Run Message History
|
|
2254
|
+
*/
|
|
948
2255
|
run_message_history?: Array<{
|
|
949
2256
|
[key: string]: unknown;
|
|
950
2257
|
}> | null;
|
|
2258
|
+
/**
|
|
2259
|
+
* Input Values
|
|
2260
|
+
*/
|
|
951
2261
|
input_values?: {
|
|
952
2262
|
[key: string]: unknown;
|
|
953
2263
|
} | null;
|
|
2264
|
+
/**
|
|
2265
|
+
* Pool Ids
|
|
2266
|
+
*/
|
|
954
2267
|
pool_ids?: Array<string> | null;
|
|
2268
|
+
/**
|
|
2269
|
+
* Sensitive Input Aliases
|
|
2270
|
+
*/
|
|
955
2271
|
sensitive_input_aliases?: {
|
|
956
2272
|
[key: string]: string;
|
|
957
2273
|
} | null;
|
|
958
2274
|
/**
|
|
2275
|
+
* Usage Metadata
|
|
2276
|
+
*
|
|
959
2277
|
* Arbitrary usage/billing metadata captured during a run
|
|
960
2278
|
*/
|
|
961
2279
|
usage_metadata?: {
|
|
962
2280
|
[key: string]: unknown;
|
|
963
2281
|
} | null;
|
|
2282
|
+
/**
|
|
2283
|
+
* Post Run Checks
|
|
2284
|
+
*
|
|
2285
|
+
* Version-tolerant snapshot/results for the run's post-run checks.
|
|
2286
|
+
*/
|
|
2287
|
+
post_run_checks?: Array<RunPostRunCheckSnapshot> | null;
|
|
2288
|
+
/**
|
|
2289
|
+
* Session Id
|
|
2290
|
+
*/
|
|
964
2291
|
session_id?: string | null;
|
|
2292
|
+
/**
|
|
2293
|
+
* Session Alias
|
|
2294
|
+
*/
|
|
965
2295
|
session_alias?: string | null;
|
|
2296
|
+
/**
|
|
2297
|
+
* Release Session After
|
|
2298
|
+
*/
|
|
966
2299
|
release_session_after?: boolean | null;
|
|
2300
|
+
/**
|
|
2301
|
+
* Created At
|
|
2302
|
+
*/
|
|
967
2303
|
created_at: string;
|
|
2304
|
+
/**
|
|
2305
|
+
* Started At
|
|
2306
|
+
*/
|
|
968
2307
|
started_at?: string | null;
|
|
2308
|
+
/**
|
|
2309
|
+
* Ended At
|
|
2310
|
+
*/
|
|
969
2311
|
ended_at?: string | null;
|
|
970
2312
|
/**
|
|
2313
|
+
* Included
|
|
2314
|
+
*
|
|
971
2315
|
* Related resources requested via the `include` query parameter
|
|
972
2316
|
*/
|
|
973
2317
|
included?: Array<IncludedResource> | null;
|
|
974
2318
|
};
|
|
975
2319
|
/**
|
|
2320
|
+
* RunRetry
|
|
2321
|
+
*
|
|
976
2322
|
* Options for retrying an existing run in-place (same run_id).
|
|
977
2323
|
*
|
|
978
2324
|
* Notes:
|
|
@@ -982,75 +2328,133 @@ export type RunResponseWithIncludes = {
|
|
|
982
2328
|
*/
|
|
983
2329
|
export type RunRetry = {
|
|
984
2330
|
/**
|
|
2331
|
+
* Input Values
|
|
2332
|
+
*
|
|
985
2333
|
* Override input values for workflow variables
|
|
986
2334
|
*/
|
|
987
2335
|
input_values?: {
|
|
988
2336
|
[key: string]: unknown;
|
|
989
2337
|
} | null;
|
|
990
2338
|
/**
|
|
2339
|
+
* Sensitive Input Values
|
|
2340
|
+
*
|
|
991
2341
|
* Provide new sensitive inputs (supports nested objects); stored in vault and mapped to aliases
|
|
992
2342
|
*/
|
|
993
2343
|
sensitive_input_values?: {
|
|
994
2344
|
[key: string]: unknown;
|
|
995
2345
|
} | null;
|
|
996
2346
|
/**
|
|
2347
|
+
* File Inputs
|
|
2348
|
+
*
|
|
997
2349
|
* Provide new input files for this retry; replaces existing input attachments
|
|
998
2350
|
*/
|
|
999
2351
|
file_inputs?: Array<FileInput> | null;
|
|
1000
2352
|
/**
|
|
2353
|
+
* Machine Id
|
|
2354
|
+
*
|
|
1001
2355
|
* Override specific machine for this retry
|
|
1002
2356
|
*/
|
|
1003
2357
|
machine_id?: string | null;
|
|
1004
2358
|
/**
|
|
2359
|
+
* Pool Ids
|
|
2360
|
+
*
|
|
1005
2361
|
* Override pool filters if not using a specific machine
|
|
1006
2362
|
*/
|
|
1007
2363
|
pool_ids?: Array<string> | null;
|
|
1008
2364
|
/**
|
|
2365
|
+
* Reuse Session
|
|
2366
|
+
*
|
|
1009
2367
|
* Keep existing session_id. If false and no session_id provided, clears session fields
|
|
1010
2368
|
*/
|
|
1011
2369
|
reuse_session?: boolean | null;
|
|
1012
2370
|
/**
|
|
2371
|
+
* Session Id
|
|
2372
|
+
*
|
|
1013
2373
|
* Set/override session_id for this retry
|
|
1014
2374
|
*/
|
|
1015
2375
|
session_id?: string | null;
|
|
1016
2376
|
/**
|
|
2377
|
+
* Start Session
|
|
2378
|
+
*
|
|
1017
2379
|
* Start a fresh new session for this retry (creates new session_id)
|
|
1018
2380
|
*/
|
|
1019
2381
|
start_session?: boolean | null;
|
|
1020
2382
|
/**
|
|
2383
|
+
* Session Alias
|
|
2384
|
+
*
|
|
1021
2385
|
* Set/override session_alias for this retry (used with start_session or session_id)
|
|
1022
2386
|
*/
|
|
1023
2387
|
session_alias?: string | null;
|
|
1024
2388
|
/**
|
|
2389
|
+
* Release Session After
|
|
2390
|
+
*
|
|
1025
2391
|
* Override release_session_after behavior for this retry
|
|
1026
2392
|
*/
|
|
1027
2393
|
release_session_after?: boolean | null;
|
|
1028
2394
|
};
|
|
1029
|
-
export type RunStatus = 'scheduling' | 'running' | 'success' | 'cancelled' | 'task_failed' | 'error';
|
|
1030
2395
|
/**
|
|
2396
|
+
* RunStatus
|
|
2397
|
+
*/
|
|
2398
|
+
export type RunStatus = 'scheduling' | 'running' | 'running_checks' | 'success' | 'cancelled' | 'task_failed' | 'error';
|
|
2399
|
+
/**
|
|
2400
|
+
* RunUpdate
|
|
2401
|
+
*
|
|
1031
2402
|
* Schema for updating a run
|
|
1032
2403
|
*/
|
|
1033
2404
|
export type RunUpdate = {
|
|
1034
2405
|
status?: RunStatus | null;
|
|
2406
|
+
/**
|
|
2407
|
+
* Error
|
|
2408
|
+
*/
|
|
1035
2409
|
error?: Array<string> | null;
|
|
2410
|
+
/**
|
|
2411
|
+
* Output Data
|
|
2412
|
+
*/
|
|
1036
2413
|
output_data?: {
|
|
1037
2414
|
[key: string]: unknown;
|
|
1038
2415
|
} | null;
|
|
2416
|
+
/**
|
|
2417
|
+
* Output Attachment Ids
|
|
2418
|
+
*/
|
|
1039
2419
|
output_attachment_ids?: Array<string> | null;
|
|
2420
|
+
/**
|
|
2421
|
+
* Run Message History
|
|
2422
|
+
*/
|
|
1040
2423
|
run_message_history?: Array<{
|
|
1041
2424
|
[key: string]: unknown;
|
|
1042
2425
|
}> | null;
|
|
2426
|
+
/**
|
|
2427
|
+
* Input Values
|
|
2428
|
+
*/
|
|
1043
2429
|
input_values?: {
|
|
1044
2430
|
[key: string]: unknown;
|
|
1045
2431
|
} | null;
|
|
2432
|
+
/**
|
|
2433
|
+
* Usage Metadata
|
|
2434
|
+
*/
|
|
1046
2435
|
usage_metadata?: {
|
|
1047
2436
|
[key: string]: unknown;
|
|
1048
2437
|
} | null;
|
|
2438
|
+
/**
|
|
2439
|
+
* Post Run Checks
|
|
2440
|
+
*/
|
|
2441
|
+
post_run_checks?: Array<RunPostRunCheckSnapshot> | null;
|
|
2442
|
+
/**
|
|
2443
|
+
* Started At
|
|
2444
|
+
*/
|
|
1049
2445
|
started_at?: string | null;
|
|
2446
|
+
/**
|
|
2447
|
+
* Ended At
|
|
2448
|
+
*/
|
|
1050
2449
|
ended_at?: string | null;
|
|
2450
|
+
/**
|
|
2451
|
+
* Release Session After
|
|
2452
|
+
*/
|
|
1051
2453
|
release_session_after?: boolean | null;
|
|
1052
2454
|
};
|
|
1053
2455
|
/**
|
|
2456
|
+
* TrajectoryCreate
|
|
2457
|
+
*
|
|
1054
2458
|
* Schema for creating a trajectory.
|
|
1055
2459
|
*
|
|
1056
2460
|
* Note: `is_generated` is intentionally omitted here. New trajectories always
|
|
@@ -1058,189 +2462,392 @@ export type RunUpdate = {
|
|
|
1058
2462
|
* POST /runs/{run_id}/generate-trajectory.
|
|
1059
2463
|
*/
|
|
1060
2464
|
export type TrajectoryCreate = {
|
|
2465
|
+
/**
|
|
2466
|
+
* Name
|
|
2467
|
+
*/
|
|
1061
2468
|
name?: string | null;
|
|
2469
|
+
/**
|
|
2470
|
+
* Description
|
|
2471
|
+
*/
|
|
1062
2472
|
description?: string | null;
|
|
1063
|
-
workflow_id: string | null;
|
|
1064
2473
|
/**
|
|
2474
|
+
* Workflow Id
|
|
2475
|
+
*/
|
|
2476
|
+
workflow_id: string;
|
|
2477
|
+
/**
|
|
2478
|
+
* Run Id
|
|
2479
|
+
*
|
|
1065
2480
|
* Optional run that created this trajectory
|
|
1066
2481
|
*/
|
|
1067
2482
|
run_id?: string | null;
|
|
2483
|
+
/**
|
|
2484
|
+
* Trajectory Data
|
|
2485
|
+
*/
|
|
1068
2486
|
trajectory_data: Array<{
|
|
1069
2487
|
[key: string]: unknown;
|
|
1070
2488
|
}>;
|
|
1071
2489
|
/**
|
|
2490
|
+
* Dimensions
|
|
2491
|
+
*
|
|
1072
2492
|
* Display dimensions when trajectory was recorded
|
|
1073
2493
|
*/
|
|
1074
2494
|
dimensions: {
|
|
1075
2495
|
[key: string]: number;
|
|
1076
2496
|
};
|
|
1077
2497
|
/**
|
|
2498
|
+
* Original Input Values
|
|
2499
|
+
*
|
|
1078
2500
|
* Original input values used when trajectory was created
|
|
1079
2501
|
*/
|
|
1080
2502
|
original_input_values?: {
|
|
1081
2503
|
[key: string]: unknown;
|
|
1082
2504
|
} | null;
|
|
1083
2505
|
/**
|
|
2506
|
+
* Is Approved
|
|
2507
|
+
*
|
|
1084
2508
|
* Whether this trajectory is approved for use
|
|
1085
2509
|
*/
|
|
1086
2510
|
is_approved?: boolean;
|
|
1087
2511
|
};
|
|
1088
2512
|
/**
|
|
2513
|
+
* TrajectoryResponse
|
|
2514
|
+
*
|
|
1089
2515
|
* Trajectory response schema
|
|
1090
2516
|
*/
|
|
1091
2517
|
export type TrajectoryResponse = {
|
|
2518
|
+
/**
|
|
2519
|
+
* Name
|
|
2520
|
+
*/
|
|
1092
2521
|
name?: string | null;
|
|
2522
|
+
/**
|
|
2523
|
+
* Description
|
|
2524
|
+
*/
|
|
1093
2525
|
description?: string | null;
|
|
1094
|
-
workflow_id: string | null;
|
|
1095
2526
|
/**
|
|
2527
|
+
* Workflow Id
|
|
2528
|
+
*/
|
|
2529
|
+
workflow_id: string;
|
|
2530
|
+
/**
|
|
2531
|
+
* Run Id
|
|
2532
|
+
*
|
|
1096
2533
|
* Optional run that created this trajectory
|
|
1097
2534
|
*/
|
|
1098
2535
|
run_id?: string | null;
|
|
2536
|
+
/**
|
|
2537
|
+
* Trajectory Data
|
|
2538
|
+
*/
|
|
1099
2539
|
trajectory_data: Array<{
|
|
1100
2540
|
[key: string]: unknown;
|
|
1101
2541
|
}>;
|
|
1102
2542
|
/**
|
|
2543
|
+
* Dimensions
|
|
2544
|
+
*
|
|
1103
2545
|
* Display dimensions when trajectory was recorded
|
|
1104
2546
|
*/
|
|
1105
2547
|
dimensions: {
|
|
1106
2548
|
[key: string]: number;
|
|
1107
2549
|
};
|
|
1108
2550
|
/**
|
|
2551
|
+
* Original Input Values
|
|
2552
|
+
*
|
|
1109
2553
|
* Original input values used when trajectory was created
|
|
1110
2554
|
*/
|
|
1111
2555
|
original_input_values?: {
|
|
1112
2556
|
[key: string]: unknown;
|
|
1113
2557
|
} | null;
|
|
2558
|
+
/**
|
|
2559
|
+
* Is Approved
|
|
2560
|
+
*/
|
|
1114
2561
|
is_approved: boolean;
|
|
2562
|
+
/**
|
|
2563
|
+
* Is Generated
|
|
2564
|
+
*/
|
|
1115
2565
|
is_generated: boolean;
|
|
2566
|
+
/**
|
|
2567
|
+
* Id
|
|
2568
|
+
*/
|
|
1116
2569
|
id: string;
|
|
2570
|
+
/**
|
|
2571
|
+
* User Id
|
|
2572
|
+
*/
|
|
1117
2573
|
user_id?: string | null;
|
|
2574
|
+
/**
|
|
2575
|
+
* Organization Id
|
|
2576
|
+
*/
|
|
1118
2577
|
organization_id?: string | null;
|
|
2578
|
+
/**
|
|
2579
|
+
* Created At
|
|
2580
|
+
*/
|
|
1119
2581
|
created_at: string;
|
|
2582
|
+
/**
|
|
2583
|
+
* Updated At
|
|
2584
|
+
*/
|
|
1120
2585
|
updated_at: string;
|
|
1121
2586
|
};
|
|
1122
2587
|
/**
|
|
2588
|
+
* TrajectoryResponseWithIncludes
|
|
2589
|
+
*
|
|
1123
2590
|
* Trajectory response with optional included related resources.
|
|
1124
2591
|
*/
|
|
1125
2592
|
export type TrajectoryResponseWithIncludes = {
|
|
2593
|
+
/**
|
|
2594
|
+
* Id
|
|
2595
|
+
*/
|
|
1126
2596
|
id: string;
|
|
1127
|
-
|
|
2597
|
+
/**
|
|
2598
|
+
* Workflow Id
|
|
2599
|
+
*/
|
|
2600
|
+
workflow_id: string;
|
|
2601
|
+
/**
|
|
2602
|
+
* Run Id
|
|
2603
|
+
*/
|
|
1128
2604
|
run_id?: string | null;
|
|
2605
|
+
/**
|
|
2606
|
+
* User Id
|
|
2607
|
+
*/
|
|
1129
2608
|
user_id?: string | null;
|
|
2609
|
+
/**
|
|
2610
|
+
* Organization Id
|
|
2611
|
+
*/
|
|
1130
2612
|
organization_id?: string | null;
|
|
2613
|
+
/**
|
|
2614
|
+
* Name
|
|
2615
|
+
*/
|
|
1131
2616
|
name?: string | null;
|
|
2617
|
+
/**
|
|
2618
|
+
* Description
|
|
2619
|
+
*/
|
|
1132
2620
|
description?: string | null;
|
|
2621
|
+
/**
|
|
2622
|
+
* Is Approved
|
|
2623
|
+
*/
|
|
1133
2624
|
is_approved: boolean;
|
|
2625
|
+
/**
|
|
2626
|
+
* Is Generated
|
|
2627
|
+
*/
|
|
1134
2628
|
is_generated: boolean;
|
|
2629
|
+
/**
|
|
2630
|
+
* Trajectory Data
|
|
2631
|
+
*/
|
|
1135
2632
|
trajectory_data?: Array<{
|
|
1136
2633
|
[key: string]: unknown;
|
|
1137
2634
|
}> | null;
|
|
1138
2635
|
/**
|
|
2636
|
+
* Dimensions
|
|
2637
|
+
*
|
|
1139
2638
|
* Display dimensions when trajectory was recorded
|
|
1140
2639
|
*/
|
|
1141
2640
|
dimensions: {
|
|
1142
2641
|
[key: string]: number;
|
|
1143
2642
|
};
|
|
1144
2643
|
/**
|
|
2644
|
+
* Original Input Values
|
|
2645
|
+
*
|
|
1145
2646
|
* Original input values used when trajectory was created
|
|
1146
2647
|
*/
|
|
1147
2648
|
original_input_values?: {
|
|
1148
2649
|
[key: string]: unknown;
|
|
1149
2650
|
} | null;
|
|
2651
|
+
/**
|
|
2652
|
+
* Created At
|
|
2653
|
+
*/
|
|
1150
2654
|
created_at: string;
|
|
2655
|
+
/**
|
|
2656
|
+
* Updated At
|
|
2657
|
+
*/
|
|
1151
2658
|
updated_at: string;
|
|
1152
2659
|
/**
|
|
2660
|
+
* Included
|
|
2661
|
+
*
|
|
1153
2662
|
* Related resources requested via the `include` query parameter
|
|
1154
2663
|
*/
|
|
1155
2664
|
included?: Array<IncludedResource> | null;
|
|
1156
2665
|
};
|
|
1157
2666
|
/**
|
|
2667
|
+
* TrajectoryUpdate
|
|
2668
|
+
*
|
|
1158
2669
|
* Schema for updating a trajectory
|
|
1159
2670
|
*/
|
|
1160
2671
|
export type TrajectoryUpdate = {
|
|
2672
|
+
/**
|
|
2673
|
+
* Name
|
|
2674
|
+
*/
|
|
1161
2675
|
name?: string | null;
|
|
2676
|
+
/**
|
|
2677
|
+
* Description
|
|
2678
|
+
*/
|
|
1162
2679
|
description?: string | null;
|
|
2680
|
+
/**
|
|
2681
|
+
* Trajectory Data
|
|
2682
|
+
*/
|
|
1163
2683
|
trajectory_data?: Array<{
|
|
1164
2684
|
[key: string]: unknown;
|
|
1165
2685
|
}> | null;
|
|
1166
2686
|
/**
|
|
2687
|
+
* Is Approved
|
|
2688
|
+
*
|
|
1167
2689
|
* Whether this trajectory is approved for use
|
|
1168
2690
|
*/
|
|
1169
2691
|
is_approved?: boolean | null;
|
|
1170
2692
|
};
|
|
1171
2693
|
/**
|
|
2694
|
+
* UsageAggregateResponse
|
|
2695
|
+
*
|
|
1172
2696
|
* Response schema for usage aggregation.
|
|
1173
2697
|
*/
|
|
1174
2698
|
export type UsageAggregateResponse = {
|
|
2699
|
+
/**
|
|
2700
|
+
* Total Agentic Steps
|
|
2701
|
+
*/
|
|
1175
2702
|
total_agentic_steps: number;
|
|
2703
|
+
/**
|
|
2704
|
+
* Total Cached Steps
|
|
2705
|
+
*/
|
|
1176
2706
|
total_cached_steps: number;
|
|
2707
|
+
/**
|
|
2708
|
+
* Period Start
|
|
2709
|
+
*/
|
|
1177
2710
|
period_start: string;
|
|
2711
|
+
/**
|
|
2712
|
+
* Period End
|
|
2713
|
+
*/
|
|
1178
2714
|
period_end: string;
|
|
1179
2715
|
mode: UsageMode;
|
|
2716
|
+
/**
|
|
2717
|
+
* Runs Counted
|
|
2718
|
+
*/
|
|
1180
2719
|
runs_counted: number;
|
|
1181
2720
|
};
|
|
1182
2721
|
/**
|
|
2722
|
+
* UsageMode
|
|
2723
|
+
*
|
|
1183
2724
|
* Mode for counting usage steps.
|
|
1184
2725
|
*/
|
|
1185
2726
|
export type UsageMode = 'simulated' | 'billed';
|
|
2727
|
+
/**
|
|
2728
|
+
* ValidationError
|
|
2729
|
+
*/
|
|
1186
2730
|
export type ValidationError = {
|
|
2731
|
+
/**
|
|
2732
|
+
* Location
|
|
2733
|
+
*/
|
|
1187
2734
|
loc: Array<string | number>;
|
|
2735
|
+
/**
|
|
2736
|
+
* Message
|
|
2737
|
+
*/
|
|
1188
2738
|
msg: string;
|
|
2739
|
+
/**
|
|
2740
|
+
* Error Type
|
|
2741
|
+
*/
|
|
1189
2742
|
type: string;
|
|
2743
|
+
/**
|
|
2744
|
+
* Input
|
|
2745
|
+
*/
|
|
1190
2746
|
input?: unknown;
|
|
2747
|
+
/**
|
|
2748
|
+
* Context
|
|
2749
|
+
*/
|
|
1191
2750
|
ctx?: {
|
|
1192
2751
|
[key: string]: unknown;
|
|
1193
2752
|
};
|
|
1194
2753
|
};
|
|
1195
2754
|
/**
|
|
2755
|
+
* WorkflowChainCreate
|
|
2756
|
+
*
|
|
1196
2757
|
* Request to create and run a multi-step chain on a single reserved session/machine
|
|
1197
2758
|
*/
|
|
1198
2759
|
export type WorkflowChainCreate = {
|
|
2760
|
+
/**
|
|
2761
|
+
* Steps
|
|
2762
|
+
*/
|
|
1199
2763
|
steps: Array<ChainStep>;
|
|
2764
|
+
/**
|
|
2765
|
+
* Shared Inputs
|
|
2766
|
+
*/
|
|
1200
2767
|
shared_inputs?: {
|
|
1201
2768
|
[key: string]: unknown;
|
|
1202
2769
|
} | null;
|
|
1203
2770
|
/**
|
|
2771
|
+
* Shared Sensitive Inputs
|
|
2772
|
+
*
|
|
1204
2773
|
* Shared sensitive inputs (supports nested objects) for all steps
|
|
1205
2774
|
*/
|
|
1206
2775
|
shared_sensitive_inputs?: {
|
|
1207
2776
|
[key: string]: unknown;
|
|
1208
2777
|
} | null;
|
|
2778
|
+
/**
|
|
2779
|
+
* Shared File Inputs
|
|
2780
|
+
*/
|
|
1209
2781
|
shared_file_inputs?: Array<FileInput> | null;
|
|
2782
|
+
/**
|
|
2783
|
+
* Keep Session After Completion
|
|
2784
|
+
*/
|
|
1210
2785
|
keep_session_after_completion?: boolean | null;
|
|
2786
|
+
/**
|
|
2787
|
+
* Machine Id
|
|
2788
|
+
*/
|
|
1211
2789
|
machine_id?: string | null;
|
|
1212
2790
|
/**
|
|
2791
|
+
* Pool Ids
|
|
2792
|
+
*
|
|
1213
2793
|
* Pool IDs to filter available machines when starting a new session. Machine must belong to ALL of these pools (intersection). Ignored when machine_id is provided.
|
|
1214
2794
|
*/
|
|
1215
2795
|
pool_ids?: Array<string> | null;
|
|
2796
|
+
/**
|
|
2797
|
+
* Session Id
|
|
2798
|
+
*/
|
|
1216
2799
|
session_id?: string | null;
|
|
1217
2800
|
};
|
|
1218
2801
|
/**
|
|
2802
|
+
* WorkflowChainResponse
|
|
2803
|
+
*
|
|
1219
2804
|
* Response for chain creation
|
|
1220
2805
|
*/
|
|
1221
2806
|
export type WorkflowChainResponse = {
|
|
2807
|
+
/**
|
|
2808
|
+
* Session Id
|
|
2809
|
+
*/
|
|
1222
2810
|
session_id: string;
|
|
2811
|
+
/**
|
|
2812
|
+
* Run Ids
|
|
2813
|
+
*/
|
|
1223
2814
|
run_ids: Array<string>;
|
|
1224
2815
|
};
|
|
1225
2816
|
/**
|
|
2817
|
+
* WorkflowCreate
|
|
2818
|
+
*
|
|
1226
2819
|
* Schema for creating a workflow
|
|
1227
2820
|
*/
|
|
1228
2821
|
export type WorkflowCreate = {
|
|
2822
|
+
/**
|
|
2823
|
+
* Name
|
|
2824
|
+
*/
|
|
1229
2825
|
name?: string | null;
|
|
2826
|
+
/**
|
|
2827
|
+
* Main Prompt
|
|
2828
|
+
*/
|
|
1230
2829
|
main_prompt: string;
|
|
1231
2830
|
/**
|
|
2831
|
+
* Input Schema
|
|
2832
|
+
*
|
|
1232
2833
|
* JSON schema for validating merged run inputs. Sensitive root keys are exposed with a '$' prefix in schema validation (for example sensitive_input_values.api_key -> '$api_key').
|
|
1233
2834
|
*/
|
|
1234
2835
|
input_schema?: string | null;
|
|
1235
2836
|
/**
|
|
2837
|
+
* Output Schema
|
|
2838
|
+
*
|
|
1236
2839
|
* JSON schema for output data transformation
|
|
1237
2840
|
*/
|
|
1238
2841
|
output_schema?: string | null;
|
|
1239
2842
|
/**
|
|
2843
|
+
* Includes File Exports
|
|
2844
|
+
*
|
|
1240
2845
|
* Enable AI-based file export detection
|
|
1241
2846
|
*/
|
|
1242
2847
|
includes_file_exports?: boolean;
|
|
1243
2848
|
/**
|
|
2849
|
+
* Is Webhooks Enabled
|
|
2850
|
+
*
|
|
1244
2851
|
* Send webhook on run completion
|
|
1245
2852
|
*/
|
|
1246
2853
|
is_webhooks_enabled?: boolean;
|
|
@@ -1248,64 +2855,98 @@ export type WorkflowCreate = {
|
|
|
1248
2855
|
* Optional workflow-level model configuration metadata (main agent, cache detection, and fallbacks).
|
|
1249
2856
|
*/
|
|
1250
2857
|
model_metadata?: WorkflowModelMetadata | null;
|
|
2858
|
+
/**
|
|
2859
|
+
* Post Run Checks
|
|
2860
|
+
*
|
|
2861
|
+
* Workflow-managed post-run checks, reconciled on save.
|
|
2862
|
+
*/
|
|
2863
|
+
post_run_checks?: Array<WorkflowPostRunCheckUpsert> | null;
|
|
1251
2864
|
};
|
|
1252
2865
|
/**
|
|
2866
|
+
* WorkflowDuplicateRequest
|
|
2867
|
+
*
|
|
1253
2868
|
* Schema for duplicating workflows.
|
|
1254
2869
|
*/
|
|
1255
2870
|
export type WorkflowDuplicateRequest = {
|
|
1256
2871
|
/**
|
|
2872
|
+
* Include Trajectories
|
|
2873
|
+
*
|
|
1257
2874
|
* Whether to duplicate generated trajectories onto the copied workflow. Non-generated trajectories are never duplicated.
|
|
1258
2875
|
*/
|
|
1259
2876
|
include_trajectories?: boolean;
|
|
1260
2877
|
};
|
|
1261
2878
|
/**
|
|
2879
|
+
* WorkflowInternalMetadata
|
|
2880
|
+
*
|
|
1262
2881
|
* Backend workflow metadata exposed read-only for internal observability.
|
|
1263
2882
|
*/
|
|
1264
2883
|
export type WorkflowInternalMetadata = {
|
|
1265
2884
|
/**
|
|
2885
|
+
* Has Unaddressed Error
|
|
2886
|
+
*
|
|
1266
2887
|
* True when at least one run has failed and remains unaddressed.
|
|
1267
2888
|
*/
|
|
1268
2889
|
has_unaddressed_error?: boolean | null;
|
|
1269
2890
|
/**
|
|
2891
|
+
* Last Errored Run Start
|
|
2892
|
+
*
|
|
1270
2893
|
* Start timestamp of the most recent errored/task_failed run.
|
|
1271
2894
|
*/
|
|
1272
2895
|
last_errored_run_start?: string | null;
|
|
1273
2896
|
/**
|
|
2897
|
+
* Last Errored Run Uuid
|
|
2898
|
+
*
|
|
1274
2899
|
* Run UUID of the most recent errored/task_failed run.
|
|
1275
2900
|
*/
|
|
1276
2901
|
last_errored_run_uuid?: string | null;
|
|
1277
2902
|
};
|
|
1278
2903
|
/**
|
|
2904
|
+
* WorkflowInternalMetadataUpdate
|
|
2905
|
+
*
|
|
1279
2906
|
* Patchable workflow metadata fields for internal workflow maintenance.
|
|
1280
2907
|
*/
|
|
1281
2908
|
export type WorkflowInternalMetadataUpdate = {
|
|
1282
2909
|
/**
|
|
2910
|
+
* Has Unaddressed Error
|
|
2911
|
+
*
|
|
1283
2912
|
* Set to false when workflow errors have been addressed.
|
|
1284
2913
|
*/
|
|
1285
2914
|
has_unaddressed_error?: boolean | null;
|
|
1286
2915
|
/**
|
|
2916
|
+
* Last Errored Run Start
|
|
2917
|
+
*
|
|
1287
2918
|
* Start timestamp of the most recent errored/task_failed run.
|
|
1288
2919
|
*/
|
|
1289
2920
|
last_errored_run_start?: string | null;
|
|
1290
2921
|
/**
|
|
2922
|
+
* Last Errored Run Uuid
|
|
2923
|
+
*
|
|
1291
2924
|
* Run UUID of the most recent errored/task_failed run.
|
|
1292
2925
|
*/
|
|
1293
2926
|
last_errored_run_uuid?: string | null;
|
|
1294
2927
|
};
|
|
1295
2928
|
/**
|
|
2929
|
+
* WorkflowMergeRequest
|
|
2930
|
+
*
|
|
1296
2931
|
* Schema for merging workflows
|
|
1297
2932
|
*/
|
|
1298
2933
|
export type WorkflowMergeRequest = {
|
|
1299
2934
|
/**
|
|
2935
|
+
* Target Workflow Id
|
|
2936
|
+
*
|
|
1300
2937
|
* Workflow ID to merge into
|
|
1301
2938
|
*/
|
|
1302
2939
|
target_workflow_id: string;
|
|
1303
2940
|
/**
|
|
2941
|
+
* Copy Trajectories
|
|
2942
|
+
*
|
|
1304
2943
|
* Whether to copy trajectories to the target workflow
|
|
1305
2944
|
*/
|
|
1306
2945
|
copy_trajectories?: boolean;
|
|
1307
2946
|
};
|
|
1308
2947
|
/**
|
|
2948
|
+
* WorkflowModelMetadata
|
|
2949
|
+
*
|
|
1309
2950
|
* JSONB-backed workflow model configuration metadata.
|
|
1310
2951
|
*
|
|
1311
2952
|
* Stored on the Workflow row as `model_metadata` to avoid adding many FK columns.
|
|
@@ -1313,108 +2954,383 @@ export type WorkflowMergeRequest = {
|
|
|
1313
2954
|
*/
|
|
1314
2955
|
export type WorkflowModelMetadata = {
|
|
1315
2956
|
/**
|
|
2957
|
+
* Main Agent Model Id
|
|
2958
|
+
*
|
|
1316
2959
|
* ModelConfiguration.id used for the main agent. Null → Cyberdesk default.
|
|
1317
2960
|
*/
|
|
1318
2961
|
main_agent_model_id?: string | null;
|
|
1319
2962
|
/**
|
|
2963
|
+
* Cache Detection Model Id
|
|
2964
|
+
*
|
|
1320
2965
|
* ModelConfiguration.id used for cache detection. Null → Cyberdesk default.
|
|
1321
2966
|
*/
|
|
1322
2967
|
cache_detection_model_id?: string | null;
|
|
1323
2968
|
/**
|
|
2969
|
+
* Fallback Model 1 Id
|
|
2970
|
+
*
|
|
1324
2971
|
* ModelConfiguration.id used as fallback 1 (global across agents).
|
|
1325
2972
|
*/
|
|
1326
2973
|
fallback_model_1_id?: string | null;
|
|
1327
2974
|
/**
|
|
2975
|
+
* Fallback Model 2 Id
|
|
2976
|
+
*
|
|
1328
2977
|
* ModelConfiguration.id used as fallback 2 (global across agents).
|
|
1329
2978
|
*/
|
|
1330
2979
|
fallback_model_2_id?: string | null;
|
|
1331
2980
|
};
|
|
1332
2981
|
/**
|
|
2982
|
+
* WorkflowPostRunCheckResponse
|
|
2983
|
+
*
|
|
2984
|
+
* Workflow response shape for post-run checks, including workflow-specific order.
|
|
2985
|
+
*/
|
|
2986
|
+
export type WorkflowPostRunCheckResponse = {
|
|
2987
|
+
/**
|
|
2988
|
+
* Name
|
|
2989
|
+
*/
|
|
2990
|
+
name: string;
|
|
2991
|
+
/**
|
|
2992
|
+
* Description
|
|
2993
|
+
*/
|
|
2994
|
+
description?: string | null;
|
|
2995
|
+
type: PostRunCheckType;
|
|
2996
|
+
file_target_mode?: PostRunCheckFileTargetMode | null;
|
|
2997
|
+
/**
|
|
2998
|
+
* File Names
|
|
2999
|
+
*/
|
|
3000
|
+
file_names?: Array<string> | null;
|
|
3001
|
+
/**
|
|
3002
|
+
* File Name Regex
|
|
3003
|
+
*/
|
|
3004
|
+
file_name_regex?: string | null;
|
|
3005
|
+
/**
|
|
3006
|
+
* Expected Match Count
|
|
3007
|
+
*/
|
|
3008
|
+
expected_match_count?: number | null;
|
|
3009
|
+
/**
|
|
3010
|
+
* Expected Match Count Ref
|
|
3011
|
+
*/
|
|
3012
|
+
expected_match_count_ref?: string | null;
|
|
3013
|
+
/**
|
|
3014
|
+
* Loop Input
|
|
3015
|
+
*/
|
|
3016
|
+
loop_input?: string | null;
|
|
3017
|
+
/**
|
|
3018
|
+
* Loop Item Filename Template
|
|
3019
|
+
*/
|
|
3020
|
+
loop_item_filename_template?: string | null;
|
|
3021
|
+
/**
|
|
3022
|
+
* Check Prompt
|
|
3023
|
+
*/
|
|
3024
|
+
check_prompt?: string | null;
|
|
3025
|
+
/**
|
|
3026
|
+
* Model
|
|
3027
|
+
*
|
|
3028
|
+
* Optional ModelConfiguration id override for agentic post-run checks.
|
|
3029
|
+
*/
|
|
3030
|
+
model?: string | null;
|
|
3031
|
+
/**
|
|
3032
|
+
* Id
|
|
3033
|
+
*/
|
|
3034
|
+
id: string;
|
|
3035
|
+
/**
|
|
3036
|
+
* Organization Id
|
|
3037
|
+
*/
|
|
3038
|
+
organization_id: string;
|
|
3039
|
+
/**
|
|
3040
|
+
* User Id
|
|
3041
|
+
*/
|
|
3042
|
+
user_id?: string | null;
|
|
3043
|
+
/**
|
|
3044
|
+
* Order
|
|
3045
|
+
*/
|
|
3046
|
+
order: number;
|
|
3047
|
+
/**
|
|
3048
|
+
* Created At
|
|
3049
|
+
*/
|
|
3050
|
+
created_at: string;
|
|
3051
|
+
/**
|
|
3052
|
+
* Updated At
|
|
3053
|
+
*/
|
|
3054
|
+
updated_at: string;
|
|
3055
|
+
};
|
|
3056
|
+
/**
|
|
3057
|
+
* WorkflowPostRunCheckUpsert
|
|
3058
|
+
*
|
|
3059
|
+
* Create/update payload for workflow-managed post-run checks.
|
|
3060
|
+
*/
|
|
3061
|
+
export type WorkflowPostRunCheckUpsert = {
|
|
3062
|
+
/**
|
|
3063
|
+
* Name
|
|
3064
|
+
*/
|
|
3065
|
+
name: string;
|
|
3066
|
+
/**
|
|
3067
|
+
* Description
|
|
3068
|
+
*/
|
|
3069
|
+
description?: string | null;
|
|
3070
|
+
type: PostRunCheckType;
|
|
3071
|
+
file_target_mode?: PostRunCheckFileTargetMode | null;
|
|
3072
|
+
/**
|
|
3073
|
+
* File Names
|
|
3074
|
+
*/
|
|
3075
|
+
file_names?: Array<string> | null;
|
|
3076
|
+
/**
|
|
3077
|
+
* File Name Regex
|
|
3078
|
+
*/
|
|
3079
|
+
file_name_regex?: string | null;
|
|
3080
|
+
/**
|
|
3081
|
+
* Expected Match Count
|
|
3082
|
+
*/
|
|
3083
|
+
expected_match_count?: number | null;
|
|
3084
|
+
/**
|
|
3085
|
+
* Expected Match Count Ref
|
|
3086
|
+
*/
|
|
3087
|
+
expected_match_count_ref?: string | null;
|
|
3088
|
+
/**
|
|
3089
|
+
* Loop Input
|
|
3090
|
+
*/
|
|
3091
|
+
loop_input?: string | null;
|
|
3092
|
+
/**
|
|
3093
|
+
* Loop Item Filename Template
|
|
3094
|
+
*/
|
|
3095
|
+
loop_item_filename_template?: string | null;
|
|
3096
|
+
/**
|
|
3097
|
+
* Check Prompt
|
|
3098
|
+
*/
|
|
3099
|
+
check_prompt?: string | null;
|
|
3100
|
+
/**
|
|
3101
|
+
* Model
|
|
3102
|
+
*
|
|
3103
|
+
* Optional ModelConfiguration id override for agentic post-run checks.
|
|
3104
|
+
*/
|
|
3105
|
+
model?: string | null;
|
|
3106
|
+
/**
|
|
3107
|
+
* Id
|
|
3108
|
+
*/
|
|
3109
|
+
id?: string | null;
|
|
3110
|
+
};
|
|
3111
|
+
/**
|
|
3112
|
+
* WorkflowPromptImageListItem
|
|
3113
|
+
*
|
|
1333
3114
|
* Schema for an item in the workflow prompt images list
|
|
1334
3115
|
*/
|
|
1335
3116
|
export type WorkflowPromptImageListItem = {
|
|
1336
3117
|
/**
|
|
3118
|
+
* Supabase Url
|
|
3119
|
+
*
|
|
1337
3120
|
* The stable supabase:// URL to use in workflow prompt HTML
|
|
1338
3121
|
*/
|
|
1339
3122
|
supabase_url: string;
|
|
1340
3123
|
/**
|
|
3124
|
+
* Path
|
|
3125
|
+
*
|
|
1341
3126
|
* The storage path of the image
|
|
1342
3127
|
*/
|
|
1343
3128
|
path: string;
|
|
1344
3129
|
/**
|
|
3130
|
+
* Filename
|
|
3131
|
+
*
|
|
1345
3132
|
* The filename of the image
|
|
1346
3133
|
*/
|
|
1347
3134
|
filename: string;
|
|
1348
3135
|
/**
|
|
3136
|
+
* Created At
|
|
3137
|
+
*
|
|
1349
3138
|
* When the image was uploaded
|
|
1350
3139
|
*/
|
|
1351
3140
|
created_at?: string | null;
|
|
1352
3141
|
/**
|
|
3142
|
+
* Size Bytes
|
|
3143
|
+
*
|
|
1353
3144
|
* The size of the file in bytes
|
|
1354
3145
|
*/
|
|
1355
3146
|
size_bytes?: number | null;
|
|
1356
3147
|
};
|
|
1357
3148
|
/**
|
|
3149
|
+
* WorkflowPromptImageResponse
|
|
3150
|
+
*
|
|
1358
3151
|
* Response schema for uploaded workflow prompt image
|
|
1359
3152
|
*/
|
|
1360
3153
|
export type WorkflowPromptImageResponse = {
|
|
1361
3154
|
/**
|
|
3155
|
+
* Supabase Url
|
|
3156
|
+
*
|
|
1362
3157
|
* The stable supabase:// URL to use in workflow prompt HTML. Example: supabase://workflow-prompt-images/org_xxx/prompt-assets/image.png
|
|
1363
3158
|
*/
|
|
1364
3159
|
supabase_url: string;
|
|
1365
3160
|
/**
|
|
3161
|
+
* Signed Url
|
|
3162
|
+
*
|
|
1366
3163
|
* A temporary signed URL for immediate display (expires in 1 hour)
|
|
1367
3164
|
*/
|
|
1368
3165
|
signed_url: string;
|
|
1369
3166
|
/**
|
|
3167
|
+
* Filename
|
|
3168
|
+
*
|
|
1370
3169
|
* The sanitized filename as stored
|
|
1371
3170
|
*/
|
|
1372
3171
|
filename: string;
|
|
1373
3172
|
/**
|
|
3173
|
+
* Content Type
|
|
3174
|
+
*
|
|
1374
3175
|
* The MIME type of the uploaded image
|
|
1375
3176
|
*/
|
|
1376
3177
|
content_type: string;
|
|
1377
3178
|
/**
|
|
3179
|
+
* Size Bytes
|
|
3180
|
+
*
|
|
1378
3181
|
* The size of the uploaded file in bytes
|
|
1379
3182
|
*/
|
|
1380
3183
|
size_bytes: number;
|
|
1381
3184
|
};
|
|
1382
3185
|
/**
|
|
3186
|
+
* WorkflowPromptImageSignedUrlResponse
|
|
3187
|
+
*
|
|
1383
3188
|
* Response schema for getting a signed URL for an existing image
|
|
1384
3189
|
*/
|
|
1385
3190
|
export type WorkflowPromptImageSignedUrlResponse = {
|
|
1386
3191
|
/**
|
|
3192
|
+
* Supabase Url
|
|
3193
|
+
*
|
|
1387
3194
|
* The stable supabase:// URL
|
|
1388
3195
|
*/
|
|
1389
3196
|
supabase_url: string;
|
|
1390
3197
|
/**
|
|
3198
|
+
* Signed Url
|
|
3199
|
+
*
|
|
1391
3200
|
* A temporary signed URL (expires in 1 hour)
|
|
1392
3201
|
*/
|
|
1393
3202
|
signed_url: string;
|
|
1394
3203
|
/**
|
|
3204
|
+
* Expires In
|
|
3205
|
+
*
|
|
1395
3206
|
* Seconds until the signed URL expires
|
|
1396
3207
|
*/
|
|
1397
3208
|
expires_in: number;
|
|
1398
3209
|
};
|
|
1399
3210
|
/**
|
|
3211
|
+
* WorkflowResponse
|
|
3212
|
+
*
|
|
1400
3213
|
* Workflow response schema
|
|
1401
3214
|
*/
|
|
1402
3215
|
export type WorkflowResponse = {
|
|
3216
|
+
/**
|
|
3217
|
+
* Name
|
|
3218
|
+
*/
|
|
3219
|
+
name?: string | null;
|
|
3220
|
+
/**
|
|
3221
|
+
* Main Prompt
|
|
3222
|
+
*/
|
|
3223
|
+
main_prompt: string;
|
|
3224
|
+
/**
|
|
3225
|
+
* Input Schema
|
|
3226
|
+
*
|
|
3227
|
+
* JSON schema for validating merged run inputs. Sensitive root keys are exposed with a '$' prefix in schema validation (for example sensitive_input_values.api_key -> '$api_key').
|
|
3228
|
+
*/
|
|
3229
|
+
input_schema?: string | null;
|
|
3230
|
+
/**
|
|
3231
|
+
* Output Schema
|
|
3232
|
+
*
|
|
3233
|
+
* JSON schema for output data transformation
|
|
3234
|
+
*/
|
|
3235
|
+
output_schema?: string | null;
|
|
3236
|
+
/**
|
|
3237
|
+
* Includes File Exports
|
|
3238
|
+
*
|
|
3239
|
+
* Enable AI-based file export detection
|
|
3240
|
+
*/
|
|
3241
|
+
includes_file_exports?: boolean;
|
|
3242
|
+
/**
|
|
3243
|
+
* Is Webhooks Enabled
|
|
3244
|
+
*
|
|
3245
|
+
* Send webhook on run completion
|
|
3246
|
+
*/
|
|
3247
|
+
is_webhooks_enabled?: boolean;
|
|
3248
|
+
/**
|
|
3249
|
+
* Optional workflow-level model configuration metadata (main agent, cache detection, and fallbacks).
|
|
3250
|
+
*/
|
|
3251
|
+
model_metadata?: WorkflowModelMetadata | null;
|
|
3252
|
+
/**
|
|
3253
|
+
* Id
|
|
3254
|
+
*/
|
|
3255
|
+
id: string;
|
|
3256
|
+
/**
|
|
3257
|
+
* User Id
|
|
3258
|
+
*/
|
|
3259
|
+
user_id?: string | null;
|
|
3260
|
+
/**
|
|
3261
|
+
* Organization Id
|
|
3262
|
+
*/
|
|
3263
|
+
organization_id?: string | null;
|
|
3264
|
+
/**
|
|
3265
|
+
* Includes Input Variables
|
|
3266
|
+
*/
|
|
3267
|
+
includes_input_variables?: boolean;
|
|
3268
|
+
/**
|
|
3269
|
+
* Internal workflow metadata used for run/error tracking.
|
|
3270
|
+
*/
|
|
3271
|
+
workflow_metadata?: WorkflowInternalMetadata | null;
|
|
3272
|
+
/**
|
|
3273
|
+
* Old Versions
|
|
3274
|
+
*/
|
|
3275
|
+
old_versions?: Array<{
|
|
3276
|
+
[key: string]: unknown;
|
|
3277
|
+
}> | null;
|
|
3278
|
+
/**
|
|
3279
|
+
* Created At
|
|
3280
|
+
*/
|
|
3281
|
+
created_at: string;
|
|
3282
|
+
/**
|
|
3283
|
+
* Updated At
|
|
3284
|
+
*/
|
|
3285
|
+
updated_at: string;
|
|
3286
|
+
/**
|
|
3287
|
+
* Tags
|
|
3288
|
+
*
|
|
3289
|
+
* Tags assigned to this workflow
|
|
3290
|
+
*/
|
|
3291
|
+
tags?: Array<WorkflowTagResponse> | null;
|
|
3292
|
+
/**
|
|
3293
|
+
* Post Run Checks
|
|
3294
|
+
*
|
|
3295
|
+
* Post-run checks assigned to this workflow.
|
|
3296
|
+
*/
|
|
3297
|
+
post_run_checks?: Array<WorkflowPostRunCheckResponse> | null;
|
|
3298
|
+
};
|
|
3299
|
+
/**
|
|
3300
|
+
* WorkflowResponseWithIncludes
|
|
3301
|
+
*
|
|
3302
|
+
* Workflow response with optional included related resources.
|
|
3303
|
+
*/
|
|
3304
|
+
export type WorkflowResponseWithIncludes = {
|
|
3305
|
+
/**
|
|
3306
|
+
* Name
|
|
3307
|
+
*/
|
|
1403
3308
|
name?: string | null;
|
|
3309
|
+
/**
|
|
3310
|
+
* Main Prompt
|
|
3311
|
+
*/
|
|
1404
3312
|
main_prompt: string;
|
|
1405
3313
|
/**
|
|
3314
|
+
* Input Schema
|
|
3315
|
+
*
|
|
1406
3316
|
* JSON schema for validating merged run inputs. Sensitive root keys are exposed with a '$' prefix in schema validation (for example sensitive_input_values.api_key -> '$api_key').
|
|
1407
3317
|
*/
|
|
1408
3318
|
input_schema?: string | null;
|
|
1409
3319
|
/**
|
|
3320
|
+
* Output Schema
|
|
3321
|
+
*
|
|
1410
3322
|
* JSON schema for output data transformation
|
|
1411
3323
|
*/
|
|
1412
3324
|
output_schema?: string | null;
|
|
1413
3325
|
/**
|
|
3326
|
+
* Includes File Exports
|
|
3327
|
+
*
|
|
1414
3328
|
* Enable AI-based file export detection
|
|
1415
3329
|
*/
|
|
1416
3330
|
includes_file_exports?: boolean;
|
|
1417
3331
|
/**
|
|
3332
|
+
* Is Webhooks Enabled
|
|
3333
|
+
*
|
|
1418
3334
|
* Send webhook on run completion
|
|
1419
3335
|
*/
|
|
1420
3336
|
is_webhooks_enabled?: boolean;
|
|
@@ -1422,88 +3338,232 @@ export type WorkflowResponse = {
|
|
|
1422
3338
|
* Optional workflow-level model configuration metadata (main agent, cache detection, and fallbacks).
|
|
1423
3339
|
*/
|
|
1424
3340
|
model_metadata?: WorkflowModelMetadata | null;
|
|
3341
|
+
/**
|
|
3342
|
+
* Id
|
|
3343
|
+
*/
|
|
1425
3344
|
id: string;
|
|
3345
|
+
/**
|
|
3346
|
+
* User Id
|
|
3347
|
+
*/
|
|
1426
3348
|
user_id?: string | null;
|
|
3349
|
+
/**
|
|
3350
|
+
* Organization Id
|
|
3351
|
+
*/
|
|
1427
3352
|
organization_id?: string | null;
|
|
3353
|
+
/**
|
|
3354
|
+
* Includes Input Variables
|
|
3355
|
+
*/
|
|
1428
3356
|
includes_input_variables?: boolean;
|
|
1429
3357
|
/**
|
|
1430
3358
|
* Internal workflow metadata used for run/error tracking.
|
|
1431
3359
|
*/
|
|
1432
3360
|
workflow_metadata?: WorkflowInternalMetadata | null;
|
|
3361
|
+
/**
|
|
3362
|
+
* Old Versions
|
|
3363
|
+
*/
|
|
1433
3364
|
old_versions?: Array<{
|
|
1434
3365
|
[key: string]: unknown;
|
|
1435
3366
|
}> | null;
|
|
3367
|
+
/**
|
|
3368
|
+
* Created At
|
|
3369
|
+
*/
|
|
1436
3370
|
created_at: string;
|
|
3371
|
+
/**
|
|
3372
|
+
* Updated At
|
|
3373
|
+
*/
|
|
1437
3374
|
updated_at: string;
|
|
1438
3375
|
/**
|
|
3376
|
+
* Tags
|
|
3377
|
+
*
|
|
1439
3378
|
* Tags assigned to this workflow
|
|
1440
3379
|
*/
|
|
1441
3380
|
tags?: Array<WorkflowTagResponse> | null;
|
|
3381
|
+
/**
|
|
3382
|
+
* Post Run Checks
|
|
3383
|
+
*
|
|
3384
|
+
* Post-run checks assigned to this workflow.
|
|
3385
|
+
*/
|
|
3386
|
+
post_run_checks?: Array<WorkflowPostRunCheckResponse> | null;
|
|
3387
|
+
/**
|
|
3388
|
+
* Included
|
|
3389
|
+
*
|
|
3390
|
+
* Related resources requested via the `include` query parameter
|
|
3391
|
+
*/
|
|
3392
|
+
included?: Array<IncludedResource> | null;
|
|
1442
3393
|
};
|
|
1443
3394
|
/**
|
|
3395
|
+
* WorkflowTagCreate
|
|
3396
|
+
*
|
|
1444
3397
|
* Schema for creating a workflow tag
|
|
1445
3398
|
*/
|
|
1446
3399
|
export type WorkflowTagCreate = {
|
|
3400
|
+
/**
|
|
3401
|
+
* Name
|
|
3402
|
+
*/
|
|
1447
3403
|
name: string;
|
|
3404
|
+
/**
|
|
3405
|
+
* Description
|
|
3406
|
+
*/
|
|
1448
3407
|
description?: string | null;
|
|
3408
|
+
/**
|
|
3409
|
+
* Emoji
|
|
3410
|
+
*/
|
|
1449
3411
|
emoji?: string | null;
|
|
3412
|
+
/**
|
|
3413
|
+
* Color
|
|
3414
|
+
*/
|
|
1450
3415
|
color?: string | null;
|
|
1451
3416
|
/**
|
|
3417
|
+
* Group Id
|
|
3418
|
+
*
|
|
1452
3419
|
* Optional group for mutual exclusivity
|
|
1453
3420
|
*/
|
|
1454
3421
|
group_id?: string | null;
|
|
1455
3422
|
};
|
|
1456
3423
|
/**
|
|
3424
|
+
* WorkflowTagGroupCreate
|
|
3425
|
+
*
|
|
1457
3426
|
* Schema for creating a workflow tag group
|
|
1458
3427
|
*/
|
|
1459
3428
|
export type WorkflowTagGroupCreate = {
|
|
3429
|
+
/**
|
|
3430
|
+
* Name
|
|
3431
|
+
*/
|
|
1460
3432
|
name: string;
|
|
3433
|
+
/**
|
|
3434
|
+
* Description
|
|
3435
|
+
*/
|
|
1461
3436
|
description?: string | null;
|
|
3437
|
+
/**
|
|
3438
|
+
* Emoji
|
|
3439
|
+
*/
|
|
1462
3440
|
emoji?: string | null;
|
|
3441
|
+
/**
|
|
3442
|
+
* Color
|
|
3443
|
+
*/
|
|
1463
3444
|
color?: string | null;
|
|
1464
3445
|
};
|
|
1465
3446
|
/**
|
|
3447
|
+
* WorkflowTagGroupResponse
|
|
3448
|
+
*
|
|
1466
3449
|
* Workflow tag group response schema
|
|
1467
3450
|
*/
|
|
1468
3451
|
export type WorkflowTagGroupResponse = {
|
|
3452
|
+
/**
|
|
3453
|
+
* Name
|
|
3454
|
+
*/
|
|
1469
3455
|
name: string;
|
|
3456
|
+
/**
|
|
3457
|
+
* Description
|
|
3458
|
+
*/
|
|
1470
3459
|
description?: string | null;
|
|
3460
|
+
/**
|
|
3461
|
+
* Emoji
|
|
3462
|
+
*/
|
|
1471
3463
|
emoji?: string | null;
|
|
3464
|
+
/**
|
|
3465
|
+
* Color
|
|
3466
|
+
*/
|
|
1472
3467
|
color?: string | null;
|
|
3468
|
+
/**
|
|
3469
|
+
* Id
|
|
3470
|
+
*/
|
|
1473
3471
|
id: string;
|
|
3472
|
+
/**
|
|
3473
|
+
* Organization Id
|
|
3474
|
+
*/
|
|
1474
3475
|
organization_id: string;
|
|
3476
|
+
/**
|
|
3477
|
+
* Order
|
|
3478
|
+
*/
|
|
1475
3479
|
order: number;
|
|
3480
|
+
/**
|
|
3481
|
+
* Created At
|
|
3482
|
+
*/
|
|
1476
3483
|
created_at: string;
|
|
3484
|
+
/**
|
|
3485
|
+
* Updated At
|
|
3486
|
+
*/
|
|
1477
3487
|
updated_at: string;
|
|
1478
3488
|
};
|
|
1479
3489
|
/**
|
|
3490
|
+
* WorkflowTagGroupUpdate
|
|
3491
|
+
*
|
|
1480
3492
|
* Schema for updating a workflow tag group
|
|
1481
3493
|
*/
|
|
1482
3494
|
export type WorkflowTagGroupUpdate = {
|
|
3495
|
+
/**
|
|
3496
|
+
* Name
|
|
3497
|
+
*/
|
|
1483
3498
|
name?: string | null;
|
|
3499
|
+
/**
|
|
3500
|
+
* Description
|
|
3501
|
+
*/
|
|
1484
3502
|
description?: string | null;
|
|
3503
|
+
/**
|
|
3504
|
+
* Emoji
|
|
3505
|
+
*/
|
|
1485
3506
|
emoji?: string | null;
|
|
3507
|
+
/**
|
|
3508
|
+
* Color
|
|
3509
|
+
*/
|
|
1486
3510
|
color?: string | null;
|
|
1487
3511
|
};
|
|
1488
3512
|
/**
|
|
3513
|
+
* WorkflowTagResponse
|
|
3514
|
+
*
|
|
1489
3515
|
* Workflow tag response schema
|
|
1490
3516
|
*/
|
|
1491
3517
|
export type WorkflowTagResponse = {
|
|
3518
|
+
/**
|
|
3519
|
+
* Name
|
|
3520
|
+
*/
|
|
1492
3521
|
name: string;
|
|
3522
|
+
/**
|
|
3523
|
+
* Description
|
|
3524
|
+
*/
|
|
1493
3525
|
description?: string | null;
|
|
3526
|
+
/**
|
|
3527
|
+
* Emoji
|
|
3528
|
+
*/
|
|
1494
3529
|
emoji?: string | null;
|
|
3530
|
+
/**
|
|
3531
|
+
* Color
|
|
3532
|
+
*/
|
|
1495
3533
|
color?: string | null;
|
|
1496
3534
|
/**
|
|
3535
|
+
* Group Id
|
|
3536
|
+
*
|
|
1497
3537
|
* Optional group for mutual exclusivity
|
|
1498
3538
|
*/
|
|
1499
3539
|
group_id?: string | null;
|
|
3540
|
+
/**
|
|
3541
|
+
* Id
|
|
3542
|
+
*/
|
|
1500
3543
|
id: string;
|
|
3544
|
+
/**
|
|
3545
|
+
* Organization Id
|
|
3546
|
+
*/
|
|
1501
3547
|
organization_id: string;
|
|
3548
|
+
/**
|
|
3549
|
+
* Order
|
|
3550
|
+
*/
|
|
1502
3551
|
order: number;
|
|
3552
|
+
/**
|
|
3553
|
+
* Is Archived
|
|
3554
|
+
*/
|
|
1503
3555
|
is_archived?: boolean;
|
|
3556
|
+
/**
|
|
3557
|
+
* Created At
|
|
3558
|
+
*/
|
|
1504
3559
|
created_at: string;
|
|
3560
|
+
/**
|
|
3561
|
+
* Updated At
|
|
3562
|
+
*/
|
|
1505
3563
|
updated_at: string;
|
|
1506
3564
|
/**
|
|
3565
|
+
* Workflow Count
|
|
3566
|
+
*
|
|
1507
3567
|
* Number of workflows with this tag (returned in list endpoint)
|
|
1508
3568
|
*/
|
|
1509
3569
|
workflow_count?: number | null;
|
|
@@ -1513,41 +3573,75 @@ export type WorkflowTagResponse = {
|
|
|
1513
3573
|
group?: WorkflowTagGroupResponse | null;
|
|
1514
3574
|
};
|
|
1515
3575
|
/**
|
|
3576
|
+
* WorkflowTagUpdate
|
|
3577
|
+
*
|
|
1516
3578
|
* Schema for updating a workflow tag
|
|
1517
3579
|
*/
|
|
1518
3580
|
export type WorkflowTagUpdate = {
|
|
3581
|
+
/**
|
|
3582
|
+
* Name
|
|
3583
|
+
*/
|
|
1519
3584
|
name?: string | null;
|
|
3585
|
+
/**
|
|
3586
|
+
* Description
|
|
3587
|
+
*/
|
|
1520
3588
|
description?: string | null;
|
|
3589
|
+
/**
|
|
3590
|
+
* Emoji
|
|
3591
|
+
*/
|
|
1521
3592
|
emoji?: string | null;
|
|
3593
|
+
/**
|
|
3594
|
+
* Color
|
|
3595
|
+
*/
|
|
1522
3596
|
color?: string | null;
|
|
1523
3597
|
/**
|
|
3598
|
+
* Group Id
|
|
3599
|
+
*
|
|
1524
3600
|
* Optional group for mutual exclusivity
|
|
1525
3601
|
*/
|
|
1526
3602
|
group_id?: string | null;
|
|
1527
3603
|
/**
|
|
3604
|
+
* Is Archived
|
|
3605
|
+
*
|
|
1528
3606
|
* Archive tag to prevent new assignments
|
|
1529
3607
|
*/
|
|
1530
3608
|
is_archived?: boolean | null;
|
|
1531
3609
|
};
|
|
1532
3610
|
/**
|
|
3611
|
+
* WorkflowUpdate
|
|
3612
|
+
*
|
|
1533
3613
|
* Schema for updating a workflow
|
|
1534
3614
|
*/
|
|
1535
3615
|
export type WorkflowUpdate = {
|
|
3616
|
+
/**
|
|
3617
|
+
* Name
|
|
3618
|
+
*/
|
|
1536
3619
|
name?: string | null;
|
|
3620
|
+
/**
|
|
3621
|
+
* Main Prompt
|
|
3622
|
+
*/
|
|
1537
3623
|
main_prompt?: string | null;
|
|
1538
3624
|
/**
|
|
3625
|
+
* Input Schema
|
|
3626
|
+
*
|
|
1539
3627
|
* JSON schema for validating merged run inputs. Sensitive root keys are exposed with a '$' prefix in schema validation (for example sensitive_input_values.api_key -> '$api_key').
|
|
1540
3628
|
*/
|
|
1541
3629
|
input_schema?: string | null;
|
|
1542
3630
|
/**
|
|
3631
|
+
* Output Schema
|
|
3632
|
+
*
|
|
1543
3633
|
* JSON schema for output data transformation
|
|
1544
3634
|
*/
|
|
1545
3635
|
output_schema?: string | null;
|
|
1546
3636
|
/**
|
|
3637
|
+
* Includes File Exports
|
|
3638
|
+
*
|
|
1547
3639
|
* Enable AI-based file export detection
|
|
1548
3640
|
*/
|
|
1549
3641
|
includes_file_exports?: boolean | null;
|
|
1550
3642
|
/**
|
|
3643
|
+
* Is Webhooks Enabled
|
|
3644
|
+
*
|
|
1551
3645
|
* Send webhook on run completion
|
|
1552
3646
|
*/
|
|
1553
3647
|
is_webhooks_enabled?: boolean | null;
|
|
@@ -1559,6 +3653,12 @@ export type WorkflowUpdate = {
|
|
|
1559
3653
|
* Optional internal workflow metadata patch. Top-level null clears all workflow metadata. Omit this field to leave existing metadata unchanged. Set individual keys to null to remove only those keys.
|
|
1560
3654
|
*/
|
|
1561
3655
|
workflow_metadata?: WorkflowInternalMetadataUpdate | null;
|
|
3656
|
+
/**
|
|
3657
|
+
* Post Run Checks
|
|
3658
|
+
*
|
|
3659
|
+
* Workflow-managed post-run checks, reconciled on save when present.
|
|
3660
|
+
*/
|
|
3661
|
+
post_run_checks?: Array<WorkflowPostRunCheckUpsert> | null;
|
|
1562
3662
|
};
|
|
1563
3663
|
export type HealthCheckV1HealthGetData = {
|
|
1564
3664
|
body?: never;
|
|
@@ -1568,6 +3668,8 @@ export type HealthCheckV1HealthGetData = {
|
|
|
1568
3668
|
};
|
|
1569
3669
|
export type HealthCheckV1HealthGetResponses = {
|
|
1570
3670
|
/**
|
|
3671
|
+
* Response Health Check V1 Health Get
|
|
3672
|
+
*
|
|
1571
3673
|
* Successful Response
|
|
1572
3674
|
*/
|
|
1573
3675
|
200: {
|
|
@@ -1592,26 +3694,42 @@ export type ListMachinesV1MachinesGetData = {
|
|
|
1592
3694
|
path?: never;
|
|
1593
3695
|
query?: {
|
|
1594
3696
|
/**
|
|
3697
|
+
* Search
|
|
3698
|
+
*
|
|
1595
3699
|
* Search machines by id, name, or hostname (case-insensitive substring match)
|
|
1596
3700
|
*/
|
|
1597
3701
|
search?: string | null;
|
|
1598
3702
|
/**
|
|
3703
|
+
* Status
|
|
3704
|
+
*
|
|
1599
3705
|
* Filter by machine status
|
|
1600
3706
|
*/
|
|
1601
3707
|
status?: MachineStatus | null;
|
|
1602
3708
|
/**
|
|
3709
|
+
* Created At From
|
|
3710
|
+
*
|
|
1603
3711
|
* Filter machines created at or after this ISO timestamp (UTC)
|
|
1604
3712
|
*/
|
|
1605
3713
|
created_at_from?: string | null;
|
|
1606
3714
|
/**
|
|
3715
|
+
* Created At To
|
|
3716
|
+
*
|
|
1607
3717
|
* Filter machines created at or before this ISO timestamp (UTC)
|
|
1608
3718
|
*/
|
|
1609
3719
|
created_at_to?: string | null;
|
|
1610
3720
|
/**
|
|
3721
|
+
* Include
|
|
3722
|
+
*
|
|
1611
3723
|
* Comma-separated list of related resources to include. Allowed values: pools. Example: include=pools
|
|
1612
3724
|
*/
|
|
1613
3725
|
include?: string | null;
|
|
3726
|
+
/**
|
|
3727
|
+
* Skip
|
|
3728
|
+
*/
|
|
1614
3729
|
skip?: number;
|
|
3730
|
+
/**
|
|
3731
|
+
* Limit
|
|
3732
|
+
*/
|
|
1615
3733
|
limit?: number;
|
|
1616
3734
|
};
|
|
1617
3735
|
url: '/v1/machines';
|
|
@@ -1665,6 +3783,9 @@ export type DeleteMachineV1MachinesMachineIdDeleteData = {
|
|
|
1665
3783
|
'Idempotency-Key'?: string;
|
|
1666
3784
|
};
|
|
1667
3785
|
path: {
|
|
3786
|
+
/**
|
|
3787
|
+
* Machine Id
|
|
3788
|
+
*/
|
|
1668
3789
|
machine_id: string;
|
|
1669
3790
|
};
|
|
1670
3791
|
query?: never;
|
|
@@ -1687,10 +3808,15 @@ export type DeleteMachineV1MachinesMachineIdDeleteResponse = DeleteMachineV1Mach
|
|
|
1687
3808
|
export type GetMachineV1MachinesMachineIdGetData = {
|
|
1688
3809
|
body?: never;
|
|
1689
3810
|
path: {
|
|
3811
|
+
/**
|
|
3812
|
+
* Machine Id
|
|
3813
|
+
*/
|
|
1690
3814
|
machine_id: string;
|
|
1691
3815
|
};
|
|
1692
3816
|
query?: {
|
|
1693
3817
|
/**
|
|
3818
|
+
* Include
|
|
3819
|
+
*
|
|
1694
3820
|
* Comma-separated list of related resources to include. Allowed values: pools. Example: include=pools
|
|
1695
3821
|
*/
|
|
1696
3822
|
include?: string | null;
|
|
@@ -1720,6 +3846,9 @@ export type UpdateMachineV1MachinesMachineIdPatchData = {
|
|
|
1720
3846
|
'Idempotency-Key'?: string;
|
|
1721
3847
|
};
|
|
1722
3848
|
path: {
|
|
3849
|
+
/**
|
|
3850
|
+
* Machine Id
|
|
3851
|
+
*/
|
|
1723
3852
|
machine_id: string;
|
|
1724
3853
|
};
|
|
1725
3854
|
query?: never;
|
|
@@ -1742,6 +3871,9 @@ export type UpdateMachineV1MachinesMachineIdPatchResponse = UpdateMachineV1Machi
|
|
|
1742
3871
|
export type GetMachinePoolsV1MachinesMachineIdPoolsGetData = {
|
|
1743
3872
|
body?: never;
|
|
1744
3873
|
path: {
|
|
3874
|
+
/**
|
|
3875
|
+
* Machine Id
|
|
3876
|
+
*/
|
|
1745
3877
|
machine_id: string;
|
|
1746
3878
|
};
|
|
1747
3879
|
query?: never;
|
|
@@ -1756,6 +3888,8 @@ export type GetMachinePoolsV1MachinesMachineIdPoolsGetErrors = {
|
|
|
1756
3888
|
export type GetMachinePoolsV1MachinesMachineIdPoolsGetError = GetMachinePoolsV1MachinesMachineIdPoolsGetErrors[keyof GetMachinePoolsV1MachinesMachineIdPoolsGetErrors];
|
|
1757
3889
|
export type GetMachinePoolsV1MachinesMachineIdPoolsGetResponses = {
|
|
1758
3890
|
/**
|
|
3891
|
+
* Response Get Machine Pools V1 Machines Machine Id Pools Get
|
|
3892
|
+
*
|
|
1759
3893
|
* Successful Response
|
|
1760
3894
|
*/
|
|
1761
3895
|
200: Array<PoolResponse>;
|
|
@@ -1770,6 +3904,9 @@ export type UpdateMachinePoolsV1MachinesMachineIdPoolsPutData = {
|
|
|
1770
3904
|
'Idempotency-Key'?: string;
|
|
1771
3905
|
};
|
|
1772
3906
|
path: {
|
|
3907
|
+
/**
|
|
3908
|
+
* Machine Id
|
|
3909
|
+
*/
|
|
1773
3910
|
machine_id: string;
|
|
1774
3911
|
};
|
|
1775
3912
|
query?: never;
|
|
@@ -1794,10 +3931,18 @@ export type ListPoolsV1PoolsGetData = {
|
|
|
1794
3931
|
path?: never;
|
|
1795
3932
|
query?: {
|
|
1796
3933
|
/**
|
|
3934
|
+
* Include
|
|
3935
|
+
*
|
|
1797
3936
|
* Comma-separated list of related resources to include. Allowed values: machines. Example: include=machines
|
|
1798
3937
|
*/
|
|
1799
3938
|
include?: string | null;
|
|
3939
|
+
/**
|
|
3940
|
+
* Skip
|
|
3941
|
+
*/
|
|
1800
3942
|
skip?: number;
|
|
3943
|
+
/**
|
|
3944
|
+
* Limit
|
|
3945
|
+
*/
|
|
1801
3946
|
limit?: number;
|
|
1802
3947
|
};
|
|
1803
3948
|
url: '/v1/pools';
|
|
@@ -1851,6 +3996,9 @@ export type DeletePoolV1PoolsPoolIdDeleteData = {
|
|
|
1851
3996
|
'Idempotency-Key'?: string;
|
|
1852
3997
|
};
|
|
1853
3998
|
path: {
|
|
3999
|
+
/**
|
|
4000
|
+
* Pool Id
|
|
4001
|
+
*/
|
|
1854
4002
|
pool_id: string;
|
|
1855
4003
|
};
|
|
1856
4004
|
query?: never;
|
|
@@ -1873,14 +4021,21 @@ export type DeletePoolV1PoolsPoolIdDeleteResponse = DeletePoolV1PoolsPoolIdDelet
|
|
|
1873
4021
|
export type GetPoolV1PoolsPoolIdGetData = {
|
|
1874
4022
|
body?: never;
|
|
1875
4023
|
path: {
|
|
4024
|
+
/**
|
|
4025
|
+
* Pool Id
|
|
4026
|
+
*/
|
|
1876
4027
|
pool_id: string;
|
|
1877
4028
|
};
|
|
1878
4029
|
query?: {
|
|
1879
4030
|
/**
|
|
4031
|
+
* Include Machines
|
|
4032
|
+
*
|
|
1880
4033
|
* [Deprecated] Use include=machines instead. Include full machine details
|
|
1881
4034
|
*/
|
|
1882
4035
|
include_machines?: boolean;
|
|
1883
4036
|
/**
|
|
4037
|
+
* Include
|
|
4038
|
+
*
|
|
1884
4039
|
* Comma-separated list of related resources to include. Allowed values: machines. Example: include=machines
|
|
1885
4040
|
*/
|
|
1886
4041
|
include?: string | null;
|
|
@@ -1910,6 +4065,9 @@ export type UpdatePoolV1PoolsPoolIdPatchData = {
|
|
|
1910
4065
|
'Idempotency-Key'?: string;
|
|
1911
4066
|
};
|
|
1912
4067
|
path: {
|
|
4068
|
+
/**
|
|
4069
|
+
* Pool Id
|
|
4070
|
+
*/
|
|
1913
4071
|
pool_id: string;
|
|
1914
4072
|
};
|
|
1915
4073
|
query?: never;
|
|
@@ -1938,6 +4096,9 @@ export type RemoveMachinesFromPoolV1PoolsPoolIdMachinesDeleteData = {
|
|
|
1938
4096
|
'Idempotency-Key'?: string;
|
|
1939
4097
|
};
|
|
1940
4098
|
path: {
|
|
4099
|
+
/**
|
|
4100
|
+
* Pool Id
|
|
4101
|
+
*/
|
|
1941
4102
|
pool_id: string;
|
|
1942
4103
|
};
|
|
1943
4104
|
query?: never;
|
|
@@ -1966,6 +4127,9 @@ export type AddMachinesToPoolV1PoolsPoolIdMachinesPostData = {
|
|
|
1966
4127
|
'Idempotency-Key'?: string;
|
|
1967
4128
|
};
|
|
1968
4129
|
path: {
|
|
4130
|
+
/**
|
|
4131
|
+
* Pool Id
|
|
4132
|
+
*/
|
|
1969
4133
|
pool_id: string;
|
|
1970
4134
|
};
|
|
1971
4135
|
query?: never;
|
|
@@ -1990,34 +4154,60 @@ export type ListWorkflowsV1WorkflowsGetData = {
|
|
|
1990
4154
|
path?: never;
|
|
1991
4155
|
query?: {
|
|
1992
4156
|
/**
|
|
4157
|
+
* Search
|
|
4158
|
+
*
|
|
1993
4159
|
* Search workflows by id or name (case-insensitive substring match)
|
|
1994
4160
|
*/
|
|
1995
4161
|
search?: string | null;
|
|
1996
4162
|
/**
|
|
4163
|
+
* Created At From
|
|
4164
|
+
*
|
|
1997
4165
|
* Filter workflows created at or after this ISO timestamp (UTC)
|
|
1998
4166
|
*/
|
|
1999
4167
|
created_at_from?: string | null;
|
|
2000
4168
|
/**
|
|
4169
|
+
* Created At To
|
|
4170
|
+
*
|
|
2001
4171
|
* Filter workflows created at or before this ISO timestamp (UTC)
|
|
2002
4172
|
*/
|
|
2003
4173
|
created_at_to?: string | null;
|
|
2004
4174
|
/**
|
|
4175
|
+
* Updated At From
|
|
4176
|
+
*
|
|
2005
4177
|
* Filter workflows updated at or after this ISO timestamp (UTC)
|
|
2006
4178
|
*/
|
|
2007
4179
|
updated_at_from?: string | null;
|
|
2008
4180
|
/**
|
|
4181
|
+
* Updated At To
|
|
4182
|
+
*
|
|
2009
4183
|
* Filter workflows updated at or before this ISO timestamp (UTC)
|
|
2010
4184
|
*/
|
|
2011
4185
|
updated_at_to?: string | null;
|
|
2012
4186
|
/**
|
|
4187
|
+
* Tag Ids
|
|
4188
|
+
*
|
|
2013
4189
|
* Comma-separated list of tag UUIDs. Returns workflows with ALL specified tags (AND logic).
|
|
2014
4190
|
*/
|
|
2015
4191
|
tag_ids?: string | null;
|
|
2016
4192
|
/**
|
|
4193
|
+
* Include Tags
|
|
4194
|
+
*
|
|
2017
4195
|
* Include tags in the response
|
|
2018
4196
|
*/
|
|
2019
4197
|
include_tags?: boolean;
|
|
4198
|
+
/**
|
|
4199
|
+
* Include
|
|
4200
|
+
*
|
|
4201
|
+
* Comma-separated list of related resources to include. Allowed values: tags, post_run_checks. If provided, overrides legacy include_tags.
|
|
4202
|
+
*/
|
|
4203
|
+
include?: string | null;
|
|
4204
|
+
/**
|
|
4205
|
+
* Skip
|
|
4206
|
+
*/
|
|
2020
4207
|
skip?: number;
|
|
4208
|
+
/**
|
|
4209
|
+
* Limit
|
|
4210
|
+
*/
|
|
2021
4211
|
limit?: number;
|
|
2022
4212
|
};
|
|
2023
4213
|
url: '/v1/workflows';
|
|
@@ -2033,7 +4223,7 @@ export type ListWorkflowsV1WorkflowsGetResponses = {
|
|
|
2033
4223
|
/**
|
|
2034
4224
|
* Successful Response
|
|
2035
4225
|
*/
|
|
2036
|
-
200:
|
|
4226
|
+
200: PaginatedResponseWithIncludesWorkflowResponse;
|
|
2037
4227
|
};
|
|
2038
4228
|
export type ListWorkflowsV1WorkflowsGetResponse = ListWorkflowsV1WorkflowsGetResponses[keyof ListWorkflowsV1WorkflowsGetResponses];
|
|
2039
4229
|
export type CreateWorkflowV1WorkflowsPostData = {
|
|
@@ -2097,6 +4287,9 @@ export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteData = {
|
|
|
2097
4287
|
'Idempotency-Key'?: string;
|
|
2098
4288
|
};
|
|
2099
4289
|
path: {
|
|
4290
|
+
/**
|
|
4291
|
+
* Workflow Id
|
|
4292
|
+
*/
|
|
2100
4293
|
workflow_id: string;
|
|
2101
4294
|
};
|
|
2102
4295
|
query?: never;
|
|
@@ -2119,9 +4312,19 @@ export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteResponse = DeleteWorkflowV1
|
|
|
2119
4312
|
export type GetWorkflowV1WorkflowsWorkflowIdGetData = {
|
|
2120
4313
|
body?: never;
|
|
2121
4314
|
path: {
|
|
4315
|
+
/**
|
|
4316
|
+
* Workflow Id
|
|
4317
|
+
*/
|
|
2122
4318
|
workflow_id: string;
|
|
2123
4319
|
};
|
|
2124
|
-
query?:
|
|
4320
|
+
query?: {
|
|
4321
|
+
/**
|
|
4322
|
+
* Include
|
|
4323
|
+
*
|
|
4324
|
+
* Comma-separated list of related resources to include. Allowed values: tags, post_run_checks. Defaults to tags and post_run_checks when omitted.
|
|
4325
|
+
*/
|
|
4326
|
+
include?: string | null;
|
|
4327
|
+
};
|
|
2125
4328
|
url: '/v1/workflows/{workflow_id}';
|
|
2126
4329
|
};
|
|
2127
4330
|
export type GetWorkflowV1WorkflowsWorkflowIdGetErrors = {
|
|
@@ -2135,7 +4338,7 @@ export type GetWorkflowV1WorkflowsWorkflowIdGetResponses = {
|
|
|
2135
4338
|
/**
|
|
2136
4339
|
* Successful Response
|
|
2137
4340
|
*/
|
|
2138
|
-
200:
|
|
4341
|
+
200: WorkflowResponseWithIncludes;
|
|
2139
4342
|
};
|
|
2140
4343
|
export type GetWorkflowV1WorkflowsWorkflowIdGetResponse = GetWorkflowV1WorkflowsWorkflowIdGetResponses[keyof GetWorkflowV1WorkflowsWorkflowIdGetResponses];
|
|
2141
4344
|
export type UpdateWorkflowV1WorkflowsWorkflowIdPatchData = {
|
|
@@ -2147,6 +4350,9 @@ export type UpdateWorkflowV1WorkflowsWorkflowIdPatchData = {
|
|
|
2147
4350
|
'Idempotency-Key'?: string;
|
|
2148
4351
|
};
|
|
2149
4352
|
path: {
|
|
4353
|
+
/**
|
|
4354
|
+
* Workflow Id
|
|
4355
|
+
*/
|
|
2150
4356
|
workflow_id: string;
|
|
2151
4357
|
};
|
|
2152
4358
|
query?: never;
|
|
@@ -2167,6 +4373,9 @@ export type UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses = {
|
|
|
2167
4373
|
};
|
|
2168
4374
|
export type UpdateWorkflowV1WorkflowsWorkflowIdPatchResponse = UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses[keyof UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses];
|
|
2169
4375
|
export type DuplicateWorkflowV1WorkflowsWorkflowIdDuplicatePostData = {
|
|
4376
|
+
/**
|
|
4377
|
+
* Duplicate Data
|
|
4378
|
+
*/
|
|
2170
4379
|
body?: WorkflowDuplicateRequest | null;
|
|
2171
4380
|
headers?: {
|
|
2172
4381
|
/**
|
|
@@ -2175,6 +4384,9 @@ export type DuplicateWorkflowV1WorkflowsWorkflowIdDuplicatePostData = {
|
|
|
2175
4384
|
'Idempotency-Key'?: string;
|
|
2176
4385
|
};
|
|
2177
4386
|
path: {
|
|
4387
|
+
/**
|
|
4388
|
+
* Workflow Id
|
|
4389
|
+
*/
|
|
2178
4390
|
workflow_id: string;
|
|
2179
4391
|
};
|
|
2180
4392
|
query?: never;
|
|
@@ -2203,6 +4415,9 @@ export type MergeWorkflowV1WorkflowsWorkflowIdMergePostData = {
|
|
|
2203
4415
|
'Idempotency-Key'?: string;
|
|
2204
4416
|
};
|
|
2205
4417
|
path: {
|
|
4418
|
+
/**
|
|
4419
|
+
* Workflow Id
|
|
4420
|
+
*/
|
|
2206
4421
|
workflow_id: string;
|
|
2207
4422
|
};
|
|
2208
4423
|
query?: never;
|
|
@@ -2225,6 +4440,9 @@ export type MergeWorkflowV1WorkflowsWorkflowIdMergePostResponse = MergeWorkflowV
|
|
|
2225
4440
|
export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetData = {
|
|
2226
4441
|
body?: never;
|
|
2227
4442
|
path: {
|
|
4443
|
+
/**
|
|
4444
|
+
* Workflow Id
|
|
4445
|
+
*/
|
|
2228
4446
|
workflow_id: string;
|
|
2229
4447
|
};
|
|
2230
4448
|
query?: never;
|
|
@@ -2239,6 +4457,8 @@ export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors = {
|
|
|
2239
4457
|
export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetError = GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors[keyof GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors];
|
|
2240
4458
|
export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetResponses = {
|
|
2241
4459
|
/**
|
|
4460
|
+
* Response Get Workflow Versions V1 Workflows Workflow Id Versions Get
|
|
4461
|
+
*
|
|
2242
4462
|
* Successful Response
|
|
2243
4463
|
*/
|
|
2244
4464
|
200: Array<{
|
|
@@ -2257,6 +4477,8 @@ export type DeleteWorkflowPromptImageV1WorkflowsPromptImageDeleteData = {
|
|
|
2257
4477
|
path?: never;
|
|
2258
4478
|
query: {
|
|
2259
4479
|
/**
|
|
4480
|
+
* Path
|
|
4481
|
+
*
|
|
2260
4482
|
* The storage path of the image to delete
|
|
2261
4483
|
*/
|
|
2262
4484
|
path: string;
|
|
@@ -2311,6 +4533,8 @@ export type ListWorkflowPromptImagesV1WorkflowsPromptImagesGetData = {
|
|
|
2311
4533
|
};
|
|
2312
4534
|
export type ListWorkflowPromptImagesV1WorkflowsPromptImagesGetResponses = {
|
|
2313
4535
|
/**
|
|
4536
|
+
* Response List Workflow Prompt Images V1 Workflows Prompt Images Get
|
|
4537
|
+
*
|
|
2314
4538
|
* Successful Response
|
|
2315
4539
|
*/
|
|
2316
4540
|
200: Array<WorkflowPromptImageListItem>;
|
|
@@ -2321,6 +4545,8 @@ export type GetWorkflowPromptImageSignedUrlV1WorkflowsPromptImageSignedUrlGetDat
|
|
|
2321
4545
|
path?: never;
|
|
2322
4546
|
query: {
|
|
2323
4547
|
/**
|
|
4548
|
+
* Path
|
|
4549
|
+
*
|
|
2324
4550
|
* The storage path of the image (e.g., org_xxx/prompt-assets/image.png)
|
|
2325
4551
|
*/
|
|
2326
4552
|
path: string;
|
|
@@ -2344,6 +4570,9 @@ export type GetWorkflowPromptImageSignedUrlV1WorkflowsPromptImageSignedUrlGetRes
|
|
|
2344
4570
|
export type GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetData = {
|
|
2345
4571
|
body?: never;
|
|
2346
4572
|
path: {
|
|
4573
|
+
/**
|
|
4574
|
+
* Workflow Id
|
|
4575
|
+
*/
|
|
2347
4576
|
workflow_id: string;
|
|
2348
4577
|
};
|
|
2349
4578
|
query?: never;
|
|
@@ -2358,6 +4587,8 @@ export type GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetErrors = {
|
|
|
2358
4587
|
export type GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetError = GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetErrors[keyof GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetErrors];
|
|
2359
4588
|
export type GetWorkflowTagsV1WorkflowsWorkflowIdTagsGetResponses = {
|
|
2360
4589
|
/**
|
|
4590
|
+
* Response Get Workflow Tags V1 Workflows Workflow Id Tags Get
|
|
4591
|
+
*
|
|
2361
4592
|
* Successful Response
|
|
2362
4593
|
*/
|
|
2363
4594
|
200: Array<WorkflowTagResponse>;
|
|
@@ -2372,6 +4603,9 @@ export type AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostData = {
|
|
|
2372
4603
|
'Idempotency-Key'?: string;
|
|
2373
4604
|
};
|
|
2374
4605
|
path: {
|
|
4606
|
+
/**
|
|
4607
|
+
* Workflow Id
|
|
4608
|
+
*/
|
|
2375
4609
|
workflow_id: string;
|
|
2376
4610
|
};
|
|
2377
4611
|
query?: never;
|
|
@@ -2386,6 +4620,8 @@ export type AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostErrors = {
|
|
|
2386
4620
|
export type AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostError = AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostErrors[keyof AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostErrors];
|
|
2387
4621
|
export type AddTagsToWorkflowV1WorkflowsWorkflowIdTagsPostResponses = {
|
|
2388
4622
|
/**
|
|
4623
|
+
* Response Add Tags To Workflow V1 Workflows Workflow Id Tags Post
|
|
4624
|
+
*
|
|
2389
4625
|
* Successful Response
|
|
2390
4626
|
*/
|
|
2391
4627
|
200: Array<WorkflowTagResponse>;
|
|
@@ -2400,7 +4636,13 @@ export type RemoveTagFromWorkflowV1WorkflowsWorkflowIdTagsTagIdDeleteData = {
|
|
|
2400
4636
|
'Idempotency-Key'?: string;
|
|
2401
4637
|
};
|
|
2402
4638
|
path: {
|
|
4639
|
+
/**
|
|
4640
|
+
* Workflow Id
|
|
4641
|
+
*/
|
|
2403
4642
|
workflow_id: string;
|
|
4643
|
+
/**
|
|
4644
|
+
* Tag Id
|
|
4645
|
+
*/
|
|
2404
4646
|
tag_id: string;
|
|
2405
4647
|
};
|
|
2406
4648
|
query?: never;
|
|
@@ -2425,6 +4667,8 @@ export type ListTagsV1WorkflowTagsGetData = {
|
|
|
2425
4667
|
path?: never;
|
|
2426
4668
|
query?: {
|
|
2427
4669
|
/**
|
|
4670
|
+
* Include Archived
|
|
4671
|
+
*
|
|
2428
4672
|
* Include archived tags in the response
|
|
2429
4673
|
*/
|
|
2430
4674
|
include_archived?: boolean;
|
|
@@ -2440,6 +4684,8 @@ export type ListTagsV1WorkflowTagsGetErrors = {
|
|
|
2440
4684
|
export type ListTagsV1WorkflowTagsGetError = ListTagsV1WorkflowTagsGetErrors[keyof ListTagsV1WorkflowTagsGetErrors];
|
|
2441
4685
|
export type ListTagsV1WorkflowTagsGetResponses = {
|
|
2442
4686
|
/**
|
|
4687
|
+
* Response List Tags V1 Workflow Tags Get
|
|
4688
|
+
*
|
|
2443
4689
|
* Successful Response
|
|
2444
4690
|
*/
|
|
2445
4691
|
200: Array<WorkflowTagResponse>;
|
|
@@ -2480,6 +4726,9 @@ export type DeleteTagV1WorkflowTagsTagIdDeleteData = {
|
|
|
2480
4726
|
'Idempotency-Key'?: string;
|
|
2481
4727
|
};
|
|
2482
4728
|
path: {
|
|
4729
|
+
/**
|
|
4730
|
+
* Tag Id
|
|
4731
|
+
*/
|
|
2483
4732
|
tag_id: string;
|
|
2484
4733
|
};
|
|
2485
4734
|
query?: never;
|
|
@@ -2502,6 +4751,9 @@ export type DeleteTagV1WorkflowTagsTagIdDeleteResponse = DeleteTagV1WorkflowTags
|
|
|
2502
4751
|
export type GetTagV1WorkflowTagsTagIdGetData = {
|
|
2503
4752
|
body?: never;
|
|
2504
4753
|
path: {
|
|
4754
|
+
/**
|
|
4755
|
+
* Tag Id
|
|
4756
|
+
*/
|
|
2505
4757
|
tag_id: string;
|
|
2506
4758
|
};
|
|
2507
4759
|
query?: never;
|
|
@@ -2530,6 +4782,9 @@ export type UpdateTagV1WorkflowTagsTagIdPatchData = {
|
|
|
2530
4782
|
'Idempotency-Key'?: string;
|
|
2531
4783
|
};
|
|
2532
4784
|
path: {
|
|
4785
|
+
/**
|
|
4786
|
+
* Tag Id
|
|
4787
|
+
*/
|
|
2533
4788
|
tag_id: string;
|
|
2534
4789
|
};
|
|
2535
4790
|
query?: never;
|
|
@@ -2558,6 +4813,9 @@ export type ArchiveTagV1WorkflowTagsTagIdArchivePostData = {
|
|
|
2558
4813
|
'Idempotency-Key'?: string;
|
|
2559
4814
|
};
|
|
2560
4815
|
path: {
|
|
4816
|
+
/**
|
|
4817
|
+
* Tag Id
|
|
4818
|
+
*/
|
|
2561
4819
|
tag_id: string;
|
|
2562
4820
|
};
|
|
2563
4821
|
query?: never;
|
|
@@ -2586,6 +4844,9 @@ export type UnarchiveTagV1WorkflowTagsTagIdUnarchivePostData = {
|
|
|
2586
4844
|
'Idempotency-Key'?: string;
|
|
2587
4845
|
};
|
|
2588
4846
|
path: {
|
|
4847
|
+
/**
|
|
4848
|
+
* Tag Id
|
|
4849
|
+
*/
|
|
2589
4850
|
tag_id: string;
|
|
2590
4851
|
};
|
|
2591
4852
|
query?: never;
|
|
@@ -2639,6 +4900,8 @@ export type ListTagGroupsV1WorkflowTagGroupsGetData = {
|
|
|
2639
4900
|
};
|
|
2640
4901
|
export type ListTagGroupsV1WorkflowTagGroupsGetResponses = {
|
|
2641
4902
|
/**
|
|
4903
|
+
* Response List Tag Groups V1 Workflow Tag Groups Get
|
|
4904
|
+
*
|
|
2642
4905
|
* Successful Response
|
|
2643
4906
|
*/
|
|
2644
4907
|
200: Array<WorkflowTagGroupResponse>;
|
|
@@ -2679,6 +4942,9 @@ export type DeleteTagGroupV1WorkflowTagGroupsGroupIdDeleteData = {
|
|
|
2679
4942
|
'Idempotency-Key'?: string;
|
|
2680
4943
|
};
|
|
2681
4944
|
path: {
|
|
4945
|
+
/**
|
|
4946
|
+
* Group Id
|
|
4947
|
+
*/
|
|
2682
4948
|
group_id: string;
|
|
2683
4949
|
};
|
|
2684
4950
|
query?: never;
|
|
@@ -2701,6 +4967,9 @@ export type DeleteTagGroupV1WorkflowTagGroupsGroupIdDeleteResponse = DeleteTagGr
|
|
|
2701
4967
|
export type GetTagGroupV1WorkflowTagGroupsGroupIdGetData = {
|
|
2702
4968
|
body?: never;
|
|
2703
4969
|
path: {
|
|
4970
|
+
/**
|
|
4971
|
+
* Group Id
|
|
4972
|
+
*/
|
|
2704
4973
|
group_id: string;
|
|
2705
4974
|
};
|
|
2706
4975
|
query?: never;
|
|
@@ -2729,6 +4998,9 @@ export type UpdateTagGroupV1WorkflowTagGroupsGroupIdPatchData = {
|
|
|
2729
4998
|
'Idempotency-Key'?: string;
|
|
2730
4999
|
};
|
|
2731
5000
|
path: {
|
|
5001
|
+
/**
|
|
5002
|
+
* Group Id
|
|
5003
|
+
*/
|
|
2732
5004
|
group_id: string;
|
|
2733
5005
|
};
|
|
2734
5006
|
query?: never;
|
|
@@ -2782,6 +5054,8 @@ export type ListModelConfigurationsV1ModelConfigurationsGetData = {
|
|
|
2782
5054
|
};
|
|
2783
5055
|
export type ListModelConfigurationsV1ModelConfigurationsGetResponses = {
|
|
2784
5056
|
/**
|
|
5057
|
+
* Response List Model Configurations V1 Model Configurations Get
|
|
5058
|
+
*
|
|
2785
5059
|
* Successful Response
|
|
2786
5060
|
*/
|
|
2787
5061
|
200: Array<ModelConfigurationResponse>;
|
|
@@ -2822,6 +5096,9 @@ export type DeleteModelConfigurationV1ModelConfigurationsModelConfigurationIdDel
|
|
|
2822
5096
|
'Idempotency-Key'?: string;
|
|
2823
5097
|
};
|
|
2824
5098
|
path: {
|
|
5099
|
+
/**
|
|
5100
|
+
* Model Configuration Id
|
|
5101
|
+
*/
|
|
2825
5102
|
model_configuration_id: string;
|
|
2826
5103
|
};
|
|
2827
5104
|
query?: never;
|
|
@@ -2844,6 +5121,9 @@ export type DeleteModelConfigurationV1ModelConfigurationsModelConfigurationIdDel
|
|
|
2844
5121
|
export type GetModelConfigurationV1ModelConfigurationsModelConfigurationIdGetData = {
|
|
2845
5122
|
body?: never;
|
|
2846
5123
|
path: {
|
|
5124
|
+
/**
|
|
5125
|
+
* Model Configuration Id
|
|
5126
|
+
*/
|
|
2847
5127
|
model_configuration_id: string;
|
|
2848
5128
|
};
|
|
2849
5129
|
query?: never;
|
|
@@ -2872,6 +5152,9 @@ export type UpdateModelConfigurationV1ModelConfigurationsModelConfigurationIdPat
|
|
|
2872
5152
|
'Idempotency-Key'?: string;
|
|
2873
5153
|
};
|
|
2874
5154
|
path: {
|
|
5155
|
+
/**
|
|
5156
|
+
* Model Configuration Id
|
|
5157
|
+
*/
|
|
2875
5158
|
model_configuration_id: string;
|
|
2876
5159
|
};
|
|
2877
5160
|
query?: never;
|
|
@@ -2896,30 +5179,38 @@ export type ListRunsV1RunsGetData = {
|
|
|
2896
5179
|
path?: never;
|
|
2897
5180
|
query?: {
|
|
2898
5181
|
/**
|
|
5182
|
+
* Workflow Id
|
|
5183
|
+
*
|
|
2899
5184
|
* Filter by workflow ID
|
|
2900
5185
|
*/
|
|
2901
5186
|
workflow_id?: string | null;
|
|
2902
5187
|
/**
|
|
2903
|
-
*
|
|
2904
|
-
|
|
2905
|
-
run_kind?: RunKind | null;
|
|
2906
|
-
/**
|
|
5188
|
+
* Machine Id
|
|
5189
|
+
*
|
|
2907
5190
|
* Filter by machine ID
|
|
2908
5191
|
*/
|
|
2909
5192
|
machine_id?: string | null;
|
|
2910
5193
|
/**
|
|
5194
|
+
* Session Id
|
|
5195
|
+
*
|
|
2911
5196
|
* Filter by session ID
|
|
2912
5197
|
*/
|
|
2913
5198
|
session_id?: string | null;
|
|
2914
5199
|
/**
|
|
5200
|
+
* Status
|
|
5201
|
+
*
|
|
2915
5202
|
* Filter by run status
|
|
2916
5203
|
*/
|
|
2917
5204
|
status?: RunStatus | null;
|
|
2918
5205
|
/**
|
|
5206
|
+
* Created At From
|
|
5207
|
+
*
|
|
2919
5208
|
* Filter runs created at or after this ISO timestamp (UTC)
|
|
2920
5209
|
*/
|
|
2921
5210
|
created_at_from?: string | null;
|
|
2922
5211
|
/**
|
|
5212
|
+
* Created At To
|
|
5213
|
+
*
|
|
2923
5214
|
* Filter runs created at or before this ISO timestamp (UTC)
|
|
2924
5215
|
*/
|
|
2925
5216
|
created_at_to?: string | null;
|
|
@@ -2928,22 +5219,36 @@ export type ListRunsV1RunsGetData = {
|
|
|
2928
5219
|
*/
|
|
2929
5220
|
sort_mode?: RunListSortMode;
|
|
2930
5221
|
/**
|
|
5222
|
+
* Search
|
|
5223
|
+
*
|
|
2931
5224
|
* Search runs by id, input_values, output_data, error, session_alias (case-insensitive substring match)
|
|
2932
5225
|
*/
|
|
2933
5226
|
search?: string | null;
|
|
2934
5227
|
/**
|
|
5228
|
+
* Deep Search
|
|
5229
|
+
*
|
|
2935
5230
|
* If true, also search run_message_history (slower but more comprehensive)
|
|
2936
5231
|
*/
|
|
2937
5232
|
deep_search?: boolean;
|
|
2938
5233
|
/**
|
|
2939
|
-
*
|
|
5234
|
+
* Fields
|
|
5235
|
+
*
|
|
5236
|
+
* Optional list of fields to include per run. Always includes: id, workflow_id, machine_id, status, created_at. Provide multiple 'fields=' params to include more.
|
|
2940
5237
|
*/
|
|
2941
5238
|
fields?: Array<RunField> | null;
|
|
2942
5239
|
/**
|
|
5240
|
+
* Include
|
|
5241
|
+
*
|
|
2943
5242
|
* Comma-separated list of related resources to include. Allowed values: workflow, machine, machine.pools. Example: include=workflow,machine
|
|
2944
5243
|
*/
|
|
2945
5244
|
include?: string | null;
|
|
5245
|
+
/**
|
|
5246
|
+
* Skip
|
|
5247
|
+
*/
|
|
2946
5248
|
skip?: number;
|
|
5249
|
+
/**
|
|
5250
|
+
* Limit
|
|
5251
|
+
*/
|
|
2947
5252
|
limit?: number;
|
|
2948
5253
|
};
|
|
2949
5254
|
url: '/v1/runs';
|
|
@@ -2985,7 +5290,7 @@ export type CreateRunV1RunsPostResponses = {
|
|
|
2985
5290
|
/**
|
|
2986
5291
|
* Successful Response
|
|
2987
5292
|
*/
|
|
2988
|
-
201:
|
|
5293
|
+
201: RunResponseOutput;
|
|
2989
5294
|
};
|
|
2990
5295
|
export type CreateRunV1RunsPostResponse = CreateRunV1RunsPostResponses[keyof CreateRunV1RunsPostResponses];
|
|
2991
5296
|
export type DeleteRunV1RunsRunIdDeleteData = {
|
|
@@ -2997,6 +5302,9 @@ export type DeleteRunV1RunsRunIdDeleteData = {
|
|
|
2997
5302
|
'Idempotency-Key'?: string;
|
|
2998
5303
|
};
|
|
2999
5304
|
path: {
|
|
5305
|
+
/**
|
|
5306
|
+
* Run Id
|
|
5307
|
+
*/
|
|
3000
5308
|
run_id: string;
|
|
3001
5309
|
};
|
|
3002
5310
|
query?: never;
|
|
@@ -3019,10 +5327,15 @@ export type DeleteRunV1RunsRunIdDeleteResponse = DeleteRunV1RunsRunIdDeleteRespo
|
|
|
3019
5327
|
export type GetRunV1RunsRunIdGetData = {
|
|
3020
5328
|
body?: never;
|
|
3021
5329
|
path: {
|
|
5330
|
+
/**
|
|
5331
|
+
* Run Id
|
|
5332
|
+
*/
|
|
3022
5333
|
run_id: string;
|
|
3023
5334
|
};
|
|
3024
5335
|
query?: {
|
|
3025
5336
|
/**
|
|
5337
|
+
* Include
|
|
5338
|
+
*
|
|
3026
5339
|
* Comma-separated list of related resources to include. Allowed values: workflow, machine, machine.pools. Example: include=workflow,machine
|
|
3027
5340
|
*/
|
|
3028
5341
|
include?: string | null;
|
|
@@ -3052,6 +5365,9 @@ export type UpdateRunV1RunsRunIdPatchData = {
|
|
|
3052
5365
|
'Idempotency-Key'?: string;
|
|
3053
5366
|
};
|
|
3054
5367
|
path: {
|
|
5368
|
+
/**
|
|
5369
|
+
* Run Id
|
|
5370
|
+
*/
|
|
3055
5371
|
run_id: string;
|
|
3056
5372
|
};
|
|
3057
5373
|
query?: never;
|
|
@@ -3068,12 +5384,15 @@ export type UpdateRunV1RunsRunIdPatchResponses = {
|
|
|
3068
5384
|
/**
|
|
3069
5385
|
* Successful Response
|
|
3070
5386
|
*/
|
|
3071
|
-
200:
|
|
5387
|
+
200: RunResponseOutput;
|
|
3072
5388
|
};
|
|
3073
5389
|
export type UpdateRunV1RunsRunIdPatchResponse = UpdateRunV1RunsRunIdPatchResponses[keyof UpdateRunV1RunsRunIdPatchResponses];
|
|
3074
5390
|
export type GetRunTrajectoryV1RunsRunIdTrajectoryGetData = {
|
|
3075
5391
|
body?: never;
|
|
3076
5392
|
path: {
|
|
5393
|
+
/**
|
|
5394
|
+
* Run Id
|
|
5395
|
+
*/
|
|
3077
5396
|
run_id: string;
|
|
3078
5397
|
};
|
|
3079
5398
|
query?: never;
|
|
@@ -3102,6 +5421,9 @@ export type GenerateRunTrajectoryV1RunsRunIdGenerateTrajectoryPostData = {
|
|
|
3102
5421
|
'Idempotency-Key'?: string;
|
|
3103
5422
|
};
|
|
3104
5423
|
path: {
|
|
5424
|
+
/**
|
|
5425
|
+
* Run Id
|
|
5426
|
+
*/
|
|
3105
5427
|
run_id: string;
|
|
3106
5428
|
};
|
|
3107
5429
|
query?: never;
|
|
@@ -3182,6 +5504,9 @@ export type RetryRunV1RunsRunIdRetryPostData = {
|
|
|
3182
5504
|
'Idempotency-Key'?: string;
|
|
3183
5505
|
};
|
|
3184
5506
|
path: {
|
|
5507
|
+
/**
|
|
5508
|
+
* Run Id
|
|
5509
|
+
*/
|
|
3185
5510
|
run_id: string;
|
|
3186
5511
|
};
|
|
3187
5512
|
query?: never;
|
|
@@ -3198,7 +5523,7 @@ export type RetryRunV1RunsRunIdRetryPostResponses = {
|
|
|
3198
5523
|
/**
|
|
3199
5524
|
* Successful Response
|
|
3200
5525
|
*/
|
|
3201
|
-
200:
|
|
5526
|
+
200: RunResponseOutput;
|
|
3202
5527
|
};
|
|
3203
5528
|
export type RetryRunV1RunsRunIdRetryPostResponse = RetryRunV1RunsRunIdRetryPostResponses[keyof RetryRunV1RunsRunIdRetryPostResponses];
|
|
3204
5529
|
export type ListRunAttachmentsV1RunAttachmentsGetData = {
|
|
@@ -3206,14 +5531,24 @@ export type ListRunAttachmentsV1RunAttachmentsGetData = {
|
|
|
3206
5531
|
path?: never;
|
|
3207
5532
|
query?: {
|
|
3208
5533
|
/**
|
|
5534
|
+
* Run Id
|
|
5535
|
+
*
|
|
3209
5536
|
* Filter by run ID
|
|
3210
5537
|
*/
|
|
3211
5538
|
run_id?: string | null;
|
|
3212
5539
|
/**
|
|
5540
|
+
* Attachment Type
|
|
5541
|
+
*
|
|
3213
5542
|
* Filter by attachment type
|
|
3214
5543
|
*/
|
|
3215
5544
|
attachment_type?: AttachmentType | null;
|
|
5545
|
+
/**
|
|
5546
|
+
* Skip
|
|
5547
|
+
*/
|
|
3216
5548
|
skip?: number;
|
|
5549
|
+
/**
|
|
5550
|
+
* Limit
|
|
5551
|
+
*/
|
|
3217
5552
|
limit?: number;
|
|
3218
5553
|
};
|
|
3219
5554
|
url: '/v1/run-attachments';
|
|
@@ -3267,6 +5602,9 @@ export type DeleteRunAttachmentV1RunAttachmentsAttachmentIdDeleteData = {
|
|
|
3267
5602
|
'Idempotency-Key'?: string;
|
|
3268
5603
|
};
|
|
3269
5604
|
path: {
|
|
5605
|
+
/**
|
|
5606
|
+
* Attachment Id
|
|
5607
|
+
*/
|
|
3270
5608
|
attachment_id: string;
|
|
3271
5609
|
};
|
|
3272
5610
|
query?: never;
|
|
@@ -3289,6 +5627,9 @@ export type DeleteRunAttachmentV1RunAttachmentsAttachmentIdDeleteResponse = Dele
|
|
|
3289
5627
|
export type GetRunAttachmentV1RunAttachmentsAttachmentIdGetData = {
|
|
3290
5628
|
body?: never;
|
|
3291
5629
|
path: {
|
|
5630
|
+
/**
|
|
5631
|
+
* Attachment Id
|
|
5632
|
+
*/
|
|
3292
5633
|
attachment_id: string;
|
|
3293
5634
|
};
|
|
3294
5635
|
query?: never;
|
|
@@ -3317,6 +5658,9 @@ export type UpdateRunAttachmentV1RunAttachmentsAttachmentIdPutData = {
|
|
|
3317
5658
|
'Idempotency-Key'?: string;
|
|
3318
5659
|
};
|
|
3319
5660
|
path: {
|
|
5661
|
+
/**
|
|
5662
|
+
* Attachment Id
|
|
5663
|
+
*/
|
|
3320
5664
|
attachment_id: string;
|
|
3321
5665
|
};
|
|
3322
5666
|
query?: never;
|
|
@@ -3339,10 +5683,15 @@ export type UpdateRunAttachmentV1RunAttachmentsAttachmentIdPutResponse = UpdateR
|
|
|
3339
5683
|
export type GetRunAttachmentDownloadUrlV1RunAttachmentsAttachmentIdDownloadUrlGetData = {
|
|
3340
5684
|
body?: never;
|
|
3341
5685
|
path: {
|
|
5686
|
+
/**
|
|
5687
|
+
* Attachment Id
|
|
5688
|
+
*/
|
|
3342
5689
|
attachment_id: string;
|
|
3343
5690
|
};
|
|
3344
5691
|
query?: {
|
|
3345
5692
|
/**
|
|
5693
|
+
* Expires In
|
|
5694
|
+
*
|
|
3346
5695
|
* URL expiration time in seconds (10-3600)
|
|
3347
5696
|
*/
|
|
3348
5697
|
expires_in?: number;
|
|
@@ -3366,6 +5715,9 @@ export type GetRunAttachmentDownloadUrlV1RunAttachmentsAttachmentIdDownloadUrlGe
|
|
|
3366
5715
|
export type DownloadRunAttachmentV1RunAttachmentsAttachmentIdDownloadGetData = {
|
|
3367
5716
|
body?: never;
|
|
3368
5717
|
path: {
|
|
5718
|
+
/**
|
|
5719
|
+
* Attachment Id
|
|
5720
|
+
*/
|
|
3369
5721
|
attachment_id: string;
|
|
3370
5722
|
};
|
|
3371
5723
|
query?: never;
|
|
@@ -3390,14 +5742,24 @@ export type ListConnectionsV1ConnectionsGetData = {
|
|
|
3390
5742
|
path?: never;
|
|
3391
5743
|
query?: {
|
|
3392
5744
|
/**
|
|
5745
|
+
* Machine Id
|
|
5746
|
+
*
|
|
3393
5747
|
* Filter by machine ID
|
|
3394
5748
|
*/
|
|
3395
5749
|
machine_id?: string | null;
|
|
3396
5750
|
/**
|
|
5751
|
+
* Status
|
|
5752
|
+
*
|
|
3397
5753
|
* Filter by connection status
|
|
3398
5754
|
*/
|
|
3399
5755
|
status?: ConnectionStatus | null;
|
|
5756
|
+
/**
|
|
5757
|
+
* Skip
|
|
5758
|
+
*/
|
|
3400
5759
|
skip?: number;
|
|
5760
|
+
/**
|
|
5761
|
+
* Limit
|
|
5762
|
+
*/
|
|
3401
5763
|
limit?: number;
|
|
3402
5764
|
};
|
|
3403
5765
|
url: '/v1/connections';
|
|
@@ -3451,6 +5813,9 @@ export type DeleteConnectionV1ConnectionsConnectionIdDeleteData = {
|
|
|
3451
5813
|
'Idempotency-Key'?: string;
|
|
3452
5814
|
};
|
|
3453
5815
|
path: {
|
|
5816
|
+
/**
|
|
5817
|
+
* Connection Id
|
|
5818
|
+
*/
|
|
3454
5819
|
connection_id: string;
|
|
3455
5820
|
};
|
|
3456
5821
|
query?: never;
|
|
@@ -3473,6 +5838,9 @@ export type DeleteConnectionV1ConnectionsConnectionIdDeleteResponse = DeleteConn
|
|
|
3473
5838
|
export type GetConnectionV1ConnectionsConnectionIdGetData = {
|
|
3474
5839
|
body?: never;
|
|
3475
5840
|
path: {
|
|
5841
|
+
/**
|
|
5842
|
+
* Connection Id
|
|
5843
|
+
*/
|
|
3476
5844
|
connection_id: string;
|
|
3477
5845
|
};
|
|
3478
5846
|
query?: never;
|
|
@@ -3501,6 +5869,9 @@ export type UpdateConnectionV1ConnectionsConnectionIdPatchData = {
|
|
|
3501
5869
|
'Idempotency-Key'?: string;
|
|
3502
5870
|
};
|
|
3503
5871
|
path: {
|
|
5872
|
+
/**
|
|
5873
|
+
* Connection Id
|
|
5874
|
+
*/
|
|
3504
5875
|
connection_id: string;
|
|
3505
5876
|
};
|
|
3506
5877
|
query?: never;
|
|
@@ -3525,18 +5896,30 @@ export type ListRequestLogsV1RequestLogsGetData = {
|
|
|
3525
5896
|
path?: never;
|
|
3526
5897
|
query?: {
|
|
3527
5898
|
/**
|
|
5899
|
+
* Machine Id
|
|
5900
|
+
*
|
|
3528
5901
|
* Filter by machine ID
|
|
3529
5902
|
*/
|
|
3530
5903
|
machine_id?: string | null;
|
|
3531
5904
|
/**
|
|
5905
|
+
* Method
|
|
5906
|
+
*
|
|
3532
5907
|
* Filter by HTTP method
|
|
3533
5908
|
*/
|
|
3534
5909
|
method?: string | null;
|
|
3535
5910
|
/**
|
|
5911
|
+
* Status Code
|
|
5912
|
+
*
|
|
3536
5913
|
* Filter by status code
|
|
3537
5914
|
*/
|
|
3538
5915
|
status_code?: number | null;
|
|
5916
|
+
/**
|
|
5917
|
+
* Skip
|
|
5918
|
+
*/
|
|
3539
5919
|
skip?: number;
|
|
5920
|
+
/**
|
|
5921
|
+
* Limit
|
|
5922
|
+
*/
|
|
3540
5923
|
limit?: number;
|
|
3541
5924
|
};
|
|
3542
5925
|
url: '/v1/request-logs';
|
|
@@ -3590,6 +5973,9 @@ export type DeleteRequestLogV1RequestLogsLogIdDeleteData = {
|
|
|
3590
5973
|
'Idempotency-Key'?: string;
|
|
3591
5974
|
};
|
|
3592
5975
|
path: {
|
|
5976
|
+
/**
|
|
5977
|
+
* Log Id
|
|
5978
|
+
*/
|
|
3593
5979
|
log_id: string;
|
|
3594
5980
|
};
|
|
3595
5981
|
query?: never;
|
|
@@ -3612,6 +5998,9 @@ export type DeleteRequestLogV1RequestLogsLogIdDeleteResponse = DeleteRequestLogV
|
|
|
3612
5998
|
export type GetRequestLogV1RequestLogsLogIdGetData = {
|
|
3613
5999
|
body?: never;
|
|
3614
6000
|
path: {
|
|
6001
|
+
/**
|
|
6002
|
+
* Log Id
|
|
6003
|
+
*/
|
|
3615
6004
|
log_id: string;
|
|
3616
6005
|
};
|
|
3617
6006
|
query?: never;
|
|
@@ -3640,6 +6029,9 @@ export type UpdateRequestLogV1RequestLogsLogIdPatchData = {
|
|
|
3640
6029
|
'Idempotency-Key'?: string;
|
|
3641
6030
|
};
|
|
3642
6031
|
path: {
|
|
6032
|
+
/**
|
|
6033
|
+
* Log Id
|
|
6034
|
+
*/
|
|
3643
6035
|
log_id: string;
|
|
3644
6036
|
};
|
|
3645
6037
|
query?: never;
|
|
@@ -3664,46 +6056,72 @@ export type ListTrajectoriesV1TrajectoriesGetData = {
|
|
|
3664
6056
|
path?: never;
|
|
3665
6057
|
query?: {
|
|
3666
6058
|
/**
|
|
6059
|
+
* Search
|
|
6060
|
+
*
|
|
3667
6061
|
* Search trajectories by id, name, or description (case-insensitive substring match)
|
|
3668
6062
|
*/
|
|
3669
6063
|
search?: string | null;
|
|
3670
6064
|
/**
|
|
6065
|
+
* Workflow Id
|
|
6066
|
+
*
|
|
3671
6067
|
* Filter by workflow ID
|
|
3672
6068
|
*/
|
|
3673
6069
|
workflow_id?: string | null;
|
|
3674
6070
|
/**
|
|
6071
|
+
* Run Id
|
|
6072
|
+
*
|
|
3675
6073
|
* Filter by run ID
|
|
3676
6074
|
*/
|
|
3677
6075
|
run_id?: string | null;
|
|
3678
6076
|
/**
|
|
6077
|
+
* Is Approved
|
|
6078
|
+
*
|
|
3679
6079
|
* Filter by approval status (true=approved, false=not approved)
|
|
3680
6080
|
*/
|
|
3681
6081
|
is_approved?: boolean | null;
|
|
3682
6082
|
/**
|
|
6083
|
+
* Is Generated
|
|
6084
|
+
*
|
|
3683
6085
|
* Filter by generated status (true=generated, false=pending generation). Defaults to true.
|
|
3684
6086
|
*/
|
|
3685
6087
|
is_generated?: boolean | null;
|
|
3686
6088
|
/**
|
|
6089
|
+
* Created At From
|
|
6090
|
+
*
|
|
3687
6091
|
* Filter trajectories created at or after this ISO timestamp (UTC)
|
|
3688
6092
|
*/
|
|
3689
6093
|
created_at_from?: string | null;
|
|
3690
6094
|
/**
|
|
6095
|
+
* Created At To
|
|
6096
|
+
*
|
|
3691
6097
|
* Filter trajectories created at or before this ISO timestamp (UTC)
|
|
3692
6098
|
*/
|
|
3693
6099
|
created_at_to?: string | null;
|
|
3694
6100
|
/**
|
|
6101
|
+
* Updated At From
|
|
6102
|
+
*
|
|
3695
6103
|
* Filter trajectories updated at or after this ISO timestamp (UTC)
|
|
3696
6104
|
*/
|
|
3697
6105
|
updated_at_from?: string | null;
|
|
3698
6106
|
/**
|
|
6107
|
+
* Updated At To
|
|
6108
|
+
*
|
|
3699
6109
|
* Filter trajectories updated at or before this ISO timestamp (UTC)
|
|
3700
6110
|
*/
|
|
3701
6111
|
updated_at_to?: string | null;
|
|
3702
6112
|
/**
|
|
6113
|
+
* Include
|
|
6114
|
+
*
|
|
3703
6115
|
* Comma-separated list of related resources to include. Allowed values: workflow. Example: include=workflow
|
|
3704
6116
|
*/
|
|
3705
6117
|
include?: string | null;
|
|
6118
|
+
/**
|
|
6119
|
+
* Skip
|
|
6120
|
+
*/
|
|
3706
6121
|
skip?: number;
|
|
6122
|
+
/**
|
|
6123
|
+
* Limit
|
|
6124
|
+
*/
|
|
3707
6125
|
limit?: number;
|
|
3708
6126
|
};
|
|
3709
6127
|
url: '/v1/trajectories';
|
|
@@ -3757,6 +6175,9 @@ export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteData = {
|
|
|
3757
6175
|
'Idempotency-Key'?: string;
|
|
3758
6176
|
};
|
|
3759
6177
|
path: {
|
|
6178
|
+
/**
|
|
6179
|
+
* Trajectory Id
|
|
6180
|
+
*/
|
|
3760
6181
|
trajectory_id: string;
|
|
3761
6182
|
};
|
|
3762
6183
|
query?: never;
|
|
@@ -3779,10 +6200,15 @@ export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteResponse = DeleteTra
|
|
|
3779
6200
|
export type GetTrajectoryV1TrajectoriesTrajectoryIdGetData = {
|
|
3780
6201
|
body?: never;
|
|
3781
6202
|
path: {
|
|
6203
|
+
/**
|
|
6204
|
+
* Trajectory Id
|
|
6205
|
+
*/
|
|
3782
6206
|
trajectory_id: string;
|
|
3783
6207
|
};
|
|
3784
6208
|
query?: {
|
|
3785
6209
|
/**
|
|
6210
|
+
* Include
|
|
6211
|
+
*
|
|
3786
6212
|
* Comma-separated list of related resources to include. Allowed values: workflow. Example: include=workflow
|
|
3787
6213
|
*/
|
|
3788
6214
|
include?: string | null;
|
|
@@ -3812,6 +6238,9 @@ export type UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchData = {
|
|
|
3812
6238
|
'Idempotency-Key'?: string;
|
|
3813
6239
|
};
|
|
3814
6240
|
path: {
|
|
6241
|
+
/**
|
|
6242
|
+
* Trajectory Id
|
|
6243
|
+
*/
|
|
3815
6244
|
trajectory_id: string;
|
|
3816
6245
|
};
|
|
3817
6246
|
query?: never;
|
|
@@ -3840,6 +6269,9 @@ export type DuplicateTrajectoryV1TrajectoriesTrajectoryIdDuplicatePostData = {
|
|
|
3840
6269
|
'Idempotency-Key'?: string;
|
|
3841
6270
|
};
|
|
3842
6271
|
path: {
|
|
6272
|
+
/**
|
|
6273
|
+
* Trajectory Id
|
|
6274
|
+
*/
|
|
3843
6275
|
trajectory_id: string;
|
|
3844
6276
|
};
|
|
3845
6277
|
query?: never;
|
|
@@ -3862,6 +6294,9 @@ export type DuplicateTrajectoryV1TrajectoriesTrajectoryIdDuplicatePostResponse =
|
|
|
3862
6294
|
export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetData = {
|
|
3863
6295
|
body?: never;
|
|
3864
6296
|
path: {
|
|
6297
|
+
/**
|
|
6298
|
+
* Workflow Id
|
|
6299
|
+
*/
|
|
3865
6300
|
workflow_id: string;
|
|
3866
6301
|
};
|
|
3867
6302
|
query?: never;
|
|
@@ -3884,6 +6319,9 @@ export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryG
|
|
|
3884
6319
|
export type GetScreenshotV1ComputerMachineIdDisplayScreenshotGetData = {
|
|
3885
6320
|
body?: never;
|
|
3886
6321
|
path: {
|
|
6322
|
+
/**
|
|
6323
|
+
* Machine Id
|
|
6324
|
+
*/
|
|
3887
6325
|
machine_id: string;
|
|
3888
6326
|
};
|
|
3889
6327
|
query?: never;
|
|
@@ -3905,6 +6343,9 @@ export type GetScreenshotV1ComputerMachineIdDisplayScreenshotGetResponses = {
|
|
|
3905
6343
|
export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetData = {
|
|
3906
6344
|
body?: never;
|
|
3907
6345
|
path: {
|
|
6346
|
+
/**
|
|
6347
|
+
* Machine Id
|
|
6348
|
+
*/
|
|
3908
6349
|
machine_id: string;
|
|
3909
6350
|
};
|
|
3910
6351
|
query?: never;
|
|
@@ -3924,64 +6365,6 @@ export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetResponses
|
|
|
3924
6365
|
200: DisplayDimensions;
|
|
3925
6366
|
};
|
|
3926
6367
|
export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetResponse = GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetResponses[keyof GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetResponses];
|
|
3927
|
-
export type CreateAdHocComputerTaskV1ComputerMachineIdTaskPostData = {
|
|
3928
|
-
body: string | ComputerTaskObjectRequest;
|
|
3929
|
-
headers?: {
|
|
3930
|
-
/**
|
|
3931
|
-
* Unique key for idempotent requests. If provided, the server ensures the request is processed at most once. Retries with the same key return the original response. SDKs auto-generate this for write requests.
|
|
3932
|
-
*/
|
|
3933
|
-
'Idempotency-Key'?: string;
|
|
3934
|
-
};
|
|
3935
|
-
path: {
|
|
3936
|
-
machine_id: string;
|
|
3937
|
-
};
|
|
3938
|
-
query?: never;
|
|
3939
|
-
url: '/v1/computer/{machine_id}/task';
|
|
3940
|
-
};
|
|
3941
|
-
export type CreateAdHocComputerTaskV1ComputerMachineIdTaskPostErrors = {
|
|
3942
|
-
/**
|
|
3943
|
-
* Validation Error
|
|
3944
|
-
*/
|
|
3945
|
-
422: HttpValidationError;
|
|
3946
|
-
};
|
|
3947
|
-
export type CreateAdHocComputerTaskV1ComputerMachineIdTaskPostError = CreateAdHocComputerTaskV1ComputerMachineIdTaskPostErrors[keyof CreateAdHocComputerTaskV1ComputerMachineIdTaskPostErrors];
|
|
3948
|
-
export type CreateAdHocComputerTaskV1ComputerMachineIdTaskPostResponses = {
|
|
3949
|
-
/**
|
|
3950
|
-
* Successful Response
|
|
3951
|
-
*/
|
|
3952
|
-
202: ComputerTaskAcceptedResponse;
|
|
3953
|
-
};
|
|
3954
|
-
export type CreateAdHocComputerTaskV1ComputerMachineIdTaskPostResponse = CreateAdHocComputerTaskV1ComputerMachineIdTaskPostResponses[keyof CreateAdHocComputerTaskV1ComputerMachineIdTaskPostResponses];
|
|
3955
|
-
export type NotifyTaskDoneV1ComputerMachineIdTaskDonePostData = {
|
|
3956
|
-
body?: never;
|
|
3957
|
-
headers?: {
|
|
3958
|
-
/**
|
|
3959
|
-
* Unique key for idempotent requests. If provided, the server ensures the request is processed at most once. Retries with the same key return the original response. SDKs auto-generate this for write requests.
|
|
3960
|
-
*/
|
|
3961
|
-
'Idempotency-Key'?: string;
|
|
3962
|
-
};
|
|
3963
|
-
path: {
|
|
3964
|
-
machine_id: string;
|
|
3965
|
-
};
|
|
3966
|
-
query?: never;
|
|
3967
|
-
url: '/v1/computer/{machine_id}/task-done';
|
|
3968
|
-
};
|
|
3969
|
-
export type NotifyTaskDoneV1ComputerMachineIdTaskDonePostErrors = {
|
|
3970
|
-
/**
|
|
3971
|
-
* Validation Error
|
|
3972
|
-
*/
|
|
3973
|
-
422: HttpValidationError;
|
|
3974
|
-
};
|
|
3975
|
-
export type NotifyTaskDoneV1ComputerMachineIdTaskDonePostError = NotifyTaskDoneV1ComputerMachineIdTaskDonePostErrors[keyof NotifyTaskDoneV1ComputerMachineIdTaskDonePostErrors];
|
|
3976
|
-
export type NotifyTaskDoneV1ComputerMachineIdTaskDonePostResponses = {
|
|
3977
|
-
/**
|
|
3978
|
-
* Successful Response
|
|
3979
|
-
*/
|
|
3980
|
-
200: {
|
|
3981
|
-
[key: string]: unknown;
|
|
3982
|
-
};
|
|
3983
|
-
};
|
|
3984
|
-
export type NotifyTaskDoneV1ComputerMachineIdTaskDonePostResponse = NotifyTaskDoneV1ComputerMachineIdTaskDonePostResponses[keyof NotifyTaskDoneV1ComputerMachineIdTaskDonePostResponses];
|
|
3985
6368
|
export type KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostData = {
|
|
3986
6369
|
body: KeyboardTypeRequest;
|
|
3987
6370
|
headers?: {
|
|
@@ -3991,6 +6374,9 @@ export type KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostData = {
|
|
|
3991
6374
|
'Idempotency-Key'?: string;
|
|
3992
6375
|
};
|
|
3993
6376
|
path: {
|
|
6377
|
+
/**
|
|
6378
|
+
* Machine Id
|
|
6379
|
+
*/
|
|
3994
6380
|
machine_id: string;
|
|
3995
6381
|
};
|
|
3996
6382
|
query?: never;
|
|
@@ -4019,6 +6405,9 @@ export type KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostData = {
|
|
|
4019
6405
|
'Idempotency-Key'?: string;
|
|
4020
6406
|
};
|
|
4021
6407
|
path: {
|
|
6408
|
+
/**
|
|
6409
|
+
* Machine Id
|
|
6410
|
+
*/
|
|
4022
6411
|
machine_id: string;
|
|
4023
6412
|
};
|
|
4024
6413
|
query?: never;
|
|
@@ -4047,6 +6436,9 @@ export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostData = {
|
|
|
4047
6436
|
'Idempotency-Key'?: string;
|
|
4048
6437
|
};
|
|
4049
6438
|
path: {
|
|
6439
|
+
/**
|
|
6440
|
+
* Machine Id
|
|
6441
|
+
*/
|
|
4050
6442
|
machine_id: string;
|
|
4051
6443
|
};
|
|
4052
6444
|
query?: never;
|
|
@@ -4061,6 +6453,8 @@ export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostErrors = {
|
|
|
4061
6453
|
export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostError = CopyToClipboardV1ComputerMachineIdCopyToClipboardPostErrors[keyof CopyToClipboardV1ComputerMachineIdCopyToClipboardPostErrors];
|
|
4062
6454
|
export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostResponses = {
|
|
4063
6455
|
/**
|
|
6456
|
+
* Response Copy To Clipboard V1 Computer Machine Id Copy To Clipboard Post
|
|
6457
|
+
*
|
|
4064
6458
|
* Successful Response
|
|
4065
6459
|
*/
|
|
4066
6460
|
200: {
|
|
@@ -4071,6 +6465,9 @@ export type CopyToClipboardV1ComputerMachineIdCopyToClipboardPostResponse = Copy
|
|
|
4071
6465
|
export type GetMousePositionV1ComputerMachineIdInputMousePositionGetData = {
|
|
4072
6466
|
body?: never;
|
|
4073
6467
|
path: {
|
|
6468
|
+
/**
|
|
6469
|
+
* Machine Id
|
|
6470
|
+
*/
|
|
4074
6471
|
machine_id: string;
|
|
4075
6472
|
};
|
|
4076
6473
|
query?: never;
|
|
@@ -4099,6 +6496,9 @@ export type MouseMoveV1ComputerMachineIdInputMouseMovePostData = {
|
|
|
4099
6496
|
'Idempotency-Key'?: string;
|
|
4100
6497
|
};
|
|
4101
6498
|
path: {
|
|
6499
|
+
/**
|
|
6500
|
+
* Machine Id
|
|
6501
|
+
*/
|
|
4102
6502
|
machine_id: string;
|
|
4103
6503
|
};
|
|
4104
6504
|
query?: never;
|
|
@@ -4127,6 +6527,9 @@ export type MouseClickV1ComputerMachineIdInputMouseClickPostData = {
|
|
|
4127
6527
|
'Idempotency-Key'?: string;
|
|
4128
6528
|
};
|
|
4129
6529
|
path: {
|
|
6530
|
+
/**
|
|
6531
|
+
* Machine Id
|
|
6532
|
+
*/
|
|
4130
6533
|
machine_id: string;
|
|
4131
6534
|
};
|
|
4132
6535
|
query?: never;
|
|
@@ -4155,6 +6558,9 @@ export type MouseScrollV1ComputerMachineIdInputMouseScrollPostData = {
|
|
|
4155
6558
|
'Idempotency-Key'?: string;
|
|
4156
6559
|
};
|
|
4157
6560
|
path: {
|
|
6561
|
+
/**
|
|
6562
|
+
* Machine Id
|
|
6563
|
+
*/
|
|
4158
6564
|
machine_id: string;
|
|
4159
6565
|
};
|
|
4160
6566
|
query?: never;
|
|
@@ -4183,6 +6589,9 @@ export type MouseDragV1ComputerMachineIdInputMouseDragPostData = {
|
|
|
4183
6589
|
'Idempotency-Key'?: string;
|
|
4184
6590
|
};
|
|
4185
6591
|
path: {
|
|
6592
|
+
/**
|
|
6593
|
+
* Machine Id
|
|
6594
|
+
*/
|
|
4186
6595
|
machine_id: string;
|
|
4187
6596
|
};
|
|
4188
6597
|
query?: never;
|
|
@@ -4205,9 +6614,15 @@ export type MouseDragV1ComputerMachineIdInputMouseDragPostResponse = MouseDragV1
|
|
|
4205
6614
|
export type FsListV1ComputerMachineIdFsListGetData = {
|
|
4206
6615
|
body?: never;
|
|
4207
6616
|
path: {
|
|
6617
|
+
/**
|
|
6618
|
+
* Machine Id
|
|
6619
|
+
*/
|
|
4208
6620
|
machine_id: string;
|
|
4209
6621
|
};
|
|
4210
6622
|
query?: {
|
|
6623
|
+
/**
|
|
6624
|
+
* Path
|
|
6625
|
+
*/
|
|
4211
6626
|
path?: string;
|
|
4212
6627
|
};
|
|
4213
6628
|
url: '/v1/computer/{machine_id}/fs/list';
|
|
@@ -4221,6 +6636,8 @@ export type FsListV1ComputerMachineIdFsListGetErrors = {
|
|
|
4221
6636
|
export type FsListV1ComputerMachineIdFsListGetError = FsListV1ComputerMachineIdFsListGetErrors[keyof FsListV1ComputerMachineIdFsListGetErrors];
|
|
4222
6637
|
export type FsListV1ComputerMachineIdFsListGetResponses = {
|
|
4223
6638
|
/**
|
|
6639
|
+
* Response Fs List V1 Computer Machine Id Fs List Get
|
|
6640
|
+
*
|
|
4224
6641
|
* Successful Response
|
|
4225
6642
|
*/
|
|
4226
6643
|
200: {
|
|
@@ -4231,9 +6648,15 @@ export type FsListV1ComputerMachineIdFsListGetResponse = FsListV1ComputerMachine
|
|
|
4231
6648
|
export type FsReadV1ComputerMachineIdFsReadGetData = {
|
|
4232
6649
|
body?: never;
|
|
4233
6650
|
path: {
|
|
6651
|
+
/**
|
|
6652
|
+
* Machine Id
|
|
6653
|
+
*/
|
|
4234
6654
|
machine_id: string;
|
|
4235
6655
|
};
|
|
4236
6656
|
query: {
|
|
6657
|
+
/**
|
|
6658
|
+
* Path
|
|
6659
|
+
*/
|
|
4237
6660
|
path: string;
|
|
4238
6661
|
};
|
|
4239
6662
|
url: '/v1/computer/{machine_id}/fs/read';
|
|
@@ -4247,6 +6670,8 @@ export type FsReadV1ComputerMachineIdFsReadGetErrors = {
|
|
|
4247
6670
|
export type FsReadV1ComputerMachineIdFsReadGetError = FsReadV1ComputerMachineIdFsReadGetErrors[keyof FsReadV1ComputerMachineIdFsReadGetErrors];
|
|
4248
6671
|
export type FsReadV1ComputerMachineIdFsReadGetResponses = {
|
|
4249
6672
|
/**
|
|
6673
|
+
* Response Fs Read V1 Computer Machine Id Fs Read Get
|
|
6674
|
+
*
|
|
4250
6675
|
* Successful Response
|
|
4251
6676
|
*/
|
|
4252
6677
|
200: {
|
|
@@ -4263,6 +6688,9 @@ export type FsWriteV1ComputerMachineIdFsWritePostData = {
|
|
|
4263
6688
|
'Idempotency-Key'?: string;
|
|
4264
6689
|
};
|
|
4265
6690
|
path: {
|
|
6691
|
+
/**
|
|
6692
|
+
* Machine Id
|
|
6693
|
+
*/
|
|
4266
6694
|
machine_id: string;
|
|
4267
6695
|
};
|
|
4268
6696
|
query?: never;
|
|
@@ -4277,6 +6705,8 @@ export type FsWriteV1ComputerMachineIdFsWritePostErrors = {
|
|
|
4277
6705
|
export type FsWriteV1ComputerMachineIdFsWritePostError = FsWriteV1ComputerMachineIdFsWritePostErrors[keyof FsWriteV1ComputerMachineIdFsWritePostErrors];
|
|
4278
6706
|
export type FsWriteV1ComputerMachineIdFsWritePostResponses = {
|
|
4279
6707
|
/**
|
|
6708
|
+
* Response Fs Write V1 Computer Machine Id Fs Write Post
|
|
6709
|
+
*
|
|
4280
6710
|
* Successful Response
|
|
4281
6711
|
*/
|
|
4282
6712
|
200: {
|
|
@@ -4293,6 +6723,9 @@ export type PowershellExecV1ComputerMachineIdShellPowershellExecPostData = {
|
|
|
4293
6723
|
'Idempotency-Key'?: string;
|
|
4294
6724
|
};
|
|
4295
6725
|
path: {
|
|
6726
|
+
/**
|
|
6727
|
+
* Machine Id
|
|
6728
|
+
*/
|
|
4296
6729
|
machine_id: string;
|
|
4297
6730
|
};
|
|
4298
6731
|
query?: never;
|
|
@@ -4307,6 +6740,8 @@ export type PowershellExecV1ComputerMachineIdShellPowershellExecPostErrors = {
|
|
|
4307
6740
|
export type PowershellExecV1ComputerMachineIdShellPowershellExecPostError = PowershellExecV1ComputerMachineIdShellPowershellExecPostErrors[keyof PowershellExecV1ComputerMachineIdShellPowershellExecPostErrors];
|
|
4308
6741
|
export type PowershellExecV1ComputerMachineIdShellPowershellExecPostResponses = {
|
|
4309
6742
|
/**
|
|
6743
|
+
* Response Powershell Exec V1 Computer Machine Id Shell Powershell Exec Post
|
|
6744
|
+
*
|
|
4310
6745
|
* Successful Response
|
|
4311
6746
|
*/
|
|
4312
6747
|
200: {
|
|
@@ -4323,6 +6758,9 @@ export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostData =
|
|
|
4323
6758
|
'Idempotency-Key'?: string;
|
|
4324
6759
|
};
|
|
4325
6760
|
path: {
|
|
6761
|
+
/**
|
|
6762
|
+
* Machine Id
|
|
6763
|
+
*/
|
|
4326
6764
|
machine_id: string;
|
|
4327
6765
|
};
|
|
4328
6766
|
query?: never;
|
|
@@ -4337,6 +6775,8 @@ export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostErrors
|
|
|
4337
6775
|
export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostError = PowershellSessionV1ComputerMachineIdShellPowershellSessionPostErrors[keyof PowershellSessionV1ComputerMachineIdShellPowershellSessionPostErrors];
|
|
4338
6776
|
export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostResponses = {
|
|
4339
6777
|
/**
|
|
6778
|
+
* Response Powershell Session V1 Computer Machine Id Shell Powershell Session Post
|
|
6779
|
+
*
|
|
4340
6780
|
* Successful Response
|
|
4341
6781
|
*/
|
|
4342
6782
|
200: {
|
|
@@ -4345,6 +6785,9 @@ export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostRespon
|
|
|
4345
6785
|
};
|
|
4346
6786
|
export type PowershellSessionV1ComputerMachineIdShellPowershellSessionPostResponse = PowershellSessionV1ComputerMachineIdShellPowershellSessionPostResponses[keyof PowershellSessionV1ComputerMachineIdShellPowershellSessionPostResponses];
|
|
4347
6787
|
export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostData = {
|
|
6788
|
+
/**
|
|
6789
|
+
* Request
|
|
6790
|
+
*/
|
|
4348
6791
|
body?: CyberdriverShutdownRequest | null;
|
|
4349
6792
|
headers?: {
|
|
4350
6793
|
/**
|
|
@@ -4353,6 +6796,9 @@ export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostData =
|
|
|
4353
6796
|
'Idempotency-Key'?: string;
|
|
4354
6797
|
};
|
|
4355
6798
|
path: {
|
|
6799
|
+
/**
|
|
6800
|
+
* Machine Id
|
|
6801
|
+
*/
|
|
4356
6802
|
machine_id: string;
|
|
4357
6803
|
};
|
|
4358
6804
|
query?: never;
|
|
@@ -4371,6 +6817,8 @@ export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostErrors
|
|
|
4371
6817
|
export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostError = CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostErrors[keyof CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostErrors];
|
|
4372
6818
|
export type CyberdriverShutdownV1MachinesMachineIdCyberdriverShutdownPostResponses = {
|
|
4373
6819
|
/**
|
|
6820
|
+
* Response Cyberdriver Shutdown V1 Machines Machine Id Cyberdriver Shutdown Post
|
|
6821
|
+
*
|
|
4374
6822
|
* Shutdown was accepted by CyberDriver
|
|
4375
6823
|
*/
|
|
4376
6824
|
200: {
|
|
@@ -4383,10 +6831,14 @@ export type GetUsageAggregateV1UsageAggregateGetData = {
|
|
|
4383
6831
|
path?: never;
|
|
4384
6832
|
query: {
|
|
4385
6833
|
/**
|
|
6834
|
+
* From Date
|
|
6835
|
+
*
|
|
4386
6836
|
* Start of period (inclusive, ISO format)
|
|
4387
6837
|
*/
|
|
4388
6838
|
from_date: string;
|
|
4389
6839
|
/**
|
|
6840
|
+
* To Date
|
|
6841
|
+
*
|
|
4390
6842
|
* End of period (exclusive, ISO format)
|
|
4391
6843
|
*/
|
|
4392
6844
|
to_date: string;
|
|
@@ -4491,6 +6943,10 @@ export type HealthMachinesV1HealthMachinesGetResponses = {
|
|
|
4491
6943
|
200: MachinesHealthCheckResponse;
|
|
4492
6944
|
};
|
|
4493
6945
|
export type HealthMachinesV1HealthMachinesGetResponse = HealthMachinesV1HealthMachinesGetResponses[keyof HealthMachinesV1HealthMachinesGetResponses];
|
|
4494
|
-
export type
|
|
4495
|
-
|
|
6946
|
+
export type RunCompleteWebhookrunCompletePostWebhookPayload = RunCompletedEvent;
|
|
6947
|
+
export type RunCompleteWebhookrunCompletePostWebhookRequest = {
|
|
6948
|
+
body: RunCompleteWebhookrunCompletePostWebhookPayload;
|
|
6949
|
+
key: 'run_complete';
|
|
6950
|
+
path?: never;
|
|
6951
|
+
query?: never;
|
|
4496
6952
|
};
|