langgraph-api 0.2.28__py3-none-any.whl → 0.2.29__py3-none-any.whl
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.
Potentially problematic release.
This version of langgraph-api might be problematic. Click here for more details.
- langgraph_api/__init__.py +1 -1
- {langgraph_api-0.2.28.dist-info → langgraph_api-0.2.29.dist-info}/METADATA +1 -1
- {langgraph_api-0.2.28.dist-info → langgraph_api-0.2.29.dist-info}/RECORD +9 -6
- langgraph_api-0.2.29.dist-info/licenses/LICENSE +93 -0
- logging.json +22 -0
- openapi.json +4562 -0
- /langgraph_api-0.2.28.dist-info/licenses/LICENSE → /LICENSE +0 -0
- {langgraph_api-0.2.28.dist-info → langgraph_api-0.2.29.dist-info}/WHEEL +0 -0
- {langgraph_api-0.2.28.dist-info → langgraph_api-0.2.29.dist-info}/entry_points.txt +0 -0
openapi.json
ADDED
|
@@ -0,0 +1,4562 @@
|
|
|
1
|
+
{
|
|
2
|
+
"openapi": "3.1.0",
|
|
3
|
+
"info": {
|
|
4
|
+
"title": "LangGraph Platform",
|
|
5
|
+
"version": "0.1.0"
|
|
6
|
+
},
|
|
7
|
+
"tags": [
|
|
8
|
+
{
|
|
9
|
+
"name": "Assistants",
|
|
10
|
+
"description": "An assistant is a configured instance of a graph."
|
|
11
|
+
},
|
|
12
|
+
{
|
|
13
|
+
"name": "Threads",
|
|
14
|
+
"description": "A thread contains the accumulated outputs of a group of runs."
|
|
15
|
+
},
|
|
16
|
+
{
|
|
17
|
+
"name": "Thread Runs",
|
|
18
|
+
"description": "A run is an invocation of a graph / assistant on a thread. It updates the state of the thread."
|
|
19
|
+
},
|
|
20
|
+
{
|
|
21
|
+
"name": "Stateless Runs",
|
|
22
|
+
"description": "A run is an invocation of a graph / assistant, with no state or memory persistence."
|
|
23
|
+
},
|
|
24
|
+
{
|
|
25
|
+
"name": "Crons (Plus tier)",
|
|
26
|
+
"description": "A cron is a periodic run that recurs on a given schedule. The repeats can be isolated, or share state in a thread"
|
|
27
|
+
},
|
|
28
|
+
{
|
|
29
|
+
"name": "Store",
|
|
30
|
+
"description": "Store is an API for managing persistent key-value store (long-term memory) that is available from any thread."
|
|
31
|
+
}
|
|
32
|
+
],
|
|
33
|
+
"paths": {
|
|
34
|
+
"/assistants": {
|
|
35
|
+
"post": {
|
|
36
|
+
"tags": ["Assistants"],
|
|
37
|
+
"summary": "Create Assistant",
|
|
38
|
+
"description": "Create an assistant.\n\nAn initial version of the assistant will be created and the assistant is set to that version. To change versions, use the `POST /assistants/{assistant_id}/latest` endpoint.",
|
|
39
|
+
"operationId": "create_assistant_assistants_post",
|
|
40
|
+
"requestBody": {
|
|
41
|
+
"content": {
|
|
42
|
+
"application/json": {
|
|
43
|
+
"schema": {
|
|
44
|
+
"$ref": "#/components/schemas/AssistantCreate"
|
|
45
|
+
}
|
|
46
|
+
}
|
|
47
|
+
},
|
|
48
|
+
"required": true
|
|
49
|
+
},
|
|
50
|
+
"responses": {
|
|
51
|
+
"200": {
|
|
52
|
+
"description": "Success",
|
|
53
|
+
"content": {
|
|
54
|
+
"application/json": {
|
|
55
|
+
"schema": {
|
|
56
|
+
"$ref": "#/components/schemas/Assistant"
|
|
57
|
+
}
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
},
|
|
61
|
+
"404": {
|
|
62
|
+
"description": "Not Found",
|
|
63
|
+
"content": {
|
|
64
|
+
"application/json": {
|
|
65
|
+
"schema": {
|
|
66
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
67
|
+
}
|
|
68
|
+
}
|
|
69
|
+
}
|
|
70
|
+
},
|
|
71
|
+
"409": {
|
|
72
|
+
"description": "Conflict",
|
|
73
|
+
"content": {
|
|
74
|
+
"application/json": {
|
|
75
|
+
"schema": {
|
|
76
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
},
|
|
81
|
+
"422": {
|
|
82
|
+
"description": "Validation Error",
|
|
83
|
+
"content": {
|
|
84
|
+
"application/json": {
|
|
85
|
+
"schema": {
|
|
86
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
}
|
|
93
|
+
},
|
|
94
|
+
"/assistants/search": {
|
|
95
|
+
"post": {
|
|
96
|
+
"tags": ["Assistants"],
|
|
97
|
+
"summary": "Search Assistants",
|
|
98
|
+
"description": "Search for assistants.\n\nThis endpoint also functions as the endpoint to list all assistants.",
|
|
99
|
+
"operationId": "search_assistants_assistants_search_post",
|
|
100
|
+
"requestBody": {
|
|
101
|
+
"content": {
|
|
102
|
+
"application/json": {
|
|
103
|
+
"schema": {
|
|
104
|
+
"$ref": "#/components/schemas/AssistantSearchRequest"
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
},
|
|
108
|
+
"required": true
|
|
109
|
+
},
|
|
110
|
+
"responses": {
|
|
111
|
+
"200": {
|
|
112
|
+
"description": "Success",
|
|
113
|
+
"content": {
|
|
114
|
+
"application/json": {
|
|
115
|
+
"schema": {
|
|
116
|
+
"items": {
|
|
117
|
+
"$ref": "#/components/schemas/Assistant"
|
|
118
|
+
},
|
|
119
|
+
"type": "array",
|
|
120
|
+
"title": "Response Search Assistants Assistants Search Post"
|
|
121
|
+
}
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
},
|
|
125
|
+
"404": {
|
|
126
|
+
"description": "Not Found",
|
|
127
|
+
"content": {
|
|
128
|
+
"application/json": {
|
|
129
|
+
"schema": {
|
|
130
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
131
|
+
}
|
|
132
|
+
}
|
|
133
|
+
}
|
|
134
|
+
},
|
|
135
|
+
"422": {
|
|
136
|
+
"description": "Validation Error",
|
|
137
|
+
"content": {
|
|
138
|
+
"application/json": {
|
|
139
|
+
"schema": {
|
|
140
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
141
|
+
}
|
|
142
|
+
}
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
},
|
|
148
|
+
"/assistants/{assistant_id}": {
|
|
149
|
+
"get": {
|
|
150
|
+
"tags": ["Assistants"],
|
|
151
|
+
"summary": "Get Assistant",
|
|
152
|
+
"description": "Get an assistant by ID.",
|
|
153
|
+
"operationId": "get_assistant_assistants__assistant_id__get",
|
|
154
|
+
"parameters": [
|
|
155
|
+
{
|
|
156
|
+
"description": "The ID of the assistant.",
|
|
157
|
+
"required": true,
|
|
158
|
+
"schema": {
|
|
159
|
+
"type": "string",
|
|
160
|
+
"format": "uuid",
|
|
161
|
+
"title": "Assistant ID",
|
|
162
|
+
"description": "The ID of the assistant."
|
|
163
|
+
},
|
|
164
|
+
"name": "assistant_id",
|
|
165
|
+
"in": "path"
|
|
166
|
+
}
|
|
167
|
+
],
|
|
168
|
+
"responses": {
|
|
169
|
+
"200": {
|
|
170
|
+
"description": "Success",
|
|
171
|
+
"content": {
|
|
172
|
+
"application/json": {
|
|
173
|
+
"schema": {
|
|
174
|
+
"$ref": "#/components/schemas/Assistant"
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
}
|
|
178
|
+
},
|
|
179
|
+
"404": {
|
|
180
|
+
"description": "Not Found",
|
|
181
|
+
"content": {
|
|
182
|
+
"application/json": {
|
|
183
|
+
"schema": {
|
|
184
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
185
|
+
}
|
|
186
|
+
}
|
|
187
|
+
}
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
},
|
|
191
|
+
"delete": {
|
|
192
|
+
"tags": ["Assistants"],
|
|
193
|
+
"summary": "Delete Assistant",
|
|
194
|
+
"description": "Delete an assistant by ID.\n\nAll versions of the assistant will be deleted as well.",
|
|
195
|
+
"operationId": "delete_assistant_assistants__assistant_id__delete",
|
|
196
|
+
"parameters": [
|
|
197
|
+
{
|
|
198
|
+
"description": "The ID of the assistant.",
|
|
199
|
+
"required": true,
|
|
200
|
+
"schema": {
|
|
201
|
+
"type": "string",
|
|
202
|
+
"format": "uuid",
|
|
203
|
+
"title": "Assistant ID",
|
|
204
|
+
"description": "The ID of the assistant."
|
|
205
|
+
},
|
|
206
|
+
"name": "assistant_id",
|
|
207
|
+
"in": "path"
|
|
208
|
+
}
|
|
209
|
+
],
|
|
210
|
+
"responses": {
|
|
211
|
+
"200": {
|
|
212
|
+
"description": "Success",
|
|
213
|
+
"content": {
|
|
214
|
+
"application/json": {
|
|
215
|
+
"schema": {}
|
|
216
|
+
}
|
|
217
|
+
}
|
|
218
|
+
},
|
|
219
|
+
"404": {
|
|
220
|
+
"description": "Not Found",
|
|
221
|
+
"content": {
|
|
222
|
+
"application/json": {
|
|
223
|
+
"schema": {
|
|
224
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
225
|
+
}
|
|
226
|
+
}
|
|
227
|
+
}
|
|
228
|
+
},
|
|
229
|
+
"422": {
|
|
230
|
+
"description": "Validation Error",
|
|
231
|
+
"content": {
|
|
232
|
+
"application/json": {
|
|
233
|
+
"schema": {
|
|
234
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
235
|
+
}
|
|
236
|
+
}
|
|
237
|
+
}
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
},
|
|
241
|
+
"patch": {
|
|
242
|
+
"tags": ["Assistants"],
|
|
243
|
+
"summary": "Patch Assistant",
|
|
244
|
+
"description": "Update an assistant.",
|
|
245
|
+
"operationId": "patch_assistant_assistants__assistant_id__patch",
|
|
246
|
+
"parameters": [
|
|
247
|
+
{
|
|
248
|
+
"description": "The ID of the assistant.",
|
|
249
|
+
"required": true,
|
|
250
|
+
"schema": {
|
|
251
|
+
"type": "string",
|
|
252
|
+
"format": "uuid",
|
|
253
|
+
"title": "Assistant ID",
|
|
254
|
+
"description": "The ID of the assistant."
|
|
255
|
+
},
|
|
256
|
+
"name": "assistant_id",
|
|
257
|
+
"in": "path"
|
|
258
|
+
}
|
|
259
|
+
],
|
|
260
|
+
"requestBody": {
|
|
261
|
+
"content": {
|
|
262
|
+
"application/json": {
|
|
263
|
+
"schema": {
|
|
264
|
+
"$ref": "#/components/schemas/AssistantPatch"
|
|
265
|
+
}
|
|
266
|
+
}
|
|
267
|
+
},
|
|
268
|
+
"required": true
|
|
269
|
+
},
|
|
270
|
+
"responses": {
|
|
271
|
+
"200": {
|
|
272
|
+
"description": "Success",
|
|
273
|
+
"content": {
|
|
274
|
+
"application/json": {
|
|
275
|
+
"schema": {
|
|
276
|
+
"$ref": "#/components/schemas/Assistant"
|
|
277
|
+
}
|
|
278
|
+
}
|
|
279
|
+
}
|
|
280
|
+
},
|
|
281
|
+
"404": {
|
|
282
|
+
"description": "Not Found",
|
|
283
|
+
"content": {
|
|
284
|
+
"application/json": {
|
|
285
|
+
"schema": {
|
|
286
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
}
|
|
290
|
+
},
|
|
291
|
+
"422": {
|
|
292
|
+
"description": "Validation Error",
|
|
293
|
+
"content": {
|
|
294
|
+
"application/json": {
|
|
295
|
+
"schema": {
|
|
296
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
297
|
+
}
|
|
298
|
+
}
|
|
299
|
+
}
|
|
300
|
+
}
|
|
301
|
+
}
|
|
302
|
+
}
|
|
303
|
+
},
|
|
304
|
+
"/assistants/{assistant_id}/graph": {
|
|
305
|
+
"get": {
|
|
306
|
+
"tags": ["Assistants"],
|
|
307
|
+
"summary": "Get Assistant Graph",
|
|
308
|
+
"description": "Get an assistant by ID.",
|
|
309
|
+
"operationId": "get_assistant_graph_assistants__assistant_id__graph_get",
|
|
310
|
+
"parameters": [
|
|
311
|
+
{
|
|
312
|
+
"description": "The ID of the assistant.",
|
|
313
|
+
"required": true,
|
|
314
|
+
"schema": {
|
|
315
|
+
"anyOf": [
|
|
316
|
+
{
|
|
317
|
+
"type": "string",
|
|
318
|
+
"format": "uuid",
|
|
319
|
+
"title": "Assistant ID",
|
|
320
|
+
"description": "The ID of the assistant."
|
|
321
|
+
},
|
|
322
|
+
{
|
|
323
|
+
"type": "string",
|
|
324
|
+
"title": "Graph ID",
|
|
325
|
+
"description": "The ID of the graph."
|
|
326
|
+
}
|
|
327
|
+
]
|
|
328
|
+
},
|
|
329
|
+
"name": "assistant_id",
|
|
330
|
+
"in": "path"
|
|
331
|
+
},
|
|
332
|
+
{
|
|
333
|
+
"description": "Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included.",
|
|
334
|
+
"required": false,
|
|
335
|
+
"schema": {
|
|
336
|
+
"oneOf": [
|
|
337
|
+
{
|
|
338
|
+
"type": "boolean"
|
|
339
|
+
},
|
|
340
|
+
{
|
|
341
|
+
"type": "integer"
|
|
342
|
+
}
|
|
343
|
+
],
|
|
344
|
+
"title": "Xray",
|
|
345
|
+
"default": false,
|
|
346
|
+
"description": "Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included."
|
|
347
|
+
},
|
|
348
|
+
"name": "xray",
|
|
349
|
+
"in": "query"
|
|
350
|
+
}
|
|
351
|
+
],
|
|
352
|
+
"responses": {
|
|
353
|
+
"200": {
|
|
354
|
+
"description": "Success",
|
|
355
|
+
"content": {
|
|
356
|
+
"application/json": {
|
|
357
|
+
"schema": {
|
|
358
|
+
"additionalProperties": {
|
|
359
|
+
"items": {
|
|
360
|
+
"type": "object"
|
|
361
|
+
},
|
|
362
|
+
"type": "array"
|
|
363
|
+
},
|
|
364
|
+
"type": "object",
|
|
365
|
+
"title": "Response Get Assistant Graph Assistants Assistant Id Graph Get"
|
|
366
|
+
}
|
|
367
|
+
}
|
|
368
|
+
}
|
|
369
|
+
},
|
|
370
|
+
"404": {
|
|
371
|
+
"description": "Not Found",
|
|
372
|
+
"content": {
|
|
373
|
+
"application/json": {
|
|
374
|
+
"schema": {
|
|
375
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
376
|
+
}
|
|
377
|
+
}
|
|
378
|
+
}
|
|
379
|
+
},
|
|
380
|
+
"422": {
|
|
381
|
+
"description": "Validation Error",
|
|
382
|
+
"content": {
|
|
383
|
+
"application/json": {
|
|
384
|
+
"schema": {
|
|
385
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
386
|
+
}
|
|
387
|
+
}
|
|
388
|
+
}
|
|
389
|
+
}
|
|
390
|
+
}
|
|
391
|
+
}
|
|
392
|
+
},
|
|
393
|
+
"/assistants/{assistant_id}/subgraphs": {
|
|
394
|
+
"get": {
|
|
395
|
+
"tags": ["Assistants"],
|
|
396
|
+
"summary": "Get Assistant Subgraphs",
|
|
397
|
+
"description": "Get an assistant's subgraphs.",
|
|
398
|
+
"operationId": "get_assistant_subgraphs_assistants__assistant_id__subgraphs_get",
|
|
399
|
+
"parameters": [
|
|
400
|
+
{
|
|
401
|
+
"description": "The ID of the assistant.",
|
|
402
|
+
"required": true,
|
|
403
|
+
"schema": {
|
|
404
|
+
"type": "string",
|
|
405
|
+
"format": "uuid",
|
|
406
|
+
"title": "Assistant Id"
|
|
407
|
+
},
|
|
408
|
+
"name": "assistant_id",
|
|
409
|
+
"in": "path"
|
|
410
|
+
},
|
|
411
|
+
{
|
|
412
|
+
"description": "Recursively retrieve subgraphs of subgraphs.",
|
|
413
|
+
"required": false,
|
|
414
|
+
"schema": {
|
|
415
|
+
"type": "boolean",
|
|
416
|
+
"title": "Recurse",
|
|
417
|
+
"default": false
|
|
418
|
+
},
|
|
419
|
+
"name": "recurse",
|
|
420
|
+
"in": "query"
|
|
421
|
+
}
|
|
422
|
+
],
|
|
423
|
+
"responses": {
|
|
424
|
+
"200": {
|
|
425
|
+
"description": "Success",
|
|
426
|
+
"content": {
|
|
427
|
+
"application/json": {
|
|
428
|
+
"schema": {
|
|
429
|
+
"$ref": "#/components/schemas/Subgraphs"
|
|
430
|
+
}
|
|
431
|
+
}
|
|
432
|
+
}
|
|
433
|
+
},
|
|
434
|
+
"404": {
|
|
435
|
+
"description": "Not Found",
|
|
436
|
+
"content": {
|
|
437
|
+
"application/json": {
|
|
438
|
+
"schema": {
|
|
439
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
}
|
|
443
|
+
},
|
|
444
|
+
"422": {
|
|
445
|
+
"description": "Validation Error",
|
|
446
|
+
"content": {
|
|
447
|
+
"application/json": {
|
|
448
|
+
"schema": {
|
|
449
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
}
|
|
454
|
+
}
|
|
455
|
+
}
|
|
456
|
+
},
|
|
457
|
+
"/assistants/{assistant_id}/subgraphs/{namespace}": {
|
|
458
|
+
"get": {
|
|
459
|
+
"tags": ["Assistants"],
|
|
460
|
+
"summary": "Get Assistant Subgraphs by Namespace",
|
|
461
|
+
"description": "Get an assistant's subgraphs filtered by namespace.",
|
|
462
|
+
"operationId": "get_assistant_subgraphs_assistants__assistant_id__subgraphs__namespace__get",
|
|
463
|
+
"parameters": [
|
|
464
|
+
{
|
|
465
|
+
"description": "The ID of the assistant.",
|
|
466
|
+
"required": true,
|
|
467
|
+
"schema": {
|
|
468
|
+
"type": "string",
|
|
469
|
+
"format": "uuid",
|
|
470
|
+
"title": "Assistant Id"
|
|
471
|
+
},
|
|
472
|
+
"name": "assistant_id",
|
|
473
|
+
"in": "path"
|
|
474
|
+
},
|
|
475
|
+
{
|
|
476
|
+
"description": "Namespace of the subgraph to filter by.",
|
|
477
|
+
"required": true,
|
|
478
|
+
"schema": {
|
|
479
|
+
"type": "string",
|
|
480
|
+
"title": "Namespace"
|
|
481
|
+
},
|
|
482
|
+
"name": "namespace",
|
|
483
|
+
"in": "path"
|
|
484
|
+
},
|
|
485
|
+
{
|
|
486
|
+
"description": "Recursively retrieve subgraphs of subgraphs.",
|
|
487
|
+
"required": false,
|
|
488
|
+
"schema": {
|
|
489
|
+
"type": "boolean",
|
|
490
|
+
"title": "Recurse",
|
|
491
|
+
"default": false
|
|
492
|
+
},
|
|
493
|
+
"name": "recurse",
|
|
494
|
+
"in": "query"
|
|
495
|
+
}
|
|
496
|
+
],
|
|
497
|
+
"responses": {
|
|
498
|
+
"200": {
|
|
499
|
+
"description": "Success",
|
|
500
|
+
"content": {
|
|
501
|
+
"application/json": {
|
|
502
|
+
"schema": {
|
|
503
|
+
"$ref": "#/components/schemas/Subgraphs"
|
|
504
|
+
}
|
|
505
|
+
}
|
|
506
|
+
}
|
|
507
|
+
},
|
|
508
|
+
"422": {
|
|
509
|
+
"description": "Validation Error",
|
|
510
|
+
"content": {
|
|
511
|
+
"application/json": {
|
|
512
|
+
"schema": {
|
|
513
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
514
|
+
}
|
|
515
|
+
}
|
|
516
|
+
}
|
|
517
|
+
}
|
|
518
|
+
}
|
|
519
|
+
}
|
|
520
|
+
},
|
|
521
|
+
"/assistants/{assistant_id}/schemas": {
|
|
522
|
+
"get": {
|
|
523
|
+
"tags": ["Assistants"],
|
|
524
|
+
"summary": "Get Assistant Schemas",
|
|
525
|
+
"description": "Get an assistant by ID.",
|
|
526
|
+
"operationId": "get_assistant_schemas_assistants__assistant_id__schemas_get",
|
|
527
|
+
"parameters": [
|
|
528
|
+
{
|
|
529
|
+
"description": "The ID of the assistant.",
|
|
530
|
+
"required": true,
|
|
531
|
+
"schema": {
|
|
532
|
+
"type": "string",
|
|
533
|
+
"format": "uuid",
|
|
534
|
+
"title": "Assistant Id",
|
|
535
|
+
"description": "The ID of the assistant."
|
|
536
|
+
},
|
|
537
|
+
"name": "assistant_id",
|
|
538
|
+
"in": "path"
|
|
539
|
+
}
|
|
540
|
+
],
|
|
541
|
+
"responses": {
|
|
542
|
+
"200": {
|
|
543
|
+
"description": "Success",
|
|
544
|
+
"content": {
|
|
545
|
+
"application/json": {
|
|
546
|
+
"schema": {
|
|
547
|
+
"$ref": "#/components/schemas/GraphSchema"
|
|
548
|
+
}
|
|
549
|
+
}
|
|
550
|
+
}
|
|
551
|
+
},
|
|
552
|
+
"404": {
|
|
553
|
+
"description": "Not Found",
|
|
554
|
+
"content": {
|
|
555
|
+
"application/json": {
|
|
556
|
+
"schema": {
|
|
557
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
558
|
+
}
|
|
559
|
+
}
|
|
560
|
+
}
|
|
561
|
+
},
|
|
562
|
+
"422": {
|
|
563
|
+
"description": "Validation Error",
|
|
564
|
+
"content": {
|
|
565
|
+
"application/json": {
|
|
566
|
+
"schema": {
|
|
567
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
568
|
+
}
|
|
569
|
+
}
|
|
570
|
+
}
|
|
571
|
+
}
|
|
572
|
+
}
|
|
573
|
+
}
|
|
574
|
+
},
|
|
575
|
+
"/assistants/{assistant_id}/versions": {
|
|
576
|
+
"post": {
|
|
577
|
+
"tags": ["Assistants"],
|
|
578
|
+
"summary": "Get Assistant Versions",
|
|
579
|
+
"description": "Get all versions of an assistant.",
|
|
580
|
+
"operationId": "get_assistant_versions_assistants__assistant_id__versions_get",
|
|
581
|
+
"parameters": [
|
|
582
|
+
{
|
|
583
|
+
"description": "The ID of the assistant.",
|
|
584
|
+
"required": true,
|
|
585
|
+
"schema": {
|
|
586
|
+
"type": "string",
|
|
587
|
+
"format": "uuid",
|
|
588
|
+
"title": "Assistant Id",
|
|
589
|
+
"description": "The ID of the assistant."
|
|
590
|
+
},
|
|
591
|
+
"name": "assistant_id",
|
|
592
|
+
"in": "path"
|
|
593
|
+
}
|
|
594
|
+
],
|
|
595
|
+
"responses": {
|
|
596
|
+
"200": {
|
|
597
|
+
"description": "Success",
|
|
598
|
+
"content": {
|
|
599
|
+
"application/json": {
|
|
600
|
+
"schema": {
|
|
601
|
+
"items": {
|
|
602
|
+
"$ref": "#/components/schemas/Assistant"
|
|
603
|
+
},
|
|
604
|
+
"type": "array",
|
|
605
|
+
"title": "Response Search Assistants Assistants Search Post"
|
|
606
|
+
}
|
|
607
|
+
}
|
|
608
|
+
}
|
|
609
|
+
},
|
|
610
|
+
"422": {
|
|
611
|
+
"description": "Validation Error",
|
|
612
|
+
"content": {
|
|
613
|
+
"application/json": {
|
|
614
|
+
"schema": {
|
|
615
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
616
|
+
}
|
|
617
|
+
}
|
|
618
|
+
}
|
|
619
|
+
}
|
|
620
|
+
}
|
|
621
|
+
}
|
|
622
|
+
},
|
|
623
|
+
"/assistants/{assistant_id}/latest": {
|
|
624
|
+
"post": {
|
|
625
|
+
"tags": ["Assistants"],
|
|
626
|
+
"summary": "Set Latest Assistant Version",
|
|
627
|
+
"description": "Set the latest version for an assistant.",
|
|
628
|
+
"operationId": "set_latest_assistant_version_assistants__assistant_id__versions_post",
|
|
629
|
+
"parameters": [
|
|
630
|
+
{
|
|
631
|
+
"description": "The ID of the assistant.",
|
|
632
|
+
"required": true,
|
|
633
|
+
"schema": {
|
|
634
|
+
"type": "string",
|
|
635
|
+
"format": "uuid",
|
|
636
|
+
"title": "Assistant Id",
|
|
637
|
+
"description": "The ID of the assistant."
|
|
638
|
+
},
|
|
639
|
+
"name": "assistant_id",
|
|
640
|
+
"in": "path"
|
|
641
|
+
},
|
|
642
|
+
{
|
|
643
|
+
"description": "The version to change to.",
|
|
644
|
+
"required": true,
|
|
645
|
+
"schema": {
|
|
646
|
+
"type": "integer",
|
|
647
|
+
"title": "Version",
|
|
648
|
+
"description": "The version of the assistant to change to."
|
|
649
|
+
},
|
|
650
|
+
"name": "version",
|
|
651
|
+
"in": "query"
|
|
652
|
+
}
|
|
653
|
+
],
|
|
654
|
+
"responses": {
|
|
655
|
+
"200": {
|
|
656
|
+
"description": "Success",
|
|
657
|
+
"content": {
|
|
658
|
+
"application/json": {
|
|
659
|
+
"schema": {
|
|
660
|
+
"$ref": "#/components/schemas/Assistant"
|
|
661
|
+
}
|
|
662
|
+
}
|
|
663
|
+
}
|
|
664
|
+
},
|
|
665
|
+
"404": {
|
|
666
|
+
"description": "Not Found",
|
|
667
|
+
"content": {
|
|
668
|
+
"application/json": {
|
|
669
|
+
"schema": {
|
|
670
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
671
|
+
}
|
|
672
|
+
}
|
|
673
|
+
}
|
|
674
|
+
},
|
|
675
|
+
"422": {
|
|
676
|
+
"description": "Validation Error",
|
|
677
|
+
"content": {
|
|
678
|
+
"application/json": {
|
|
679
|
+
"schema": {
|
|
680
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
681
|
+
}
|
|
682
|
+
}
|
|
683
|
+
}
|
|
684
|
+
}
|
|
685
|
+
}
|
|
686
|
+
}
|
|
687
|
+
},
|
|
688
|
+
"/threads": {
|
|
689
|
+
"post": {
|
|
690
|
+
"tags": ["Threads"],
|
|
691
|
+
"summary": "Create Thread",
|
|
692
|
+
"description": "Create a thread.",
|
|
693
|
+
"operationId": "create_thread_threads_post",
|
|
694
|
+
"requestBody": {
|
|
695
|
+
"content": {
|
|
696
|
+
"application/json": {
|
|
697
|
+
"schema": {
|
|
698
|
+
"$ref": "#/components/schemas/ThreadCreate"
|
|
699
|
+
}
|
|
700
|
+
}
|
|
701
|
+
},
|
|
702
|
+
"required": true
|
|
703
|
+
},
|
|
704
|
+
"responses": {
|
|
705
|
+
"200": {
|
|
706
|
+
"description": "Success",
|
|
707
|
+
"content": {
|
|
708
|
+
"application/json": {
|
|
709
|
+
"schema": {
|
|
710
|
+
"$ref": "#/components/schemas/Thread"
|
|
711
|
+
}
|
|
712
|
+
}
|
|
713
|
+
}
|
|
714
|
+
},
|
|
715
|
+
"409": {
|
|
716
|
+
"description": "Conflict",
|
|
717
|
+
"content": {
|
|
718
|
+
"application/json": {
|
|
719
|
+
"schema": {
|
|
720
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
721
|
+
}
|
|
722
|
+
}
|
|
723
|
+
}
|
|
724
|
+
},
|
|
725
|
+
"422": {
|
|
726
|
+
"description": "Validation Error",
|
|
727
|
+
"content": {
|
|
728
|
+
"application/json": {
|
|
729
|
+
"schema": {
|
|
730
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
731
|
+
}
|
|
732
|
+
}
|
|
733
|
+
}
|
|
734
|
+
}
|
|
735
|
+
}
|
|
736
|
+
}
|
|
737
|
+
},
|
|
738
|
+
"/threads/search": {
|
|
739
|
+
"post": {
|
|
740
|
+
"tags": ["Threads"],
|
|
741
|
+
"summary": "Search Threads",
|
|
742
|
+
"description": "Search for threads.\n\nThis endpoint also functions as the endpoint to list all threads.",
|
|
743
|
+
"operationId": "search_threads_threads_search_post",
|
|
744
|
+
"requestBody": {
|
|
745
|
+
"content": {
|
|
746
|
+
"application/json": {
|
|
747
|
+
"schema": {
|
|
748
|
+
"$ref": "#/components/schemas/ThreadSearchRequest"
|
|
749
|
+
}
|
|
750
|
+
}
|
|
751
|
+
},
|
|
752
|
+
"required": true
|
|
753
|
+
},
|
|
754
|
+
"responses": {
|
|
755
|
+
"200": {
|
|
756
|
+
"description": "Success",
|
|
757
|
+
"content": {
|
|
758
|
+
"application/json": {
|
|
759
|
+
"schema": {
|
|
760
|
+
"items": {
|
|
761
|
+
"$ref": "#/components/schemas/Thread"
|
|
762
|
+
},
|
|
763
|
+
"type": "array",
|
|
764
|
+
"title": "Response Search Threads Threads Search Post"
|
|
765
|
+
}
|
|
766
|
+
}
|
|
767
|
+
}
|
|
768
|
+
},
|
|
769
|
+
"422": {
|
|
770
|
+
"description": "Validation Error",
|
|
771
|
+
"content": {
|
|
772
|
+
"application/json": {
|
|
773
|
+
"schema": {
|
|
774
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
775
|
+
}
|
|
776
|
+
}
|
|
777
|
+
}
|
|
778
|
+
}
|
|
779
|
+
}
|
|
780
|
+
}
|
|
781
|
+
},
|
|
782
|
+
"/threads/{thread_id}/state": {
|
|
783
|
+
"get": {
|
|
784
|
+
"tags": ["Threads"],
|
|
785
|
+
"summary": "Get Thread State",
|
|
786
|
+
"description": "Get state for a thread.\n\nThe latest state of the thread (i.e. latest checkpoint) is returned.",
|
|
787
|
+
"operationId": "get_latest_thread_state_threads__thread_id__state_get",
|
|
788
|
+
"parameters": [
|
|
789
|
+
{
|
|
790
|
+
"description": "The ID of the thread.",
|
|
791
|
+
"required": true,
|
|
792
|
+
"schema": {
|
|
793
|
+
"type": "string",
|
|
794
|
+
"format": "uuid",
|
|
795
|
+
"title": "Thread Id",
|
|
796
|
+
"description": "The ID of the thread."
|
|
797
|
+
},
|
|
798
|
+
"name": "thread_id",
|
|
799
|
+
"in": "path"
|
|
800
|
+
},
|
|
801
|
+
{
|
|
802
|
+
"description": "Whether to include subgraphs in the response.",
|
|
803
|
+
"required": false,
|
|
804
|
+
"schema": {
|
|
805
|
+
"type": "boolean",
|
|
806
|
+
"title": "Subgraphs",
|
|
807
|
+
"description": "Whether to include subgraphs in the response."
|
|
808
|
+
},
|
|
809
|
+
"name": "subgraphs",
|
|
810
|
+
"in": "query"
|
|
811
|
+
}
|
|
812
|
+
],
|
|
813
|
+
"responses": {
|
|
814
|
+
"200": {
|
|
815
|
+
"description": "Success",
|
|
816
|
+
"content": {
|
|
817
|
+
"application/json": {
|
|
818
|
+
"schema": {
|
|
819
|
+
"$ref": "#/components/schemas/ThreadState"
|
|
820
|
+
}
|
|
821
|
+
}
|
|
822
|
+
}
|
|
823
|
+
},
|
|
824
|
+
"422": {
|
|
825
|
+
"description": "Validation Error",
|
|
826
|
+
"content": {
|
|
827
|
+
"application/json": {
|
|
828
|
+
"schema": {
|
|
829
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
830
|
+
}
|
|
831
|
+
}
|
|
832
|
+
}
|
|
833
|
+
}
|
|
834
|
+
}
|
|
835
|
+
},
|
|
836
|
+
"post": {
|
|
837
|
+
"tags": ["Threads"],
|
|
838
|
+
"summary": "Update Thread State",
|
|
839
|
+
"description": "Add state to a thread.",
|
|
840
|
+
"operationId": "update_thread_state_threads__thread_id__state_post",
|
|
841
|
+
"parameters": [
|
|
842
|
+
{
|
|
843
|
+
"description": "The ID of the thread.",
|
|
844
|
+
"required": true,
|
|
845
|
+
"schema": {
|
|
846
|
+
"type": "string",
|
|
847
|
+
"format": "uuid",
|
|
848
|
+
"title": "Thread Id",
|
|
849
|
+
"description": "The ID of the thread."
|
|
850
|
+
},
|
|
851
|
+
"name": "thread_id",
|
|
852
|
+
"in": "path"
|
|
853
|
+
}
|
|
854
|
+
],
|
|
855
|
+
"requestBody": {
|
|
856
|
+
"content": {
|
|
857
|
+
"application/json": {
|
|
858
|
+
"schema": {
|
|
859
|
+
"$ref": "#/components/schemas/ThreadStateUpdate"
|
|
860
|
+
}
|
|
861
|
+
}
|
|
862
|
+
},
|
|
863
|
+
"required": true
|
|
864
|
+
},
|
|
865
|
+
"responses": {
|
|
866
|
+
"200": {
|
|
867
|
+
"description": "Success",
|
|
868
|
+
"content": {
|
|
869
|
+
"application/json": {
|
|
870
|
+
"schema": {
|
|
871
|
+
"$ref": "#/components/schemas/ThreadStateUpdateResponse"
|
|
872
|
+
}
|
|
873
|
+
}
|
|
874
|
+
}
|
|
875
|
+
},
|
|
876
|
+
"422": {
|
|
877
|
+
"description": "Validation Error",
|
|
878
|
+
"content": {
|
|
879
|
+
"application/json": {
|
|
880
|
+
"schema": {
|
|
881
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
882
|
+
}
|
|
883
|
+
}
|
|
884
|
+
}
|
|
885
|
+
}
|
|
886
|
+
}
|
|
887
|
+
}
|
|
888
|
+
},
|
|
889
|
+
"/threads/{thread_id}/state/{checkpoint_id}": {
|
|
890
|
+
"get": {
|
|
891
|
+
"tags": ["Threads"],
|
|
892
|
+
"summary": "Get Thread State At Checkpoint",
|
|
893
|
+
"description": "Get state for a thread at a specific checkpoint.",
|
|
894
|
+
"operationId": "get_thread_state_at_checkpoint_threads__thread_id__state__checkpoint_id__get",
|
|
895
|
+
"parameters": [
|
|
896
|
+
{
|
|
897
|
+
"description": "The ID of the thread.",
|
|
898
|
+
"required": true,
|
|
899
|
+
"schema": {
|
|
900
|
+
"type": "string",
|
|
901
|
+
"format": "uuid",
|
|
902
|
+
"title": "Thread Id",
|
|
903
|
+
"description": "The ID of the thread."
|
|
904
|
+
},
|
|
905
|
+
"name": "thread_id",
|
|
906
|
+
"in": "path"
|
|
907
|
+
},
|
|
908
|
+
{
|
|
909
|
+
"description": "The ID of the checkpoint.",
|
|
910
|
+
"required": true,
|
|
911
|
+
"schema": {
|
|
912
|
+
"type": "string",
|
|
913
|
+
"format": "uuid",
|
|
914
|
+
"title": "Checkpoint Id",
|
|
915
|
+
"description": "The ID of the checkpoint."
|
|
916
|
+
},
|
|
917
|
+
"name": "checkpoint_id",
|
|
918
|
+
"in": "path"
|
|
919
|
+
},
|
|
920
|
+
{
|
|
921
|
+
"description": "Whether to include subgraphs in the response.",
|
|
922
|
+
"required": false,
|
|
923
|
+
"schema": {
|
|
924
|
+
"type": "boolean",
|
|
925
|
+
"title": "Subgraphs",
|
|
926
|
+
"description": "Whether to include subgraphs in the response."
|
|
927
|
+
},
|
|
928
|
+
"name": "subgraphs",
|
|
929
|
+
"in": "query"
|
|
930
|
+
}
|
|
931
|
+
],
|
|
932
|
+
"responses": {
|
|
933
|
+
"200": {
|
|
934
|
+
"description": "Success",
|
|
935
|
+
"content": {
|
|
936
|
+
"application/json": {
|
|
937
|
+
"schema": {
|
|
938
|
+
"$ref": "#/components/schemas/ThreadState"
|
|
939
|
+
}
|
|
940
|
+
}
|
|
941
|
+
}
|
|
942
|
+
},
|
|
943
|
+
"422": {
|
|
944
|
+
"description": "Validation Error",
|
|
945
|
+
"content": {
|
|
946
|
+
"application/json": {
|
|
947
|
+
"schema": {
|
|
948
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
949
|
+
}
|
|
950
|
+
}
|
|
951
|
+
}
|
|
952
|
+
}
|
|
953
|
+
}
|
|
954
|
+
}
|
|
955
|
+
},
|
|
956
|
+
"/threads/{thread_id}/state/checkpoint": {
|
|
957
|
+
"post": {
|
|
958
|
+
"tags": ["Threads"],
|
|
959
|
+
"summary": "Get Thread State At Checkpoint",
|
|
960
|
+
"description": "Get state for a thread at a specific checkpoint.",
|
|
961
|
+
"operationId": "post_thread_state_at_checkpoint_threads__thread_id__state__checkpoint_id__get",
|
|
962
|
+
"parameters": [
|
|
963
|
+
{
|
|
964
|
+
"description": "The ID of the thread.",
|
|
965
|
+
"required": true,
|
|
966
|
+
"schema": {
|
|
967
|
+
"type": "string",
|
|
968
|
+
"format": "uuid",
|
|
969
|
+
"title": "Thread Id",
|
|
970
|
+
"description": "The ID of the thread."
|
|
971
|
+
},
|
|
972
|
+
"name": "thread_id",
|
|
973
|
+
"in": "path"
|
|
974
|
+
},
|
|
975
|
+
{
|
|
976
|
+
"required": false,
|
|
977
|
+
"schema": {
|
|
978
|
+
"type": "boolean",
|
|
979
|
+
"title": "Subgraphs",
|
|
980
|
+
"description": "If true, includes subgraph states."
|
|
981
|
+
},
|
|
982
|
+
"name": "subgraphs",
|
|
983
|
+
"in": "query"
|
|
984
|
+
}
|
|
985
|
+
],
|
|
986
|
+
"requestBody": {
|
|
987
|
+
"content": {
|
|
988
|
+
"application/json": {
|
|
989
|
+
"schema": {
|
|
990
|
+
"$ref": "#/components/schemas/ThreadStateCheckpointRequest"
|
|
991
|
+
}
|
|
992
|
+
}
|
|
993
|
+
},
|
|
994
|
+
"required": true
|
|
995
|
+
},
|
|
996
|
+
"responses": {
|
|
997
|
+
"200": {
|
|
998
|
+
"description": "Success",
|
|
999
|
+
"content": {
|
|
1000
|
+
"application/json": {
|
|
1001
|
+
"schema": {
|
|
1002
|
+
"$ref": "#/components/schemas/ThreadState"
|
|
1003
|
+
}
|
|
1004
|
+
}
|
|
1005
|
+
}
|
|
1006
|
+
},
|
|
1007
|
+
"422": {
|
|
1008
|
+
"description": "Validation Error",
|
|
1009
|
+
"content": {
|
|
1010
|
+
"application/json": {
|
|
1011
|
+
"schema": {
|
|
1012
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1013
|
+
}
|
|
1014
|
+
}
|
|
1015
|
+
}
|
|
1016
|
+
}
|
|
1017
|
+
}
|
|
1018
|
+
}
|
|
1019
|
+
},
|
|
1020
|
+
"/threads/{thread_id}/history": {
|
|
1021
|
+
"get": {
|
|
1022
|
+
"tags": ["Threads"],
|
|
1023
|
+
"summary": "Get Thread History",
|
|
1024
|
+
"description": "Get all past states for a thread.",
|
|
1025
|
+
"operationId": "get_thread_history_threads__thread_id__history_get",
|
|
1026
|
+
"parameters": [
|
|
1027
|
+
{
|
|
1028
|
+
"description": "The ID of the thread.",
|
|
1029
|
+
"required": true,
|
|
1030
|
+
"schema": {
|
|
1031
|
+
"type": "string",
|
|
1032
|
+
"format": "uuid",
|
|
1033
|
+
"title": "Thread Id",
|
|
1034
|
+
"description": "The ID of the thread."
|
|
1035
|
+
},
|
|
1036
|
+
"name": "thread_id",
|
|
1037
|
+
"in": "path"
|
|
1038
|
+
},
|
|
1039
|
+
{
|
|
1040
|
+
"required": false,
|
|
1041
|
+
"schema": {
|
|
1042
|
+
"type": "integer",
|
|
1043
|
+
"title": "Limit",
|
|
1044
|
+
"default": 10
|
|
1045
|
+
},
|
|
1046
|
+
"name": "limit",
|
|
1047
|
+
"in": "query"
|
|
1048
|
+
},
|
|
1049
|
+
{
|
|
1050
|
+
"required": false,
|
|
1051
|
+
"schema": {
|
|
1052
|
+
"type": "string",
|
|
1053
|
+
"title": "Before"
|
|
1054
|
+
},
|
|
1055
|
+
"name": "before",
|
|
1056
|
+
"in": "query"
|
|
1057
|
+
}
|
|
1058
|
+
],
|
|
1059
|
+
"responses": {
|
|
1060
|
+
"200": {
|
|
1061
|
+
"description": "Success",
|
|
1062
|
+
"content": {
|
|
1063
|
+
"application/json": {
|
|
1064
|
+
"schema": {
|
|
1065
|
+
"items": {
|
|
1066
|
+
"$ref": "#/components/schemas/ThreadState"
|
|
1067
|
+
},
|
|
1068
|
+
"type": "array",
|
|
1069
|
+
"title": "Response Get Thread History Threads Thread Id History Get"
|
|
1070
|
+
}
|
|
1071
|
+
}
|
|
1072
|
+
}
|
|
1073
|
+
},
|
|
1074
|
+
"422": {
|
|
1075
|
+
"description": "Validation Error",
|
|
1076
|
+
"content": {
|
|
1077
|
+
"application/json": {
|
|
1078
|
+
"schema": {
|
|
1079
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1080
|
+
}
|
|
1081
|
+
}
|
|
1082
|
+
}
|
|
1083
|
+
}
|
|
1084
|
+
}
|
|
1085
|
+
},
|
|
1086
|
+
"post": {
|
|
1087
|
+
"tags": ["Threads"],
|
|
1088
|
+
"summary": "Get Thread History Post",
|
|
1089
|
+
"description": "Get all past states for a thread.",
|
|
1090
|
+
"operationId": "get_thread_history_post_threads__thread_id__history_post",
|
|
1091
|
+
"parameters": [
|
|
1092
|
+
{
|
|
1093
|
+
"description": "The ID of the thread.",
|
|
1094
|
+
"required": true,
|
|
1095
|
+
"schema": {
|
|
1096
|
+
"type": "string",
|
|
1097
|
+
"format": "uuid",
|
|
1098
|
+
"title": "Thread Id",
|
|
1099
|
+
"description": "The ID of the thread."
|
|
1100
|
+
},
|
|
1101
|
+
"name": "thread_id",
|
|
1102
|
+
"in": "path"
|
|
1103
|
+
}
|
|
1104
|
+
],
|
|
1105
|
+
"requestBody": {
|
|
1106
|
+
"content": {
|
|
1107
|
+
"application/json": {
|
|
1108
|
+
"schema": {
|
|
1109
|
+
"$ref": "#/components/schemas/ThreadStateSearch"
|
|
1110
|
+
}
|
|
1111
|
+
}
|
|
1112
|
+
},
|
|
1113
|
+
"required": true
|
|
1114
|
+
},
|
|
1115
|
+
"responses": {
|
|
1116
|
+
"200": {
|
|
1117
|
+
"description": "Success",
|
|
1118
|
+
"content": {
|
|
1119
|
+
"application/json": {
|
|
1120
|
+
"schema": {
|
|
1121
|
+
"items": {
|
|
1122
|
+
"$ref": "#/components/schemas/ThreadState"
|
|
1123
|
+
},
|
|
1124
|
+
"type": "array",
|
|
1125
|
+
"title": "Response Get Thread History Post Threads Thread Id History Post"
|
|
1126
|
+
}
|
|
1127
|
+
}
|
|
1128
|
+
}
|
|
1129
|
+
},
|
|
1130
|
+
"422": {
|
|
1131
|
+
"description": "Validation Error",
|
|
1132
|
+
"content": {
|
|
1133
|
+
"application/json": {
|
|
1134
|
+
"schema": {
|
|
1135
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1136
|
+
}
|
|
1137
|
+
}
|
|
1138
|
+
}
|
|
1139
|
+
}
|
|
1140
|
+
}
|
|
1141
|
+
}
|
|
1142
|
+
},
|
|
1143
|
+
"/threads/{thread_id}/copy": {
|
|
1144
|
+
"post": {
|
|
1145
|
+
"tags": ["Threads"],
|
|
1146
|
+
"summary": "Copy Thread",
|
|
1147
|
+
"description": "Create a new thread with a copy of the state and checkpoints from an existing thread.",
|
|
1148
|
+
"operationId": "copy_thread_post_threads__thread_id__copy_post",
|
|
1149
|
+
"parameters": [
|
|
1150
|
+
{
|
|
1151
|
+
"description": "The ID of the thread.",
|
|
1152
|
+
"required": true,
|
|
1153
|
+
"schema": {
|
|
1154
|
+
"type": "string",
|
|
1155
|
+
"format": "uuid",
|
|
1156
|
+
"title": "Thread Id",
|
|
1157
|
+
"description": "The ID of the thread."
|
|
1158
|
+
},
|
|
1159
|
+
"name": "thread_id",
|
|
1160
|
+
"in": "path"
|
|
1161
|
+
}
|
|
1162
|
+
],
|
|
1163
|
+
"responses": {
|
|
1164
|
+
"200": {
|
|
1165
|
+
"description": "Success",
|
|
1166
|
+
"content": {
|
|
1167
|
+
"application/json": {
|
|
1168
|
+
"schema": {
|
|
1169
|
+
"$ref": "#/components/schemas/Thread"
|
|
1170
|
+
}
|
|
1171
|
+
}
|
|
1172
|
+
}
|
|
1173
|
+
},
|
|
1174
|
+
"409": {
|
|
1175
|
+
"description": "Conflict",
|
|
1176
|
+
"content": {
|
|
1177
|
+
"application/json": {
|
|
1178
|
+
"schema": {
|
|
1179
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1180
|
+
}
|
|
1181
|
+
}
|
|
1182
|
+
}
|
|
1183
|
+
},
|
|
1184
|
+
"422": {
|
|
1185
|
+
"description": "Validation Error",
|
|
1186
|
+
"content": {
|
|
1187
|
+
"application/json": {
|
|
1188
|
+
"schema": {
|
|
1189
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1190
|
+
}
|
|
1191
|
+
}
|
|
1192
|
+
}
|
|
1193
|
+
}
|
|
1194
|
+
}
|
|
1195
|
+
}
|
|
1196
|
+
},
|
|
1197
|
+
"/threads/{thread_id}": {
|
|
1198
|
+
"get": {
|
|
1199
|
+
"tags": ["Threads"],
|
|
1200
|
+
"summary": "Get Thread",
|
|
1201
|
+
"description": "Get a thread by ID.",
|
|
1202
|
+
"operationId": "get_thread_threads__thread_id__get",
|
|
1203
|
+
"parameters": [
|
|
1204
|
+
{
|
|
1205
|
+
"description": "The ID of the thread.",
|
|
1206
|
+
"required": true,
|
|
1207
|
+
"schema": {
|
|
1208
|
+
"type": "string",
|
|
1209
|
+
"format": "uuid",
|
|
1210
|
+
"title": "Thread Id",
|
|
1211
|
+
"description": "The ID of the thread."
|
|
1212
|
+
},
|
|
1213
|
+
"name": "thread_id",
|
|
1214
|
+
"in": "path"
|
|
1215
|
+
}
|
|
1216
|
+
],
|
|
1217
|
+
"responses": {
|
|
1218
|
+
"200": {
|
|
1219
|
+
"description": "Success",
|
|
1220
|
+
"content": {
|
|
1221
|
+
"application/json": {
|
|
1222
|
+
"schema": {
|
|
1223
|
+
"$ref": "#/components/schemas/Thread"
|
|
1224
|
+
}
|
|
1225
|
+
}
|
|
1226
|
+
}
|
|
1227
|
+
},
|
|
1228
|
+
"404": {
|
|
1229
|
+
"description": "Not Found",
|
|
1230
|
+
"content": {
|
|
1231
|
+
"application/json": {
|
|
1232
|
+
"schema": {
|
|
1233
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1234
|
+
}
|
|
1235
|
+
}
|
|
1236
|
+
}
|
|
1237
|
+
},
|
|
1238
|
+
"422": {
|
|
1239
|
+
"description": "Validation Error",
|
|
1240
|
+
"content": {
|
|
1241
|
+
"application/json": {
|
|
1242
|
+
"schema": {
|
|
1243
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1244
|
+
}
|
|
1245
|
+
}
|
|
1246
|
+
}
|
|
1247
|
+
}
|
|
1248
|
+
}
|
|
1249
|
+
},
|
|
1250
|
+
"delete": {
|
|
1251
|
+
"tags": ["Threads"],
|
|
1252
|
+
"summary": "Delete Thread",
|
|
1253
|
+
"description": "Delete a thread by ID.",
|
|
1254
|
+
"operationId": "delete_thread_threads__thread_id__delete",
|
|
1255
|
+
"parameters": [
|
|
1256
|
+
{
|
|
1257
|
+
"description": "The ID of the thread.",
|
|
1258
|
+
"required": true,
|
|
1259
|
+
"schema": {
|
|
1260
|
+
"type": "string",
|
|
1261
|
+
"format": "uuid",
|
|
1262
|
+
"title": "Thread Id",
|
|
1263
|
+
"description": "The ID of the thread."
|
|
1264
|
+
},
|
|
1265
|
+
"name": "thread_id",
|
|
1266
|
+
"in": "path"
|
|
1267
|
+
}
|
|
1268
|
+
],
|
|
1269
|
+
"responses": {
|
|
1270
|
+
"200": {
|
|
1271
|
+
"description": "Success",
|
|
1272
|
+
"content": {
|
|
1273
|
+
"application/json": {
|
|
1274
|
+
"schema": {}
|
|
1275
|
+
}
|
|
1276
|
+
}
|
|
1277
|
+
},
|
|
1278
|
+
"404": {
|
|
1279
|
+
"description": "Not Found",
|
|
1280
|
+
"content": {
|
|
1281
|
+
"application/json": {
|
|
1282
|
+
"schema": {
|
|
1283
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1284
|
+
}
|
|
1285
|
+
}
|
|
1286
|
+
}
|
|
1287
|
+
},
|
|
1288
|
+
"422": {
|
|
1289
|
+
"description": "Validation Error",
|
|
1290
|
+
"content": {
|
|
1291
|
+
"application/json": {
|
|
1292
|
+
"schema": {
|
|
1293
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1294
|
+
}
|
|
1295
|
+
}
|
|
1296
|
+
}
|
|
1297
|
+
}
|
|
1298
|
+
}
|
|
1299
|
+
},
|
|
1300
|
+
"patch": {
|
|
1301
|
+
"tags": ["Threads"],
|
|
1302
|
+
"summary": "Patch Thread",
|
|
1303
|
+
"description": "Update a thread.",
|
|
1304
|
+
"operationId": "patch_thread_threads__thread_id__patch",
|
|
1305
|
+
"parameters": [
|
|
1306
|
+
{
|
|
1307
|
+
"description": "The ID of the thread.",
|
|
1308
|
+
"required": true,
|
|
1309
|
+
"schema": {
|
|
1310
|
+
"type": "string",
|
|
1311
|
+
"format": "uuid",
|
|
1312
|
+
"title": "Thread Id",
|
|
1313
|
+
"description": "The ID of the thread."
|
|
1314
|
+
},
|
|
1315
|
+
"name": "thread_id",
|
|
1316
|
+
"in": "path"
|
|
1317
|
+
}
|
|
1318
|
+
],
|
|
1319
|
+
"requestBody": {
|
|
1320
|
+
"content": {
|
|
1321
|
+
"application/json": {
|
|
1322
|
+
"schema": {
|
|
1323
|
+
"$ref": "#/components/schemas/ThreadPatch"
|
|
1324
|
+
}
|
|
1325
|
+
}
|
|
1326
|
+
},
|
|
1327
|
+
"required": true
|
|
1328
|
+
},
|
|
1329
|
+
"responses": {
|
|
1330
|
+
"200": {
|
|
1331
|
+
"description": "Success",
|
|
1332
|
+
"content": {
|
|
1333
|
+
"application/json": {
|
|
1334
|
+
"schema": {
|
|
1335
|
+
"$ref": "#/components/schemas/Thread"
|
|
1336
|
+
}
|
|
1337
|
+
}
|
|
1338
|
+
}
|
|
1339
|
+
},
|
|
1340
|
+
"404": {
|
|
1341
|
+
"description": "Not Found",
|
|
1342
|
+
"content": {
|
|
1343
|
+
"application/json": {
|
|
1344
|
+
"schema": {
|
|
1345
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1346
|
+
}
|
|
1347
|
+
}
|
|
1348
|
+
}
|
|
1349
|
+
},
|
|
1350
|
+
"422": {
|
|
1351
|
+
"description": "Validation Error",
|
|
1352
|
+
"content": {
|
|
1353
|
+
"application/json": {
|
|
1354
|
+
"schema": {
|
|
1355
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1356
|
+
}
|
|
1357
|
+
}
|
|
1358
|
+
}
|
|
1359
|
+
}
|
|
1360
|
+
}
|
|
1361
|
+
}
|
|
1362
|
+
},
|
|
1363
|
+
"/threads/{thread_id}/runs": {
|
|
1364
|
+
"get": {
|
|
1365
|
+
"tags": ["Thread Runs"],
|
|
1366
|
+
"summary": "List Runs",
|
|
1367
|
+
"description": "List runs for a thread.",
|
|
1368
|
+
"operationId": "list_runs_http_threads__thread_id__runs_get",
|
|
1369
|
+
"parameters": [
|
|
1370
|
+
{
|
|
1371
|
+
"description": "The ID of the thread.",
|
|
1372
|
+
"required": true,
|
|
1373
|
+
"schema": {
|
|
1374
|
+
"type": "string",
|
|
1375
|
+
"format": "uuid",
|
|
1376
|
+
"title": "Thread Id",
|
|
1377
|
+
"description": "The ID of the thread."
|
|
1378
|
+
},
|
|
1379
|
+
"name": "thread_id",
|
|
1380
|
+
"in": "path"
|
|
1381
|
+
},
|
|
1382
|
+
{
|
|
1383
|
+
"required": false,
|
|
1384
|
+
"schema": {
|
|
1385
|
+
"type": "integer",
|
|
1386
|
+
"title": "Limit",
|
|
1387
|
+
"default": 10
|
|
1388
|
+
},
|
|
1389
|
+
"name": "limit",
|
|
1390
|
+
"in": "query"
|
|
1391
|
+
},
|
|
1392
|
+
{
|
|
1393
|
+
"required": false,
|
|
1394
|
+
"schema": {
|
|
1395
|
+
"type": "integer",
|
|
1396
|
+
"title": "Offset",
|
|
1397
|
+
"default": 0
|
|
1398
|
+
},
|
|
1399
|
+
"name": "offset",
|
|
1400
|
+
"in": "query"
|
|
1401
|
+
},
|
|
1402
|
+
{
|
|
1403
|
+
"required": false,
|
|
1404
|
+
"schema": {
|
|
1405
|
+
"type": "string",
|
|
1406
|
+
"enum": ["pending", "error", "success", "timeout", "interrupted"]
|
|
1407
|
+
},
|
|
1408
|
+
"name": "status",
|
|
1409
|
+
"in": "query"
|
|
1410
|
+
}
|
|
1411
|
+
],
|
|
1412
|
+
"responses": {
|
|
1413
|
+
"200": {
|
|
1414
|
+
"description": "Success",
|
|
1415
|
+
"content": {
|
|
1416
|
+
"application/json": {
|
|
1417
|
+
"schema": {
|
|
1418
|
+
"items": {
|
|
1419
|
+
"$ref": "#/components/schemas/Run"
|
|
1420
|
+
},
|
|
1421
|
+
"type": "array"
|
|
1422
|
+
}
|
|
1423
|
+
}
|
|
1424
|
+
}
|
|
1425
|
+
},
|
|
1426
|
+
"404": {
|
|
1427
|
+
"description": "Not Found",
|
|
1428
|
+
"content": {
|
|
1429
|
+
"application/json": {
|
|
1430
|
+
"schema": {
|
|
1431
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1432
|
+
}
|
|
1433
|
+
}
|
|
1434
|
+
}
|
|
1435
|
+
},
|
|
1436
|
+
"422": {
|
|
1437
|
+
"description": "Validation Error",
|
|
1438
|
+
"content": {
|
|
1439
|
+
"application/json": {
|
|
1440
|
+
"schema": {
|
|
1441
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1442
|
+
}
|
|
1443
|
+
}
|
|
1444
|
+
}
|
|
1445
|
+
}
|
|
1446
|
+
}
|
|
1447
|
+
},
|
|
1448
|
+
"post": {
|
|
1449
|
+
"tags": ["Thread Runs"],
|
|
1450
|
+
"summary": "Create Background Run",
|
|
1451
|
+
"description": "Create a run in existing thread, return the run ID immediately. Don't wait for the final run output.",
|
|
1452
|
+
"operationId": "create_run_threads__thread_id__runs_post",
|
|
1453
|
+
"parameters": [
|
|
1454
|
+
{
|
|
1455
|
+
"description": "The ID of the thread.",
|
|
1456
|
+
"required": true,
|
|
1457
|
+
"schema": {
|
|
1458
|
+
"type": "string",
|
|
1459
|
+
"format": "uuid",
|
|
1460
|
+
"title": "Thread Id",
|
|
1461
|
+
"description": "The ID of the thread."
|
|
1462
|
+
},
|
|
1463
|
+
"name": "thread_id",
|
|
1464
|
+
"in": "path"
|
|
1465
|
+
}
|
|
1466
|
+
],
|
|
1467
|
+
"requestBody": {
|
|
1468
|
+
"content": {
|
|
1469
|
+
"application/json": {
|
|
1470
|
+
"schema": {
|
|
1471
|
+
"$ref": "#/components/schemas/RunCreateStateful"
|
|
1472
|
+
}
|
|
1473
|
+
}
|
|
1474
|
+
},
|
|
1475
|
+
"required": true
|
|
1476
|
+
},
|
|
1477
|
+
"responses": {
|
|
1478
|
+
"200": {
|
|
1479
|
+
"description": "Success",
|
|
1480
|
+
"content": {
|
|
1481
|
+
"application/json": {
|
|
1482
|
+
"schema": {
|
|
1483
|
+
"$ref": "#/components/schemas/Run"
|
|
1484
|
+
}
|
|
1485
|
+
}
|
|
1486
|
+
}
|
|
1487
|
+
},
|
|
1488
|
+
"404": {
|
|
1489
|
+
"description": "Not Found",
|
|
1490
|
+
"content": {
|
|
1491
|
+
"application/json": {
|
|
1492
|
+
"schema": {
|
|
1493
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1494
|
+
}
|
|
1495
|
+
}
|
|
1496
|
+
}
|
|
1497
|
+
},
|
|
1498
|
+
"409": {
|
|
1499
|
+
"description": "Conflict",
|
|
1500
|
+
"content": {
|
|
1501
|
+
"application/json": {
|
|
1502
|
+
"schema": {
|
|
1503
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1504
|
+
}
|
|
1505
|
+
}
|
|
1506
|
+
}
|
|
1507
|
+
},
|
|
1508
|
+
"422": {
|
|
1509
|
+
"description": "Validation Error",
|
|
1510
|
+
"content": {
|
|
1511
|
+
"application/json": {
|
|
1512
|
+
"schema": {
|
|
1513
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1514
|
+
}
|
|
1515
|
+
}
|
|
1516
|
+
}
|
|
1517
|
+
}
|
|
1518
|
+
}
|
|
1519
|
+
}
|
|
1520
|
+
},
|
|
1521
|
+
"/threads/{thread_id}/runs/crons": {
|
|
1522
|
+
"post": {
|
|
1523
|
+
"tags": ["Crons (Plus tier)"],
|
|
1524
|
+
"summary": "Create Thread Cron",
|
|
1525
|
+
"description": "Create a cron to schedule runs on a thread.",
|
|
1526
|
+
"operationId": "create_thread_cron_threads__thread_id__runs_crons_post",
|
|
1527
|
+
"parameters": [
|
|
1528
|
+
{
|
|
1529
|
+
"description": "The ID of the thread.",
|
|
1530
|
+
"required": true,
|
|
1531
|
+
"schema": {
|
|
1532
|
+
"type": "string",
|
|
1533
|
+
"format": "uuid",
|
|
1534
|
+
"title": "Thread Id",
|
|
1535
|
+
"description": "The ID of the thread."
|
|
1536
|
+
},
|
|
1537
|
+
"name": "thread_id",
|
|
1538
|
+
"in": "path"
|
|
1539
|
+
}
|
|
1540
|
+
],
|
|
1541
|
+
"requestBody": {
|
|
1542
|
+
"content": {
|
|
1543
|
+
"application/json": {
|
|
1544
|
+
"schema": {
|
|
1545
|
+
"$ref": "#/components/schemas/CronCreate"
|
|
1546
|
+
}
|
|
1547
|
+
}
|
|
1548
|
+
},
|
|
1549
|
+
"required": true
|
|
1550
|
+
},
|
|
1551
|
+
"responses": {
|
|
1552
|
+
"200": {
|
|
1553
|
+
"description": "Success",
|
|
1554
|
+
"content": {
|
|
1555
|
+
"application/json": {
|
|
1556
|
+
"schema": {
|
|
1557
|
+
"$ref": "#/components/schemas/Cron"
|
|
1558
|
+
}
|
|
1559
|
+
}
|
|
1560
|
+
}
|
|
1561
|
+
},
|
|
1562
|
+
"404": {
|
|
1563
|
+
"description": "Not Found",
|
|
1564
|
+
"content": {
|
|
1565
|
+
"application/json": {
|
|
1566
|
+
"schema": {
|
|
1567
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1568
|
+
}
|
|
1569
|
+
}
|
|
1570
|
+
}
|
|
1571
|
+
},
|
|
1572
|
+
"422": {
|
|
1573
|
+
"description": "Validation Error",
|
|
1574
|
+
"content": {
|
|
1575
|
+
"application/json": {
|
|
1576
|
+
"schema": {
|
|
1577
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1578
|
+
}
|
|
1579
|
+
}
|
|
1580
|
+
}
|
|
1581
|
+
}
|
|
1582
|
+
}
|
|
1583
|
+
}
|
|
1584
|
+
},
|
|
1585
|
+
"/threads/{thread_id}/runs/stream": {
|
|
1586
|
+
"post": {
|
|
1587
|
+
"tags": ["Thread Runs"],
|
|
1588
|
+
"summary": "Create Run, Stream Output",
|
|
1589
|
+
"description": "Create a run in existing thread. Stream the output.",
|
|
1590
|
+
"operationId": "stream_run_threads__thread_id__runs_stream_post",
|
|
1591
|
+
"parameters": [
|
|
1592
|
+
{
|
|
1593
|
+
"description": "The ID of the thread.",
|
|
1594
|
+
"required": true,
|
|
1595
|
+
"schema": {
|
|
1596
|
+
"type": "string",
|
|
1597
|
+
"format": "uuid",
|
|
1598
|
+
"title": "Thread Id",
|
|
1599
|
+
"description": "The ID of the thread."
|
|
1600
|
+
},
|
|
1601
|
+
"name": "thread_id",
|
|
1602
|
+
"in": "path"
|
|
1603
|
+
}
|
|
1604
|
+
],
|
|
1605
|
+
"requestBody": {
|
|
1606
|
+
"content": {
|
|
1607
|
+
"application/json": {
|
|
1608
|
+
"schema": {
|
|
1609
|
+
"$ref": "#/components/schemas/RunCreateStateful"
|
|
1610
|
+
}
|
|
1611
|
+
}
|
|
1612
|
+
},
|
|
1613
|
+
"required": true
|
|
1614
|
+
},
|
|
1615
|
+
"responses": {
|
|
1616
|
+
"200": {
|
|
1617
|
+
"description": "Success",
|
|
1618
|
+
"content": {
|
|
1619
|
+
"text/event-stream": {
|
|
1620
|
+
"schema": {
|
|
1621
|
+
"type": "string",
|
|
1622
|
+
"description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
|
|
1623
|
+
}
|
|
1624
|
+
}
|
|
1625
|
+
}
|
|
1626
|
+
},
|
|
1627
|
+
"404": {
|
|
1628
|
+
"description": "Not Found",
|
|
1629
|
+
"content": {
|
|
1630
|
+
"application/json": {
|
|
1631
|
+
"schema": {
|
|
1632
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1633
|
+
}
|
|
1634
|
+
}
|
|
1635
|
+
}
|
|
1636
|
+
},
|
|
1637
|
+
"409": {
|
|
1638
|
+
"description": "Conflict",
|
|
1639
|
+
"content": {
|
|
1640
|
+
"application/json": {
|
|
1641
|
+
"schema": {
|
|
1642
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1643
|
+
}
|
|
1644
|
+
}
|
|
1645
|
+
}
|
|
1646
|
+
},
|
|
1647
|
+
"422": {
|
|
1648
|
+
"description": "Validation Error",
|
|
1649
|
+
"content": {
|
|
1650
|
+
"application/json": {
|
|
1651
|
+
"schema": {
|
|
1652
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1653
|
+
}
|
|
1654
|
+
}
|
|
1655
|
+
}
|
|
1656
|
+
}
|
|
1657
|
+
}
|
|
1658
|
+
}
|
|
1659
|
+
},
|
|
1660
|
+
"/threads/{thread_id}/runs/wait": {
|
|
1661
|
+
"post": {
|
|
1662
|
+
"tags": ["Thread Runs"],
|
|
1663
|
+
"summary": "Create Run, Wait for Output",
|
|
1664
|
+
"description": "Create a run in existing thread. Wait for the final output and then return it.",
|
|
1665
|
+
"operationId": "wait_run_threads__thread_id__runs_wait_post",
|
|
1666
|
+
"parameters": [
|
|
1667
|
+
{
|
|
1668
|
+
"description": "The ID of the thread.",
|
|
1669
|
+
"required": true,
|
|
1670
|
+
"schema": {
|
|
1671
|
+
"type": "string",
|
|
1672
|
+
"format": "uuid",
|
|
1673
|
+
"title": "Thread Id",
|
|
1674
|
+
"description": "The ID of the thread."
|
|
1675
|
+
},
|
|
1676
|
+
"name": "thread_id",
|
|
1677
|
+
"in": "path"
|
|
1678
|
+
}
|
|
1679
|
+
],
|
|
1680
|
+
"requestBody": {
|
|
1681
|
+
"content": {
|
|
1682
|
+
"application/json": {
|
|
1683
|
+
"schema": {
|
|
1684
|
+
"$ref": "#/components/schemas/RunCreateStateful"
|
|
1685
|
+
}
|
|
1686
|
+
}
|
|
1687
|
+
},
|
|
1688
|
+
"required": true
|
|
1689
|
+
},
|
|
1690
|
+
"responses": {
|
|
1691
|
+
"200": {
|
|
1692
|
+
"description": "Success",
|
|
1693
|
+
"content": {
|
|
1694
|
+
"application/json": {
|
|
1695
|
+
"schema": {}
|
|
1696
|
+
}
|
|
1697
|
+
}
|
|
1698
|
+
},
|
|
1699
|
+
"404": {
|
|
1700
|
+
"description": "Not Found",
|
|
1701
|
+
"content": {
|
|
1702
|
+
"application/json": {
|
|
1703
|
+
"schema": {
|
|
1704
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1705
|
+
}
|
|
1706
|
+
}
|
|
1707
|
+
}
|
|
1708
|
+
},
|
|
1709
|
+
"409": {
|
|
1710
|
+
"description": "Conflict",
|
|
1711
|
+
"content": {
|
|
1712
|
+
"application/json": {
|
|
1713
|
+
"schema": {
|
|
1714
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1715
|
+
}
|
|
1716
|
+
}
|
|
1717
|
+
}
|
|
1718
|
+
},
|
|
1719
|
+
"422": {
|
|
1720
|
+
"description": "Validation Error",
|
|
1721
|
+
"content": {
|
|
1722
|
+
"application/json": {
|
|
1723
|
+
"schema": {
|
|
1724
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1725
|
+
}
|
|
1726
|
+
}
|
|
1727
|
+
}
|
|
1728
|
+
}
|
|
1729
|
+
}
|
|
1730
|
+
}
|
|
1731
|
+
},
|
|
1732
|
+
"/threads/{thread_id}/runs/{run_id}": {
|
|
1733
|
+
"get": {
|
|
1734
|
+
"tags": ["Thread Runs"],
|
|
1735
|
+
"summary": "Get Run",
|
|
1736
|
+
"description": "Get a run by ID.",
|
|
1737
|
+
"operationId": "get_run_http_threads__thread_id__runs__run_id__get",
|
|
1738
|
+
"parameters": [
|
|
1739
|
+
{
|
|
1740
|
+
"description": "The ID of the thread.",
|
|
1741
|
+
"required": true,
|
|
1742
|
+
"schema": {
|
|
1743
|
+
"type": "string",
|
|
1744
|
+
"format": "uuid",
|
|
1745
|
+
"title": "Thread Id",
|
|
1746
|
+
"description": "The ID of the thread."
|
|
1747
|
+
},
|
|
1748
|
+
"name": "thread_id",
|
|
1749
|
+
"in": "path"
|
|
1750
|
+
},
|
|
1751
|
+
{
|
|
1752
|
+
"description": "The ID of the run.",
|
|
1753
|
+
"required": true,
|
|
1754
|
+
"schema": {
|
|
1755
|
+
"type": "string",
|
|
1756
|
+
"format": "uuid",
|
|
1757
|
+
"title": "Run Id",
|
|
1758
|
+
"description": "The ID of the run."
|
|
1759
|
+
},
|
|
1760
|
+
"name": "run_id",
|
|
1761
|
+
"in": "path"
|
|
1762
|
+
}
|
|
1763
|
+
],
|
|
1764
|
+
"responses": {
|
|
1765
|
+
"200": {
|
|
1766
|
+
"description": "Success",
|
|
1767
|
+
"content": {
|
|
1768
|
+
"application/json": {
|
|
1769
|
+
"schema": {
|
|
1770
|
+
"$ref": "#/components/schemas/Run"
|
|
1771
|
+
}
|
|
1772
|
+
}
|
|
1773
|
+
}
|
|
1774
|
+
},
|
|
1775
|
+
"404": {
|
|
1776
|
+
"description": "Not Found",
|
|
1777
|
+
"content": {
|
|
1778
|
+
"application/json": {
|
|
1779
|
+
"schema": {
|
|
1780
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1781
|
+
}
|
|
1782
|
+
}
|
|
1783
|
+
}
|
|
1784
|
+
},
|
|
1785
|
+
"422": {
|
|
1786
|
+
"description": "Validation Error",
|
|
1787
|
+
"content": {
|
|
1788
|
+
"application/json": {
|
|
1789
|
+
"schema": {
|
|
1790
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1791
|
+
}
|
|
1792
|
+
}
|
|
1793
|
+
}
|
|
1794
|
+
}
|
|
1795
|
+
}
|
|
1796
|
+
},
|
|
1797
|
+
"delete": {
|
|
1798
|
+
"tags": ["Thread Runs"],
|
|
1799
|
+
"summary": "Delete Run",
|
|
1800
|
+
"description": "Delete a run by ID.",
|
|
1801
|
+
"operationId": "delete_run_threads__thread_id__runs__run_id__delete",
|
|
1802
|
+
"parameters": [
|
|
1803
|
+
{
|
|
1804
|
+
"description": "The ID of the thread.",
|
|
1805
|
+
"required": true,
|
|
1806
|
+
"schema": {
|
|
1807
|
+
"type": "string",
|
|
1808
|
+
"format": "uuid",
|
|
1809
|
+
"title": "Thread Id",
|
|
1810
|
+
"description": "The ID of the thread."
|
|
1811
|
+
},
|
|
1812
|
+
"name": "thread_id",
|
|
1813
|
+
"in": "path"
|
|
1814
|
+
},
|
|
1815
|
+
{
|
|
1816
|
+
"description": "The ID of the run.",
|
|
1817
|
+
"required": true,
|
|
1818
|
+
"schema": {
|
|
1819
|
+
"type": "string",
|
|
1820
|
+
"format": "uuid",
|
|
1821
|
+
"title": "Run Id",
|
|
1822
|
+
"description": "The ID of the run."
|
|
1823
|
+
},
|
|
1824
|
+
"name": "run_id",
|
|
1825
|
+
"in": "path"
|
|
1826
|
+
}
|
|
1827
|
+
],
|
|
1828
|
+
"responses": {
|
|
1829
|
+
"200": {
|
|
1830
|
+
"description": "Success",
|
|
1831
|
+
"content": {
|
|
1832
|
+
"application/json": {
|
|
1833
|
+
"schema": {}
|
|
1834
|
+
}
|
|
1835
|
+
}
|
|
1836
|
+
},
|
|
1837
|
+
"404": {
|
|
1838
|
+
"description": "Not Found",
|
|
1839
|
+
"content": {
|
|
1840
|
+
"application/json": {
|
|
1841
|
+
"schema": {
|
|
1842
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1843
|
+
}
|
|
1844
|
+
}
|
|
1845
|
+
}
|
|
1846
|
+
},
|
|
1847
|
+
"422": {
|
|
1848
|
+
"description": "Validation Error",
|
|
1849
|
+
"content": {
|
|
1850
|
+
"application/json": {
|
|
1851
|
+
"schema": {
|
|
1852
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1853
|
+
}
|
|
1854
|
+
}
|
|
1855
|
+
}
|
|
1856
|
+
}
|
|
1857
|
+
}
|
|
1858
|
+
}
|
|
1859
|
+
},
|
|
1860
|
+
"/threads/{thread_id}/runs/{run_id}/join": {
|
|
1861
|
+
"get": {
|
|
1862
|
+
"tags": ["Thread Runs"],
|
|
1863
|
+
"summary": "Join Run",
|
|
1864
|
+
"description": "Wait for a run to finish.",
|
|
1865
|
+
"operationId": "join_run_http_threads__thread_id__runs__run_id__join_get",
|
|
1866
|
+
"parameters": [
|
|
1867
|
+
{
|
|
1868
|
+
"description": "The ID of the thread.",
|
|
1869
|
+
"required": true,
|
|
1870
|
+
"schema": {
|
|
1871
|
+
"type": "string",
|
|
1872
|
+
"format": "uuid",
|
|
1873
|
+
"title": "Thread Id",
|
|
1874
|
+
"description": "The ID of the thread."
|
|
1875
|
+
},
|
|
1876
|
+
"name": "thread_id",
|
|
1877
|
+
"in": "path"
|
|
1878
|
+
},
|
|
1879
|
+
{
|
|
1880
|
+
"description": "The ID of the run.",
|
|
1881
|
+
"required": true,
|
|
1882
|
+
"schema": {
|
|
1883
|
+
"type": "string",
|
|
1884
|
+
"format": "uuid",
|
|
1885
|
+
"title": "Run Id",
|
|
1886
|
+
"description": "The ID of the run."
|
|
1887
|
+
},
|
|
1888
|
+
"name": "run_id",
|
|
1889
|
+
"in": "path"
|
|
1890
|
+
},
|
|
1891
|
+
{
|
|
1892
|
+
"required": false,
|
|
1893
|
+
"schema": {
|
|
1894
|
+
"type": "boolean",
|
|
1895
|
+
"title": "Cancel on Disconnect",
|
|
1896
|
+
"description": "If true, the run will be cancelled if the client disconnects.",
|
|
1897
|
+
"default": false
|
|
1898
|
+
},
|
|
1899
|
+
"name": "cancel_on_disconnect",
|
|
1900
|
+
"in": "query"
|
|
1901
|
+
}
|
|
1902
|
+
],
|
|
1903
|
+
"responses": {
|
|
1904
|
+
"200": {
|
|
1905
|
+
"description": "Success",
|
|
1906
|
+
"content": {
|
|
1907
|
+
"application/json": {
|
|
1908
|
+
"schema": {}
|
|
1909
|
+
}
|
|
1910
|
+
}
|
|
1911
|
+
},
|
|
1912
|
+
"404": {
|
|
1913
|
+
"description": "Not Found",
|
|
1914
|
+
"content": {
|
|
1915
|
+
"application/json": {
|
|
1916
|
+
"schema": {
|
|
1917
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1918
|
+
}
|
|
1919
|
+
}
|
|
1920
|
+
}
|
|
1921
|
+
},
|
|
1922
|
+
"422": {
|
|
1923
|
+
"description": "Validation Error",
|
|
1924
|
+
"content": {
|
|
1925
|
+
"application/json": {
|
|
1926
|
+
"schema": {
|
|
1927
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1928
|
+
}
|
|
1929
|
+
}
|
|
1930
|
+
}
|
|
1931
|
+
}
|
|
1932
|
+
}
|
|
1933
|
+
}
|
|
1934
|
+
},
|
|
1935
|
+
"/threads/{thread_id}/runs/{run_id}/stream": {
|
|
1936
|
+
"get": {
|
|
1937
|
+
"tags": ["Thread Runs"],
|
|
1938
|
+
"summary": "Join Run Stream",
|
|
1939
|
+
"description": "Join a run stream. This endpoint streams output in real-time from a run similar to the /threads/__THREAD_ID__/runs/stream endpoint. Only output produced after this endpoint is called will be streamed.",
|
|
1940
|
+
"operationId": "stream_run_http_threads__thread_id__runs__run_id__join_get",
|
|
1941
|
+
"parameters": [
|
|
1942
|
+
{
|
|
1943
|
+
"description": "The ID of the thread.",
|
|
1944
|
+
"required": true,
|
|
1945
|
+
"schema": {
|
|
1946
|
+
"type": "string",
|
|
1947
|
+
"format": "uuid",
|
|
1948
|
+
"title": "Thread Id",
|
|
1949
|
+
"description": "The ID of the thread."
|
|
1950
|
+
},
|
|
1951
|
+
"name": "thread_id",
|
|
1952
|
+
"in": "path"
|
|
1953
|
+
},
|
|
1954
|
+
{
|
|
1955
|
+
"description": "The ID of the run.",
|
|
1956
|
+
"required": true,
|
|
1957
|
+
"schema": {
|
|
1958
|
+
"type": "string",
|
|
1959
|
+
"format": "uuid",
|
|
1960
|
+
"title": "Run Id",
|
|
1961
|
+
"description": "The ID of the run."
|
|
1962
|
+
},
|
|
1963
|
+
"name": "run_id",
|
|
1964
|
+
"in": "path"
|
|
1965
|
+
}
|
|
1966
|
+
],
|
|
1967
|
+
"responses": {
|
|
1968
|
+
"200": {
|
|
1969
|
+
"description": "Success",
|
|
1970
|
+
"content": {
|
|
1971
|
+
"text/event-stream": {
|
|
1972
|
+
"schema": {
|
|
1973
|
+
"type": "string",
|
|
1974
|
+
"description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
|
|
1975
|
+
}
|
|
1976
|
+
}
|
|
1977
|
+
}
|
|
1978
|
+
},
|
|
1979
|
+
"404": {
|
|
1980
|
+
"description": "Not Found",
|
|
1981
|
+
"content": {
|
|
1982
|
+
"application/json": {
|
|
1983
|
+
"schema": {
|
|
1984
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1985
|
+
}
|
|
1986
|
+
}
|
|
1987
|
+
}
|
|
1988
|
+
},
|
|
1989
|
+
"422": {
|
|
1990
|
+
"description": "Validation Error",
|
|
1991
|
+
"content": {
|
|
1992
|
+
"application/json": {
|
|
1993
|
+
"schema": {
|
|
1994
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
1995
|
+
}
|
|
1996
|
+
}
|
|
1997
|
+
}
|
|
1998
|
+
}
|
|
1999
|
+
}
|
|
2000
|
+
}
|
|
2001
|
+
},
|
|
2002
|
+
"/threads/{thread_id}/runs/{run_id}/cancel": {
|
|
2003
|
+
"post": {
|
|
2004
|
+
"tags": ["Thread Runs"],
|
|
2005
|
+
"summary": "Cancel Run",
|
|
2006
|
+
"operationId": "cancel_run_http_threads__thread_id__runs__run_id__cancel_post",
|
|
2007
|
+
"parameters": [
|
|
2008
|
+
{
|
|
2009
|
+
"description": "The ID of the thread.",
|
|
2010
|
+
"required": true,
|
|
2011
|
+
"schema": {
|
|
2012
|
+
"type": "string",
|
|
2013
|
+
"format": "uuid",
|
|
2014
|
+
"title": "Thread Id",
|
|
2015
|
+
"description": "The ID of the thread."
|
|
2016
|
+
},
|
|
2017
|
+
"name": "thread_id",
|
|
2018
|
+
"in": "path"
|
|
2019
|
+
},
|
|
2020
|
+
{
|
|
2021
|
+
"description": "The ID of the run.",
|
|
2022
|
+
"required": true,
|
|
2023
|
+
"schema": {
|
|
2024
|
+
"type": "string",
|
|
2025
|
+
"format": "uuid",
|
|
2026
|
+
"title": "Run Id",
|
|
2027
|
+
"description": "The ID of the run."
|
|
2028
|
+
},
|
|
2029
|
+
"name": "run_id",
|
|
2030
|
+
"in": "path"
|
|
2031
|
+
},
|
|
2032
|
+
{
|
|
2033
|
+
"required": false,
|
|
2034
|
+
"schema": {
|
|
2035
|
+
"type": "boolean",
|
|
2036
|
+
"title": "Wait",
|
|
2037
|
+
"default": false
|
|
2038
|
+
},
|
|
2039
|
+
"name": "wait",
|
|
2040
|
+
"in": "query"
|
|
2041
|
+
},
|
|
2042
|
+
{
|
|
2043
|
+
"description": "Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.",
|
|
2044
|
+
"required": false,
|
|
2045
|
+
"schema": {
|
|
2046
|
+
"type": "string",
|
|
2047
|
+
"enum": ["interrupt", "rollback"],
|
|
2048
|
+
"title": "Action",
|
|
2049
|
+
"default": "interrupt"
|
|
2050
|
+
},
|
|
2051
|
+
"name": "action",
|
|
2052
|
+
"in": "query"
|
|
2053
|
+
}
|
|
2054
|
+
],
|
|
2055
|
+
"responses": {
|
|
2056
|
+
"200": {
|
|
2057
|
+
"description": "Success",
|
|
2058
|
+
"content": {
|
|
2059
|
+
"application/json": {
|
|
2060
|
+
"schema": {}
|
|
2061
|
+
}
|
|
2062
|
+
}
|
|
2063
|
+
},
|
|
2064
|
+
"404": {
|
|
2065
|
+
"description": "Not Found",
|
|
2066
|
+
"content": {
|
|
2067
|
+
"application/json": {
|
|
2068
|
+
"schema": {
|
|
2069
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2070
|
+
}
|
|
2071
|
+
}
|
|
2072
|
+
}
|
|
2073
|
+
},
|
|
2074
|
+
"422": {
|
|
2075
|
+
"description": "Validation Error",
|
|
2076
|
+
"content": {
|
|
2077
|
+
"application/json": {
|
|
2078
|
+
"schema": {
|
|
2079
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2080
|
+
}
|
|
2081
|
+
}
|
|
2082
|
+
}
|
|
2083
|
+
}
|
|
2084
|
+
}
|
|
2085
|
+
}
|
|
2086
|
+
},
|
|
2087
|
+
"/runs/crons": {
|
|
2088
|
+
"post": {
|
|
2089
|
+
"tags": ["Crons (Plus tier)"],
|
|
2090
|
+
"summary": "Create Cron",
|
|
2091
|
+
"description": "Create a cron to schedule runs on new threads.",
|
|
2092
|
+
"operationId": "create_cron_runs_crons_post",
|
|
2093
|
+
"requestBody": {
|
|
2094
|
+
"content": {
|
|
2095
|
+
"application/json": {
|
|
2096
|
+
"schema": {
|
|
2097
|
+
"$ref": "#/components/schemas/CronCreate"
|
|
2098
|
+
}
|
|
2099
|
+
}
|
|
2100
|
+
},
|
|
2101
|
+
"required": true
|
|
2102
|
+
},
|
|
2103
|
+
"responses": {
|
|
2104
|
+
"200": {
|
|
2105
|
+
"description": "Success",
|
|
2106
|
+
"content": {
|
|
2107
|
+
"application/json": {
|
|
2108
|
+
"schema": {
|
|
2109
|
+
"$ref": "#/components/schemas/Cron"
|
|
2110
|
+
}
|
|
2111
|
+
}
|
|
2112
|
+
}
|
|
2113
|
+
},
|
|
2114
|
+
"404": {
|
|
2115
|
+
"description": "Not Found",
|
|
2116
|
+
"content": {
|
|
2117
|
+
"application/json": {
|
|
2118
|
+
"schema": {
|
|
2119
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2120
|
+
}
|
|
2121
|
+
}
|
|
2122
|
+
}
|
|
2123
|
+
},
|
|
2124
|
+
"422": {
|
|
2125
|
+
"description": "Validation Error",
|
|
2126
|
+
"content": {
|
|
2127
|
+
"application/json": {
|
|
2128
|
+
"schema": {
|
|
2129
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2130
|
+
}
|
|
2131
|
+
}
|
|
2132
|
+
}
|
|
2133
|
+
}
|
|
2134
|
+
}
|
|
2135
|
+
}
|
|
2136
|
+
},
|
|
2137
|
+
"/runs/crons/search": {
|
|
2138
|
+
"post": {
|
|
2139
|
+
"tags": ["Crons (Plus tier)"],
|
|
2140
|
+
"summary": "Search Crons",
|
|
2141
|
+
"description": "Search all active crons",
|
|
2142
|
+
"operationId": "search_crons_runs_crons_post",
|
|
2143
|
+
"requestBody": {
|
|
2144
|
+
"content": {
|
|
2145
|
+
"application/json": {
|
|
2146
|
+
"schema": {
|
|
2147
|
+
"$ref": "#/components/schemas/CronSearch"
|
|
2148
|
+
}
|
|
2149
|
+
}
|
|
2150
|
+
},
|
|
2151
|
+
"required": true
|
|
2152
|
+
},
|
|
2153
|
+
"responses": {
|
|
2154
|
+
"200": {
|
|
2155
|
+
"description": "Success",
|
|
2156
|
+
"content": {
|
|
2157
|
+
"application/json": {
|
|
2158
|
+
"schema": {
|
|
2159
|
+
"items": {
|
|
2160
|
+
"$ref": "#/components/schemas/Cron"
|
|
2161
|
+
},
|
|
2162
|
+
"type": "array",
|
|
2163
|
+
"title": "Response Search Crons Search Post"
|
|
2164
|
+
}
|
|
2165
|
+
}
|
|
2166
|
+
}
|
|
2167
|
+
},
|
|
2168
|
+
"422": {
|
|
2169
|
+
"description": "Validation Error",
|
|
2170
|
+
"content": {
|
|
2171
|
+
"application/json": {
|
|
2172
|
+
"schema": {
|
|
2173
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2174
|
+
}
|
|
2175
|
+
}
|
|
2176
|
+
}
|
|
2177
|
+
}
|
|
2178
|
+
}
|
|
2179
|
+
}
|
|
2180
|
+
},
|
|
2181
|
+
"/runs/stream": {
|
|
2182
|
+
"post": {
|
|
2183
|
+
"tags": ["Stateless Runs"],
|
|
2184
|
+
"summary": "Create Run, Stream Output",
|
|
2185
|
+
"description": "Create a run in a new thread, stream the output.",
|
|
2186
|
+
"operationId": "stream_run_stateless_runs_stream_post",
|
|
2187
|
+
"requestBody": {
|
|
2188
|
+
"content": {
|
|
2189
|
+
"application/json": {
|
|
2190
|
+
"schema": {
|
|
2191
|
+
"$ref": "#/components/schemas/RunCreateStateless"
|
|
2192
|
+
}
|
|
2193
|
+
}
|
|
2194
|
+
},
|
|
2195
|
+
"required": true
|
|
2196
|
+
},
|
|
2197
|
+
"responses": {
|
|
2198
|
+
"200": {
|
|
2199
|
+
"description": "Success",
|
|
2200
|
+
"content": {
|
|
2201
|
+
"text/event-stream": {
|
|
2202
|
+
"schema": {
|
|
2203
|
+
"type": "string",
|
|
2204
|
+
"description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
|
|
2205
|
+
}
|
|
2206
|
+
}
|
|
2207
|
+
}
|
|
2208
|
+
},
|
|
2209
|
+
"404": {
|
|
2210
|
+
"description": "Not Found",
|
|
2211
|
+
"content": {
|
|
2212
|
+
"application/json": {
|
|
2213
|
+
"schema": {
|
|
2214
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2215
|
+
}
|
|
2216
|
+
}
|
|
2217
|
+
}
|
|
2218
|
+
},
|
|
2219
|
+
"409": {
|
|
2220
|
+
"description": "Conflict",
|
|
2221
|
+
"content": {
|
|
2222
|
+
"application/json": {
|
|
2223
|
+
"schema": {
|
|
2224
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2225
|
+
}
|
|
2226
|
+
}
|
|
2227
|
+
}
|
|
2228
|
+
},
|
|
2229
|
+
"422": {
|
|
2230
|
+
"description": "Validation Error",
|
|
2231
|
+
"content": {
|
|
2232
|
+
"application/json": {
|
|
2233
|
+
"schema": {
|
|
2234
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2235
|
+
}
|
|
2236
|
+
}
|
|
2237
|
+
}
|
|
2238
|
+
}
|
|
2239
|
+
}
|
|
2240
|
+
}
|
|
2241
|
+
},
|
|
2242
|
+
"/runs/cancel": {
|
|
2243
|
+
"post": {
|
|
2244
|
+
"tags": ["Thread Runs"],
|
|
2245
|
+
"summary": "Cancel Runs",
|
|
2246
|
+
"description": "Cancel one or more runs. Can cancel runs by thread ID and run IDs, or by status filter.",
|
|
2247
|
+
"operationId": "cancel_runs_post",
|
|
2248
|
+
"parameters": [
|
|
2249
|
+
{
|
|
2250
|
+
"description": "Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.",
|
|
2251
|
+
"required": false,
|
|
2252
|
+
"schema": {
|
|
2253
|
+
"type": "string",
|
|
2254
|
+
"enum": ["interrupt", "rollback"],
|
|
2255
|
+
"title": "Action",
|
|
2256
|
+
"default": "interrupt"
|
|
2257
|
+
},
|
|
2258
|
+
"name": "action",
|
|
2259
|
+
"in": "query"
|
|
2260
|
+
}
|
|
2261
|
+
],
|
|
2262
|
+
"requestBody": {
|
|
2263
|
+
"content": {
|
|
2264
|
+
"application/json": {
|
|
2265
|
+
"schema": {
|
|
2266
|
+
"$ref": "#/components/schemas/RunsCancel"
|
|
2267
|
+
}
|
|
2268
|
+
}
|
|
2269
|
+
},
|
|
2270
|
+
"required": true
|
|
2271
|
+
},
|
|
2272
|
+
"responses": {
|
|
2273
|
+
"204": {
|
|
2274
|
+
"description": "Success - Runs cancelled"
|
|
2275
|
+
},
|
|
2276
|
+
"404": {
|
|
2277
|
+
"description": "Not Found",
|
|
2278
|
+
"content": {
|
|
2279
|
+
"application/json": {
|
|
2280
|
+
"schema": {
|
|
2281
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2282
|
+
}
|
|
2283
|
+
}
|
|
2284
|
+
}
|
|
2285
|
+
},
|
|
2286
|
+
"422": {
|
|
2287
|
+
"description": "Validation Error",
|
|
2288
|
+
"content": {
|
|
2289
|
+
"application/json": {
|
|
2290
|
+
"schema": {
|
|
2291
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2292
|
+
}
|
|
2293
|
+
}
|
|
2294
|
+
}
|
|
2295
|
+
}
|
|
2296
|
+
}
|
|
2297
|
+
}
|
|
2298
|
+
},
|
|
2299
|
+
"/runs/wait": {
|
|
2300
|
+
"post": {
|
|
2301
|
+
"tags": ["Stateless Runs"],
|
|
2302
|
+
"summary": "Create Run, Wait for Output",
|
|
2303
|
+
"description": "Create a run in a new thread. Wait for the final output and then return it.",
|
|
2304
|
+
"operationId": "wait_run_stateless_runs_wait_post",
|
|
2305
|
+
"requestBody": {
|
|
2306
|
+
"content": {
|
|
2307
|
+
"application/json": {
|
|
2308
|
+
"schema": {
|
|
2309
|
+
"$ref": "#/components/schemas/RunCreateStateless"
|
|
2310
|
+
}
|
|
2311
|
+
}
|
|
2312
|
+
},
|
|
2313
|
+
"required": true
|
|
2314
|
+
},
|
|
2315
|
+
"responses": {
|
|
2316
|
+
"200": {
|
|
2317
|
+
"description": "Success",
|
|
2318
|
+
"content": {
|
|
2319
|
+
"application/json": {
|
|
2320
|
+
"schema": {}
|
|
2321
|
+
}
|
|
2322
|
+
}
|
|
2323
|
+
},
|
|
2324
|
+
"404": {
|
|
2325
|
+
"description": "Not Found",
|
|
2326
|
+
"content": {
|
|
2327
|
+
"application/json": {
|
|
2328
|
+
"schema": {
|
|
2329
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2330
|
+
}
|
|
2331
|
+
}
|
|
2332
|
+
}
|
|
2333
|
+
},
|
|
2334
|
+
"409": {
|
|
2335
|
+
"description": "Conflict",
|
|
2336
|
+
"content": {
|
|
2337
|
+
"application/json": {
|
|
2338
|
+
"schema": {
|
|
2339
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2340
|
+
}
|
|
2341
|
+
}
|
|
2342
|
+
}
|
|
2343
|
+
},
|
|
2344
|
+
"422": {
|
|
2345
|
+
"description": "Validation Error",
|
|
2346
|
+
"content": {
|
|
2347
|
+
"application/json": {
|
|
2348
|
+
"schema": {
|
|
2349
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2350
|
+
}
|
|
2351
|
+
}
|
|
2352
|
+
}
|
|
2353
|
+
}
|
|
2354
|
+
}
|
|
2355
|
+
}
|
|
2356
|
+
},
|
|
2357
|
+
"/runs": {
|
|
2358
|
+
"post": {
|
|
2359
|
+
"tags": ["Stateless Runs"],
|
|
2360
|
+
"summary": "Create Background Run",
|
|
2361
|
+
"description": "Create a run in a new thread, return the run ID immediately. Don't wait for the final run output.",
|
|
2362
|
+
"operationId": "run_stateless_runs_post",
|
|
2363
|
+
"requestBody": {
|
|
2364
|
+
"content": {
|
|
2365
|
+
"application/json": {
|
|
2366
|
+
"schema": {
|
|
2367
|
+
"$ref": "#/components/schemas/RunCreateStateless"
|
|
2368
|
+
}
|
|
2369
|
+
}
|
|
2370
|
+
},
|
|
2371
|
+
"required": true
|
|
2372
|
+
},
|
|
2373
|
+
"responses": {
|
|
2374
|
+
"200": {
|
|
2375
|
+
"description": "Success",
|
|
2376
|
+
"content": {
|
|
2377
|
+
"application/json": {
|
|
2378
|
+
"schema": {}
|
|
2379
|
+
}
|
|
2380
|
+
}
|
|
2381
|
+
},
|
|
2382
|
+
"404": {
|
|
2383
|
+
"description": "Not Found",
|
|
2384
|
+
"content": {
|
|
2385
|
+
"application/json": {
|
|
2386
|
+
"schema": {
|
|
2387
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2388
|
+
}
|
|
2389
|
+
}
|
|
2390
|
+
}
|
|
2391
|
+
},
|
|
2392
|
+
"409": {
|
|
2393
|
+
"description": "Conflict",
|
|
2394
|
+
"content": {
|
|
2395
|
+
"application/json": {
|
|
2396
|
+
"schema": {
|
|
2397
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2398
|
+
}
|
|
2399
|
+
}
|
|
2400
|
+
}
|
|
2401
|
+
},
|
|
2402
|
+
"422": {
|
|
2403
|
+
"description": "Validation Error",
|
|
2404
|
+
"content": {
|
|
2405
|
+
"application/json": {
|
|
2406
|
+
"schema": {
|
|
2407
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2408
|
+
}
|
|
2409
|
+
}
|
|
2410
|
+
}
|
|
2411
|
+
}
|
|
2412
|
+
}
|
|
2413
|
+
}
|
|
2414
|
+
},
|
|
2415
|
+
"/runs/batch": {
|
|
2416
|
+
"post": {
|
|
2417
|
+
"tags": ["Stateless Runs"],
|
|
2418
|
+
"summary": "Create Run Batch",
|
|
2419
|
+
"description": "Create a batch of runs in new threads, return immediately.",
|
|
2420
|
+
"operationId": "run_batch_stateless_runs_post",
|
|
2421
|
+
"requestBody": {
|
|
2422
|
+
"content": {
|
|
2423
|
+
"application/json": {
|
|
2424
|
+
"schema": {
|
|
2425
|
+
"$ref": "#/components/schemas/RunBatchCreate"
|
|
2426
|
+
}
|
|
2427
|
+
}
|
|
2428
|
+
},
|
|
2429
|
+
"required": true
|
|
2430
|
+
},
|
|
2431
|
+
"responses": {
|
|
2432
|
+
"200": {
|
|
2433
|
+
"description": "Success",
|
|
2434
|
+
"content": {
|
|
2435
|
+
"application/json": {
|
|
2436
|
+
"schema": {}
|
|
2437
|
+
}
|
|
2438
|
+
}
|
|
2439
|
+
},
|
|
2440
|
+
"404": {
|
|
2441
|
+
"description": "Not Found",
|
|
2442
|
+
"content": {
|
|
2443
|
+
"application/json": {
|
|
2444
|
+
"schema": {
|
|
2445
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2446
|
+
}
|
|
2447
|
+
}
|
|
2448
|
+
}
|
|
2449
|
+
},
|
|
2450
|
+
"409": {
|
|
2451
|
+
"description": "Conflict",
|
|
2452
|
+
"content": {
|
|
2453
|
+
"application/json": {
|
|
2454
|
+
"schema": {
|
|
2455
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2456
|
+
}
|
|
2457
|
+
}
|
|
2458
|
+
}
|
|
2459
|
+
},
|
|
2460
|
+
"422": {
|
|
2461
|
+
"description": "Validation Error",
|
|
2462
|
+
"content": {
|
|
2463
|
+
"application/json": {
|
|
2464
|
+
"schema": {
|
|
2465
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2466
|
+
}
|
|
2467
|
+
}
|
|
2468
|
+
}
|
|
2469
|
+
}
|
|
2470
|
+
}
|
|
2471
|
+
}
|
|
2472
|
+
},
|
|
2473
|
+
"/runs/crons/{cron_id}": {
|
|
2474
|
+
"delete": {
|
|
2475
|
+
"tags": ["Crons (Plus tier)"],
|
|
2476
|
+
"summary": "Delete Cron",
|
|
2477
|
+
"description": "Delete a cron by ID.",
|
|
2478
|
+
"operationId": "delete_cron_runs_crons__cron_id__delete",
|
|
2479
|
+
"parameters": [
|
|
2480
|
+
{
|
|
2481
|
+
"required": true,
|
|
2482
|
+
"schema": {
|
|
2483
|
+
"type": "string",
|
|
2484
|
+
"format": "uuid",
|
|
2485
|
+
"title": "Cron Id"
|
|
2486
|
+
},
|
|
2487
|
+
"name": "cron_id",
|
|
2488
|
+
"in": "path"
|
|
2489
|
+
}
|
|
2490
|
+
],
|
|
2491
|
+
"responses": {
|
|
2492
|
+
"200": {
|
|
2493
|
+
"description": "Success",
|
|
2494
|
+
"content": {
|
|
2495
|
+
"application/json": {
|
|
2496
|
+
"schema": {}
|
|
2497
|
+
}
|
|
2498
|
+
}
|
|
2499
|
+
},
|
|
2500
|
+
"404": {
|
|
2501
|
+
"description": "Not Found",
|
|
2502
|
+
"content": {
|
|
2503
|
+
"application/json": {
|
|
2504
|
+
"schema": {
|
|
2505
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2506
|
+
}
|
|
2507
|
+
}
|
|
2508
|
+
}
|
|
2509
|
+
},
|
|
2510
|
+
"422": {
|
|
2511
|
+
"description": "Validation Error",
|
|
2512
|
+
"content": {
|
|
2513
|
+
"application/json": {
|
|
2514
|
+
"schema": {
|
|
2515
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2516
|
+
}
|
|
2517
|
+
}
|
|
2518
|
+
}
|
|
2519
|
+
}
|
|
2520
|
+
}
|
|
2521
|
+
}
|
|
2522
|
+
},
|
|
2523
|
+
"/store/items": {
|
|
2524
|
+
"put": {
|
|
2525
|
+
"tags": ["Store"],
|
|
2526
|
+
"summary": "Store or update an item.",
|
|
2527
|
+
"operationId": "put_item",
|
|
2528
|
+
"requestBody": {
|
|
2529
|
+
"required": true,
|
|
2530
|
+
"content": {
|
|
2531
|
+
"application/json": {
|
|
2532
|
+
"schema": {
|
|
2533
|
+
"$ref": "#/components/schemas/StorePutRequest"
|
|
2534
|
+
}
|
|
2535
|
+
}
|
|
2536
|
+
}
|
|
2537
|
+
},
|
|
2538
|
+
"responses": {
|
|
2539
|
+
"204": {
|
|
2540
|
+
"description": "Success"
|
|
2541
|
+
},
|
|
2542
|
+
"422": {
|
|
2543
|
+
"description": "Validation Error",
|
|
2544
|
+
"content": {
|
|
2545
|
+
"application/json": {
|
|
2546
|
+
"schema": {
|
|
2547
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2548
|
+
}
|
|
2549
|
+
}
|
|
2550
|
+
}
|
|
2551
|
+
}
|
|
2552
|
+
}
|
|
2553
|
+
},
|
|
2554
|
+
"delete": {
|
|
2555
|
+
"tags": ["Store"],
|
|
2556
|
+
"summary": "Delete an item.",
|
|
2557
|
+
"operationId": "delete_item",
|
|
2558
|
+
"requestBody": {
|
|
2559
|
+
"required": true,
|
|
2560
|
+
"content": {
|
|
2561
|
+
"application/json": {
|
|
2562
|
+
"schema": {
|
|
2563
|
+
"$ref": "#/components/schemas/StoreDeleteRequest"
|
|
2564
|
+
}
|
|
2565
|
+
}
|
|
2566
|
+
}
|
|
2567
|
+
},
|
|
2568
|
+
"responses": {
|
|
2569
|
+
"204": {
|
|
2570
|
+
"description": "Success"
|
|
2571
|
+
},
|
|
2572
|
+
"422": {
|
|
2573
|
+
"description": "Validation Error",
|
|
2574
|
+
"content": {
|
|
2575
|
+
"application/json": {
|
|
2576
|
+
"schema": {
|
|
2577
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2578
|
+
}
|
|
2579
|
+
}
|
|
2580
|
+
}
|
|
2581
|
+
}
|
|
2582
|
+
}
|
|
2583
|
+
},
|
|
2584
|
+
"get": {
|
|
2585
|
+
"tags": ["Store"],
|
|
2586
|
+
"summary": "Retrieve a single item.",
|
|
2587
|
+
"operationId": "get_item",
|
|
2588
|
+
"parameters": [
|
|
2589
|
+
{
|
|
2590
|
+
"name": "key",
|
|
2591
|
+
"in": "query",
|
|
2592
|
+
"required": true,
|
|
2593
|
+
"schema": {
|
|
2594
|
+
"type": "string"
|
|
2595
|
+
}
|
|
2596
|
+
},
|
|
2597
|
+
{
|
|
2598
|
+
"name": "namespace",
|
|
2599
|
+
"in": "query",
|
|
2600
|
+
"required": false,
|
|
2601
|
+
"schema": {
|
|
2602
|
+
"type": "array",
|
|
2603
|
+
"items": {
|
|
2604
|
+
"type": "string"
|
|
2605
|
+
}
|
|
2606
|
+
}
|
|
2607
|
+
}
|
|
2608
|
+
],
|
|
2609
|
+
"responses": {
|
|
2610
|
+
"200": {
|
|
2611
|
+
"description": "Success",
|
|
2612
|
+
"content": {
|
|
2613
|
+
"application/json": {
|
|
2614
|
+
"schema": {
|
|
2615
|
+
"$ref": "#/components/schemas/Item"
|
|
2616
|
+
}
|
|
2617
|
+
}
|
|
2618
|
+
}
|
|
2619
|
+
},
|
|
2620
|
+
"400": {
|
|
2621
|
+
"description": "Bad Request",
|
|
2622
|
+
"content": {
|
|
2623
|
+
"application/json": {
|
|
2624
|
+
"schema": {
|
|
2625
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2626
|
+
}
|
|
2627
|
+
}
|
|
2628
|
+
}
|
|
2629
|
+
},
|
|
2630
|
+
"422": {
|
|
2631
|
+
"description": "Validation Error",
|
|
2632
|
+
"content": {
|
|
2633
|
+
"application/json": {
|
|
2634
|
+
"schema": {
|
|
2635
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2636
|
+
}
|
|
2637
|
+
}
|
|
2638
|
+
}
|
|
2639
|
+
}
|
|
2640
|
+
}
|
|
2641
|
+
}
|
|
2642
|
+
},
|
|
2643
|
+
"/store/items/search": {
|
|
2644
|
+
"post": {
|
|
2645
|
+
"tags": ["Store"],
|
|
2646
|
+
"summary": "Search for items within a namespace prefix.",
|
|
2647
|
+
"operationId": "search_items",
|
|
2648
|
+
"requestBody": {
|
|
2649
|
+
"required": true,
|
|
2650
|
+
"content": {
|
|
2651
|
+
"application/json": {
|
|
2652
|
+
"schema": {
|
|
2653
|
+
"$ref": "#/components/schemas/StoreSearchRequest"
|
|
2654
|
+
}
|
|
2655
|
+
}
|
|
2656
|
+
}
|
|
2657
|
+
},
|
|
2658
|
+
"responses": {
|
|
2659
|
+
"200": {
|
|
2660
|
+
"description": "Success",
|
|
2661
|
+
"content": {
|
|
2662
|
+
"application/json": {
|
|
2663
|
+
"schema": {
|
|
2664
|
+
"$ref": "#/components/schemas/SearchItemsResponse"
|
|
2665
|
+
}
|
|
2666
|
+
}
|
|
2667
|
+
}
|
|
2668
|
+
},
|
|
2669
|
+
"422": {
|
|
2670
|
+
"description": "Validation Error",
|
|
2671
|
+
"content": {
|
|
2672
|
+
"application/json": {
|
|
2673
|
+
"schema": {
|
|
2674
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2675
|
+
}
|
|
2676
|
+
}
|
|
2677
|
+
}
|
|
2678
|
+
}
|
|
2679
|
+
}
|
|
2680
|
+
}
|
|
2681
|
+
},
|
|
2682
|
+
"/store/namespaces": {
|
|
2683
|
+
"post": {
|
|
2684
|
+
"tags": ["Store"],
|
|
2685
|
+
"summary": "List namespaces with optional match conditions.",
|
|
2686
|
+
"operationId": "list_namespaces",
|
|
2687
|
+
"requestBody": {
|
|
2688
|
+
"required": true,
|
|
2689
|
+
"content": {
|
|
2690
|
+
"application/json": {
|
|
2691
|
+
"schema": {
|
|
2692
|
+
"$ref": "#/components/schemas/StoreListNamespacesRequest"
|
|
2693
|
+
}
|
|
2694
|
+
}
|
|
2695
|
+
}
|
|
2696
|
+
},
|
|
2697
|
+
"responses": {
|
|
2698
|
+
"200": {
|
|
2699
|
+
"description": "Success",
|
|
2700
|
+
"content": {
|
|
2701
|
+
"application/json": {
|
|
2702
|
+
"schema": {
|
|
2703
|
+
"$ref": "#/components/schemas/ListNamespaceResponse"
|
|
2704
|
+
}
|
|
2705
|
+
}
|
|
2706
|
+
}
|
|
2707
|
+
},
|
|
2708
|
+
"422": {
|
|
2709
|
+
"description": "Validation Error",
|
|
2710
|
+
"content": {
|
|
2711
|
+
"application/json": {
|
|
2712
|
+
"schema": {
|
|
2713
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
2714
|
+
}
|
|
2715
|
+
}
|
|
2716
|
+
}
|
|
2717
|
+
}
|
|
2718
|
+
}
|
|
2719
|
+
}
|
|
2720
|
+
},
|
|
2721
|
+
"/mcp/": {
|
|
2722
|
+
"get": {
|
|
2723
|
+
"operationId": "get_mcp",
|
|
2724
|
+
"summary": "MCP Get",
|
|
2725
|
+
"description": "Implemented according to the Streamable HTTP Transport specification.",
|
|
2726
|
+
"responses": {
|
|
2727
|
+
"405": {
|
|
2728
|
+
"description": "GET method not allowed; streaming not supported."
|
|
2729
|
+
}
|
|
2730
|
+
},
|
|
2731
|
+
"tags": ["MCP"]
|
|
2732
|
+
},
|
|
2733
|
+
"post": {
|
|
2734
|
+
"operationId": "post_mcp",
|
|
2735
|
+
"summary": "MCP Post",
|
|
2736
|
+
"description": "Implemented according to the Streamable HTTP Transport specification.\nSends a JSON-RPC 2.0 message to the server.\n\n- **Request**: Provide an object with `jsonrpc`, `id`, `method`, and optional `params`.\n- **Response**: Returns a JSON-RPC response or acknowledgment.\n\n**Notes:**\n- Stateless: Sessions are not persisted across requests.\n",
|
|
2737
|
+
"parameters": [
|
|
2738
|
+
{
|
|
2739
|
+
"name": "Accept",
|
|
2740
|
+
"in": "header",
|
|
2741
|
+
"required": true,
|
|
2742
|
+
"schema": {
|
|
2743
|
+
"type": "string",
|
|
2744
|
+
"enum": ["application/json, text/event-stream"]
|
|
2745
|
+
},
|
|
2746
|
+
"description": "Accept header must include both 'application/json' and 'text/event-stream' media types."
|
|
2747
|
+
}
|
|
2748
|
+
],
|
|
2749
|
+
"requestBody": {
|
|
2750
|
+
"required": true,
|
|
2751
|
+
"content": {
|
|
2752
|
+
"application/json": {
|
|
2753
|
+
"schema": { "type": "object" },
|
|
2754
|
+
"description": "A JSON-RPC 2.0 request, notification, or response object.",
|
|
2755
|
+
"example": {
|
|
2756
|
+
"jsonrpc": "2.0",
|
|
2757
|
+
"id": "1",
|
|
2758
|
+
"method": "initialize",
|
|
2759
|
+
"params": {
|
|
2760
|
+
"clientInfo": {
|
|
2761
|
+
"name": "test_client",
|
|
2762
|
+
"version": "1.0.0"
|
|
2763
|
+
},
|
|
2764
|
+
"protocolVersion": "2024-11-05",
|
|
2765
|
+
"capabilities": {}
|
|
2766
|
+
}
|
|
2767
|
+
}
|
|
2768
|
+
}
|
|
2769
|
+
}
|
|
2770
|
+
},
|
|
2771
|
+
"responses": {
|
|
2772
|
+
"200": {
|
|
2773
|
+
"description": "Successful JSON-RPC response.",
|
|
2774
|
+
"content": {
|
|
2775
|
+
"application/json": { "schema": { "type": "object" } }
|
|
2776
|
+
}
|
|
2777
|
+
},
|
|
2778
|
+
"202": {
|
|
2779
|
+
"description": "Notification or response accepted; no content body."
|
|
2780
|
+
},
|
|
2781
|
+
"400": {
|
|
2782
|
+
"description": "Bad request: invalid JSON or message format, or unacceptable Accept header."
|
|
2783
|
+
},
|
|
2784
|
+
"405": {
|
|
2785
|
+
"description": "HTTP method not allowed."
|
|
2786
|
+
},
|
|
2787
|
+
"500": {
|
|
2788
|
+
"description": "Internal server error or unexpected failure."
|
|
2789
|
+
}
|
|
2790
|
+
},
|
|
2791
|
+
"tags": ["MCP"]
|
|
2792
|
+
},
|
|
2793
|
+
"delete": {
|
|
2794
|
+
"operationId": "delete_mcp",
|
|
2795
|
+
"summary": "Terminate Session",
|
|
2796
|
+
"description": "Implemented according to the Streamable HTTP Transport specification.\nTerminate an MCP session. The server implementation is stateless, so this is a no-op.\n\n",
|
|
2797
|
+
"responses": {
|
|
2798
|
+
"404": {}
|
|
2799
|
+
},
|
|
2800
|
+
"tags": ["MCP"]
|
|
2801
|
+
}
|
|
2802
|
+
}
|
|
2803
|
+
},
|
|
2804
|
+
"components": {
|
|
2805
|
+
"schemas": {
|
|
2806
|
+
"Assistant": {
|
|
2807
|
+
"properties": {
|
|
2808
|
+
"assistant_id": {
|
|
2809
|
+
"type": "string",
|
|
2810
|
+
"format": "uuid",
|
|
2811
|
+
"title": "Assistant Id",
|
|
2812
|
+
"description": "The ID of the assistant."
|
|
2813
|
+
},
|
|
2814
|
+
"graph_id": {
|
|
2815
|
+
"type": "string",
|
|
2816
|
+
"title": "Graph Id",
|
|
2817
|
+
"description": "The ID of the graph."
|
|
2818
|
+
},
|
|
2819
|
+
"config": {
|
|
2820
|
+
"properties": {
|
|
2821
|
+
"tags": {
|
|
2822
|
+
"items": {
|
|
2823
|
+
"type": "string"
|
|
2824
|
+
},
|
|
2825
|
+
"type": "array",
|
|
2826
|
+
"title": "Tags"
|
|
2827
|
+
},
|
|
2828
|
+
"recursion_limit": {
|
|
2829
|
+
"type": "integer",
|
|
2830
|
+
"title": "Recursion Limit"
|
|
2831
|
+
},
|
|
2832
|
+
"configurable": {
|
|
2833
|
+
"type": "object",
|
|
2834
|
+
"title": "Configurable"
|
|
2835
|
+
}
|
|
2836
|
+
},
|
|
2837
|
+
"type": "object",
|
|
2838
|
+
"title": "Config",
|
|
2839
|
+
"description": "The assistant config."
|
|
2840
|
+
},
|
|
2841
|
+
"created_at": {
|
|
2842
|
+
"type": "string",
|
|
2843
|
+
"format": "date-time",
|
|
2844
|
+
"title": "Created At",
|
|
2845
|
+
"description": "The time the assistant was created."
|
|
2846
|
+
},
|
|
2847
|
+
"updated_at": {
|
|
2848
|
+
"type": "string",
|
|
2849
|
+
"format": "date-time",
|
|
2850
|
+
"title": "Updated At",
|
|
2851
|
+
"description": "The last time the assistant was updated."
|
|
2852
|
+
},
|
|
2853
|
+
"metadata": {
|
|
2854
|
+
"type": "object",
|
|
2855
|
+
"title": "Metadata",
|
|
2856
|
+
"description": "The assistant metadata."
|
|
2857
|
+
},
|
|
2858
|
+
"version": {
|
|
2859
|
+
"type": "integer",
|
|
2860
|
+
"title": "Version",
|
|
2861
|
+
"description": "The version of the assistant"
|
|
2862
|
+
},
|
|
2863
|
+
"name": {
|
|
2864
|
+
"type": "string",
|
|
2865
|
+
"title": "Assistant Name",
|
|
2866
|
+
"description": "The name of the assistant"
|
|
2867
|
+
},
|
|
2868
|
+
"description": {
|
|
2869
|
+
"type": ["string", "null"],
|
|
2870
|
+
"title": "Assistant Description",
|
|
2871
|
+
"description": "The description of the assistant"
|
|
2872
|
+
}
|
|
2873
|
+
},
|
|
2874
|
+
"type": "object",
|
|
2875
|
+
"required": [
|
|
2876
|
+
"assistant_id",
|
|
2877
|
+
"graph_id",
|
|
2878
|
+
"config",
|
|
2879
|
+
"created_at",
|
|
2880
|
+
"updated_at",
|
|
2881
|
+
"metadata"
|
|
2882
|
+
],
|
|
2883
|
+
"title": "Assistant"
|
|
2884
|
+
},
|
|
2885
|
+
"AssistantCreate": {
|
|
2886
|
+
"properties": {
|
|
2887
|
+
"assistant_id": {
|
|
2888
|
+
"type": "string",
|
|
2889
|
+
"format": "uuid",
|
|
2890
|
+
"title": "Assistant Id",
|
|
2891
|
+
"description": "The ID of the assistant. If not provided, a random UUID will be generated."
|
|
2892
|
+
},
|
|
2893
|
+
"graph_id": {
|
|
2894
|
+
"type": "string",
|
|
2895
|
+
"title": "Graph Id",
|
|
2896
|
+
"description": "The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration."
|
|
2897
|
+
},
|
|
2898
|
+
"config": {
|
|
2899
|
+
"type": "object",
|
|
2900
|
+
"title": "Config",
|
|
2901
|
+
"description": "Configuration to use for the graph. Useful when graph is configurable and you want to create different assistants based on different configurations."
|
|
2902
|
+
},
|
|
2903
|
+
"metadata": {
|
|
2904
|
+
"type": "object",
|
|
2905
|
+
"title": "Metadata",
|
|
2906
|
+
"description": "Metadata to add to assistant."
|
|
2907
|
+
},
|
|
2908
|
+
"if_exists": {
|
|
2909
|
+
"type": "string",
|
|
2910
|
+
"enum": ["raise", "do_nothing"],
|
|
2911
|
+
"title": "If Exists",
|
|
2912
|
+
"description": "How to handle duplicate creation. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing assistant).",
|
|
2913
|
+
"default": "raise"
|
|
2914
|
+
},
|
|
2915
|
+
"name": {
|
|
2916
|
+
"type": "string",
|
|
2917
|
+
"title": "Name",
|
|
2918
|
+
"description": "The name of the assistant. Defaults to 'Untitled'."
|
|
2919
|
+
},
|
|
2920
|
+
"description": {
|
|
2921
|
+
"type": ["string", "null"],
|
|
2922
|
+
"title": "Description",
|
|
2923
|
+
"description": "The description of the assistant. Defaults to null."
|
|
2924
|
+
}
|
|
2925
|
+
},
|
|
2926
|
+
"type": "object",
|
|
2927
|
+
"required": ["graph_id"],
|
|
2928
|
+
"title": "AssistantCreate",
|
|
2929
|
+
"description": "Payload for creating an assistant."
|
|
2930
|
+
},
|
|
2931
|
+
"AssistantPatch": {
|
|
2932
|
+
"properties": {
|
|
2933
|
+
"graph_id": {
|
|
2934
|
+
"type": "string",
|
|
2935
|
+
"title": "Graph Id",
|
|
2936
|
+
"description": "The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration. If not provided, assistant will keep pointing to same graph."
|
|
2937
|
+
},
|
|
2938
|
+
"config": {
|
|
2939
|
+
"type": "object",
|
|
2940
|
+
"title": "Config",
|
|
2941
|
+
"description": "Configuration to use for the graph. Useful when graph is configurable and you want to update the assistant's configuration."
|
|
2942
|
+
},
|
|
2943
|
+
"metadata": {
|
|
2944
|
+
"type": "object",
|
|
2945
|
+
"title": "Metadata",
|
|
2946
|
+
"description": "Metadata to merge with existing assistant metadata."
|
|
2947
|
+
},
|
|
2948
|
+
"name": {
|
|
2949
|
+
"type": "string",
|
|
2950
|
+
"title": "Name",
|
|
2951
|
+
"description": "The new name for the assistant. If not provided, assistant will keep its current name."
|
|
2952
|
+
},
|
|
2953
|
+
"description": {
|
|
2954
|
+
"type": "string",
|
|
2955
|
+
"title": "Description",
|
|
2956
|
+
"description": "The new description for the assistant. If not provided, assistant will keep its current description."
|
|
2957
|
+
}
|
|
2958
|
+
},
|
|
2959
|
+
"type": "object",
|
|
2960
|
+
"title": "AssistantPatch",
|
|
2961
|
+
"description": "Payload for updating an assistant."
|
|
2962
|
+
},
|
|
2963
|
+
"AssistantVersionChange": {
|
|
2964
|
+
"properties": {
|
|
2965
|
+
"version": {
|
|
2966
|
+
"type": "integer",
|
|
2967
|
+
"title": "Version",
|
|
2968
|
+
"description": "The assistant version."
|
|
2969
|
+
}
|
|
2970
|
+
},
|
|
2971
|
+
"type": "object",
|
|
2972
|
+
"title": "AssistantVersionChange",
|
|
2973
|
+
"description": "Payload for changing the version of an assistant."
|
|
2974
|
+
},
|
|
2975
|
+
"Config": {
|
|
2976
|
+
"properties": {
|
|
2977
|
+
"tags": {
|
|
2978
|
+
"items": {
|
|
2979
|
+
"type": "string"
|
|
2980
|
+
},
|
|
2981
|
+
"type": "array",
|
|
2982
|
+
"title": "Tags"
|
|
2983
|
+
},
|
|
2984
|
+
"recursion_limit": {
|
|
2985
|
+
"type": "integer",
|
|
2986
|
+
"title": "Recursion Limit"
|
|
2987
|
+
},
|
|
2988
|
+
"configurable": {
|
|
2989
|
+
"type": "object",
|
|
2990
|
+
"title": "Configurable"
|
|
2991
|
+
}
|
|
2992
|
+
},
|
|
2993
|
+
"type": "object",
|
|
2994
|
+
"title": "Config"
|
|
2995
|
+
},
|
|
2996
|
+
"Cron": {
|
|
2997
|
+
"properties": {
|
|
2998
|
+
"cron_id": {
|
|
2999
|
+
"type": "string",
|
|
3000
|
+
"format": "uuid",
|
|
3001
|
+
"title": "Cron Id",
|
|
3002
|
+
"description": "The ID of the cron."
|
|
3003
|
+
},
|
|
3004
|
+
"thread_id": {
|
|
3005
|
+
"type": "string",
|
|
3006
|
+
"format": "uuid",
|
|
3007
|
+
"title": "Thread Id",
|
|
3008
|
+
"description": "The ID of the thread."
|
|
3009
|
+
},
|
|
3010
|
+
"end_time": {
|
|
3011
|
+
"type": "string",
|
|
3012
|
+
"format": "date-time",
|
|
3013
|
+
"title": "End Time",
|
|
3014
|
+
"description": "The end date to stop running the cron."
|
|
3015
|
+
},
|
|
3016
|
+
"schedule": {
|
|
3017
|
+
"type": "string",
|
|
3018
|
+
"title": "Schedule",
|
|
3019
|
+
"description": "The schedule to run, cron format."
|
|
3020
|
+
},
|
|
3021
|
+
"created_at": {
|
|
3022
|
+
"type": "string",
|
|
3023
|
+
"format": "date-time",
|
|
3024
|
+
"title": "Created At",
|
|
3025
|
+
"description": "The time the cron was created."
|
|
3026
|
+
},
|
|
3027
|
+
"updated_at": {
|
|
3028
|
+
"type": "string",
|
|
3029
|
+
"format": "date-time",
|
|
3030
|
+
"title": "Updated At",
|
|
3031
|
+
"description": "The last time the cron was updated."
|
|
3032
|
+
},
|
|
3033
|
+
"payload": {
|
|
3034
|
+
"type": "object",
|
|
3035
|
+
"title": "Payload",
|
|
3036
|
+
"description": "The run payload to use for creating new run."
|
|
3037
|
+
}
|
|
3038
|
+
},
|
|
3039
|
+
"type": "object",
|
|
3040
|
+
"required": [
|
|
3041
|
+
"cron_id",
|
|
3042
|
+
"thread_id",
|
|
3043
|
+
"end_time",
|
|
3044
|
+
"schedule",
|
|
3045
|
+
"created_at",
|
|
3046
|
+
"updated_at",
|
|
3047
|
+
"payload"
|
|
3048
|
+
],
|
|
3049
|
+
"title": "Cron",
|
|
3050
|
+
"description": "Represents a scheduled task."
|
|
3051
|
+
},
|
|
3052
|
+
"CronCreate": {
|
|
3053
|
+
"properties": {
|
|
3054
|
+
"schedule": {
|
|
3055
|
+
"type": "string",
|
|
3056
|
+
"title": "Schedule",
|
|
3057
|
+
"description": "The cron schedule to execute this job on."
|
|
3058
|
+
},
|
|
3059
|
+
"assistant_id": {
|
|
3060
|
+
"anyOf": [
|
|
3061
|
+
{
|
|
3062
|
+
"type": "string",
|
|
3063
|
+
"format": "uuid",
|
|
3064
|
+
"title": "Assistant Id"
|
|
3065
|
+
},
|
|
3066
|
+
{
|
|
3067
|
+
"type": "string",
|
|
3068
|
+
"title": "Graph Id"
|
|
3069
|
+
}
|
|
3070
|
+
],
|
|
3071
|
+
"description": "The assistant ID or graph name to run. If using graph name, will default to the assistant automatically created from that graph by the server."
|
|
3072
|
+
},
|
|
3073
|
+
"input": {
|
|
3074
|
+
"anyOf": [
|
|
3075
|
+
{
|
|
3076
|
+
"items": {
|
|
3077
|
+
"type": "object"
|
|
3078
|
+
},
|
|
3079
|
+
"type": "array"
|
|
3080
|
+
},
|
|
3081
|
+
{
|
|
3082
|
+
"type": "object"
|
|
3083
|
+
}
|
|
3084
|
+
],
|
|
3085
|
+
"title": "Input",
|
|
3086
|
+
"description": "The input to the graph."
|
|
3087
|
+
},
|
|
3088
|
+
"metadata": {
|
|
3089
|
+
"type": "object",
|
|
3090
|
+
"title": "Metadata",
|
|
3091
|
+
"description": "Metadata to assign to the cron job runs."
|
|
3092
|
+
},
|
|
3093
|
+
"config": {
|
|
3094
|
+
"properties": {
|
|
3095
|
+
"tags": {
|
|
3096
|
+
"items": {
|
|
3097
|
+
"type": "string"
|
|
3098
|
+
},
|
|
3099
|
+
"type": "array",
|
|
3100
|
+
"title": "Tags"
|
|
3101
|
+
},
|
|
3102
|
+
"recursion_limit": {
|
|
3103
|
+
"type": "integer",
|
|
3104
|
+
"title": "Recursion Limit"
|
|
3105
|
+
},
|
|
3106
|
+
"configurable": {
|
|
3107
|
+
"type": "object",
|
|
3108
|
+
"title": "Configurable"
|
|
3109
|
+
}
|
|
3110
|
+
},
|
|
3111
|
+
"type": "object",
|
|
3112
|
+
"title": "Config",
|
|
3113
|
+
"description": "The configuration for the assistant."
|
|
3114
|
+
},
|
|
3115
|
+
"webhook": {
|
|
3116
|
+
"type": "string",
|
|
3117
|
+
"maxLength": 65536,
|
|
3118
|
+
"minLength": 1,
|
|
3119
|
+
"format": "uri-reference",
|
|
3120
|
+
"title": "Webhook",
|
|
3121
|
+
"description": "Webhook to call after LangGraph API call is done."
|
|
3122
|
+
},
|
|
3123
|
+
"interrupt_before": {
|
|
3124
|
+
"anyOf": [
|
|
3125
|
+
{
|
|
3126
|
+
"type": "string",
|
|
3127
|
+
"enum": ["*"]
|
|
3128
|
+
},
|
|
3129
|
+
{
|
|
3130
|
+
"items": {
|
|
3131
|
+
"type": "string"
|
|
3132
|
+
},
|
|
3133
|
+
"type": "array"
|
|
3134
|
+
}
|
|
3135
|
+
],
|
|
3136
|
+
"title": "Interrupt Before",
|
|
3137
|
+
"description": "Nodes to interrupt immediately before they get executed."
|
|
3138
|
+
},
|
|
3139
|
+
"interrupt_after": {
|
|
3140
|
+
"anyOf": [
|
|
3141
|
+
{
|
|
3142
|
+
"type": "string",
|
|
3143
|
+
"enum": ["*"]
|
|
3144
|
+
},
|
|
3145
|
+
{
|
|
3146
|
+
"items": {
|
|
3147
|
+
"type": "string"
|
|
3148
|
+
},
|
|
3149
|
+
"type": "array"
|
|
3150
|
+
}
|
|
3151
|
+
],
|
|
3152
|
+
"title": "Interrupt After",
|
|
3153
|
+
"description": "Nodes to interrupt immediately after they get executed."
|
|
3154
|
+
},
|
|
3155
|
+
"multitask_strategy": {
|
|
3156
|
+
"type": "string",
|
|
3157
|
+
"enum": ["reject", "rollback", "interrupt", "enqueue"],
|
|
3158
|
+
"title": "Multitask Strategy",
|
|
3159
|
+
"description": "Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.",
|
|
3160
|
+
"default": "reject"
|
|
3161
|
+
}
|
|
3162
|
+
},
|
|
3163
|
+
"type": "object",
|
|
3164
|
+
"required": ["assistant_id", "schedule"],
|
|
3165
|
+
"title": "CronCreate",
|
|
3166
|
+
"description": "Payload for creating a cron job."
|
|
3167
|
+
},
|
|
3168
|
+
"CronSearch": {
|
|
3169
|
+
"properties": {
|
|
3170
|
+
"assistant_id": {
|
|
3171
|
+
"type": "string",
|
|
3172
|
+
"format": "uuid",
|
|
3173
|
+
"title": "Assistant Id",
|
|
3174
|
+
"description": "The assistant ID or graph name to search for."
|
|
3175
|
+
},
|
|
3176
|
+
"thread_id": {
|
|
3177
|
+
"type": "string",
|
|
3178
|
+
"format": "uuid",
|
|
3179
|
+
"title": "Thread Id",
|
|
3180
|
+
"description": "The thread ID to search for."
|
|
3181
|
+
},
|
|
3182
|
+
"limit": {
|
|
3183
|
+
"type": "integer",
|
|
3184
|
+
"title": "Limit",
|
|
3185
|
+
"description": "The maximum number of results to return.",
|
|
3186
|
+
"default": 10,
|
|
3187
|
+
"minimum": 1,
|
|
3188
|
+
"maximum": 1000
|
|
3189
|
+
},
|
|
3190
|
+
"offset": {
|
|
3191
|
+
"type": "integer",
|
|
3192
|
+
"title": "Offset",
|
|
3193
|
+
"description": "The number of results to skip.",
|
|
3194
|
+
"default": 0,
|
|
3195
|
+
"minimum": 0
|
|
3196
|
+
}
|
|
3197
|
+
},
|
|
3198
|
+
"type": "object",
|
|
3199
|
+
"required": [],
|
|
3200
|
+
"title": "CronSearch",
|
|
3201
|
+
"description": "Payload for listing crons"
|
|
3202
|
+
},
|
|
3203
|
+
"GraphSchema": {
|
|
3204
|
+
"properties": {
|
|
3205
|
+
"graph_id": {
|
|
3206
|
+
"type": "string",
|
|
3207
|
+
"title": "Graph Id",
|
|
3208
|
+
"description": "The ID of the graph."
|
|
3209
|
+
},
|
|
3210
|
+
"input_schema": {
|
|
3211
|
+
"type": "object",
|
|
3212
|
+
"title": "Input Schema",
|
|
3213
|
+
"description": "The schema for the graph input. Missing if unable to generate JSON schema from graph."
|
|
3214
|
+
},
|
|
3215
|
+
"output_schema": {
|
|
3216
|
+
"type": "object",
|
|
3217
|
+
"title": "Output Schema",
|
|
3218
|
+
"description": "The schema for the graph output. Missing if unable to generate JSON schema from graph."
|
|
3219
|
+
},
|
|
3220
|
+
"state_schema": {
|
|
3221
|
+
"type": "object",
|
|
3222
|
+
"title": "State Schema",
|
|
3223
|
+
"description": "The schema for the graph state. Missing if unable to generate JSON schema from graph."
|
|
3224
|
+
},
|
|
3225
|
+
"config_schema": {
|
|
3226
|
+
"type": "object",
|
|
3227
|
+
"title": "Config Schema",
|
|
3228
|
+
"description": "The schema for the graph config. Missing if unable to generate JSON schema from graph."
|
|
3229
|
+
}
|
|
3230
|
+
},
|
|
3231
|
+
"type": "object",
|
|
3232
|
+
"required": ["graph_id", "state_schema", "config_schema"],
|
|
3233
|
+
"title": "GraphSchema",
|
|
3234
|
+
"description": "Defines the structure and properties of a graph."
|
|
3235
|
+
},
|
|
3236
|
+
"GraphSchemaNoId": {
|
|
3237
|
+
"properties": {
|
|
3238
|
+
"input_schema": {
|
|
3239
|
+
"type": "object",
|
|
3240
|
+
"title": "Input Schema",
|
|
3241
|
+
"description": "The schema for the graph input. Missing if unable to generate JSON schema from graph."
|
|
3242
|
+
},
|
|
3243
|
+
"output_schema": {
|
|
3244
|
+
"type": "object",
|
|
3245
|
+
"title": "Output Schema",
|
|
3246
|
+
"description": "The schema for the graph output. Missing if unable to generate JSON schema from graph."
|
|
3247
|
+
},
|
|
3248
|
+
"state_schema": {
|
|
3249
|
+
"type": "object",
|
|
3250
|
+
"title": "State Schema",
|
|
3251
|
+
"description": "The schema for the graph state. Missing if unable to generate JSON schema from graph."
|
|
3252
|
+
},
|
|
3253
|
+
"config_schema": {
|
|
3254
|
+
"type": "object",
|
|
3255
|
+
"title": "Config Schema",
|
|
3256
|
+
"description": "The schema for the graph config. Missing if unable to generate JSON schema from graph."
|
|
3257
|
+
}
|
|
3258
|
+
},
|
|
3259
|
+
"type": "object",
|
|
3260
|
+
"required": [
|
|
3261
|
+
"input_schema",
|
|
3262
|
+
"output_schema",
|
|
3263
|
+
"state_schema",
|
|
3264
|
+
"config_schema"
|
|
3265
|
+
],
|
|
3266
|
+
"title": "GraphSchemaNoId",
|
|
3267
|
+
"description": "Defines the structure and properties of a graph without an ID."
|
|
3268
|
+
},
|
|
3269
|
+
"Subgraphs": {
|
|
3270
|
+
"type": "object",
|
|
3271
|
+
"additionalProperties": {
|
|
3272
|
+
"$ref": "#/components/schemas/GraphSchemaNoId"
|
|
3273
|
+
},
|
|
3274
|
+
"title": "Subgraphs",
|
|
3275
|
+
"description": "Map of graph name to graph schema metadata (`input_schema`, `output_schema`, `state_schema`, `config_schema`)."
|
|
3276
|
+
},
|
|
3277
|
+
"Run": {
|
|
3278
|
+
"properties": {
|
|
3279
|
+
"run_id": {
|
|
3280
|
+
"type": "string",
|
|
3281
|
+
"format": "uuid",
|
|
3282
|
+
"title": "Run Id",
|
|
3283
|
+
"description": "The ID of the run."
|
|
3284
|
+
},
|
|
3285
|
+
"thread_id": {
|
|
3286
|
+
"type": "string",
|
|
3287
|
+
"format": "uuid",
|
|
3288
|
+
"title": "Thread Id",
|
|
3289
|
+
"description": "The ID of the thread."
|
|
3290
|
+
},
|
|
3291
|
+
"assistant_id": {
|
|
3292
|
+
"type": "string",
|
|
3293
|
+
"format": "uuid",
|
|
3294
|
+
"title": "Assistant Id",
|
|
3295
|
+
"description": "The assistant that was used for this run."
|
|
3296
|
+
},
|
|
3297
|
+
"created_at": {
|
|
3298
|
+
"type": "string",
|
|
3299
|
+
"format": "date-time",
|
|
3300
|
+
"title": "Created At",
|
|
3301
|
+
"description": "The time the run was created."
|
|
3302
|
+
},
|
|
3303
|
+
"updated_at": {
|
|
3304
|
+
"type": "string",
|
|
3305
|
+
"format": "date-time",
|
|
3306
|
+
"title": "Updated At",
|
|
3307
|
+
"description": "The last time the run was updated."
|
|
3308
|
+
},
|
|
3309
|
+
"status": {
|
|
3310
|
+
"type": "string",
|
|
3311
|
+
"enum": ["pending", "error", "success", "timeout", "interrupted"],
|
|
3312
|
+
"title": "Status",
|
|
3313
|
+
"description": "The status of the run. One of 'pending', 'error', 'success', 'timeout', 'interrupted'."
|
|
3314
|
+
},
|
|
3315
|
+
"metadata": {
|
|
3316
|
+
"type": "object",
|
|
3317
|
+
"title": "Metadata",
|
|
3318
|
+
"description": "The run metadata."
|
|
3319
|
+
},
|
|
3320
|
+
"kwargs": {
|
|
3321
|
+
"type": "object",
|
|
3322
|
+
"title": "Kwargs"
|
|
3323
|
+
},
|
|
3324
|
+
"multitask_strategy": {
|
|
3325
|
+
"type": "string",
|
|
3326
|
+
"enum": ["reject", "rollback", "interrupt", "enqueue"],
|
|
3327
|
+
"title": "Multitask Strategy",
|
|
3328
|
+
"description": "Strategy to handle concurrent runs on the same thread."
|
|
3329
|
+
}
|
|
3330
|
+
},
|
|
3331
|
+
"type": "object",
|
|
3332
|
+
"required": [
|
|
3333
|
+
"run_id",
|
|
3334
|
+
"thread_id",
|
|
3335
|
+
"assistant_id",
|
|
3336
|
+
"created_at",
|
|
3337
|
+
"updated_at",
|
|
3338
|
+
"status",
|
|
3339
|
+
"metadata",
|
|
3340
|
+
"kwargs",
|
|
3341
|
+
"multitask_strategy"
|
|
3342
|
+
],
|
|
3343
|
+
"title": "Run"
|
|
3344
|
+
},
|
|
3345
|
+
"Send": {
|
|
3346
|
+
"type": "object",
|
|
3347
|
+
"title": "Send",
|
|
3348
|
+
"description": "A message to send to a node.",
|
|
3349
|
+
"properties": {
|
|
3350
|
+
"node": {
|
|
3351
|
+
"type": "string",
|
|
3352
|
+
"title": "Node",
|
|
3353
|
+
"description": "The node to send the message to."
|
|
3354
|
+
},
|
|
3355
|
+
"input": {
|
|
3356
|
+
"type": ["object", "array", "number", "string", "boolean", "null"],
|
|
3357
|
+
"title": "Message",
|
|
3358
|
+
"description": "The message to send."
|
|
3359
|
+
}
|
|
3360
|
+
},
|
|
3361
|
+
"required": ["node", "input"]
|
|
3362
|
+
},
|
|
3363
|
+
"Command": {
|
|
3364
|
+
"type": "object",
|
|
3365
|
+
"title": "Command",
|
|
3366
|
+
"description": "The command to run.",
|
|
3367
|
+
"properties": {
|
|
3368
|
+
"update": {
|
|
3369
|
+
"type": ["object", "array", "null"],
|
|
3370
|
+
"title": "Update",
|
|
3371
|
+
"description": "An update to the state."
|
|
3372
|
+
},
|
|
3373
|
+
"resume": {
|
|
3374
|
+
"type": ["object", "array", "number", "string", "boolean", "null"],
|
|
3375
|
+
"title": "Resume",
|
|
3376
|
+
"description": "A value to pass to an interrupted node."
|
|
3377
|
+
},
|
|
3378
|
+
"goto": {
|
|
3379
|
+
"anyOf": [
|
|
3380
|
+
{
|
|
3381
|
+
"$ref": "#/components/schemas/Send"
|
|
3382
|
+
},
|
|
3383
|
+
{
|
|
3384
|
+
"type": "array",
|
|
3385
|
+
"items": {
|
|
3386
|
+
"$ref": "#/components/schemas/Send"
|
|
3387
|
+
}
|
|
3388
|
+
},
|
|
3389
|
+
{
|
|
3390
|
+
"type": "string"
|
|
3391
|
+
},
|
|
3392
|
+
{
|
|
3393
|
+
"type": "array",
|
|
3394
|
+
"items": {
|
|
3395
|
+
"type": "string"
|
|
3396
|
+
}
|
|
3397
|
+
},
|
|
3398
|
+
{
|
|
3399
|
+
"type": "null"
|
|
3400
|
+
}
|
|
3401
|
+
],
|
|
3402
|
+
"title": "Goto",
|
|
3403
|
+
"description": "Name of the node(s) to navigate to next or node(s) to be executed with a provided input."
|
|
3404
|
+
}
|
|
3405
|
+
}
|
|
3406
|
+
},
|
|
3407
|
+
"RunCreateStateful": {
|
|
3408
|
+
"properties": {
|
|
3409
|
+
"assistant_id": {
|
|
3410
|
+
"anyOf": [
|
|
3411
|
+
{
|
|
3412
|
+
"type": "string",
|
|
3413
|
+
"format": "uuid",
|
|
3414
|
+
"title": "Assistant Id"
|
|
3415
|
+
},
|
|
3416
|
+
{
|
|
3417
|
+
"type": "string",
|
|
3418
|
+
"title": "Graph Id"
|
|
3419
|
+
}
|
|
3420
|
+
],
|
|
3421
|
+
"description": "The assistant ID or graph name to run. If using graph name, will default to first assistant created from that graph."
|
|
3422
|
+
},
|
|
3423
|
+
"checkpoint": {
|
|
3424
|
+
"type": "object",
|
|
3425
|
+
"title": "Checkpoint",
|
|
3426
|
+
"description": "The checkpoint to resume from.",
|
|
3427
|
+
"$ref": "#/components/schemas/CheckpointConfig"
|
|
3428
|
+
},
|
|
3429
|
+
"input": {
|
|
3430
|
+
"anyOf": [
|
|
3431
|
+
{
|
|
3432
|
+
"type": "object"
|
|
3433
|
+
},
|
|
3434
|
+
{
|
|
3435
|
+
"type": "array"
|
|
3436
|
+
},
|
|
3437
|
+
{
|
|
3438
|
+
"type": "string"
|
|
3439
|
+
},
|
|
3440
|
+
{
|
|
3441
|
+
"type": "number"
|
|
3442
|
+
},
|
|
3443
|
+
{
|
|
3444
|
+
"type": "boolean"
|
|
3445
|
+
},
|
|
3446
|
+
{
|
|
3447
|
+
"type": "null"
|
|
3448
|
+
}
|
|
3449
|
+
],
|
|
3450
|
+
"title": "Input",
|
|
3451
|
+
"description": "The input to the graph."
|
|
3452
|
+
},
|
|
3453
|
+
"command": {
|
|
3454
|
+
"anyOf": [
|
|
3455
|
+
{
|
|
3456
|
+
"$ref": "#/components/schemas/Command"
|
|
3457
|
+
},
|
|
3458
|
+
{
|
|
3459
|
+
"type": "null"
|
|
3460
|
+
}
|
|
3461
|
+
],
|
|
3462
|
+
"title": "Input",
|
|
3463
|
+
"description": "The input to the graph."
|
|
3464
|
+
},
|
|
3465
|
+
"metadata": {
|
|
3466
|
+
"type": "object",
|
|
3467
|
+
"title": "Metadata",
|
|
3468
|
+
"description": "Metadata to assign to the run."
|
|
3469
|
+
},
|
|
3470
|
+
"config": {
|
|
3471
|
+
"properties": {
|
|
3472
|
+
"tags": {
|
|
3473
|
+
"items": {
|
|
3474
|
+
"type": "string"
|
|
3475
|
+
},
|
|
3476
|
+
"type": "array",
|
|
3477
|
+
"title": "Tags"
|
|
3478
|
+
},
|
|
3479
|
+
"recursion_limit": {
|
|
3480
|
+
"type": "integer",
|
|
3481
|
+
"title": "Recursion Limit"
|
|
3482
|
+
},
|
|
3483
|
+
"configurable": {
|
|
3484
|
+
"type": "object",
|
|
3485
|
+
"title": "Configurable"
|
|
3486
|
+
}
|
|
3487
|
+
},
|
|
3488
|
+
"type": "object",
|
|
3489
|
+
"title": "Config",
|
|
3490
|
+
"description": "The configuration for the assistant."
|
|
3491
|
+
},
|
|
3492
|
+
"webhook": {
|
|
3493
|
+
"type": "string",
|
|
3494
|
+
"maxLength": 65536,
|
|
3495
|
+
"minLength": 1,
|
|
3496
|
+
"format": "uri-reference",
|
|
3497
|
+
"title": "Webhook",
|
|
3498
|
+
"description": "Webhook to call after LangGraph API call is done."
|
|
3499
|
+
},
|
|
3500
|
+
"interrupt_before": {
|
|
3501
|
+
"anyOf": [
|
|
3502
|
+
{
|
|
3503
|
+
"type": "string",
|
|
3504
|
+
"enum": ["*"]
|
|
3505
|
+
},
|
|
3506
|
+
{
|
|
3507
|
+
"items": {
|
|
3508
|
+
"type": "string"
|
|
3509
|
+
},
|
|
3510
|
+
"type": "array"
|
|
3511
|
+
}
|
|
3512
|
+
],
|
|
3513
|
+
"title": "Interrupt Before",
|
|
3514
|
+
"description": "Nodes to interrupt immediately before they get executed."
|
|
3515
|
+
},
|
|
3516
|
+
"interrupt_after": {
|
|
3517
|
+
"anyOf": [
|
|
3518
|
+
{
|
|
3519
|
+
"type": "string",
|
|
3520
|
+
"enum": ["*"]
|
|
3521
|
+
},
|
|
3522
|
+
{
|
|
3523
|
+
"items": {
|
|
3524
|
+
"type": "string"
|
|
3525
|
+
},
|
|
3526
|
+
"type": "array"
|
|
3527
|
+
}
|
|
3528
|
+
],
|
|
3529
|
+
"title": "Interrupt After",
|
|
3530
|
+
"description": "Nodes to interrupt immediately after they get executed."
|
|
3531
|
+
},
|
|
3532
|
+
"stream_mode": {
|
|
3533
|
+
"anyOf": [
|
|
3534
|
+
{
|
|
3535
|
+
"items": {
|
|
3536
|
+
"type": "string",
|
|
3537
|
+
"enum": [
|
|
3538
|
+
"values",
|
|
3539
|
+
"messages",
|
|
3540
|
+
"messages-tuple",
|
|
3541
|
+
"updates",
|
|
3542
|
+
"events",
|
|
3543
|
+
"debug",
|
|
3544
|
+
"custom"
|
|
3545
|
+
]
|
|
3546
|
+
},
|
|
3547
|
+
"type": "array"
|
|
3548
|
+
},
|
|
3549
|
+
{
|
|
3550
|
+
"type": "string",
|
|
3551
|
+
"enum": [
|
|
3552
|
+
"values",
|
|
3553
|
+
"messages",
|
|
3554
|
+
"messages-tuple",
|
|
3555
|
+
"updates",
|
|
3556
|
+
"events",
|
|
3557
|
+
"debug",
|
|
3558
|
+
"custom"
|
|
3559
|
+
]
|
|
3560
|
+
}
|
|
3561
|
+
],
|
|
3562
|
+
"title": "Stream Mode",
|
|
3563
|
+
"description": "The stream mode(s) to use.",
|
|
3564
|
+
"default": ["values"]
|
|
3565
|
+
},
|
|
3566
|
+
"stream_subgraphs": {
|
|
3567
|
+
"type": "boolean",
|
|
3568
|
+
"title": "Stream Subgraphs",
|
|
3569
|
+
"description": "Whether to stream output from subgraphs.",
|
|
3570
|
+
"default": false
|
|
3571
|
+
},
|
|
3572
|
+
"on_disconnect": {
|
|
3573
|
+
"type": "string",
|
|
3574
|
+
"enum": ["cancel", "continue"],
|
|
3575
|
+
"title": "On Disconnect",
|
|
3576
|
+
"description": "The disconnect mode to use. Must be one of 'cancel' or 'continue'.",
|
|
3577
|
+
"default": "cancel"
|
|
3578
|
+
},
|
|
3579
|
+
"feedback_keys": {
|
|
3580
|
+
"items": {
|
|
3581
|
+
"type": "string"
|
|
3582
|
+
},
|
|
3583
|
+
"type": "array",
|
|
3584
|
+
"title": "Feedback Keys",
|
|
3585
|
+
"description": "Feedback keys to assign to run."
|
|
3586
|
+
},
|
|
3587
|
+
"multitask_strategy": {
|
|
3588
|
+
"type": "string",
|
|
3589
|
+
"enum": ["reject", "rollback", "interrupt", "enqueue"],
|
|
3590
|
+
"title": "Multitask Strategy",
|
|
3591
|
+
"description": "Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.",
|
|
3592
|
+
"default": "reject"
|
|
3593
|
+
},
|
|
3594
|
+
"if_not_exists": {
|
|
3595
|
+
"type": "string",
|
|
3596
|
+
"enum": ["create", "reject"],
|
|
3597
|
+
"title": "If Not Exists",
|
|
3598
|
+
"description": "How to handle missing thread. Must be either 'reject' (raise error if missing), or 'create' (create new thread).",
|
|
3599
|
+
"default": "reject"
|
|
3600
|
+
},
|
|
3601
|
+
"after_seconds": {
|
|
3602
|
+
"type": "integer",
|
|
3603
|
+
"title": "After Seconds",
|
|
3604
|
+
"description": "The number of seconds to wait before starting the run. Use to schedule future runs."
|
|
3605
|
+
},
|
|
3606
|
+
"checkpoint_during": {
|
|
3607
|
+
"type": "boolean",
|
|
3608
|
+
"title": "Checkpoint During",
|
|
3609
|
+
"description": "Whether to checkpoint during the run.",
|
|
3610
|
+
"default": false
|
|
3611
|
+
}
|
|
3612
|
+
},
|
|
3613
|
+
"type": "object",
|
|
3614
|
+
"required": ["assistant_id"],
|
|
3615
|
+
"title": "RunCreateStateful",
|
|
3616
|
+
"description": "Payload for creating a run."
|
|
3617
|
+
},
|
|
3618
|
+
"RunBatchCreate": {
|
|
3619
|
+
"type": "array",
|
|
3620
|
+
"items": {
|
|
3621
|
+
"$ref": "#/components/schemas/RunCreateStateless"
|
|
3622
|
+
},
|
|
3623
|
+
"minItems": 1,
|
|
3624
|
+
"title": "RunBatchCreate",
|
|
3625
|
+
"description": "Payload for creating a batch of runs."
|
|
3626
|
+
},
|
|
3627
|
+
"RunCreateStateless": {
|
|
3628
|
+
"properties": {
|
|
3629
|
+
"assistant_id": {
|
|
3630
|
+
"anyOf": [
|
|
3631
|
+
{
|
|
3632
|
+
"type": "string",
|
|
3633
|
+
"format": "uuid",
|
|
3634
|
+
"title": "Assistant Id"
|
|
3635
|
+
},
|
|
3636
|
+
{
|
|
3637
|
+
"type": "string",
|
|
3638
|
+
"title": "Graph Id"
|
|
3639
|
+
}
|
|
3640
|
+
],
|
|
3641
|
+
"description": "The assistant ID or graph name to run. If using graph name, will default to first assistant created from that graph."
|
|
3642
|
+
},
|
|
3643
|
+
"input": {
|
|
3644
|
+
"anyOf": [
|
|
3645
|
+
{
|
|
3646
|
+
"type": "object"
|
|
3647
|
+
},
|
|
3648
|
+
{
|
|
3649
|
+
"type": "array"
|
|
3650
|
+
},
|
|
3651
|
+
{
|
|
3652
|
+
"type": "string"
|
|
3653
|
+
},
|
|
3654
|
+
{
|
|
3655
|
+
"type": "number"
|
|
3656
|
+
},
|
|
3657
|
+
{
|
|
3658
|
+
"type": "boolean"
|
|
3659
|
+
},
|
|
3660
|
+
{
|
|
3661
|
+
"type": "null"
|
|
3662
|
+
}
|
|
3663
|
+
],
|
|
3664
|
+
"title": "Input",
|
|
3665
|
+
"description": "The input to the graph."
|
|
3666
|
+
},
|
|
3667
|
+
"command": {
|
|
3668
|
+
"anyOf": [
|
|
3669
|
+
{
|
|
3670
|
+
"$ref": "#/components/schemas/Command"
|
|
3671
|
+
},
|
|
3672
|
+
{
|
|
3673
|
+
"type": "null"
|
|
3674
|
+
}
|
|
3675
|
+
],
|
|
3676
|
+
"title": "Input",
|
|
3677
|
+
"description": "The input to the graph."
|
|
3678
|
+
},
|
|
3679
|
+
"metadata": {
|
|
3680
|
+
"type": "object",
|
|
3681
|
+
"title": "Metadata",
|
|
3682
|
+
"description": "Metadata to assign to the run."
|
|
3683
|
+
},
|
|
3684
|
+
"config": {
|
|
3685
|
+
"properties": {
|
|
3686
|
+
"tags": {
|
|
3687
|
+
"items": {
|
|
3688
|
+
"type": "string"
|
|
3689
|
+
},
|
|
3690
|
+
"type": "array",
|
|
3691
|
+
"title": "Tags"
|
|
3692
|
+
},
|
|
3693
|
+
"recursion_limit": {
|
|
3694
|
+
"type": "integer",
|
|
3695
|
+
"title": "Recursion Limit"
|
|
3696
|
+
},
|
|
3697
|
+
"configurable": {
|
|
3698
|
+
"type": "object",
|
|
3699
|
+
"title": "Configurable"
|
|
3700
|
+
}
|
|
3701
|
+
},
|
|
3702
|
+
"type": "object",
|
|
3703
|
+
"title": "Config",
|
|
3704
|
+
"description": "The configuration for the assistant."
|
|
3705
|
+
},
|
|
3706
|
+
"webhook": {
|
|
3707
|
+
"type": "string",
|
|
3708
|
+
"maxLength": 65536,
|
|
3709
|
+
"minLength": 1,
|
|
3710
|
+
"format": "uri-reference",
|
|
3711
|
+
"title": "Webhook",
|
|
3712
|
+
"description": "Webhook to call after LangGraph API call is done."
|
|
3713
|
+
},
|
|
3714
|
+
"interrupt_before": {
|
|
3715
|
+
"anyOf": [
|
|
3716
|
+
{
|
|
3717
|
+
"type": "string",
|
|
3718
|
+
"enum": ["*"]
|
|
3719
|
+
},
|
|
3720
|
+
{
|
|
3721
|
+
"items": {
|
|
3722
|
+
"type": "string"
|
|
3723
|
+
},
|
|
3724
|
+
"type": "array"
|
|
3725
|
+
}
|
|
3726
|
+
],
|
|
3727
|
+
"title": "Interrupt Before",
|
|
3728
|
+
"description": "Nodes to interrupt immediately before they get executed."
|
|
3729
|
+
},
|
|
3730
|
+
"interrupt_after": {
|
|
3731
|
+
"anyOf": [
|
|
3732
|
+
{
|
|
3733
|
+
"type": "string",
|
|
3734
|
+
"enum": ["*"]
|
|
3735
|
+
},
|
|
3736
|
+
{
|
|
3737
|
+
"items": {
|
|
3738
|
+
"type": "string"
|
|
3739
|
+
},
|
|
3740
|
+
"type": "array"
|
|
3741
|
+
}
|
|
3742
|
+
],
|
|
3743
|
+
"title": "Interrupt After",
|
|
3744
|
+
"description": "Nodes to interrupt immediately after they get executed."
|
|
3745
|
+
},
|
|
3746
|
+
"stream_mode": {
|
|
3747
|
+
"anyOf": [
|
|
3748
|
+
{
|
|
3749
|
+
"items": {
|
|
3750
|
+
"type": "string",
|
|
3751
|
+
"enum": [
|
|
3752
|
+
"values",
|
|
3753
|
+
"messages",
|
|
3754
|
+
"messages-tuple",
|
|
3755
|
+
"updates",
|
|
3756
|
+
"events",
|
|
3757
|
+
"debug",
|
|
3758
|
+
"custom"
|
|
3759
|
+
]
|
|
3760
|
+
},
|
|
3761
|
+
"type": "array"
|
|
3762
|
+
},
|
|
3763
|
+
{
|
|
3764
|
+
"type": "string",
|
|
3765
|
+
"enum": [
|
|
3766
|
+
"values",
|
|
3767
|
+
"messages",
|
|
3768
|
+
"messages-tuple",
|
|
3769
|
+
"updates",
|
|
3770
|
+
"events",
|
|
3771
|
+
"debug",
|
|
3772
|
+
"custom"
|
|
3773
|
+
]
|
|
3774
|
+
}
|
|
3775
|
+
],
|
|
3776
|
+
"title": "Stream Mode",
|
|
3777
|
+
"description": "The stream mode(s) to use.",
|
|
3778
|
+
"default": ["values"]
|
|
3779
|
+
},
|
|
3780
|
+
"feedback_keys": {
|
|
3781
|
+
"items": {
|
|
3782
|
+
"type": "string"
|
|
3783
|
+
},
|
|
3784
|
+
"type": "array",
|
|
3785
|
+
"title": "Feedback Keys",
|
|
3786
|
+
"description": "Feedback keys to assign to run."
|
|
3787
|
+
},
|
|
3788
|
+
"stream_subgraphs": {
|
|
3789
|
+
"type": "boolean",
|
|
3790
|
+
"title": "Stream Subgraphs",
|
|
3791
|
+
"description": "Whether to stream output from subgraphs.",
|
|
3792
|
+
"default": false
|
|
3793
|
+
},
|
|
3794
|
+
"on_completion": {
|
|
3795
|
+
"type": "string",
|
|
3796
|
+
"enum": ["delete", "keep"],
|
|
3797
|
+
"title": "On Completion",
|
|
3798
|
+
"description": "Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'.",
|
|
3799
|
+
"default": "delete"
|
|
3800
|
+
},
|
|
3801
|
+
"on_disconnect": {
|
|
3802
|
+
"type": "string",
|
|
3803
|
+
"enum": ["cancel", "continue"],
|
|
3804
|
+
"title": "On Disconnect",
|
|
3805
|
+
"description": "The disconnect mode to use. Must be one of 'cancel' or 'continue'.",
|
|
3806
|
+
"default": "cancel"
|
|
3807
|
+
},
|
|
3808
|
+
"after_seconds": {
|
|
3809
|
+
"type": "integer",
|
|
3810
|
+
"title": "After Seconds",
|
|
3811
|
+
"description": "The number of seconds to wait before starting the run. Use to schedule future runs."
|
|
3812
|
+
},
|
|
3813
|
+
"checkpoint_during": {
|
|
3814
|
+
"type": "boolean",
|
|
3815
|
+
"title": "Checkpoint During",
|
|
3816
|
+
"description": "Whether to checkpoint during the run.",
|
|
3817
|
+
"default": false
|
|
3818
|
+
}
|
|
3819
|
+
},
|
|
3820
|
+
"type": "object",
|
|
3821
|
+
"required": ["assistant_id"],
|
|
3822
|
+
"title": "RunCreateStateless",
|
|
3823
|
+
"description": "Payload for creating a run."
|
|
3824
|
+
},
|
|
3825
|
+
"AssistantSearchRequest": {
|
|
3826
|
+
"properties": {
|
|
3827
|
+
"metadata": {
|
|
3828
|
+
"type": "object",
|
|
3829
|
+
"title": "Metadata",
|
|
3830
|
+
"description": "Metadata to filter by. Exact match filter for each KV pair."
|
|
3831
|
+
},
|
|
3832
|
+
"graph_id": {
|
|
3833
|
+
"type": "string",
|
|
3834
|
+
"title": "Graph Id",
|
|
3835
|
+
"description": "The ID of the graph to filter by. The graph ID is normally set in your langgraph.json configuration."
|
|
3836
|
+
},
|
|
3837
|
+
"limit": {
|
|
3838
|
+
"type": "integer",
|
|
3839
|
+
"title": "Limit",
|
|
3840
|
+
"description": "The maximum number of results to return.",
|
|
3841
|
+
"default": 10,
|
|
3842
|
+
"minimum": 1,
|
|
3843
|
+
"maximum": 1000
|
|
3844
|
+
},
|
|
3845
|
+
"offset": {
|
|
3846
|
+
"type": "integer",
|
|
3847
|
+
"title": "Offset",
|
|
3848
|
+
"description": "The number of results to skip.",
|
|
3849
|
+
"default": 0,
|
|
3850
|
+
"minimum": 0
|
|
3851
|
+
},
|
|
3852
|
+
"sort_by": {
|
|
3853
|
+
"type": "string",
|
|
3854
|
+
"enum": [
|
|
3855
|
+
"assistant_id",
|
|
3856
|
+
"created_at",
|
|
3857
|
+
"updated_at",
|
|
3858
|
+
"name",
|
|
3859
|
+
"graph_id"
|
|
3860
|
+
],
|
|
3861
|
+
"title": "Sort By",
|
|
3862
|
+
"description": "The field to sort by."
|
|
3863
|
+
},
|
|
3864
|
+
"sort_order": {
|
|
3865
|
+
"type": "string",
|
|
3866
|
+
"enum": ["asc", "desc"],
|
|
3867
|
+
"title": "Sort Order",
|
|
3868
|
+
"description": "The order to sort by."
|
|
3869
|
+
}
|
|
3870
|
+
},
|
|
3871
|
+
"type": "object",
|
|
3872
|
+
"title": "AssistantSearchRequest",
|
|
3873
|
+
"description": "Payload for listing assistants."
|
|
3874
|
+
},
|
|
3875
|
+
"AssistantVersionsSearchRequest": {
|
|
3876
|
+
"properties": {
|
|
3877
|
+
"metadata": {
|
|
3878
|
+
"type": "object",
|
|
3879
|
+
"title": "Metadata",
|
|
3880
|
+
"description": "Metadata to filter versions by. Exact match filter for each KV pair."
|
|
3881
|
+
},
|
|
3882
|
+
"limit": {
|
|
3883
|
+
"type": "integer",
|
|
3884
|
+
"title": "Limit",
|
|
3885
|
+
"description": "The maximum number of versions to return.",
|
|
3886
|
+
"default": 10,
|
|
3887
|
+
"minimum": 1,
|
|
3888
|
+
"maximum": 1000
|
|
3889
|
+
},
|
|
3890
|
+
"offset": {
|
|
3891
|
+
"type": "integer",
|
|
3892
|
+
"title": "Offset",
|
|
3893
|
+
"description": "The number of versions to skip.",
|
|
3894
|
+
"default": 0,
|
|
3895
|
+
"minimum": 0
|
|
3896
|
+
}
|
|
3897
|
+
},
|
|
3898
|
+
"type": "object",
|
|
3899
|
+
"title": "SearchRequest",
|
|
3900
|
+
"description": "Payload for listing assistant versions."
|
|
3901
|
+
},
|
|
3902
|
+
"ThreadSearchRequest": {
|
|
3903
|
+
"properties": {
|
|
3904
|
+
"metadata": {
|
|
3905
|
+
"type": "object",
|
|
3906
|
+
"title": "Metadata",
|
|
3907
|
+
"description": "Thread metadata to filter on."
|
|
3908
|
+
},
|
|
3909
|
+
"values": {
|
|
3910
|
+
"type": "object",
|
|
3911
|
+
"title": "Values",
|
|
3912
|
+
"description": "State values to filter on."
|
|
3913
|
+
},
|
|
3914
|
+
"status": {
|
|
3915
|
+
"type": "string",
|
|
3916
|
+
"enum": ["idle", "busy", "interrupted", "error"],
|
|
3917
|
+
"title": "Status",
|
|
3918
|
+
"description": "Thread status to filter on."
|
|
3919
|
+
},
|
|
3920
|
+
"limit": {
|
|
3921
|
+
"type": "integer",
|
|
3922
|
+
"title": "Limit",
|
|
3923
|
+
"description": "Maximum number to return.",
|
|
3924
|
+
"default": 10,
|
|
3925
|
+
"minimum": 1,
|
|
3926
|
+
"maximum": 1000
|
|
3927
|
+
},
|
|
3928
|
+
"offset": {
|
|
3929
|
+
"type": "integer",
|
|
3930
|
+
"title": "Offset",
|
|
3931
|
+
"description": "Offset to start from.",
|
|
3932
|
+
"default": 0,
|
|
3933
|
+
"minimum": 0
|
|
3934
|
+
},
|
|
3935
|
+
"sort_by": {
|
|
3936
|
+
"type": "string",
|
|
3937
|
+
"enum": ["thread_id", "status", "created_at", "updated_at"],
|
|
3938
|
+
"title": "Sort By",
|
|
3939
|
+
"description": "Sort by field."
|
|
3940
|
+
},
|
|
3941
|
+
"sort_order": {
|
|
3942
|
+
"type": "string",
|
|
3943
|
+
"enum": ["asc", "desc"],
|
|
3944
|
+
"title": "Sort Order",
|
|
3945
|
+
"description": "Sort order."
|
|
3946
|
+
}
|
|
3947
|
+
},
|
|
3948
|
+
"type": "object",
|
|
3949
|
+
"title": "ThreadSearchRequest",
|
|
3950
|
+
"description": "Payload for listing threads."
|
|
3951
|
+
},
|
|
3952
|
+
"Thread": {
|
|
3953
|
+
"properties": {
|
|
3954
|
+
"thread_id": {
|
|
3955
|
+
"type": "string",
|
|
3956
|
+
"format": "uuid",
|
|
3957
|
+
"title": "Thread Id",
|
|
3958
|
+
"description": "The ID of the thread."
|
|
3959
|
+
},
|
|
3960
|
+
"created_at": {
|
|
3961
|
+
"type": "string",
|
|
3962
|
+
"format": "date-time",
|
|
3963
|
+
"title": "Created At",
|
|
3964
|
+
"description": "The time the thread was created."
|
|
3965
|
+
},
|
|
3966
|
+
"updated_at": {
|
|
3967
|
+
"type": "string",
|
|
3968
|
+
"format": "date-time",
|
|
3969
|
+
"title": "Updated At",
|
|
3970
|
+
"description": "The last time the thread was updated."
|
|
3971
|
+
},
|
|
3972
|
+
"metadata": {
|
|
3973
|
+
"type": "object",
|
|
3974
|
+
"title": "Metadata",
|
|
3975
|
+
"description": "The thread metadata."
|
|
3976
|
+
},
|
|
3977
|
+
"status": {
|
|
3978
|
+
"type": "string",
|
|
3979
|
+
"enum": ["idle", "busy", "interrupted", "error"],
|
|
3980
|
+
"title": "Status",
|
|
3981
|
+
"description": "The status of the thread."
|
|
3982
|
+
},
|
|
3983
|
+
"values": {
|
|
3984
|
+
"type": "object",
|
|
3985
|
+
"title": "Values",
|
|
3986
|
+
"description": "The current state of the thread."
|
|
3987
|
+
}
|
|
3988
|
+
},
|
|
3989
|
+
"type": "object",
|
|
3990
|
+
"required": [
|
|
3991
|
+
"thread_id",
|
|
3992
|
+
"created_at",
|
|
3993
|
+
"updated_at",
|
|
3994
|
+
"metadata",
|
|
3995
|
+
"status"
|
|
3996
|
+
],
|
|
3997
|
+
"title": "Thread"
|
|
3998
|
+
},
|
|
3999
|
+
"ThreadCreate": {
|
|
4000
|
+
"properties": {
|
|
4001
|
+
"thread_id": {
|
|
4002
|
+
"type": "string",
|
|
4003
|
+
"format": "uuid",
|
|
4004
|
+
"title": "Thread Id",
|
|
4005
|
+
"description": "The ID of the thread. If not provided, a random UUID will be generated."
|
|
4006
|
+
},
|
|
4007
|
+
"metadata": {
|
|
4008
|
+
"type": "object",
|
|
4009
|
+
"title": "Metadata",
|
|
4010
|
+
"description": "Metadata to add to thread."
|
|
4011
|
+
},
|
|
4012
|
+
"if_exists": {
|
|
4013
|
+
"type": "string",
|
|
4014
|
+
"enum": ["raise", "do_nothing"],
|
|
4015
|
+
"title": "If Exists",
|
|
4016
|
+
"description": "How to handle duplicate creation. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing thread).",
|
|
4017
|
+
"default": "raise"
|
|
4018
|
+
},
|
|
4019
|
+
"ttl": {
|
|
4020
|
+
"type": "object",
|
|
4021
|
+
"title": "TTL",
|
|
4022
|
+
"description": "The time-to-live for the thread.",
|
|
4023
|
+
"properties": {
|
|
4024
|
+
"strategy": {
|
|
4025
|
+
"type": "string",
|
|
4026
|
+
"enum": ["delete"],
|
|
4027
|
+
"description": "The TTL strategy. 'delete' removes the entire thread.",
|
|
4028
|
+
"default": "delete"
|
|
4029
|
+
},
|
|
4030
|
+
"ttl": {
|
|
4031
|
+
"type": "number",
|
|
4032
|
+
"description": "The time-to-live in minutes from now until thread should be swept."
|
|
4033
|
+
}
|
|
4034
|
+
}
|
|
4035
|
+
},
|
|
4036
|
+
"supersteps": {
|
|
4037
|
+
"type": "array",
|
|
4038
|
+
"items": {
|
|
4039
|
+
"type": "object",
|
|
4040
|
+
"properties": {
|
|
4041
|
+
"updates": {
|
|
4042
|
+
"type": "array",
|
|
4043
|
+
"items": {
|
|
4044
|
+
"$ref": "#/components/schemas/ThreadSuperstepUpdate"
|
|
4045
|
+
}
|
|
4046
|
+
}
|
|
4047
|
+
},
|
|
4048
|
+
"required": ["updates"]
|
|
4049
|
+
}
|
|
4050
|
+
}
|
|
4051
|
+
},
|
|
4052
|
+
"type": "object",
|
|
4053
|
+
"title": "ThreadCreate",
|
|
4054
|
+
"description": "Payload for creating a thread."
|
|
4055
|
+
},
|
|
4056
|
+
"ThreadPatch": {
|
|
4057
|
+
"properties": {
|
|
4058
|
+
"metadata": {
|
|
4059
|
+
"type": "object",
|
|
4060
|
+
"title": "Metadata",
|
|
4061
|
+
"description": "Metadata to merge with existing thread metadata."
|
|
4062
|
+
}
|
|
4063
|
+
},
|
|
4064
|
+
"type": "object",
|
|
4065
|
+
"title": "ThreadPatch",
|
|
4066
|
+
"description": "Payload for creating a thread."
|
|
4067
|
+
},
|
|
4068
|
+
"ThreadStateCheckpointRequest": {
|
|
4069
|
+
"properties": {
|
|
4070
|
+
"checkpoint": {
|
|
4071
|
+
"$ref": "#/components/schemas/CheckpointConfig",
|
|
4072
|
+
"title": "Checkpoint",
|
|
4073
|
+
"description": "The checkpoint to get the state for."
|
|
4074
|
+
},
|
|
4075
|
+
"subgraphs": {
|
|
4076
|
+
"type": "boolean",
|
|
4077
|
+
"title": "Subgraphs",
|
|
4078
|
+
"description": "Include subgraph states."
|
|
4079
|
+
}
|
|
4080
|
+
},
|
|
4081
|
+
"required": ["checkpoint"],
|
|
4082
|
+
"type": "object",
|
|
4083
|
+
"title": "ThreadStateCheckpointRequest",
|
|
4084
|
+
"description": "Payload for getting the state of a thread at a checkpoint."
|
|
4085
|
+
},
|
|
4086
|
+
"ThreadState": {
|
|
4087
|
+
"properties": {
|
|
4088
|
+
"values": {
|
|
4089
|
+
"anyOf": [
|
|
4090
|
+
{
|
|
4091
|
+
"items": {
|
|
4092
|
+
"type": "object"
|
|
4093
|
+
},
|
|
4094
|
+
"type": "array"
|
|
4095
|
+
},
|
|
4096
|
+
{
|
|
4097
|
+
"type": "object"
|
|
4098
|
+
}
|
|
4099
|
+
],
|
|
4100
|
+
"title": "Values"
|
|
4101
|
+
},
|
|
4102
|
+
"next": {
|
|
4103
|
+
"items": {
|
|
4104
|
+
"type": "string"
|
|
4105
|
+
},
|
|
4106
|
+
"type": "array",
|
|
4107
|
+
"title": "Next"
|
|
4108
|
+
},
|
|
4109
|
+
"tasks": {
|
|
4110
|
+
"items": {
|
|
4111
|
+
"type": "object",
|
|
4112
|
+
"properties": {
|
|
4113
|
+
"id": {
|
|
4114
|
+
"type": "string",
|
|
4115
|
+
"title": "Task Id"
|
|
4116
|
+
},
|
|
4117
|
+
"name": {
|
|
4118
|
+
"type": "string",
|
|
4119
|
+
"title": "Node Name"
|
|
4120
|
+
},
|
|
4121
|
+
"error": {
|
|
4122
|
+
"type": "string",
|
|
4123
|
+
"title": "Error"
|
|
4124
|
+
},
|
|
4125
|
+
"interrupts": {
|
|
4126
|
+
"type": "array",
|
|
4127
|
+
"items": {}
|
|
4128
|
+
},
|
|
4129
|
+
"checkpoint": {
|
|
4130
|
+
"$ref": "#/components/schemas/CheckpointConfig",
|
|
4131
|
+
"title": "Checkpoint"
|
|
4132
|
+
},
|
|
4133
|
+
"state": {
|
|
4134
|
+
"$ref": "#/components/schemas/ThreadState"
|
|
4135
|
+
}
|
|
4136
|
+
},
|
|
4137
|
+
"required": ["id", "name"]
|
|
4138
|
+
},
|
|
4139
|
+
"type": "array",
|
|
4140
|
+
"title": "Tasks"
|
|
4141
|
+
},
|
|
4142
|
+
"checkpoint": {
|
|
4143
|
+
"$ref": "#/components/schemas/CheckpointConfig",
|
|
4144
|
+
"title": "Checkpoint"
|
|
4145
|
+
},
|
|
4146
|
+
"metadata": {
|
|
4147
|
+
"type": "object",
|
|
4148
|
+
"title": "Metadata"
|
|
4149
|
+
},
|
|
4150
|
+
"created_at": {
|
|
4151
|
+
"type": "string",
|
|
4152
|
+
"title": "Created At"
|
|
4153
|
+
},
|
|
4154
|
+
"parent_checkpoint": {
|
|
4155
|
+
"type": "object",
|
|
4156
|
+
"title": "Parent Checkpoint"
|
|
4157
|
+
}
|
|
4158
|
+
},
|
|
4159
|
+
"type": "object",
|
|
4160
|
+
"required": ["values", "next", "checkpoint", "metadata", "created_at"],
|
|
4161
|
+
"title": "ThreadState"
|
|
4162
|
+
},
|
|
4163
|
+
"ThreadStateSearch": {
|
|
4164
|
+
"properties": {
|
|
4165
|
+
"limit": {
|
|
4166
|
+
"type": "integer",
|
|
4167
|
+
"title": "Limit",
|
|
4168
|
+
"description": "The maximum number of states to return.",
|
|
4169
|
+
"default": 10,
|
|
4170
|
+
"maximum": 1000,
|
|
4171
|
+
"minimum": 1
|
|
4172
|
+
},
|
|
4173
|
+
"before": {
|
|
4174
|
+
"title": "Before",
|
|
4175
|
+
"description": "Return states before this checkpoint.",
|
|
4176
|
+
"$ref": "#/components/schemas/CheckpointConfig"
|
|
4177
|
+
},
|
|
4178
|
+
"metadata": {
|
|
4179
|
+
"type": "object",
|
|
4180
|
+
"title": "Metadata",
|
|
4181
|
+
"description": "Filter states by metadata key-value pairs."
|
|
4182
|
+
},
|
|
4183
|
+
"checkpoint": {
|
|
4184
|
+
"$ref": "#/components/schemas/CheckpointConfig",
|
|
4185
|
+
"title": "Checkpoint",
|
|
4186
|
+
"description": "Return states for this subgraph."
|
|
4187
|
+
}
|
|
4188
|
+
},
|
|
4189
|
+
"type": "object",
|
|
4190
|
+
"title": "ThreadStateSearch"
|
|
4191
|
+
},
|
|
4192
|
+
"ThreadStateUpdate": {
|
|
4193
|
+
"properties": {
|
|
4194
|
+
"values": {
|
|
4195
|
+
"anyOf": [
|
|
4196
|
+
{
|
|
4197
|
+
"items": {
|
|
4198
|
+
"type": "object"
|
|
4199
|
+
},
|
|
4200
|
+
"type": "array"
|
|
4201
|
+
},
|
|
4202
|
+
{
|
|
4203
|
+
"type": "object"
|
|
4204
|
+
},
|
|
4205
|
+
{
|
|
4206
|
+
"type": "null"
|
|
4207
|
+
}
|
|
4208
|
+
],
|
|
4209
|
+
"title": "Values",
|
|
4210
|
+
"description": "The values to update the state with."
|
|
4211
|
+
},
|
|
4212
|
+
"checkpoint": {
|
|
4213
|
+
"$ref": "#/components/schemas/CheckpointConfig",
|
|
4214
|
+
"title": "Checkpoint",
|
|
4215
|
+
"description": "The checkpoint to update the state of."
|
|
4216
|
+
},
|
|
4217
|
+
"as_node": {
|
|
4218
|
+
"type": "string",
|
|
4219
|
+
"title": "As Node",
|
|
4220
|
+
"description": "Update the state as if this node had just executed."
|
|
4221
|
+
}
|
|
4222
|
+
},
|
|
4223
|
+
"type": "object",
|
|
4224
|
+
"title": "ThreadStateUpdate",
|
|
4225
|
+
"description": "Payload for updating the state of a thread."
|
|
4226
|
+
},
|
|
4227
|
+
"ThreadSuperstepUpdate": {
|
|
4228
|
+
"properties": {
|
|
4229
|
+
"values": {
|
|
4230
|
+
"anyOf": [
|
|
4231
|
+
{
|
|
4232
|
+
"type": "array",
|
|
4233
|
+
"items": {
|
|
4234
|
+
"type": "object"
|
|
4235
|
+
}
|
|
4236
|
+
},
|
|
4237
|
+
{
|
|
4238
|
+
"type": "object"
|
|
4239
|
+
},
|
|
4240
|
+
{
|
|
4241
|
+
"type": "null"
|
|
4242
|
+
}
|
|
4243
|
+
]
|
|
4244
|
+
},
|
|
4245
|
+
"command": {
|
|
4246
|
+
"anyOf": [
|
|
4247
|
+
{
|
|
4248
|
+
"$ref": "#/components/schemas/Command"
|
|
4249
|
+
},
|
|
4250
|
+
{
|
|
4251
|
+
"type": "null"
|
|
4252
|
+
}
|
|
4253
|
+
],
|
|
4254
|
+
"description": "The command associated with the update."
|
|
4255
|
+
},
|
|
4256
|
+
"as_node": {
|
|
4257
|
+
"type": "string",
|
|
4258
|
+
"description": "Update the state as if this node had just executed."
|
|
4259
|
+
}
|
|
4260
|
+
},
|
|
4261
|
+
"required": ["as_node"],
|
|
4262
|
+
"type": "object"
|
|
4263
|
+
},
|
|
4264
|
+
"ThreadStateUpdateResponse": {
|
|
4265
|
+
"properties": {
|
|
4266
|
+
"checkpoint": {
|
|
4267
|
+
"type": "object",
|
|
4268
|
+
"title": "Checkpoint"
|
|
4269
|
+
}
|
|
4270
|
+
},
|
|
4271
|
+
"type": "object",
|
|
4272
|
+
"title": "ThreadStateUpdateResponse",
|
|
4273
|
+
"description": "Response for adding state to a thread."
|
|
4274
|
+
},
|
|
4275
|
+
"CheckpointConfig": {
|
|
4276
|
+
"type": "object",
|
|
4277
|
+
"title": "CheckpointConfig",
|
|
4278
|
+
"description": "Checkpoint config.",
|
|
4279
|
+
"properties": {
|
|
4280
|
+
"thread_id": {
|
|
4281
|
+
"type": "string",
|
|
4282
|
+
"description": "Unique identifier for the thread associated with this checkpoint."
|
|
4283
|
+
},
|
|
4284
|
+
"checkpoint_ns": {
|
|
4285
|
+
"type": "string",
|
|
4286
|
+
"description": "Namespace for the checkpoint, used for organization and retrieval."
|
|
4287
|
+
},
|
|
4288
|
+
"checkpoint_id": {
|
|
4289
|
+
"type": "string",
|
|
4290
|
+
"description": "Optional unique identifier for the checkpoint itself."
|
|
4291
|
+
},
|
|
4292
|
+
"checkpoint_map": {
|
|
4293
|
+
"type": "object",
|
|
4294
|
+
"description": "Optional dictionary containing checkpoint-specific data."
|
|
4295
|
+
}
|
|
4296
|
+
}
|
|
4297
|
+
},
|
|
4298
|
+
"StorePutRequest": {
|
|
4299
|
+
"type": "object",
|
|
4300
|
+
"required": ["namespace", "key", "value"],
|
|
4301
|
+
"properties": {
|
|
4302
|
+
"namespace": {
|
|
4303
|
+
"type": "array",
|
|
4304
|
+
"items": {
|
|
4305
|
+
"type": "string"
|
|
4306
|
+
},
|
|
4307
|
+
"title": "Namespace",
|
|
4308
|
+
"description": "A list of strings representing the namespace path."
|
|
4309
|
+
},
|
|
4310
|
+
"key": {
|
|
4311
|
+
"type": "string",
|
|
4312
|
+
"title": "Key",
|
|
4313
|
+
"description": "The unique identifier for the item within the namespace."
|
|
4314
|
+
},
|
|
4315
|
+
"value": {
|
|
4316
|
+
"type": "object",
|
|
4317
|
+
"title": "Value",
|
|
4318
|
+
"description": "A dictionary containing the item's data."
|
|
4319
|
+
}
|
|
4320
|
+
},
|
|
4321
|
+
"title": "StorePutRequest",
|
|
4322
|
+
"description": "Request to store or update an item."
|
|
4323
|
+
},
|
|
4324
|
+
"StoreDeleteRequest": {
|
|
4325
|
+
"type": "object",
|
|
4326
|
+
"required": ["key"],
|
|
4327
|
+
"properties": {
|
|
4328
|
+
"namespace": {
|
|
4329
|
+
"type": "array",
|
|
4330
|
+
"items": {
|
|
4331
|
+
"type": "string"
|
|
4332
|
+
},
|
|
4333
|
+
"title": "Namespace",
|
|
4334
|
+
"description": "A list of strings representing the namespace path."
|
|
4335
|
+
},
|
|
4336
|
+
"key": {
|
|
4337
|
+
"type": "string",
|
|
4338
|
+
"title": "Key",
|
|
4339
|
+
"description": "The unique identifier for the item."
|
|
4340
|
+
}
|
|
4341
|
+
},
|
|
4342
|
+
"title": "StoreDeleteRequest",
|
|
4343
|
+
"description": "Request to delete an item."
|
|
4344
|
+
},
|
|
4345
|
+
"StoreSearchRequest": {
|
|
4346
|
+
"type": "object",
|
|
4347
|
+
"properties": {
|
|
4348
|
+
"namespace_prefix": {
|
|
4349
|
+
"type": ["array", "null"],
|
|
4350
|
+
"items": {
|
|
4351
|
+
"type": "string"
|
|
4352
|
+
},
|
|
4353
|
+
"title": "Namespace Prefix",
|
|
4354
|
+
"description": "List of strings representing the namespace prefix."
|
|
4355
|
+
},
|
|
4356
|
+
"filter": {
|
|
4357
|
+
"type": ["object", "null"],
|
|
4358
|
+
"additionalProperties": true,
|
|
4359
|
+
"title": "Filter",
|
|
4360
|
+
"description": "Optional dictionary of key-value pairs to filter results."
|
|
4361
|
+
},
|
|
4362
|
+
"limit": {
|
|
4363
|
+
"type": "integer",
|
|
4364
|
+
"default": 10,
|
|
4365
|
+
"title": "Limit",
|
|
4366
|
+
"description": "Maximum number of items to return (default is 10)."
|
|
4367
|
+
},
|
|
4368
|
+
"offset": {
|
|
4369
|
+
"type": "integer",
|
|
4370
|
+
"default": 0,
|
|
4371
|
+
"title": "Offset",
|
|
4372
|
+
"description": "Number of items to skip before returning results (default is 0)."
|
|
4373
|
+
}
|
|
4374
|
+
},
|
|
4375
|
+
"title": "StoreSearchRequest",
|
|
4376
|
+
"description": "Request to search for items within a namespace prefix."
|
|
4377
|
+
},
|
|
4378
|
+
"StoreListNamespacesRequest": {
|
|
4379
|
+
"type": "object",
|
|
4380
|
+
"properties": {
|
|
4381
|
+
"prefix": {
|
|
4382
|
+
"type": "array",
|
|
4383
|
+
"items": {
|
|
4384
|
+
"type": "string"
|
|
4385
|
+
},
|
|
4386
|
+
"title": "Prefix",
|
|
4387
|
+
"description": "Optional list of strings representing the prefix to filter namespaces."
|
|
4388
|
+
},
|
|
4389
|
+
"suffix": {
|
|
4390
|
+
"type": "array",
|
|
4391
|
+
"items": {
|
|
4392
|
+
"type": "string"
|
|
4393
|
+
},
|
|
4394
|
+
"title": "Suffix",
|
|
4395
|
+
"description": "Optional list of strings representing the suffix to filter namespaces."
|
|
4396
|
+
},
|
|
4397
|
+
"max_depth": {
|
|
4398
|
+
"type": "integer",
|
|
4399
|
+
"title": "Max Depth",
|
|
4400
|
+
"description": "Optional integer specifying the maximum depth of namespaces to return."
|
|
4401
|
+
},
|
|
4402
|
+
"limit": {
|
|
4403
|
+
"type": "integer",
|
|
4404
|
+
"default": 100,
|
|
4405
|
+
"title": "Limit",
|
|
4406
|
+
"description": "Maximum number of namespaces to return (default is 100)."
|
|
4407
|
+
},
|
|
4408
|
+
"offset": {
|
|
4409
|
+
"type": "integer",
|
|
4410
|
+
"default": 0,
|
|
4411
|
+
"title": "Offset",
|
|
4412
|
+
"description": "Number of namespaces to skip before returning results (default is 0)."
|
|
4413
|
+
}
|
|
4414
|
+
}
|
|
4415
|
+
},
|
|
4416
|
+
"Item": {
|
|
4417
|
+
"type": "object",
|
|
4418
|
+
"required": ["namespace", "key", "value", "created_at", "updated_at"],
|
|
4419
|
+
"properties": {
|
|
4420
|
+
"namespace": {
|
|
4421
|
+
"type": "array",
|
|
4422
|
+
"items": {
|
|
4423
|
+
"type": "string"
|
|
4424
|
+
},
|
|
4425
|
+
"description": "The namespace of the item. A namespace is analogous to a document's directory."
|
|
4426
|
+
},
|
|
4427
|
+
"key": {
|
|
4428
|
+
"type": "string",
|
|
4429
|
+
"description": "The unique identifier of the item within its namespace. In general, keys needn't be globally unique."
|
|
4430
|
+
},
|
|
4431
|
+
"value": {
|
|
4432
|
+
"type": "object",
|
|
4433
|
+
"description": "The value stored in the item. This is the document itself."
|
|
4434
|
+
},
|
|
4435
|
+
"created_at": {
|
|
4436
|
+
"type": "string",
|
|
4437
|
+
"format": "date-time",
|
|
4438
|
+
"description": "The timestamp when the item was created."
|
|
4439
|
+
},
|
|
4440
|
+
"updated_at": {
|
|
4441
|
+
"type": "string",
|
|
4442
|
+
"format": "date-time",
|
|
4443
|
+
"description": "The timestamp when the item was last updated."
|
|
4444
|
+
}
|
|
4445
|
+
},
|
|
4446
|
+
"description": "Represents a single document or data entry in the graph's Store. Items are used to store cross-thread memories."
|
|
4447
|
+
},
|
|
4448
|
+
"RunsCancel": {
|
|
4449
|
+
"type": "object",
|
|
4450
|
+
"title": "RunsCancel",
|
|
4451
|
+
"description": "Payload for cancelling runs.",
|
|
4452
|
+
"properties": {
|
|
4453
|
+
"status": {
|
|
4454
|
+
"type": "string",
|
|
4455
|
+
"enum": ["pending", "running", "all"],
|
|
4456
|
+
"title": "Status",
|
|
4457
|
+
"description": "Filter runs by status to cancel. Must be one of 'pending', 'running', or 'all'."
|
|
4458
|
+
},
|
|
4459
|
+
"thread_id": {
|
|
4460
|
+
"type": "string",
|
|
4461
|
+
"format": "uuid",
|
|
4462
|
+
"title": "Thread Id",
|
|
4463
|
+
"description": "The ID of the thread containing runs to cancel."
|
|
4464
|
+
},
|
|
4465
|
+
"run_ids": {
|
|
4466
|
+
"type": "array",
|
|
4467
|
+
"items": {
|
|
4468
|
+
"type": "string",
|
|
4469
|
+
"format": "uuid"
|
|
4470
|
+
},
|
|
4471
|
+
"title": "Run Ids",
|
|
4472
|
+
"description": "List of run IDs to cancel."
|
|
4473
|
+
}
|
|
4474
|
+
},
|
|
4475
|
+
"oneOf": [
|
|
4476
|
+
{
|
|
4477
|
+
"required": ["status"]
|
|
4478
|
+
},
|
|
4479
|
+
{
|
|
4480
|
+
"required": ["thread_id", "run_ids"]
|
|
4481
|
+
}
|
|
4482
|
+
]
|
|
4483
|
+
},
|
|
4484
|
+
"SearchItemsResponse": {
|
|
4485
|
+
"type": "object",
|
|
4486
|
+
"required": ["items"],
|
|
4487
|
+
"properties": {
|
|
4488
|
+
"items": {
|
|
4489
|
+
"type": "array",
|
|
4490
|
+
"items": {
|
|
4491
|
+
"$ref": "#/components/schemas/Item"
|
|
4492
|
+
}
|
|
4493
|
+
}
|
|
4494
|
+
}
|
|
4495
|
+
},
|
|
4496
|
+
"ListNamespaceResponse": {
|
|
4497
|
+
"type": "array",
|
|
4498
|
+
"items": {
|
|
4499
|
+
"type": "array",
|
|
4500
|
+
"items": {
|
|
4501
|
+
"type": "string"
|
|
4502
|
+
}
|
|
4503
|
+
}
|
|
4504
|
+
},
|
|
4505
|
+
"ErrorResponse": {
|
|
4506
|
+
"type": "string",
|
|
4507
|
+
"title": "ErrorResponse",
|
|
4508
|
+
"description": "Error message returned from the server"
|
|
4509
|
+
}
|
|
4510
|
+
},
|
|
4511
|
+
"responses": {
|
|
4512
|
+
"GetItemResponse": {
|
|
4513
|
+
"description": "Successful retrieval of an item.",
|
|
4514
|
+
"content": {
|
|
4515
|
+
"application/json": {
|
|
4516
|
+
"schema": {
|
|
4517
|
+
"$ref": "#/components/schemas/Item"
|
|
4518
|
+
}
|
|
4519
|
+
}
|
|
4520
|
+
}
|
|
4521
|
+
},
|
|
4522
|
+
"PutItemResponse": {
|
|
4523
|
+
"description": "Item successfully stored or updated.",
|
|
4524
|
+
"content": {}
|
|
4525
|
+
},
|
|
4526
|
+
"DeleteItemResponse": {
|
|
4527
|
+
"description": "Item successfully deleted.",
|
|
4528
|
+
"content": {}
|
|
4529
|
+
},
|
|
4530
|
+
"SearchItemsResponse": {
|
|
4531
|
+
"description": "Successful search operation.",
|
|
4532
|
+
"content": {
|
|
4533
|
+
"application/json": {
|
|
4534
|
+
"schema": {
|
|
4535
|
+
"$ref": "#/components/schemas/SearchItemsResponse"
|
|
4536
|
+
}
|
|
4537
|
+
}
|
|
4538
|
+
}
|
|
4539
|
+
},
|
|
4540
|
+
"ListNamespacesResponse": {
|
|
4541
|
+
"description": "Successful retrieval of namespaces.",
|
|
4542
|
+
"content": {
|
|
4543
|
+
"application/json": {
|
|
4544
|
+
"schema": {
|
|
4545
|
+
"$ref": "#/components/schemas/ListNamespaceResponse"
|
|
4546
|
+
}
|
|
4547
|
+
}
|
|
4548
|
+
}
|
|
4549
|
+
},
|
|
4550
|
+
"ErrorResponse": {
|
|
4551
|
+
"description": "An error occurred.",
|
|
4552
|
+
"content": {
|
|
4553
|
+
"application/json": {
|
|
4554
|
+
"schema": {
|
|
4555
|
+
"$ref": "#/components/schemas/ErrorResponse"
|
|
4556
|
+
}
|
|
4557
|
+
}
|
|
4558
|
+
}
|
|
4559
|
+
}
|
|
4560
|
+
}
|
|
4561
|
+
}
|
|
4562
|
+
}
|