shuvcode 2.0.0-alpha-8 → 2.0.0-alpha-10

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,1249 @@
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
+ import: (input, requestOptions) => request({
217
+ method: "POST",
218
+ path: `/api/session/import`,
219
+ body: { info: input["info"], messages: input["messages"], location: input["location"] },
220
+ successStatus: 200,
221
+ declaredStatuses: [409, 401, 400],
222
+ empty: false,
223
+ }, requestOptions).then((value) => value.data),
224
+ export: (input, requestOptions) => request({
225
+ method: "GET",
226
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/export`,
227
+ query: { sanitize: input["sanitize"] },
228
+ successStatus: 200,
229
+ declaredStatuses: [404, 500, 401, 400],
230
+ empty: false,
231
+ }, requestOptions).then((value) => value.data),
232
+ active: (requestOptions) => request({
233
+ method: "GET",
234
+ path: `/api/session/active`,
235
+ successStatus: 200,
236
+ declaredStatuses: [401, 400],
237
+ empty: false,
238
+ }, requestOptions).then((value) => value.data),
239
+ get: (input, requestOptions) => request({
240
+ method: "GET",
241
+ path: `/api/session/${encodeURIComponent(input.sessionID)}`,
242
+ successStatus: 200,
243
+ declaredStatuses: [404, 401, 400],
244
+ empty: false,
245
+ }, requestOptions).then((value) => value.data),
246
+ remove: (input, requestOptions) => request({
247
+ method: "DELETE",
248
+ path: `/api/session/${encodeURIComponent(input.sessionID)}`,
249
+ successStatus: 204,
250
+ declaredStatuses: [404, 400, 401],
251
+ empty: true,
252
+ }, requestOptions),
253
+ fork: (input, requestOptions) => request({
254
+ method: "POST",
255
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/fork`,
256
+ body: { boundary: input["boundary"], policy: input["policy"] },
257
+ successStatus: 200,
258
+ declaredStatuses: [404, 400, 401],
259
+ empty: false,
260
+ }, requestOptions).then((value) => value.data),
261
+ switchAgent: (input, requestOptions) => request({
262
+ method: "POST",
263
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
264
+ body: { agent: input["agent"] },
265
+ successStatus: 204,
266
+ declaredStatuses: [404, 400, 401],
267
+ empty: true,
268
+ }, requestOptions),
269
+ switchModel: (input, requestOptions) => request({
270
+ method: "POST",
271
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
272
+ body: { model: input["model"] },
273
+ successStatus: 204,
274
+ declaredStatuses: [404, 400, 401],
275
+ empty: true,
276
+ }, requestOptions),
277
+ rename: (input, requestOptions) => request({
278
+ method: "POST",
279
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/rename`,
280
+ body: { title: input["title"] },
281
+ successStatus: 204,
282
+ declaredStatuses: [404, 400, 401],
283
+ empty: true,
284
+ }, requestOptions),
285
+ move: (input, requestOptions) => request({
286
+ method: "POST",
287
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
288
+ body: { directory: input["directory"], workspaceID: input["workspaceID"] },
289
+ successStatus: 204,
290
+ declaredStatuses: [404, 400, 401],
291
+ empty: true,
292
+ }, requestOptions),
293
+ prompt: (input, requestOptions) => request({
294
+ method: "POST",
295
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/prompt`,
296
+ body: {
297
+ id: input["id"],
298
+ text: input["text"],
299
+ files: input["files"],
300
+ agents: input["agents"],
301
+ output: input["output"],
302
+ skills: input["skills"],
303
+ metadata: input["metadata"],
304
+ delivery: input["delivery"],
305
+ resume: input["resume"],
306
+ },
307
+ successStatus: 200,
308
+ declaredStatuses: [409, 400, 404, 401],
309
+ empty: false,
310
+ }, requestOptions).then((value) => value.data),
311
+ command: (input, requestOptions) => request({
312
+ method: "POST",
313
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/command`,
314
+ body: {
315
+ id: input["id"],
316
+ command: input["command"],
317
+ arguments: input["arguments"],
318
+ agent: input["agent"],
319
+ model: input["model"],
320
+ files: input["files"],
321
+ agents: input["agents"],
322
+ skills: input["skills"],
323
+ delivery: input["delivery"],
324
+ resume: input["resume"],
325
+ },
326
+ successStatus: 200,
327
+ declaredStatuses: [409, 400, 404, 500, 401],
328
+ empty: false,
329
+ }, requestOptions).then((value) => value.data),
330
+ skill: (input, requestOptions) => request({
331
+ method: "POST",
332
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/skill`,
333
+ body: { id: input["id"], skill: input["skill"], resume: input["resume"] },
334
+ successStatus: 204,
335
+ declaredStatuses: [404, 400, 401],
336
+ empty: true,
337
+ }, requestOptions),
338
+ synthetic: (input, requestOptions) => request({
339
+ method: "POST",
340
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
341
+ body: {
342
+ id: input["id"],
343
+ text: input["text"],
344
+ description: input["description"],
345
+ metadata: input["metadata"],
346
+ delivery: input["delivery"],
347
+ resume: input["resume"],
348
+ },
349
+ successStatus: 200,
350
+ declaredStatuses: [409, 404, 400, 401],
351
+ empty: false,
352
+ }, requestOptions).then((value) => value.data),
353
+ shell: (input, requestOptions) => request({
354
+ method: "POST",
355
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/shell`,
356
+ body: { id: input["id"], command: input["command"] },
357
+ successStatus: 204,
358
+ declaredStatuses: [404, 400, 401],
359
+ empty: true,
360
+ }, requestOptions),
361
+ compact: (input, requestOptions) => request({
362
+ method: "POST",
363
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
364
+ body: { id: input["id"] },
365
+ successStatus: 200,
366
+ declaredStatuses: [409, 404, 400, 401],
367
+ empty: false,
368
+ }, requestOptions).then((value) => value.data),
369
+ wait: (input, requestOptions) => request({
370
+ method: "POST",
371
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/wait`,
372
+ successStatus: 204,
373
+ declaredStatuses: [404, 503, 400, 401],
374
+ empty: true,
375
+ }, requestOptions),
376
+ revert: {
377
+ stage: (input, requestOptions) => request({
378
+ method: "POST",
379
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
380
+ body: { messageID: input["messageID"], files: input["files"] },
381
+ successStatus: 200,
382
+ declaredStatuses: [404, 409, 500, 400, 401],
383
+ empty: false,
384
+ }, requestOptions).then((value) => value.data),
385
+ clear: (input, requestOptions) => request({
386
+ method: "POST",
387
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/clear`,
388
+ successStatus: 204,
389
+ declaredStatuses: [404, 409, 500, 400, 401],
390
+ empty: true,
391
+ }, requestOptions),
392
+ commit: (input, requestOptions) => request({
393
+ method: "POST",
394
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
395
+ successStatus: 204,
396
+ declaredStatuses: [404, 409, 400, 401],
397
+ empty: true,
398
+ }, requestOptions),
399
+ },
400
+ context: (input, requestOptions) => request({
401
+ method: "GET",
402
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/context`,
403
+ successStatus: 200,
404
+ declaredStatuses: [404, 500, 401, 400],
405
+ empty: false,
406
+ }, requestOptions).then((value) => value.data),
407
+ pending: {
408
+ list: (input, requestOptions) => request({
409
+ method: "GET",
410
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/pending`,
411
+ successStatus: 200,
412
+ declaredStatuses: [404, 401, 400],
413
+ empty: false,
414
+ }, requestOptions).then((value) => value.data),
415
+ cancel: (input, requestOptions) => request({
416
+ method: "DELETE",
417
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}`,
418
+ successStatus: 204,
419
+ declaredStatuses: [409, 404, 401, 400],
420
+ empty: true,
421
+ }, requestOptions),
422
+ steer: (input, requestOptions) => request({
423
+ method: "POST",
424
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/steer`,
425
+ successStatus: 204,
426
+ declaredStatuses: [409, 404, 401, 400],
427
+ empty: true,
428
+ }, requestOptions),
429
+ queue: (input, requestOptions) => request({
430
+ method: "POST",
431
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/queue`,
432
+ successStatus: 204,
433
+ declaredStatuses: [409, 404, 401, 400],
434
+ empty: true,
435
+ }, requestOptions),
436
+ },
437
+ instructions: {
438
+ entry: {
439
+ list: (input, requestOptions) => request({
440
+ method: "GET",
441
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/instructions/entries`,
442
+ successStatus: 200,
443
+ declaredStatuses: [404, 400, 401],
444
+ empty: false,
445
+ }, requestOptions).then((value) => value.data),
446
+ put: (input, requestOptions) => request({
447
+ method: "PUT",
448
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
449
+ body: { value: input["value"] },
450
+ successStatus: 204,
451
+ declaredStatuses: [404, 413, 400, 401],
452
+ empty: true,
453
+ }, requestOptions),
454
+ remove: (input, requestOptions) => request({
455
+ method: "DELETE",
456
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
457
+ successStatus: 204,
458
+ declaredStatuses: [404, 400, 401],
459
+ empty: true,
460
+ }, requestOptions),
461
+ },
462
+ },
463
+ generate: (input, requestOptions) => request({
464
+ method: "POST",
465
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/generate`,
466
+ body: { prompt: input["prompt"] },
467
+ successStatus: 200,
468
+ declaredStatuses: [404, 503, 400, 401],
469
+ empty: false,
470
+ }, requestOptions).then((value) => value.data),
471
+ log: (input, requestOptions) => sse({
472
+ method: "GET",
473
+ path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/log`,
474
+ query: { after: input["after"], follow: input["follow"] },
475
+ successStatus: 200,
476
+ declaredStatuses: [404, 401, 400],
477
+ empty: false,
478
+ }, requestOptions),
479
+ interrupt: (input, requestOptions) => request({
480
+ method: "POST",
481
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
482
+ successStatus: 204,
483
+ declaredStatuses: [404, 400, 401],
484
+ empty: true,
485
+ }, requestOptions),
486
+ background: (input, requestOptions) => request({
487
+ method: "POST",
488
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/background`,
489
+ successStatus: 204,
490
+ declaredStatuses: [404, 400, 401],
491
+ empty: true,
492
+ }, requestOptions),
493
+ message: (input, requestOptions) => request({
494
+ method: "GET",
495
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
496
+ successStatus: 200,
497
+ declaredStatuses: [404, 401, 400],
498
+ empty: false,
499
+ }, requestOptions).then((value) => value.data),
500
+ },
501
+ message: {
502
+ list: (input, requestOptions) => request({
503
+ method: "GET",
504
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
505
+ query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
506
+ successStatus: 200,
507
+ declaredStatuses: [400, 404, 500, 401],
508
+ empty: false,
509
+ }, requestOptions),
510
+ },
511
+ model: {
512
+ list: (input, requestOptions) => request({
513
+ method: "GET",
514
+ path: `/api/model`,
515
+ query: { location: input?.["location"] },
516
+ successStatus: 200,
517
+ declaredStatuses: [503, 401, 400],
518
+ empty: false,
519
+ }, requestOptions),
520
+ default: (input, requestOptions) => request({
521
+ method: "GET",
522
+ path: `/api/model/default`,
523
+ query: { location: input?.["location"] },
524
+ successStatus: 200,
525
+ declaredStatuses: [503, 401, 400],
526
+ empty: false,
527
+ }, requestOptions),
528
+ },
529
+ generate: {
530
+ text: (input, requestOptions) => request({
531
+ method: "POST",
532
+ path: `/api/generate`,
533
+ query: { location: input["location"] },
534
+ body: { prompt: input["prompt"], model: input["model"] },
535
+ successStatus: 200,
536
+ declaredStatuses: [400, 503, 401],
537
+ empty: false,
538
+ }, requestOptions).then((value) => value.data),
539
+ },
540
+ provider: {
541
+ list: (input, requestOptions) => request({
542
+ method: "GET",
543
+ path: `/api/provider`,
544
+ query: { location: input?.["location"] },
545
+ successStatus: 200,
546
+ declaredStatuses: [503, 401, 400],
547
+ empty: false,
548
+ }, requestOptions),
549
+ get: (input, requestOptions) => request({
550
+ method: "GET",
551
+ path: `/api/provider/${encodeURIComponent(input.providerID)}`,
552
+ query: { location: input["location"] },
553
+ successStatus: 200,
554
+ declaredStatuses: [404, 503, 401, 400],
555
+ empty: false,
556
+ }, requestOptions),
557
+ },
558
+ integration: {
559
+ list: (input, requestOptions) => request({
560
+ method: "GET",
561
+ path: `/api/integration`,
562
+ query: { location: input?.["location"] },
563
+ successStatus: 200,
564
+ declaredStatuses: [401, 400],
565
+ empty: false,
566
+ }, requestOptions),
567
+ get: (input, requestOptions) => request({
568
+ method: "GET",
569
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
570
+ query: { location: input["location"] },
571
+ successStatus: 200,
572
+ declaredStatuses: [401, 400],
573
+ empty: false,
574
+ }, requestOptions),
575
+ wellknown: {
576
+ add: (input, requestOptions) => request({
577
+ method: "POST",
578
+ path: `/api/experimental/integration/wellknown`,
579
+ query: { location: input["location"] },
580
+ body: { url: input["url"] },
581
+ successStatus: 204,
582
+ declaredStatuses: [400, 401],
583
+ empty: true,
584
+ }, requestOptions),
585
+ },
586
+ connect: {
587
+ key: (input, requestOptions) => request({
588
+ method: "POST",
589
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
590
+ query: { location: input["location"] },
591
+ body: { key: input["key"], answer: input["answer"], label: input["label"] },
592
+ successStatus: 204,
593
+ declaredStatuses: [400, 401],
594
+ empty: true,
595
+ }, requestOptions),
596
+ },
597
+ oauth: {
598
+ connect: (input, requestOptions) => request({
599
+ method: "POST",
600
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
601
+ query: { location: input["location"] },
602
+ body: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
603
+ successStatus: 200,
604
+ declaredStatuses: [400, 401],
605
+ empty: false,
606
+ }, requestOptions),
607
+ status: (input, requestOptions) => request({
608
+ method: "GET",
609
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
610
+ query: { location: input["location"] },
611
+ successStatus: 200,
612
+ declaredStatuses: [401, 400],
613
+ empty: false,
614
+ }, requestOptions),
615
+ complete: (input, requestOptions) => request({
616
+ method: "POST",
617
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}/complete`,
618
+ query: { location: input["location"] },
619
+ body: { code: input["code"] },
620
+ successStatus: 204,
621
+ declaredStatuses: [400, 401],
622
+ empty: true,
623
+ }, requestOptions),
624
+ cancel: (input, requestOptions) => request({
625
+ method: "DELETE",
626
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
627
+ query: { location: input["location"] },
628
+ successStatus: 204,
629
+ declaredStatuses: [401, 400],
630
+ empty: true,
631
+ }, requestOptions),
632
+ },
633
+ command: {
634
+ connect: (input, requestOptions) => request({
635
+ method: "POST",
636
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command`,
637
+ query: { location: input["location"] },
638
+ body: { methodID: input["methodID"], label: input["label"] },
639
+ successStatus: 200,
640
+ declaredStatuses: [400, 401],
641
+ empty: false,
642
+ }, requestOptions),
643
+ status: (input, requestOptions) => request({
644
+ method: "GET",
645
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
646
+ query: { location: input["location"] },
647
+ successStatus: 200,
648
+ declaredStatuses: [401, 400],
649
+ empty: false,
650
+ }, requestOptions),
651
+ cancel: (input, requestOptions) => request({
652
+ method: "DELETE",
653
+ path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
654
+ query: { location: input["location"] },
655
+ successStatus: 204,
656
+ declaredStatuses: [401, 400],
657
+ empty: true,
658
+ }, requestOptions),
659
+ },
660
+ },
661
+ auth: {
662
+ status: (input, requestOptions) => request({
663
+ method: "GET",
664
+ path: `/api/auth/status`,
665
+ query: { location: input?.["location"] },
666
+ successStatus: 200,
667
+ declaredStatuses: [401, 400],
668
+ empty: false,
669
+ }, requestOptions),
670
+ },
671
+ mcp: {
672
+ list: (input, requestOptions) => request({
673
+ method: "GET",
674
+ path: `/api/mcp`,
675
+ query: { location: input?.["location"] },
676
+ successStatus: 200,
677
+ declaredStatuses: [401, 400],
678
+ empty: false,
679
+ }, requestOptions),
680
+ add: (input, requestOptions) => request({
681
+ method: "PUT",
682
+ path: `/api/mcp/${encodeURIComponent(input.server)}`,
683
+ query: { location: input["location"] },
684
+ body: { config: input["config"] },
685
+ successStatus: 204,
686
+ declaredStatuses: [401, 400],
687
+ empty: true,
688
+ }, requestOptions),
689
+ remove: (input, requestOptions) => request({
690
+ method: "DELETE",
691
+ path: `/api/mcp/${encodeURIComponent(input.server)}`,
692
+ query: { location: input["location"] },
693
+ successStatus: 204,
694
+ declaredStatuses: [404, 401, 400],
695
+ empty: true,
696
+ }, requestOptions),
697
+ connect: (input, requestOptions) => request({
698
+ method: "POST",
699
+ path: `/api/mcp/${encodeURIComponent(input.server)}/connect`,
700
+ query: { location: input["location"] },
701
+ successStatus: 204,
702
+ declaredStatuses: [404, 401, 400],
703
+ empty: true,
704
+ }, requestOptions),
705
+ disconnect: (input, requestOptions) => request({
706
+ method: "POST",
707
+ path: `/api/mcp/${encodeURIComponent(input.server)}/disconnect`,
708
+ query: { location: input["location"] },
709
+ successStatus: 204,
710
+ declaredStatuses: [404, 401, 400],
711
+ empty: true,
712
+ }, requestOptions),
713
+ resource: {
714
+ catalog: (input, requestOptions) => request({
715
+ method: "GET",
716
+ path: `/api/mcp/resource`,
717
+ query: { location: input?.["location"] },
718
+ successStatus: 200,
719
+ declaredStatuses: [401, 400],
720
+ empty: false,
721
+ }, requestOptions),
722
+ },
723
+ },
724
+ credential: {
725
+ update: (input, requestOptions) => request({
726
+ method: "PATCH",
727
+ path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
728
+ query: { location: input["location"] },
729
+ body: { label: input["label"] },
730
+ successStatus: 204,
731
+ declaredStatuses: [401, 400],
732
+ empty: true,
733
+ }, requestOptions),
734
+ remove: (input, requestOptions) => request({
735
+ method: "DELETE",
736
+ path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
737
+ query: { location: input["location"] },
738
+ successStatus: 204,
739
+ declaredStatuses: [401, 400],
740
+ empty: true,
741
+ }, requestOptions),
742
+ },
743
+ project: {
744
+ list: (requestOptions) => request({ method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
745
+ current: (input, requestOptions) => request({
746
+ method: "GET",
747
+ path: `/api/project/current`,
748
+ query: { location: input?.["location"] },
749
+ successStatus: 200,
750
+ declaredStatuses: [401, 400],
751
+ empty: false,
752
+ }, requestOptions),
753
+ directories: (input, requestOptions) => request({
754
+ method: "GET",
755
+ path: `/api/project/${encodeURIComponent(input.projectID)}/directories`,
756
+ query: { location: input["location"] },
757
+ successStatus: 200,
758
+ declaredStatuses: [401, 400],
759
+ empty: false,
760
+ }, requestOptions),
761
+ },
762
+ form: {
763
+ request: {
764
+ list: (input, requestOptions) => request({
765
+ method: "GET",
766
+ path: `/api/form/request`,
767
+ query: { location: input?.["location"] },
768
+ successStatus: 200,
769
+ declaredStatuses: [401, 400],
770
+ empty: false,
771
+ }, requestOptions),
772
+ },
773
+ list: (input, requestOptions) => request({
774
+ method: "GET",
775
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
776
+ successStatus: 200,
777
+ declaredStatuses: [404, 400, 401],
778
+ empty: false,
779
+ }, requestOptions).then((value) => value.data),
780
+ create: (input, requestOptions) => request({
781
+ method: "POST",
782
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
783
+ body: { id: input["id"], title: input["title"], metadata: input["metadata"], fields: input["fields"] },
784
+ successStatus: 200,
785
+ declaredStatuses: [404, 409, 400, 401],
786
+ empty: false,
787
+ }, requestOptions).then((value) => value.data),
788
+ get: (input, requestOptions) => request({
789
+ method: "GET",
790
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
791
+ successStatus: 200,
792
+ declaredStatuses: [404, 400, 401],
793
+ empty: false,
794
+ }, requestOptions).then((value) => value.data),
795
+ state: (input, requestOptions) => request({
796
+ method: "GET",
797
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/state`,
798
+ successStatus: 200,
799
+ declaredStatuses: [404, 400, 401],
800
+ empty: false,
801
+ }, requestOptions).then((value) => value.data),
802
+ reply: (input, requestOptions) => request({
803
+ method: "POST",
804
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/reply`,
805
+ body: { answer: input["answer"] },
806
+ successStatus: 204,
807
+ declaredStatuses: [404, 409, 400, 401],
808
+ empty: true,
809
+ }, requestOptions),
810
+ cancel: (input, requestOptions) => request({
811
+ method: "POST",
812
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/cancel`,
813
+ successStatus: 204,
814
+ declaredStatuses: [404, 409, 400, 401],
815
+ empty: true,
816
+ }, requestOptions),
817
+ },
818
+ permission: {
819
+ request: {
820
+ list: (input, requestOptions) => request({
821
+ method: "GET",
822
+ path: `/api/permission/request`,
823
+ query: { location: input?.["location"] },
824
+ successStatus: 200,
825
+ declaredStatuses: [401, 400],
826
+ empty: false,
827
+ }, requestOptions),
828
+ },
829
+ saved: {
830
+ list: (input, requestOptions) => request({
831
+ method: "GET",
832
+ path: `/api/permission/saved`,
833
+ query: { projectID: input?.["projectID"] },
834
+ successStatus: 200,
835
+ declaredStatuses: [401, 400],
836
+ empty: false,
837
+ }, requestOptions).then((value) => value.data),
838
+ remove: (input, requestOptions) => request({
839
+ method: "DELETE",
840
+ path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
841
+ successStatus: 204,
842
+ declaredStatuses: [401, 400],
843
+ empty: true,
844
+ }, requestOptions),
845
+ },
846
+ create: (input, requestOptions) => request({
847
+ method: "POST",
848
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
849
+ body: {
850
+ id: input["id"],
851
+ action: input["action"],
852
+ resources: input["resources"],
853
+ save: input["save"],
854
+ metadata: input["metadata"],
855
+ source: input["source"],
856
+ agent: input["agent"],
857
+ },
858
+ successStatus: 200,
859
+ declaredStatuses: [404, 400, 401],
860
+ empty: false,
861
+ }, requestOptions).then((value) => value.data),
862
+ list: (input, requestOptions) => request({
863
+ method: "GET",
864
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
865
+ successStatus: 200,
866
+ declaredStatuses: [404, 400, 401],
867
+ empty: false,
868
+ }, requestOptions).then((value) => value.data),
869
+ get: (input, requestOptions) => request({
870
+ method: "GET",
871
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}`,
872
+ successStatus: 200,
873
+ declaredStatuses: [404, 400, 401],
874
+ empty: false,
875
+ }, requestOptions).then((value) => value.data),
876
+ reply: (input, requestOptions) => request({
877
+ method: "POST",
878
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}/reply`,
879
+ body: { reply: input["reply"], message: input["message"] },
880
+ successStatus: 204,
881
+ declaredStatuses: [404, 400, 401],
882
+ empty: true,
883
+ }, requestOptions),
884
+ },
885
+ file: {
886
+ read: (input, requestOptions) => request({
887
+ method: "GET",
888
+ path: `/api/fs/read/${encodePath(input.path)}`,
889
+ query: { location: input["location"] },
890
+ successStatus: 200,
891
+ declaredStatuses: [401, 400],
892
+ empty: false,
893
+ binary: true,
894
+ }, requestOptions),
895
+ list: (input, requestOptions) => request({
896
+ method: "GET",
897
+ path: `/api/fs/list`,
898
+ query: { location: input?.["location"], path: input?.["path"] },
899
+ successStatus: 200,
900
+ declaredStatuses: [401, 400],
901
+ empty: false,
902
+ }, requestOptions),
903
+ find: (input, requestOptions) => request({
904
+ method: "GET",
905
+ path: `/api/fs/find`,
906
+ query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
907
+ successStatus: 200,
908
+ declaredStatuses: [401, 400],
909
+ empty: false,
910
+ }, requestOptions),
911
+ },
912
+ command: {
913
+ list: (input, requestOptions) => request({
914
+ method: "GET",
915
+ path: `/api/command`,
916
+ query: { location: input?.["location"] },
917
+ successStatus: 200,
918
+ declaredStatuses: [401, 400],
919
+ empty: false,
920
+ }, requestOptions),
921
+ },
922
+ skill: {
923
+ list: (input, requestOptions) => request({
924
+ method: "GET",
925
+ path: `/api/skill`,
926
+ query: { location: input?.["location"] },
927
+ successStatus: 200,
928
+ declaredStatuses: [401, 400],
929
+ empty: false,
930
+ }, requestOptions),
931
+ },
932
+ event: {
933
+ subscribe: (requestOptions) => sse({ method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
934
+ },
935
+ pty: {
936
+ list: (input, requestOptions) => request({
937
+ method: "GET",
938
+ path: `/api/pty`,
939
+ query: { location: input?.["location"] },
940
+ successStatus: 200,
941
+ declaredStatuses: [401, 400],
942
+ empty: false,
943
+ }, requestOptions),
944
+ create: (input, requestOptions) => request({
945
+ method: "POST",
946
+ path: `/api/pty`,
947
+ query: { location: input?.["location"] },
948
+ body: {
949
+ command: input?.["command"],
950
+ args: input?.["args"],
951
+ cwd: input?.["cwd"],
952
+ title: input?.["title"],
953
+ env: input?.["env"],
954
+ },
955
+ successStatus: 200,
956
+ declaredStatuses: [401, 400],
957
+ empty: false,
958
+ }, requestOptions),
959
+ get: (input, requestOptions) => request({
960
+ method: "GET",
961
+ path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
962
+ query: { location: input["location"] },
963
+ successStatus: 200,
964
+ declaredStatuses: [404, 401, 400],
965
+ empty: false,
966
+ }, requestOptions),
967
+ update: (input, requestOptions) => request({
968
+ method: "PUT",
969
+ path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
970
+ query: { location: input["location"] },
971
+ body: { title: input["title"], size: input["size"] },
972
+ successStatus: 200,
973
+ declaredStatuses: [404, 401, 400],
974
+ empty: false,
975
+ }, requestOptions),
976
+ remove: (input, requestOptions) => request({
977
+ method: "DELETE",
978
+ path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
979
+ query: { location: input["location"] },
980
+ successStatus: 204,
981
+ declaredStatuses: [404, 401, 400],
982
+ empty: true,
983
+ }, requestOptions),
984
+ },
985
+ shell: {
986
+ list: (input, requestOptions) => request({
987
+ method: "GET",
988
+ path: `/api/shell`,
989
+ query: { location: input?.["location"] },
990
+ successStatus: 200,
991
+ declaredStatuses: [401, 400],
992
+ empty: false,
993
+ }, requestOptions),
994
+ create: (input, requestOptions) => request({
995
+ method: "POST",
996
+ path: `/api/shell`,
997
+ query: { location: input["location"] },
998
+ body: {
999
+ command: input["command"],
1000
+ cwd: input["cwd"],
1001
+ timeout: input["timeout"],
1002
+ metadata: input["metadata"],
1003
+ },
1004
+ successStatus: 200,
1005
+ declaredStatuses: [401, 400],
1006
+ empty: false,
1007
+ }, requestOptions),
1008
+ get: (input, requestOptions) => request({
1009
+ method: "GET",
1010
+ path: `/api/shell/${encodeURIComponent(input.id)}`,
1011
+ query: { location: input["location"] },
1012
+ successStatus: 200,
1013
+ declaredStatuses: [404, 401, 400],
1014
+ empty: false,
1015
+ }, requestOptions),
1016
+ timeout: (input, requestOptions) => request({
1017
+ method: "PATCH",
1018
+ path: `/api/shell/${encodeURIComponent(input.id)}/timeout`,
1019
+ query: { location: input["location"] },
1020
+ body: { timeout: input["timeout"] },
1021
+ successStatus: 200,
1022
+ declaredStatuses: [404, 401, 400],
1023
+ empty: false,
1024
+ }, requestOptions),
1025
+ output: (input, requestOptions) => request({
1026
+ method: "GET",
1027
+ path: `/api/shell/${encodeURIComponent(input.id)}/output`,
1028
+ query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
1029
+ successStatus: 200,
1030
+ declaredStatuses: [404, 401, 400],
1031
+ empty: false,
1032
+ }, requestOptions),
1033
+ remove: (input, requestOptions) => request({
1034
+ method: "DELETE",
1035
+ path: `/api/shell/${encodeURIComponent(input.id)}`,
1036
+ query: { location: input["location"] },
1037
+ successStatus: 204,
1038
+ declaredStatuses: [404, 401, 400],
1039
+ empty: true,
1040
+ }, requestOptions),
1041
+ },
1042
+ question: {
1043
+ request: {
1044
+ list: (input, requestOptions) => request({
1045
+ method: "GET",
1046
+ path: `/api/question/request`,
1047
+ query: { location: input?.["location"] },
1048
+ successStatus: 200,
1049
+ declaredStatuses: [401, 400],
1050
+ empty: false,
1051
+ }, requestOptions),
1052
+ },
1053
+ list: (input, requestOptions) => request({
1054
+ method: "GET",
1055
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/question`,
1056
+ successStatus: 200,
1057
+ declaredStatuses: [404, 400, 401],
1058
+ empty: false,
1059
+ }, requestOptions).then((value) => value.data),
1060
+ reply: (input, requestOptions) => request({
1061
+ method: "POST",
1062
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reply`,
1063
+ body: { answers: input["answers"] },
1064
+ successStatus: 204,
1065
+ declaredStatuses: [404, 400, 401],
1066
+ empty: true,
1067
+ }, requestOptions),
1068
+ reject: (input, requestOptions) => request({
1069
+ method: "POST",
1070
+ path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reject`,
1071
+ successStatus: 204,
1072
+ declaredStatuses: [404, 400, 401],
1073
+ empty: true,
1074
+ }, requestOptions),
1075
+ },
1076
+ reference: {
1077
+ list: (input, requestOptions) => request({
1078
+ method: "GET",
1079
+ path: `/api/reference`,
1080
+ query: { location: input?.["location"] },
1081
+ successStatus: 200,
1082
+ declaredStatuses: [401, 400],
1083
+ empty: false,
1084
+ }, requestOptions),
1085
+ },
1086
+ projectCopy: {
1087
+ create: (input, requestOptions) => request({
1088
+ method: "POST",
1089
+ path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
1090
+ query: { location: input["location"] },
1091
+ body: { strategy: input["strategy"], directory: input["directory"], name: input["name"] },
1092
+ successStatus: 200,
1093
+ declaredStatuses: [400, 401],
1094
+ empty: false,
1095
+ }, requestOptions),
1096
+ remove: (input, requestOptions) => request({
1097
+ method: "DELETE",
1098
+ path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
1099
+ query: { location: input["location"] },
1100
+ body: { directory: input["directory"], force: input["force"] },
1101
+ successStatus: 204,
1102
+ declaredStatuses: [400, 401],
1103
+ empty: true,
1104
+ }, requestOptions),
1105
+ refresh: (input, requestOptions) => request({
1106
+ method: "POST",
1107
+ path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy/refresh`,
1108
+ query: { location: input["location"] },
1109
+ successStatus: 204,
1110
+ declaredStatuses: [400, 401],
1111
+ empty: true,
1112
+ }, requestOptions),
1113
+ },
1114
+ vcs: {
1115
+ get: (input, requestOptions) => request({
1116
+ method: "GET",
1117
+ path: `/api/vcs`,
1118
+ query: { location: input?.["location"] },
1119
+ successStatus: 200,
1120
+ declaredStatuses: [401, 400],
1121
+ empty: false,
1122
+ }, requestOptions),
1123
+ status: (input, requestOptions) => request({
1124
+ method: "GET",
1125
+ path: `/api/vcs/status`,
1126
+ query: { location: input?.["location"] },
1127
+ successStatus: 200,
1128
+ declaredStatuses: [401, 400],
1129
+ empty: false,
1130
+ }, requestOptions),
1131
+ diff: (input, requestOptions) => request({
1132
+ method: "GET",
1133
+ path: `/api/vcs/diff`,
1134
+ query: { location: input["location"], mode: input["mode"], context: input["context"] },
1135
+ successStatus: 200,
1136
+ declaredStatuses: [401, 400],
1137
+ empty: false,
1138
+ }, requestOptions),
1139
+ },
1140
+ debug: {
1141
+ location: {
1142
+ list: (requestOptions) => request({
1143
+ method: "GET",
1144
+ path: `/api/debug/location`,
1145
+ successStatus: 200,
1146
+ declaredStatuses: [401, 400],
1147
+ empty: false,
1148
+ }, requestOptions),
1149
+ evict: (input, requestOptions) => request({
1150
+ method: "DELETE",
1151
+ path: `/api/debug/location`,
1152
+ query: { location: input?.["location"] },
1153
+ successStatus: 204,
1154
+ declaredStatuses: [401, 400],
1155
+ empty: true,
1156
+ }, requestOptions),
1157
+ },
1158
+ },
1159
+ migration: {
1160
+ v1: {
1161
+ status: (requestOptions) => request({
1162
+ method: "GET",
1163
+ path: `/api/experimental/migration/v1`,
1164
+ successStatus: 200,
1165
+ declaredStatuses: [401, 400],
1166
+ empty: false,
1167
+ }, requestOptions),
1168
+ },
1169
+ },
1170
+ websearch: {
1171
+ providers: (input, requestOptions) => request({
1172
+ method: "GET",
1173
+ path: `/api/websearch/provider`,
1174
+ query: { location: input?.["location"] },
1175
+ successStatus: 200,
1176
+ declaredStatuses: [503, 401, 400],
1177
+ empty: false,
1178
+ }, requestOptions),
1179
+ query: (input, requestOptions) => request({
1180
+ method: "POST",
1181
+ path: `/api/websearch`,
1182
+ query: { location: input["location"] },
1183
+ body: { query: input["query"], providerID: input["providerID"] },
1184
+ successStatus: 200,
1185
+ declaredStatuses: [400, 503, 401],
1186
+ empty: false,
1187
+ }, requestOptions),
1188
+ },
1189
+ config: {
1190
+ get: (input, requestOptions) => request({
1191
+ method: "GET",
1192
+ path: `/api/config`,
1193
+ query: { location: input?.["location"] },
1194
+ successStatus: 200,
1195
+ declaredStatuses: [401, 400],
1196
+ empty: false,
1197
+ }, requestOptions),
1198
+ },
1199
+ };
1200
+ }
1201
+ function encodePath(value) {
1202
+ return value.split("/").map(encodeURIComponent).join("/");
1203
+ }
1204
+ function appendQuery(params, key, value) {
1205
+ if (value === undefined)
1206
+ return;
1207
+ if (value === null) {
1208
+ params.append(key, "null");
1209
+ return;
1210
+ }
1211
+ if (Array.isArray(value)) {
1212
+ for (const item of value)
1213
+ appendQuery(params, key, item);
1214
+ return;
1215
+ }
1216
+ if (typeof value === "object") {
1217
+ for (const [child, item] of Object.entries(value))
1218
+ appendQuery(params, `${key}[${child}]`, item);
1219
+ return;
1220
+ }
1221
+ params.append(key, String(value));
1222
+ }
1223
+ async function json(response) {
1224
+ if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
1225
+ try {
1226
+ await response.body?.cancel();
1227
+ }
1228
+ catch { }
1229
+ throw new ClientError("UnsupportedContentType");
1230
+ }
1231
+ let text;
1232
+ try {
1233
+ text = await response.text();
1234
+ }
1235
+ catch (cause) {
1236
+ throw new ClientError("Transport", { cause });
1237
+ }
1238
+ if (text === "")
1239
+ throw new ClientError("MalformedResponse");
1240
+ try {
1241
+ return JSON.parse(text);
1242
+ }
1243
+ catch (cause) {
1244
+ throw new ClientError("MalformedResponse", { cause });
1245
+ }
1246
+ }
1247
+ function isContentType(response, expected) {
1248
+ return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected;
1249
+ }