shuvcode 2.0.0-alpha-7 → 2.0.0-alpha-9

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.
@@ -0,0 +1,1189 @@
1
+ import { ClientError } from "./client-error";
2
+ const maxSseEventBytes = 16 * 1024 * 1024;
3
+ export function make(options) {
4
+ const fetch = options.fetch ?? globalThis.fetch;
5
+ const prepare = (descriptor, requestOptions) => {
6
+ const url = new URL(descriptor.path, options.baseUrl);
7
+ for (const [key, value] of Object.entries(descriptor.query ?? {}))
8
+ appendQuery(url.searchParams, key, value);
9
+ const headers = new Headers(options.headers);
10
+ for (const [key, value] of Object.entries(descriptor.headers ?? {})) {
11
+ if (value !== undefined && value !== null)
12
+ headers.set(key, String(value));
13
+ }
14
+ for (const [key, value] of new Headers(requestOptions?.headers))
15
+ headers.set(key, value);
16
+ if (descriptor.body !== undefined && !headers.has("content-type"))
17
+ headers.set("content-type", "application/json");
18
+ return {
19
+ url,
20
+ init: {
21
+ method: descriptor.method,
22
+ signal: requestOptions?.signal,
23
+ headers,
24
+ body: descriptor.body === undefined ? undefined : JSON.stringify(descriptor.body),
25
+ },
26
+ };
27
+ };
28
+ const execute = async (descriptor, requestOptions) => {
29
+ try {
30
+ const prepared = prepare(descriptor, requestOptions);
31
+ return await fetch(prepared.url, prepared.init);
32
+ }
33
+ catch (cause) {
34
+ throw new ClientError("Transport", { cause });
35
+ }
36
+ };
37
+ const responseError = async (response, descriptor) => {
38
+ if (descriptor.declaredStatuses.includes(response.status))
39
+ throw await json(response);
40
+ try {
41
+ await response.body?.cancel();
42
+ }
43
+ catch { }
44
+ throw new ClientError("UnexpectedStatus", { cause: { status: response.status } });
45
+ };
46
+ const request = async (descriptor, requestOptions) => {
47
+ const response = await execute(descriptor, requestOptions);
48
+ if (response.status !== descriptor.successStatus)
49
+ return responseError(response, descriptor);
50
+ if (descriptor.binary)
51
+ return new Uint8Array(await response.arrayBuffer());
52
+ if (descriptor.empty) {
53
+ try {
54
+ await response.body?.cancel();
55
+ }
56
+ catch { }
57
+ return undefined;
58
+ }
59
+ return (await json(response));
60
+ };
61
+ const sse = (descriptor, requestOptions) => ({
62
+ async *[Symbol.asyncIterator]() {
63
+ const response = await execute(descriptor, requestOptions);
64
+ if (response.status !== descriptor.successStatus)
65
+ await responseError(response, descriptor);
66
+ if (!isContentType(response, "text/event-stream")) {
67
+ try {
68
+ await response.body?.cancel();
69
+ }
70
+ catch { }
71
+ throw new ClientError("UnsupportedContentType");
72
+ }
73
+ if (response.body === null)
74
+ throw new ClientError("MalformedResponse");
75
+ const reader = response.body.getReader();
76
+ const decoder = new TextDecoder();
77
+ let buffer = "";
78
+ try {
79
+ while (true) {
80
+ let next;
81
+ try {
82
+ next = await reader.read();
83
+ }
84
+ catch (cause) {
85
+ throw new ClientError("Transport", { cause });
86
+ }
87
+ buffer += decoder.decode(next.value, { stream: !next.done });
88
+ if (buffer.length > maxSseEventBytes)
89
+ throw new ClientError("SseEventTooLarge");
90
+ const trailingCarriageReturn = !next.done && buffer.endsWith("\r");
91
+ if (trailingCarriageReturn)
92
+ buffer = buffer.slice(0, -1);
93
+ buffer = buffer.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
94
+ if (trailingCarriageReturn)
95
+ buffer += "\r";
96
+ if (next.done && buffer !== "")
97
+ buffer += "\n\n";
98
+ let boundary = buffer.indexOf("\n\n");
99
+ while (boundary >= 0) {
100
+ const block = buffer.slice(0, boundary);
101
+ buffer = buffer.slice(boundary + 2);
102
+ const data = block
103
+ .split("\n")
104
+ .flatMap((line) => (line.startsWith("data:") ? [line.slice(5).trimStart()] : []))
105
+ .join("\n");
106
+ if (data !== "") {
107
+ try {
108
+ yield JSON.parse(data);
109
+ }
110
+ catch (cause) {
111
+ throw new ClientError("MalformedResponse", { cause });
112
+ }
113
+ }
114
+ boundary = buffer.indexOf("\n\n");
115
+ }
116
+ if (next.done)
117
+ return;
118
+ }
119
+ }
120
+ finally {
121
+ try {
122
+ await reader.cancel();
123
+ }
124
+ catch { }
125
+ reader.releaseLock();
126
+ }
127
+ },
128
+ });
129
+ return {
130
+ health: {
131
+ get: (requestOptions) => request({ method: "GET", path: `/api/health`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
132
+ stop: (input, requestOptions) => request({
133
+ method: "POST",
134
+ path: `/api/service/stop`,
135
+ body: { instanceID: input["instanceID"] },
136
+ successStatus: 200,
137
+ declaredStatuses: [401, 400],
138
+ empty: false,
139
+ }, requestOptions),
140
+ },
141
+ server: {
142
+ get: (requestOptions) => request({ method: "GET", path: `/api/server`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
143
+ },
144
+ location: {
145
+ get: (input, requestOptions) => request({
146
+ method: "GET",
147
+ path: `/api/location`,
148
+ query: { location: input?.["location"] },
149
+ successStatus: 200,
150
+ declaredStatuses: [401, 400],
151
+ empty: false,
152
+ }, requestOptions),
153
+ },
154
+ agent: {
155
+ list: (input, requestOptions) => request({
156
+ method: "GET",
157
+ path: `/api/agent`,
158
+ query: { location: input?.["location"] },
159
+ successStatus: 200,
160
+ declaredStatuses: [401, 400],
161
+ empty: false,
162
+ }, requestOptions),
163
+ get: (input, requestOptions) => request({
164
+ method: "GET",
165
+ path: `/api/agent/${encodeURIComponent(input.agentID)}`,
166
+ query: { location: input["location"] },
167
+ successStatus: 200,
168
+ declaredStatuses: [404, 401, 400],
169
+ empty: false,
170
+ }, requestOptions),
171
+ },
172
+ plugin: {
173
+ list: (input, requestOptions) => request({
174
+ method: "GET",
175
+ path: `/api/plugin`,
176
+ query: { location: input?.["location"] },
177
+ successStatus: 200,
178
+ declaredStatuses: [401, 400],
179
+ empty: false,
180
+ }, requestOptions),
181
+ },
182
+ session: {
183
+ list: (input, requestOptions) => request({
184
+ method: "GET",
185
+ path: `/api/session`,
186
+ query: {
187
+ workspace: input?.["workspace"],
188
+ limit: input?.["limit"],
189
+ order: input?.["order"],
190
+ search: input?.["search"],
191
+ parentID: input?.["parentID"],
192
+ directory: input?.["directory"],
193
+ project: input?.["project"],
194
+ subpath: input?.["subpath"],
195
+ cursor: input?.["cursor"],
196
+ },
197
+ successStatus: 200,
198
+ declaredStatuses: [400, 401],
199
+ empty: false,
200
+ }, requestOptions),
201
+ create: (input, requestOptions) => request({
202
+ method: "POST",
203
+ path: `/api/session`,
204
+ body: {
205
+ id: input?.["id"],
206
+ title: input?.["title"],
207
+ agent: input?.["agent"],
208
+ model: input?.["model"],
209
+ location: input?.["location"],
210
+ policy: input?.["policy"],
211
+ },
212
+ successStatus: 200,
213
+ declaredStatuses: [401, 400],
214
+ empty: false,
215
+ }, requestOptions).then((value) => value.data),
216
+ active: (requestOptions) => request({
217
+ method: "GET",
218
+ path: `/api/session/active`,
219
+ successStatus: 200,
220
+ declaredStatuses: [401, 400],
221
+ empty: false,
222
+ }, requestOptions).then((value) => value.data),
223
+ get: (input, requestOptions) => request({
224
+ method: "GET",
225
+ path: `/api/session/${encodeURIComponent(input.sessionID)}`,
226
+ successStatus: 200,
227
+ declaredStatuses: [404, 400, 401],
228
+ empty: false,
229
+ }, requestOptions).then((value) => value.data),
230
+ remove: (input, requestOptions) => request({
231
+ method: "DELETE",
232
+ path: `/api/session/${encodeURIComponent(input.sessionID)}`,
233
+ successStatus: 204,
234
+ declaredStatuses: [404, 400, 401],
235
+ empty: true,
236
+ }, requestOptions),
237
+ fork: (input, requestOptions) => request({
238
+ method: "POST",
239
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/fork`,
240
+ body: { boundary: input["boundary"], policy: input["policy"] },
241
+ successStatus: 200,
242
+ declaredStatuses: [404, 400, 401],
243
+ empty: false,
244
+ }, requestOptions).then((value) => value.data),
245
+ switchAgent: (input, requestOptions) => request({
246
+ method: "POST",
247
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
248
+ body: { agent: input["agent"] },
249
+ successStatus: 204,
250
+ declaredStatuses: [404, 400, 401],
251
+ empty: true,
252
+ }, requestOptions),
253
+ switchModel: (input, requestOptions) => request({
254
+ method: "POST",
255
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
256
+ body: { model: input["model"] },
257
+ successStatus: 204,
258
+ declaredStatuses: [404, 400, 401],
259
+ empty: true,
260
+ }, requestOptions),
261
+ rename: (input, requestOptions) => request({
262
+ method: "POST",
263
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/rename`,
264
+ body: { title: input["title"] },
265
+ successStatus: 204,
266
+ declaredStatuses: [404, 400, 401],
267
+ empty: true,
268
+ }, requestOptions),
269
+ move: (input, requestOptions) => request({
270
+ method: "POST",
271
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
272
+ body: { directory: input["directory"], workspaceID: input["workspaceID"] },
273
+ successStatus: 204,
274
+ declaredStatuses: [404, 400, 401],
275
+ empty: true,
276
+ }, requestOptions),
277
+ prompt: (input, requestOptions) => request({
278
+ method: "POST",
279
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/prompt`,
280
+ body: {
281
+ id: input["id"],
282
+ text: input["text"],
283
+ files: input["files"],
284
+ agents: input["agents"],
285
+ output: input["output"],
286
+ metadata: input["metadata"],
287
+ delivery: input["delivery"],
288
+ resume: input["resume"],
289
+ },
290
+ successStatus: 200,
291
+ declaredStatuses: [409, 400, 404, 401],
292
+ empty: false,
293
+ }, requestOptions).then((value) => value.data),
294
+ command: (input, requestOptions) => request({
295
+ method: "POST",
296
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/command`,
297
+ body: {
298
+ id: input["id"],
299
+ command: input["command"],
300
+ arguments: input["arguments"],
301
+ agent: input["agent"],
302
+ model: input["model"],
303
+ files: input["files"],
304
+ agents: input["agents"],
305
+ delivery: input["delivery"],
306
+ resume: input["resume"],
307
+ },
308
+ successStatus: 200,
309
+ declaredStatuses: [409, 400, 404, 500, 401],
310
+ empty: false,
311
+ }, requestOptions).then((value) => value.data),
312
+ skill: (input, requestOptions) => request({
313
+ method: "POST",
314
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/skill`,
315
+ body: { id: input["id"], skill: input["skill"], resume: input["resume"] },
316
+ successStatus: 204,
317
+ declaredStatuses: [404, 400, 401],
318
+ empty: true,
319
+ }, requestOptions),
320
+ synthetic: (input, requestOptions) => request({
321
+ method: "POST",
322
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
323
+ body: {
324
+ id: input["id"],
325
+ text: input["text"],
326
+ description: input["description"],
327
+ metadata: input["metadata"],
328
+ delivery: input["delivery"],
329
+ resume: input["resume"],
330
+ },
331
+ successStatus: 200,
332
+ declaredStatuses: [409, 404, 400, 401],
333
+ empty: false,
334
+ }, requestOptions).then((value) => value.data),
335
+ shell: (input, requestOptions) => request({
336
+ method: "POST",
337
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/shell`,
338
+ body: { id: input["id"], command: input["command"] },
339
+ successStatus: 204,
340
+ declaredStatuses: [404, 400, 401],
341
+ empty: true,
342
+ }, requestOptions),
343
+ compact: (input, requestOptions) => request({
344
+ method: "POST",
345
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
346
+ body: { id: input["id"] },
347
+ successStatus: 200,
348
+ declaredStatuses: [409, 404, 400, 401],
349
+ empty: false,
350
+ }, requestOptions).then((value) => value.data),
351
+ wait: (input, requestOptions) => request({
352
+ method: "POST",
353
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/wait`,
354
+ successStatus: 204,
355
+ declaredStatuses: [404, 503, 400, 401],
356
+ empty: true,
357
+ }, requestOptions),
358
+ revert: {
359
+ stage: (input, requestOptions) => request({
360
+ method: "POST",
361
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
362
+ body: { messageID: input["messageID"], files: input["files"] },
363
+ successStatus: 200,
364
+ declaredStatuses: [404, 409, 500, 400, 401],
365
+ empty: false,
366
+ }, requestOptions).then((value) => value.data),
367
+ clear: (input, requestOptions) => request({
368
+ method: "POST",
369
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/clear`,
370
+ successStatus: 204,
371
+ declaredStatuses: [404, 409, 500, 400, 401],
372
+ empty: true,
373
+ }, requestOptions),
374
+ commit: (input, requestOptions) => request({
375
+ method: "POST",
376
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
377
+ successStatus: 204,
378
+ declaredStatuses: [404, 409, 400, 401],
379
+ empty: true,
380
+ }, requestOptions),
381
+ },
382
+ context: (input, requestOptions) => request({
383
+ method: "GET",
384
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/context`,
385
+ successStatus: 200,
386
+ declaredStatuses: [404, 500, 400, 401],
387
+ empty: false,
388
+ }, requestOptions).then((value) => value.data),
389
+ pending: {
390
+ list: (input, requestOptions) => request({
391
+ method: "GET",
392
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/pending`,
393
+ successStatus: 200,
394
+ declaredStatuses: [404, 400, 401],
395
+ empty: false,
396
+ }, requestOptions).then((value) => value.data),
397
+ },
398
+ instructions: {
399
+ entry: {
400
+ list: (input, requestOptions) => request({
401
+ method: "GET",
402
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/instructions/entries`,
403
+ successStatus: 200,
404
+ declaredStatuses: [404, 400, 401],
405
+ empty: false,
406
+ }, requestOptions).then((value) => value.data),
407
+ put: (input, requestOptions) => request({
408
+ method: "PUT",
409
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
410
+ body: { value: input["value"] },
411
+ successStatus: 204,
412
+ declaredStatuses: [404, 413, 400, 401],
413
+ empty: true,
414
+ }, requestOptions),
415
+ remove: (input, requestOptions) => request({
416
+ method: "DELETE",
417
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
418
+ successStatus: 204,
419
+ declaredStatuses: [404, 400, 401],
420
+ empty: true,
421
+ }, requestOptions),
422
+ },
423
+ },
424
+ generate: (input, requestOptions) => request({
425
+ method: "POST",
426
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/generate`,
427
+ body: { prompt: input["prompt"] },
428
+ successStatus: 200,
429
+ declaredStatuses: [404, 503, 400, 401],
430
+ empty: false,
431
+ }, requestOptions).then((value) => value.data),
432
+ log: (input, requestOptions) => sse({
433
+ method: "GET",
434
+ path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/log`,
435
+ query: { after: input["after"], follow: input["follow"] },
436
+ successStatus: 200,
437
+ declaredStatuses: [404, 400, 401],
438
+ empty: false,
439
+ }, requestOptions),
440
+ interrupt: (input, requestOptions) => request({
441
+ method: "POST",
442
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
443
+ successStatus: 204,
444
+ declaredStatuses: [404, 400, 401],
445
+ empty: true,
446
+ }, requestOptions),
447
+ background: (input, requestOptions) => request({
448
+ method: "POST",
449
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/background`,
450
+ successStatus: 204,
451
+ declaredStatuses: [404, 400, 401],
452
+ empty: true,
453
+ }, requestOptions),
454
+ message: (input, requestOptions) => request({
455
+ method: "GET",
456
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
457
+ successStatus: 200,
458
+ declaredStatuses: [404, 400, 401],
459
+ empty: false,
460
+ }, requestOptions).then((value) => value.data),
461
+ },
462
+ message: {
463
+ list: (input, requestOptions) => request({
464
+ method: "GET",
465
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
466
+ query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
467
+ successStatus: 200,
468
+ declaredStatuses: [400, 404, 500, 401],
469
+ empty: false,
470
+ }, requestOptions),
471
+ },
472
+ model: {
473
+ list: (input, requestOptions) => request({
474
+ method: "GET",
475
+ path: `/api/model`,
476
+ query: { location: input?.["location"] },
477
+ successStatus: 200,
478
+ declaredStatuses: [503, 401, 400],
479
+ empty: false,
480
+ }, requestOptions),
481
+ default: (input, requestOptions) => request({
482
+ method: "GET",
483
+ path: `/api/model/default`,
484
+ query: { location: input?.["location"] },
485
+ successStatus: 200,
486
+ declaredStatuses: [503, 401, 400],
487
+ empty: false,
488
+ }, requestOptions),
489
+ },
490
+ generate: {
491
+ text: (input, requestOptions) => request({
492
+ method: "POST",
493
+ path: `/api/generate`,
494
+ query: { location: input["location"] },
495
+ body: { prompt: input["prompt"], model: input["model"] },
496
+ successStatus: 200,
497
+ declaredStatuses: [400, 503, 401],
498
+ empty: false,
499
+ }, requestOptions).then((value) => value.data),
500
+ },
501
+ provider: {
502
+ list: (input, requestOptions) => request({
503
+ method: "GET",
504
+ path: `/api/provider`,
505
+ query: { location: input?.["location"] },
506
+ successStatus: 200,
507
+ declaredStatuses: [503, 401, 400],
508
+ empty: false,
509
+ }, requestOptions),
510
+ get: (input, requestOptions) => request({
511
+ method: "GET",
512
+ path: `/api/provider/${encodeURIComponent(input.providerID)}`,
513
+ query: { location: input["location"] },
514
+ successStatus: 200,
515
+ declaredStatuses: [404, 503, 401, 400],
516
+ empty: false,
517
+ }, requestOptions),
518
+ },
519
+ integration: {
520
+ list: (input, requestOptions) => request({
521
+ method: "GET",
522
+ path: `/api/integration`,
523
+ query: { location: input?.["location"] },
524
+ successStatus: 200,
525
+ declaredStatuses: [401, 400],
526
+ empty: false,
527
+ }, requestOptions),
528
+ get: (input, requestOptions) => request({
529
+ method: "GET",
530
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
531
+ query: { location: input["location"] },
532
+ successStatus: 200,
533
+ declaredStatuses: [401, 400],
534
+ empty: false,
535
+ }, requestOptions),
536
+ wellknown: {
537
+ add: (input, requestOptions) => request({
538
+ method: "POST",
539
+ path: `/api/experimental/integration/wellknown`,
540
+ query: { location: input["location"] },
541
+ body: { url: input["url"] },
542
+ successStatus: 204,
543
+ declaredStatuses: [400, 401],
544
+ empty: true,
545
+ }, requestOptions),
546
+ },
547
+ connect: {
548
+ key: (input, requestOptions) => request({
549
+ method: "POST",
550
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
551
+ query: { location: input["location"] },
552
+ body: { key: input["key"], label: input["label"] },
553
+ successStatus: 204,
554
+ declaredStatuses: [400, 401],
555
+ empty: true,
556
+ }, requestOptions),
557
+ },
558
+ oauth: {
559
+ connect: (input, requestOptions) => request({
560
+ method: "POST",
561
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
562
+ query: { location: input["location"] },
563
+ body: { methodID: input["methodID"], inputs: input["inputs"], label: input["label"] },
564
+ successStatus: 200,
565
+ declaredStatuses: [400, 401],
566
+ empty: false,
567
+ }, requestOptions),
568
+ status: (input, requestOptions) => request({
569
+ method: "GET",
570
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
571
+ query: { location: input["location"] },
572
+ successStatus: 200,
573
+ declaredStatuses: [401, 400],
574
+ empty: false,
575
+ }, requestOptions),
576
+ complete: (input, requestOptions) => request({
577
+ method: "POST",
578
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}/complete`,
579
+ query: { location: input["location"] },
580
+ body: { code: input["code"] },
581
+ successStatus: 204,
582
+ declaredStatuses: [400, 401],
583
+ empty: true,
584
+ }, requestOptions),
585
+ cancel: (input, requestOptions) => request({
586
+ method: "DELETE",
587
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
588
+ query: { location: input["location"] },
589
+ successStatus: 204,
590
+ declaredStatuses: [401, 400],
591
+ empty: true,
592
+ }, requestOptions),
593
+ },
594
+ command: {
595
+ connect: (input, requestOptions) => request({
596
+ method: "POST",
597
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command`,
598
+ query: { location: input["location"] },
599
+ body: { methodID: input["methodID"], label: input["label"] },
600
+ successStatus: 200,
601
+ declaredStatuses: [400, 401],
602
+ empty: false,
603
+ }, requestOptions),
604
+ status: (input, requestOptions) => request({
605
+ method: "GET",
606
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
607
+ query: { location: input["location"] },
608
+ successStatus: 200,
609
+ declaredStatuses: [401, 400],
610
+ empty: false,
611
+ }, requestOptions),
612
+ cancel: (input, requestOptions) => request({
613
+ method: "DELETE",
614
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
615
+ query: { location: input["location"] },
616
+ successStatus: 204,
617
+ declaredStatuses: [401, 400],
618
+ empty: true,
619
+ }, requestOptions),
620
+ },
621
+ },
622
+ auth: {
623
+ status: (input, requestOptions) => request({
624
+ method: "GET",
625
+ path: `/api/auth/status`,
626
+ query: { location: input?.["location"] },
627
+ successStatus: 200,
628
+ declaredStatuses: [401, 400],
629
+ empty: false,
630
+ }, requestOptions),
631
+ },
632
+ mcp: {
633
+ list: (input, requestOptions) => request({
634
+ method: "GET",
635
+ path: `/api/mcp`,
636
+ query: { location: input?.["location"] },
637
+ successStatus: 200,
638
+ declaredStatuses: [401, 400],
639
+ empty: false,
640
+ }, requestOptions),
641
+ add: (input, requestOptions) => request({
642
+ method: "PUT",
643
+ path: `/api/mcp/${encodeURIComponent(input.server)}`,
644
+ query: { location: input["location"] },
645
+ body: { config: input["config"] },
646
+ successStatus: 204,
647
+ declaredStatuses: [401, 400],
648
+ empty: true,
649
+ }, requestOptions),
650
+ remove: (input, requestOptions) => request({
651
+ method: "DELETE",
652
+ path: `/api/mcp/${encodeURIComponent(input.server)}`,
653
+ query: { location: input["location"] },
654
+ successStatus: 204,
655
+ declaredStatuses: [404, 401, 400],
656
+ empty: true,
657
+ }, requestOptions),
658
+ connect: (input, requestOptions) => request({
659
+ method: "POST",
660
+ path: `/api/mcp/${encodeURIComponent(input.server)}/connect`,
661
+ query: { location: input["location"] },
662
+ successStatus: 204,
663
+ declaredStatuses: [404, 401, 400],
664
+ empty: true,
665
+ }, requestOptions),
666
+ disconnect: (input, requestOptions) => request({
667
+ method: "POST",
668
+ path: `/api/mcp/${encodeURIComponent(input.server)}/disconnect`,
669
+ query: { location: input["location"] },
670
+ successStatus: 204,
671
+ declaredStatuses: [404, 401, 400],
672
+ empty: true,
673
+ }, requestOptions),
674
+ resource: {
675
+ catalog: (input, requestOptions) => request({
676
+ method: "GET",
677
+ path: `/api/mcp/resource`,
678
+ query: { location: input?.["location"] },
679
+ successStatus: 200,
680
+ declaredStatuses: [401, 400],
681
+ empty: false,
682
+ }, requestOptions),
683
+ },
684
+ },
685
+ credential: {
686
+ update: (input, requestOptions) => request({
687
+ method: "PATCH",
688
+ path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
689
+ query: { location: input["location"] },
690
+ body: { label: input["label"] },
691
+ successStatus: 204,
692
+ declaredStatuses: [401, 400],
693
+ empty: true,
694
+ }, requestOptions),
695
+ remove: (input, requestOptions) => request({
696
+ method: "DELETE",
697
+ path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
698
+ query: { location: input["location"] },
699
+ successStatus: 204,
700
+ declaredStatuses: [401, 400],
701
+ empty: true,
702
+ }, requestOptions),
703
+ },
704
+ project: {
705
+ list: (requestOptions) => request({ method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
706
+ current: (input, requestOptions) => request({
707
+ method: "GET",
708
+ path: `/api/project/current`,
709
+ query: { location: input?.["location"] },
710
+ successStatus: 200,
711
+ declaredStatuses: [401, 400],
712
+ empty: false,
713
+ }, requestOptions),
714
+ directories: (input, requestOptions) => request({
715
+ method: "GET",
716
+ path: `/api/project/${encodeURIComponent(input.projectID)}/directories`,
717
+ query: { location: input["location"] },
718
+ successStatus: 200,
719
+ declaredStatuses: [401, 400],
720
+ empty: false,
721
+ }, requestOptions),
722
+ },
723
+ form: {
724
+ request: {
725
+ list: (input, requestOptions) => request({
726
+ method: "GET",
727
+ path: `/api/form/request`,
728
+ query: { location: input?.["location"] },
729
+ successStatus: 200,
730
+ declaredStatuses: [401, 400],
731
+ empty: false,
732
+ }, requestOptions),
733
+ },
734
+ list: (input, requestOptions) => request({
735
+ method: "GET",
736
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
737
+ successStatus: 200,
738
+ declaredStatuses: [404, 400, 401],
739
+ empty: false,
740
+ }, requestOptions).then((value) => value.data),
741
+ create: (input, requestOptions) => request({
742
+ method: "POST",
743
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
744
+ body: { id: input["id"], title: input["title"], metadata: input["metadata"], fields: input["fields"] },
745
+ successStatus: 200,
746
+ declaredStatuses: [404, 409, 400, 401],
747
+ empty: false,
748
+ }, requestOptions).then((value) => value.data),
749
+ get: (input, requestOptions) => request({
750
+ method: "GET",
751
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
752
+ successStatus: 200,
753
+ declaredStatuses: [404, 400, 401],
754
+ empty: false,
755
+ }, requestOptions).then((value) => value.data),
756
+ state: (input, requestOptions) => request({
757
+ method: "GET",
758
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/state`,
759
+ successStatus: 200,
760
+ declaredStatuses: [404, 400, 401],
761
+ empty: false,
762
+ }, requestOptions).then((value) => value.data),
763
+ reply: (input, requestOptions) => request({
764
+ method: "POST",
765
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/reply`,
766
+ body: { answer: input["answer"] },
767
+ successStatus: 204,
768
+ declaredStatuses: [404, 409, 400, 401],
769
+ empty: true,
770
+ }, requestOptions),
771
+ cancel: (input, requestOptions) => request({
772
+ method: "POST",
773
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/cancel`,
774
+ successStatus: 204,
775
+ declaredStatuses: [404, 409, 400, 401],
776
+ empty: true,
777
+ }, requestOptions),
778
+ },
779
+ permission: {
780
+ request: {
781
+ list: (input, requestOptions) => request({
782
+ method: "GET",
783
+ path: `/api/permission/request`,
784
+ query: { location: input?.["location"] },
785
+ successStatus: 200,
786
+ declaredStatuses: [401, 400],
787
+ empty: false,
788
+ }, requestOptions),
789
+ },
790
+ saved: {
791
+ list: (input, requestOptions) => request({
792
+ method: "GET",
793
+ path: `/api/permission/saved`,
794
+ query: { projectID: input?.["projectID"] },
795
+ successStatus: 200,
796
+ declaredStatuses: [401, 400],
797
+ empty: false,
798
+ }, requestOptions).then((value) => value.data),
799
+ remove: (input, requestOptions) => request({
800
+ method: "DELETE",
801
+ path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
802
+ successStatus: 204,
803
+ declaredStatuses: [401, 400],
804
+ empty: true,
805
+ }, requestOptions),
806
+ },
807
+ create: (input, requestOptions) => request({
808
+ method: "POST",
809
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
810
+ body: {
811
+ id: input["id"],
812
+ action: input["action"],
813
+ resources: input["resources"],
814
+ save: input["save"],
815
+ metadata: input["metadata"],
816
+ source: input["source"],
817
+ agent: input["agent"],
818
+ },
819
+ successStatus: 200,
820
+ declaredStatuses: [404, 400, 401],
821
+ empty: false,
822
+ }, requestOptions).then((value) => value.data),
823
+ list: (input, requestOptions) => request({
824
+ method: "GET",
825
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
826
+ successStatus: 200,
827
+ declaredStatuses: [404, 400, 401],
828
+ empty: false,
829
+ }, requestOptions).then((value) => value.data),
830
+ get: (input, requestOptions) => request({
831
+ method: "GET",
832
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}`,
833
+ successStatus: 200,
834
+ declaredStatuses: [404, 400, 401],
835
+ empty: false,
836
+ }, requestOptions).then((value) => value.data),
837
+ reply: (input, requestOptions) => request({
838
+ method: "POST",
839
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}/reply`,
840
+ body: { reply: input["reply"], message: input["message"] },
841
+ successStatus: 204,
842
+ declaredStatuses: [404, 400, 401],
843
+ empty: true,
844
+ }, requestOptions),
845
+ },
846
+ file: {
847
+ read: (input, requestOptions) => request({
848
+ method: "GET",
849
+ path: `/api/fs/read/${encodePath(input.path)}`,
850
+ query: { location: input["location"] },
851
+ successStatus: 200,
852
+ declaredStatuses: [401, 400],
853
+ empty: false,
854
+ binary: true,
855
+ }, requestOptions),
856
+ list: (input, requestOptions) => request({
857
+ method: "GET",
858
+ path: `/api/fs/list`,
859
+ query: { location: input?.["location"], path: input?.["path"] },
860
+ successStatus: 200,
861
+ declaredStatuses: [401, 400],
862
+ empty: false,
863
+ }, requestOptions),
864
+ find: (input, requestOptions) => request({
865
+ method: "GET",
866
+ path: `/api/fs/find`,
867
+ query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
868
+ successStatus: 200,
869
+ declaredStatuses: [401, 400],
870
+ empty: false,
871
+ }, requestOptions),
872
+ },
873
+ command: {
874
+ list: (input, requestOptions) => request({
875
+ method: "GET",
876
+ path: `/api/command`,
877
+ query: { location: input?.["location"] },
878
+ successStatus: 200,
879
+ declaredStatuses: [401, 400],
880
+ empty: false,
881
+ }, requestOptions),
882
+ },
883
+ skill: {
884
+ list: (input, requestOptions) => request({
885
+ method: "GET",
886
+ path: `/api/skill`,
887
+ query: { location: input?.["location"] },
888
+ successStatus: 200,
889
+ declaredStatuses: [401, 400],
890
+ empty: false,
891
+ }, requestOptions),
892
+ },
893
+ event: {
894
+ subscribe: (requestOptions) => sse({ method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
895
+ },
896
+ pty: {
897
+ list: (input, requestOptions) => request({
898
+ method: "GET",
899
+ path: `/api/pty`,
900
+ query: { location: input?.["location"] },
901
+ successStatus: 200,
902
+ declaredStatuses: [401, 400],
903
+ empty: false,
904
+ }, requestOptions),
905
+ create: (input, requestOptions) => request({
906
+ method: "POST",
907
+ path: `/api/pty`,
908
+ query: { location: input?.["location"] },
909
+ body: {
910
+ command: input?.["command"],
911
+ args: input?.["args"],
912
+ cwd: input?.["cwd"],
913
+ title: input?.["title"],
914
+ env: input?.["env"],
915
+ },
916
+ successStatus: 200,
917
+ declaredStatuses: [401, 400],
918
+ empty: false,
919
+ }, requestOptions),
920
+ get: (input, requestOptions) => request({
921
+ method: "GET",
922
+ path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
923
+ query: { location: input["location"] },
924
+ successStatus: 200,
925
+ declaredStatuses: [404, 401, 400],
926
+ empty: false,
927
+ }, requestOptions),
928
+ update: (input, requestOptions) => request({
929
+ method: "PUT",
930
+ path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
931
+ query: { location: input["location"] },
932
+ body: { title: input["title"], size: input["size"] },
933
+ successStatus: 200,
934
+ declaredStatuses: [404, 401, 400],
935
+ empty: false,
936
+ }, requestOptions),
937
+ remove: (input, requestOptions) => request({
938
+ method: "DELETE",
939
+ path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
940
+ query: { location: input["location"] },
941
+ successStatus: 204,
942
+ declaredStatuses: [404, 401, 400],
943
+ empty: true,
944
+ }, requestOptions),
945
+ },
946
+ shell: {
947
+ list: (input, requestOptions) => request({
948
+ method: "GET",
949
+ path: `/api/shell`,
950
+ query: { location: input?.["location"] },
951
+ successStatus: 200,
952
+ declaredStatuses: [401, 400],
953
+ empty: false,
954
+ }, requestOptions),
955
+ create: (input, requestOptions) => request({
956
+ method: "POST",
957
+ path: `/api/shell`,
958
+ query: { location: input["location"] },
959
+ body: {
960
+ command: input["command"],
961
+ cwd: input["cwd"],
962
+ timeout: input["timeout"],
963
+ metadata: input["metadata"],
964
+ },
965
+ successStatus: 200,
966
+ declaredStatuses: [401, 400],
967
+ empty: false,
968
+ }, requestOptions),
969
+ get: (input, requestOptions) => request({
970
+ method: "GET",
971
+ path: `/api/shell/${encodeURIComponent(input.id)}`,
972
+ query: { location: input["location"] },
973
+ successStatus: 200,
974
+ declaredStatuses: [404, 401, 400],
975
+ empty: false,
976
+ }, requestOptions),
977
+ timeout: (input, requestOptions) => request({
978
+ method: "PATCH",
979
+ path: `/api/shell/${encodeURIComponent(input.id)}/timeout`,
980
+ query: { location: input["location"] },
981
+ body: { timeout: input["timeout"] },
982
+ successStatus: 200,
983
+ declaredStatuses: [404, 401, 400],
984
+ empty: false,
985
+ }, requestOptions),
986
+ output: (input, requestOptions) => request({
987
+ method: "GET",
988
+ path: `/api/shell/${encodeURIComponent(input.id)}/output`,
989
+ query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
990
+ successStatus: 200,
991
+ declaredStatuses: [404, 401, 400],
992
+ empty: false,
993
+ }, requestOptions),
994
+ remove: (input, requestOptions) => request({
995
+ method: "DELETE",
996
+ path: `/api/shell/${encodeURIComponent(input.id)}`,
997
+ query: { location: input["location"] },
998
+ successStatus: 204,
999
+ declaredStatuses: [404, 401, 400],
1000
+ empty: true,
1001
+ }, requestOptions),
1002
+ },
1003
+ question: {
1004
+ request: {
1005
+ list: (input, requestOptions) => request({
1006
+ method: "GET",
1007
+ path: `/api/question/request`,
1008
+ query: { location: input?.["location"] },
1009
+ successStatus: 200,
1010
+ declaredStatuses: [401, 400],
1011
+ empty: false,
1012
+ }, requestOptions),
1013
+ },
1014
+ list: (input, requestOptions) => request({
1015
+ method: "GET",
1016
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/question`,
1017
+ successStatus: 200,
1018
+ declaredStatuses: [404, 400, 401],
1019
+ empty: false,
1020
+ }, requestOptions).then((value) => value.data),
1021
+ reply: (input, requestOptions) => request({
1022
+ method: "POST",
1023
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reply`,
1024
+ body: { answers: input["answers"] },
1025
+ successStatus: 204,
1026
+ declaredStatuses: [404, 400, 401],
1027
+ empty: true,
1028
+ }, requestOptions),
1029
+ reject: (input, requestOptions) => request({
1030
+ method: "POST",
1031
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reject`,
1032
+ successStatus: 204,
1033
+ declaredStatuses: [404, 400, 401],
1034
+ empty: true,
1035
+ }, requestOptions),
1036
+ },
1037
+ reference: {
1038
+ list: (input, requestOptions) => request({
1039
+ method: "GET",
1040
+ path: `/api/reference`,
1041
+ query: { location: input?.["location"] },
1042
+ successStatus: 200,
1043
+ declaredStatuses: [401, 400],
1044
+ empty: false,
1045
+ }, requestOptions),
1046
+ },
1047
+ projectCopy: {
1048
+ create: (input, requestOptions) => request({
1049
+ method: "POST",
1050
+ path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
1051
+ query: { location: input["location"] },
1052
+ body: { strategy: input["strategy"], directory: input["directory"], name: input["name"] },
1053
+ successStatus: 200,
1054
+ declaredStatuses: [400, 401],
1055
+ empty: false,
1056
+ }, requestOptions),
1057
+ remove: (input, requestOptions) => request({
1058
+ method: "DELETE",
1059
+ path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
1060
+ query: { location: input["location"] },
1061
+ body: { directory: input["directory"], force: input["force"] },
1062
+ successStatus: 204,
1063
+ declaredStatuses: [400, 401],
1064
+ empty: true,
1065
+ }, requestOptions),
1066
+ refresh: (input, requestOptions) => request({
1067
+ method: "POST",
1068
+ path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy/refresh`,
1069
+ query: { location: input["location"] },
1070
+ successStatus: 204,
1071
+ declaredStatuses: [400, 401],
1072
+ empty: true,
1073
+ }, requestOptions),
1074
+ },
1075
+ vcs: {
1076
+ get: (input, requestOptions) => request({
1077
+ method: "GET",
1078
+ path: `/api/vcs`,
1079
+ query: { location: input?.["location"] },
1080
+ successStatus: 200,
1081
+ declaredStatuses: [401, 400],
1082
+ empty: false,
1083
+ }, requestOptions),
1084
+ status: (input, requestOptions) => request({
1085
+ method: "GET",
1086
+ path: `/api/vcs/status`,
1087
+ query: { location: input?.["location"] },
1088
+ successStatus: 200,
1089
+ declaredStatuses: [401, 400],
1090
+ empty: false,
1091
+ }, requestOptions),
1092
+ diff: (input, requestOptions) => request({
1093
+ method: "GET",
1094
+ path: `/api/vcs/diff`,
1095
+ query: { location: input["location"], mode: input["mode"], context: input["context"] },
1096
+ successStatus: 200,
1097
+ declaredStatuses: [401, 400],
1098
+ empty: false,
1099
+ }, requestOptions),
1100
+ },
1101
+ debug: {
1102
+ location: {
1103
+ list: (requestOptions) => request({
1104
+ method: "GET",
1105
+ path: `/api/debug/location`,
1106
+ successStatus: 200,
1107
+ declaredStatuses: [401, 400],
1108
+ empty: false,
1109
+ }, requestOptions),
1110
+ evict: (input, requestOptions) => request({
1111
+ method: "DELETE",
1112
+ path: `/api/debug/location`,
1113
+ query: { location: input?.["location"] },
1114
+ successStatus: 204,
1115
+ declaredStatuses: [401, 400],
1116
+ empty: true,
1117
+ }, requestOptions),
1118
+ },
1119
+ },
1120
+ websearch: {
1121
+ providers: (input, requestOptions) => request({
1122
+ method: "GET",
1123
+ path: `/api/websearch/provider`,
1124
+ query: { location: input?.["location"] },
1125
+ successStatus: 200,
1126
+ declaredStatuses: [503, 401, 400],
1127
+ empty: false,
1128
+ }, requestOptions),
1129
+ query: (input, requestOptions) => request({
1130
+ method: "POST",
1131
+ path: `/api/websearch`,
1132
+ query: { location: input["location"] },
1133
+ body: { query: input["query"], providerID: input["providerID"] },
1134
+ successStatus: 200,
1135
+ declaredStatuses: [400, 503, 401],
1136
+ empty: false,
1137
+ }, requestOptions),
1138
+ },
1139
+ };
1140
+ }
1141
+ function encodePath(value) {
1142
+ return value.split("/").map(encodeURIComponent).join("/");
1143
+ }
1144
+ function appendQuery(params, key, value) {
1145
+ if (value === undefined)
1146
+ return;
1147
+ if (value === null) {
1148
+ params.append(key, "null");
1149
+ return;
1150
+ }
1151
+ if (Array.isArray(value)) {
1152
+ for (const item of value)
1153
+ appendQuery(params, key, item);
1154
+ return;
1155
+ }
1156
+ if (typeof value === "object") {
1157
+ for (const [child, item] of Object.entries(value))
1158
+ appendQuery(params, `${key}[${child}]`, item);
1159
+ return;
1160
+ }
1161
+ params.append(key, String(value));
1162
+ }
1163
+ async function json(response) {
1164
+ if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
1165
+ try {
1166
+ await response.body?.cancel();
1167
+ }
1168
+ catch { }
1169
+ throw new ClientError("UnsupportedContentType");
1170
+ }
1171
+ let text;
1172
+ try {
1173
+ text = await response.text();
1174
+ }
1175
+ catch (cause) {
1176
+ throw new ClientError("Transport", { cause });
1177
+ }
1178
+ if (text === "")
1179
+ throw new ClientError("MalformedResponse");
1180
+ try {
1181
+ return JSON.parse(text);
1182
+ }
1183
+ catch (cause) {
1184
+ throw new ClientError("MalformedResponse", { cause });
1185
+ }
1186
+ }
1187
+ function isContentType(response, expected) {
1188
+ return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected;
1189
+ }