@klex/agent-admin-api 0.10.0 → 0.11.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +10 -0
- package/dist/index.d.ts +877 -635
- package/package.json +1 -1
package/dist/index.d.ts
CHANGED
|
@@ -41,12 +41,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
41
41
|
"/v1/cloud/enroll": {
|
|
42
42
|
$post: {
|
|
43
43
|
output: {
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
remediation?: string | undefined;
|
|
44
|
+
clientId: string;
|
|
45
|
+
enrolledAt: string;
|
|
47
46
|
};
|
|
48
47
|
outputFormat: "json";
|
|
49
|
-
status:
|
|
48
|
+
status: 200;
|
|
50
49
|
input: {
|
|
51
50
|
json: {
|
|
52
51
|
enrollmentCode: string;
|
|
@@ -59,7 +58,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
59
58
|
remediation?: string | undefined;
|
|
60
59
|
};
|
|
61
60
|
outputFormat: "json";
|
|
62
|
-
status:
|
|
61
|
+
status: 400;
|
|
63
62
|
input: {
|
|
64
63
|
json: {
|
|
65
64
|
enrollmentCode: string;
|
|
@@ -67,11 +66,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
67
66
|
};
|
|
68
67
|
} | {
|
|
69
68
|
output: {
|
|
70
|
-
|
|
71
|
-
|
|
69
|
+
error: string;
|
|
70
|
+
code: string;
|
|
71
|
+
remediation?: string | undefined;
|
|
72
72
|
};
|
|
73
73
|
outputFormat: "json";
|
|
74
|
-
status:
|
|
74
|
+
status: 500;
|
|
75
75
|
input: {
|
|
76
76
|
json: {
|
|
77
77
|
enrollmentCode: string;
|
|
@@ -94,12 +94,10 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
94
94
|
"/v1/settings/agent": {
|
|
95
95
|
$patch: {
|
|
96
96
|
output: {
|
|
97
|
-
|
|
98
|
-
code: string;
|
|
99
|
-
remediation?: string | undefined;
|
|
97
|
+
officialName: string;
|
|
100
98
|
};
|
|
101
99
|
outputFormat: "json";
|
|
102
|
-
status:
|
|
100
|
+
status: 200;
|
|
103
101
|
input: {
|
|
104
102
|
json: {
|
|
105
103
|
officialName: string;
|
|
@@ -112,7 +110,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
112
110
|
remediation?: string | undefined;
|
|
113
111
|
};
|
|
114
112
|
outputFormat: "json";
|
|
115
|
-
status:
|
|
113
|
+
status: 400;
|
|
116
114
|
input: {
|
|
117
115
|
json: {
|
|
118
116
|
officialName: string;
|
|
@@ -120,10 +118,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
120
118
|
};
|
|
121
119
|
} | {
|
|
122
120
|
output: {
|
|
123
|
-
|
|
121
|
+
error: string;
|
|
122
|
+
code: string;
|
|
123
|
+
remediation?: string | undefined;
|
|
124
124
|
};
|
|
125
125
|
outputFormat: "json";
|
|
126
|
-
status:
|
|
126
|
+
status: 500;
|
|
127
127
|
input: {
|
|
128
128
|
json: {
|
|
129
129
|
officialName: string;
|
|
@@ -134,15 +134,6 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
134
134
|
} & {
|
|
135
135
|
"/v1/settings/model-selection": {
|
|
136
136
|
$get: {
|
|
137
|
-
output: {
|
|
138
|
-
error: string;
|
|
139
|
-
code: string;
|
|
140
|
-
remediation?: string | undefined;
|
|
141
|
-
};
|
|
142
|
-
outputFormat: "json";
|
|
143
|
-
status: 500;
|
|
144
|
-
input: {};
|
|
145
|
-
} | {
|
|
146
137
|
output: {
|
|
147
138
|
chat: {
|
|
148
139
|
providerId: string;
|
|
@@ -207,6 +198,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
207
198
|
[x: string]: import("hono/utils/types").JSONValue;
|
|
208
199
|
};
|
|
209
200
|
} | undefined;
|
|
201
|
+
voiceId?: string | undefined;
|
|
210
202
|
}[];
|
|
211
203
|
tts: {
|
|
212
204
|
providerId: string;
|
|
@@ -231,18 +223,112 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
231
223
|
outputFormat: "json";
|
|
232
224
|
status: 200;
|
|
233
225
|
input: {};
|
|
226
|
+
} | {
|
|
227
|
+
output: {
|
|
228
|
+
error: string;
|
|
229
|
+
code: string;
|
|
230
|
+
remediation?: string | undefined;
|
|
231
|
+
};
|
|
232
|
+
outputFormat: "json";
|
|
233
|
+
status: 500;
|
|
234
|
+
input: {};
|
|
234
235
|
};
|
|
235
236
|
};
|
|
236
237
|
} & {
|
|
237
238
|
"/v1/settings/model-selection": {
|
|
238
239
|
$patch: {
|
|
239
240
|
output: {
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
241
|
+
chat: {
|
|
242
|
+
providerId: string;
|
|
243
|
+
modelId: string;
|
|
244
|
+
providerOptions?: {
|
|
245
|
+
[x: string]: {
|
|
246
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
247
|
+
};
|
|
248
|
+
} | undefined;
|
|
249
|
+
}[];
|
|
250
|
+
compaction: {
|
|
251
|
+
providerId: string;
|
|
252
|
+
modelId: string;
|
|
253
|
+
providerOptions?: {
|
|
254
|
+
[x: string]: {
|
|
255
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
256
|
+
};
|
|
257
|
+
} | undefined;
|
|
258
|
+
}[];
|
|
259
|
+
memory: {
|
|
260
|
+
providerId: string;
|
|
261
|
+
modelId: string;
|
|
262
|
+
providerOptions?: {
|
|
263
|
+
[x: string]: {
|
|
264
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
265
|
+
};
|
|
266
|
+
} | undefined;
|
|
267
|
+
}[];
|
|
268
|
+
imageVision: {
|
|
269
|
+
providerId: string;
|
|
270
|
+
modelId: string;
|
|
271
|
+
providerOptions?: {
|
|
272
|
+
[x: string]: {
|
|
273
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
274
|
+
};
|
|
275
|
+
} | undefined;
|
|
276
|
+
}[];
|
|
277
|
+
audioListening: {
|
|
278
|
+
providerId: string;
|
|
279
|
+
modelId: string;
|
|
280
|
+
providerOptions?: {
|
|
281
|
+
[x: string]: {
|
|
282
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
283
|
+
};
|
|
284
|
+
} | undefined;
|
|
285
|
+
}[];
|
|
286
|
+
consult: {
|
|
287
|
+
providerId: string;
|
|
288
|
+
modelId: string;
|
|
289
|
+
providerOptions?: {
|
|
290
|
+
[x: string]: {
|
|
291
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
292
|
+
};
|
|
293
|
+
} | undefined;
|
|
294
|
+
}[];
|
|
295
|
+
voice: {
|
|
296
|
+
sts: {
|
|
297
|
+
providerId: string;
|
|
298
|
+
modelId: string;
|
|
299
|
+
providerOptions?: {
|
|
300
|
+
[x: string]: {
|
|
301
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
302
|
+
};
|
|
303
|
+
} | undefined;
|
|
304
|
+
voiceId?: string | undefined;
|
|
305
|
+
}[];
|
|
306
|
+
tts: {
|
|
307
|
+
providerId: string;
|
|
308
|
+
modelId: string;
|
|
309
|
+
providerOptions?: {
|
|
310
|
+
[x: string]: {
|
|
311
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
312
|
+
};
|
|
313
|
+
} | undefined;
|
|
314
|
+
}[];
|
|
315
|
+
stt: {
|
|
316
|
+
providerId: string;
|
|
317
|
+
modelId: string;
|
|
318
|
+
providerOptions?: {
|
|
319
|
+
[x: string]: {
|
|
320
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
321
|
+
};
|
|
322
|
+
} | undefined;
|
|
323
|
+
}[];
|
|
324
|
+
};
|
|
325
|
+
warnings: {
|
|
326
|
+
modelId: string;
|
|
327
|
+
message: string;
|
|
328
|
+
}[];
|
|
243
329
|
};
|
|
244
330
|
outputFormat: "json";
|
|
245
|
-
status:
|
|
331
|
+
status: 200;
|
|
246
332
|
input: {
|
|
247
333
|
json: {
|
|
248
334
|
chat?: {
|
|
@@ -280,6 +366,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
280
366
|
providerId: string;
|
|
281
367
|
modelId: string;
|
|
282
368
|
providerOptions?: Record<string, Record<string, unknown>> | undefined;
|
|
369
|
+
voiceId?: string | undefined;
|
|
283
370
|
}[];
|
|
284
371
|
tts: {
|
|
285
372
|
providerId: string;
|
|
@@ -301,7 +388,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
301
388
|
remediation?: string | undefined;
|
|
302
389
|
};
|
|
303
390
|
outputFormat: "json";
|
|
304
|
-
status:
|
|
391
|
+
status: 400;
|
|
305
392
|
input: {
|
|
306
393
|
json: {
|
|
307
394
|
chat?: {
|
|
@@ -339,6 +426,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
339
426
|
providerId: string;
|
|
340
427
|
modelId: string;
|
|
341
428
|
providerOptions?: Record<string, Record<string, unknown>> | undefined;
|
|
429
|
+
voiceId?: string | undefined;
|
|
342
430
|
}[];
|
|
343
431
|
tts: {
|
|
344
432
|
providerId: string;
|
|
@@ -355,96 +443,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
355
443
|
};
|
|
356
444
|
} | {
|
|
357
445
|
output: {
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
providerOptions?: {
|
|
362
|
-
[x: string]: {
|
|
363
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
364
|
-
};
|
|
365
|
-
} | undefined;
|
|
366
|
-
}[];
|
|
367
|
-
compaction: {
|
|
368
|
-
providerId: string;
|
|
369
|
-
modelId: string;
|
|
370
|
-
providerOptions?: {
|
|
371
|
-
[x: string]: {
|
|
372
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
373
|
-
};
|
|
374
|
-
} | undefined;
|
|
375
|
-
}[];
|
|
376
|
-
memory: {
|
|
377
|
-
providerId: string;
|
|
378
|
-
modelId: string;
|
|
379
|
-
providerOptions?: {
|
|
380
|
-
[x: string]: {
|
|
381
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
382
|
-
};
|
|
383
|
-
} | undefined;
|
|
384
|
-
}[];
|
|
385
|
-
imageVision: {
|
|
386
|
-
providerId: string;
|
|
387
|
-
modelId: string;
|
|
388
|
-
providerOptions?: {
|
|
389
|
-
[x: string]: {
|
|
390
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
391
|
-
};
|
|
392
|
-
} | undefined;
|
|
393
|
-
}[];
|
|
394
|
-
audioListening: {
|
|
395
|
-
providerId: string;
|
|
396
|
-
modelId: string;
|
|
397
|
-
providerOptions?: {
|
|
398
|
-
[x: string]: {
|
|
399
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
400
|
-
};
|
|
401
|
-
} | undefined;
|
|
402
|
-
}[];
|
|
403
|
-
consult: {
|
|
404
|
-
providerId: string;
|
|
405
|
-
modelId: string;
|
|
406
|
-
providerOptions?: {
|
|
407
|
-
[x: string]: {
|
|
408
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
409
|
-
};
|
|
410
|
-
} | undefined;
|
|
411
|
-
}[];
|
|
412
|
-
voice: {
|
|
413
|
-
sts: {
|
|
414
|
-
providerId: string;
|
|
415
|
-
modelId: string;
|
|
416
|
-
providerOptions?: {
|
|
417
|
-
[x: string]: {
|
|
418
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
419
|
-
};
|
|
420
|
-
} | undefined;
|
|
421
|
-
}[];
|
|
422
|
-
tts: {
|
|
423
|
-
providerId: string;
|
|
424
|
-
modelId: string;
|
|
425
|
-
providerOptions?: {
|
|
426
|
-
[x: string]: {
|
|
427
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
428
|
-
};
|
|
429
|
-
} | undefined;
|
|
430
|
-
}[];
|
|
431
|
-
stt: {
|
|
432
|
-
providerId: string;
|
|
433
|
-
modelId: string;
|
|
434
|
-
providerOptions?: {
|
|
435
|
-
[x: string]: {
|
|
436
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
437
|
-
};
|
|
438
|
-
} | undefined;
|
|
439
|
-
}[];
|
|
440
|
-
};
|
|
441
|
-
warnings: {
|
|
442
|
-
modelId: string;
|
|
443
|
-
message: string;
|
|
444
|
-
}[];
|
|
446
|
+
error: string;
|
|
447
|
+
code: string;
|
|
448
|
+
remediation?: string | undefined;
|
|
445
449
|
};
|
|
446
450
|
outputFormat: "json";
|
|
447
|
-
status:
|
|
451
|
+
status: 500;
|
|
448
452
|
input: {
|
|
449
453
|
json: {
|
|
450
454
|
chat?: {
|
|
@@ -482,6 +486,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
482
486
|
providerId: string;
|
|
483
487
|
modelId: string;
|
|
484
488
|
providerOptions?: Record<string, Record<string, unknown>> | undefined;
|
|
489
|
+
voiceId?: string | undefined;
|
|
485
490
|
}[];
|
|
486
491
|
tts: {
|
|
487
492
|
providerId: string;
|
|
@@ -512,15 +517,6 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
512
517
|
} & {
|
|
513
518
|
"/v1/introspect": {
|
|
514
519
|
$get: {
|
|
515
|
-
output: {
|
|
516
|
-
error: string;
|
|
517
|
-
code: string;
|
|
518
|
-
remediation?: string | undefined;
|
|
519
|
-
};
|
|
520
|
-
outputFormat: "json";
|
|
521
|
-
status: 500;
|
|
522
|
-
input: {};
|
|
523
|
-
} | {
|
|
524
520
|
output: {
|
|
525
521
|
path: string[];
|
|
526
522
|
state: {
|
|
@@ -535,11 +531,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
535
531
|
outputFormat: "json";
|
|
536
532
|
status: 200;
|
|
537
533
|
input: {};
|
|
538
|
-
}
|
|
539
|
-
};
|
|
540
|
-
} & {
|
|
541
|
-
"/v1/mcp-servers": {
|
|
542
|
-
$get: {
|
|
534
|
+
} | {
|
|
543
535
|
output: {
|
|
544
536
|
error: string;
|
|
545
537
|
code: string;
|
|
@@ -548,7 +540,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
548
540
|
outputFormat: "json";
|
|
549
541
|
status: 500;
|
|
550
542
|
input: {};
|
|
551
|
-
}
|
|
543
|
+
};
|
|
544
|
+
};
|
|
545
|
+
} & {
|
|
546
|
+
"/v1/mcp-servers": {
|
|
547
|
+
$get: {
|
|
552
548
|
output: {
|
|
553
549
|
servers: {
|
|
554
550
|
name: string;
|
|
@@ -575,11 +571,51 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
575
571
|
outputFormat: "json";
|
|
576
572
|
status: 200;
|
|
577
573
|
input: {};
|
|
578
|
-
}
|
|
574
|
+
} | {
|
|
575
|
+
output: {
|
|
576
|
+
error: string;
|
|
577
|
+
code: string;
|
|
578
|
+
remediation?: string | undefined;
|
|
579
|
+
};
|
|
580
|
+
outputFormat: "json";
|
|
581
|
+
status: 500;
|
|
582
|
+
input: {};
|
|
583
|
+
};
|
|
579
584
|
};
|
|
580
585
|
} & {
|
|
581
586
|
"/v1/mcp-servers/:name": {
|
|
582
587
|
$get: {
|
|
588
|
+
output: {
|
|
589
|
+
server: {
|
|
590
|
+
name: string;
|
|
591
|
+
status: "authorization_required" | "authorizing" | "connected" | "connecting" | "disconnected" | "error";
|
|
592
|
+
toolCount: number;
|
|
593
|
+
supportsPushNotifications: boolean;
|
|
594
|
+
supportsRealtimeMedia: boolean;
|
|
595
|
+
transport: "http" | "stdio";
|
|
596
|
+
headerNames: string[];
|
|
597
|
+
usesInteractiveOAuth: boolean;
|
|
598
|
+
authorization: {
|
|
599
|
+
id: string;
|
|
600
|
+
createdAt: string;
|
|
601
|
+
expiresAt: string;
|
|
602
|
+
} | null;
|
|
603
|
+
lastError: {
|
|
604
|
+
name: string;
|
|
605
|
+
message: string;
|
|
606
|
+
at: string;
|
|
607
|
+
} | null;
|
|
608
|
+
nextRetryAt: string | null;
|
|
609
|
+
};
|
|
610
|
+
};
|
|
611
|
+
outputFormat: "json";
|
|
612
|
+
status: 200;
|
|
613
|
+
input: {
|
|
614
|
+
param: {
|
|
615
|
+
name: string;
|
|
616
|
+
};
|
|
617
|
+
};
|
|
618
|
+
} | {
|
|
583
619
|
output: {
|
|
584
620
|
error: string;
|
|
585
621
|
code: string;
|
|
@@ -605,9 +641,13 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
605
641
|
name: string;
|
|
606
642
|
};
|
|
607
643
|
};
|
|
608
|
-
}
|
|
644
|
+
};
|
|
645
|
+
};
|
|
646
|
+
} & {
|
|
647
|
+
"/v1/mcp-servers": {
|
|
648
|
+
$post: {
|
|
609
649
|
output: {
|
|
610
|
-
|
|
650
|
+
servers: {
|
|
611
651
|
name: string;
|
|
612
652
|
status: "authorization_required" | "authorizing" | "connected" | "connecting" | "disconnected" | "error";
|
|
613
653
|
toolCount: number;
|
|
@@ -627,20 +667,31 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
627
667
|
at: string;
|
|
628
668
|
} | null;
|
|
629
669
|
nextRetryAt: string | null;
|
|
630
|
-
};
|
|
670
|
+
}[];
|
|
631
671
|
};
|
|
632
672
|
outputFormat: "json";
|
|
633
|
-
status:
|
|
673
|
+
status: 201;
|
|
634
674
|
input: {
|
|
635
|
-
|
|
675
|
+
json: {
|
|
676
|
+
name: string;
|
|
677
|
+
type?: "stdio" | undefined;
|
|
678
|
+
command: string;
|
|
679
|
+
args?: string[] | undefined;
|
|
680
|
+
env?: Record<string, string> | undefined;
|
|
681
|
+
versionNegotiation?: "auto" | "legacy" | {
|
|
682
|
+
pin: string;
|
|
683
|
+
} | undefined;
|
|
684
|
+
} | {
|
|
636
685
|
name: string;
|
|
686
|
+
type?: "http" | "streamable-http" | undefined;
|
|
687
|
+
url: string;
|
|
688
|
+
headers?: Record<string, string> | undefined;
|
|
689
|
+
versionNegotiation?: "auto" | "legacy" | {
|
|
690
|
+
pin: string;
|
|
691
|
+
} | undefined;
|
|
637
692
|
};
|
|
638
693
|
};
|
|
639
|
-
}
|
|
640
|
-
};
|
|
641
|
-
} & {
|
|
642
|
-
"/v1/mcp-servers": {
|
|
643
|
-
$post: {
|
|
694
|
+
} | {
|
|
644
695
|
output: {
|
|
645
696
|
error: string;
|
|
646
697
|
code: string;
|
|
@@ -724,7 +775,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
724
775
|
} | undefined;
|
|
725
776
|
};
|
|
726
777
|
};
|
|
727
|
-
}
|
|
778
|
+
};
|
|
779
|
+
};
|
|
780
|
+
} & {
|
|
781
|
+
"/v1/mcp-servers/:name": {
|
|
782
|
+
$patch: {
|
|
728
783
|
output: {
|
|
729
784
|
servers: {
|
|
730
785
|
name: string;
|
|
@@ -749,10 +804,13 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
749
804
|
}[];
|
|
750
805
|
};
|
|
751
806
|
outputFormat: "json";
|
|
752
|
-
status:
|
|
807
|
+
status: 200;
|
|
753
808
|
input: {
|
|
754
|
-
|
|
809
|
+
param: {
|
|
755
810
|
name: string;
|
|
811
|
+
};
|
|
812
|
+
} & {
|
|
813
|
+
json: {
|
|
756
814
|
type?: "stdio" | undefined;
|
|
757
815
|
command: string;
|
|
758
816
|
args?: string[] | undefined;
|
|
@@ -761,20 +819,15 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
761
819
|
pin: string;
|
|
762
820
|
} | undefined;
|
|
763
821
|
} | {
|
|
764
|
-
name: string;
|
|
765
822
|
type?: "http" | "streamable-http" | undefined;
|
|
766
|
-
url
|
|
767
|
-
|
|
823
|
+
url?: string | undefined;
|
|
824
|
+
headerUpdates?: Record<string, string | null> | undefined;
|
|
768
825
|
versionNegotiation?: "auto" | "legacy" | {
|
|
769
826
|
pin: string;
|
|
770
827
|
} | undefined;
|
|
771
828
|
};
|
|
772
829
|
};
|
|
773
|
-
}
|
|
774
|
-
};
|
|
775
|
-
} & {
|
|
776
|
-
"/v1/mcp-servers/:name": {
|
|
777
|
-
$patch: {
|
|
830
|
+
} | {
|
|
778
831
|
output: {
|
|
779
832
|
error: string;
|
|
780
833
|
code: string;
|
|
@@ -864,7 +917,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
864
917
|
} | undefined;
|
|
865
918
|
};
|
|
866
919
|
};
|
|
867
|
-
}
|
|
920
|
+
};
|
|
921
|
+
};
|
|
922
|
+
} & {
|
|
923
|
+
"/v1/mcp-servers/:name": {
|
|
924
|
+
$delete: {
|
|
868
925
|
output: {
|
|
869
926
|
servers: {
|
|
870
927
|
name: string;
|
|
@@ -894,29 +951,8 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
894
951
|
param: {
|
|
895
952
|
name: string;
|
|
896
953
|
};
|
|
897
|
-
} & {
|
|
898
|
-
json: {
|
|
899
|
-
type?: "stdio" | undefined;
|
|
900
|
-
command: string;
|
|
901
|
-
args?: string[] | undefined;
|
|
902
|
-
env?: Record<string, string> | undefined;
|
|
903
|
-
versionNegotiation?: "auto" | "legacy" | {
|
|
904
|
-
pin: string;
|
|
905
|
-
} | undefined;
|
|
906
|
-
} | {
|
|
907
|
-
type?: "http" | "streamable-http" | undefined;
|
|
908
|
-
url?: string | undefined;
|
|
909
|
-
headerUpdates?: Record<string, string | null> | undefined;
|
|
910
|
-
versionNegotiation?: "auto" | "legacy" | {
|
|
911
|
-
pin: string;
|
|
912
|
-
} | undefined;
|
|
913
|
-
};
|
|
914
954
|
};
|
|
915
|
-
}
|
|
916
|
-
};
|
|
917
|
-
} & {
|
|
918
|
-
"/v1/mcp-servers/:name": {
|
|
919
|
-
$delete: {
|
|
955
|
+
} | {
|
|
920
956
|
output: {
|
|
921
957
|
error: string;
|
|
922
958
|
code: string;
|
|
@@ -942,55 +978,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
942
978
|
name: string;
|
|
943
979
|
};
|
|
944
980
|
};
|
|
945
|
-
} | {
|
|
946
|
-
output: {
|
|
947
|
-
servers: {
|
|
948
|
-
name: string;
|
|
949
|
-
status: "authorization_required" | "authorizing" | "connected" | "connecting" | "disconnected" | "error";
|
|
950
|
-
toolCount: number;
|
|
951
|
-
supportsPushNotifications: boolean;
|
|
952
|
-
supportsRealtimeMedia: boolean;
|
|
953
|
-
transport: "http" | "stdio";
|
|
954
|
-
headerNames: string[];
|
|
955
|
-
usesInteractiveOAuth: boolean;
|
|
956
|
-
authorization: {
|
|
957
|
-
id: string;
|
|
958
|
-
createdAt: string;
|
|
959
|
-
expiresAt: string;
|
|
960
|
-
} | null;
|
|
961
|
-
lastError: {
|
|
962
|
-
name: string;
|
|
963
|
-
message: string;
|
|
964
|
-
at: string;
|
|
965
|
-
} | null;
|
|
966
|
-
nextRetryAt: string | null;
|
|
967
|
-
}[];
|
|
968
|
-
};
|
|
969
|
-
outputFormat: "json";
|
|
970
|
-
status: 200;
|
|
971
|
-
input: {
|
|
972
|
-
param: {
|
|
973
|
-
name: string;
|
|
974
|
-
};
|
|
975
|
-
};
|
|
976
981
|
};
|
|
977
982
|
};
|
|
978
983
|
} & {
|
|
979
984
|
"/v1/mcp-servers/:name/tool-calls": {
|
|
980
985
|
$get: {
|
|
981
|
-
output: {
|
|
982
|
-
error: string;
|
|
983
|
-
code: string;
|
|
984
|
-
remediation?: string | undefined;
|
|
985
|
-
};
|
|
986
|
-
outputFormat: "json";
|
|
987
|
-
status: 500;
|
|
988
|
-
input: {
|
|
989
|
-
param: {
|
|
990
|
-
name: string;
|
|
991
|
-
};
|
|
992
|
-
};
|
|
993
|
-
} | {
|
|
994
986
|
output: {
|
|
995
987
|
toolCalls: {
|
|
996
988
|
id: string;
|
|
@@ -1013,18 +1005,34 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1013
1005
|
name: string;
|
|
1014
1006
|
};
|
|
1015
1007
|
};
|
|
1008
|
+
} | {
|
|
1009
|
+
output: {
|
|
1010
|
+
error: string;
|
|
1011
|
+
code: string;
|
|
1012
|
+
remediation?: string | undefined;
|
|
1013
|
+
};
|
|
1014
|
+
outputFormat: "json";
|
|
1015
|
+
status: 500;
|
|
1016
|
+
input: {
|
|
1017
|
+
param: {
|
|
1018
|
+
name: string;
|
|
1019
|
+
};
|
|
1020
|
+
};
|
|
1016
1021
|
};
|
|
1017
1022
|
};
|
|
1018
1023
|
} & {
|
|
1019
1024
|
"/v1/mcp-servers/:name/authorization": {
|
|
1020
1025
|
$put: {
|
|
1021
1026
|
output: {
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1027
|
+
id: string;
|
|
1028
|
+
serverName: string;
|
|
1029
|
+
serverUrl: string;
|
|
1030
|
+
authorizationUrl: string;
|
|
1031
|
+
state: string;
|
|
1032
|
+
expiresAt: string;
|
|
1025
1033
|
};
|
|
1026
1034
|
outputFormat: "json";
|
|
1027
|
-
status:
|
|
1035
|
+
status: 200;
|
|
1028
1036
|
input: {
|
|
1029
1037
|
param: {
|
|
1030
1038
|
name: string;
|
|
@@ -1037,7 +1045,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1037
1045
|
remediation?: string | undefined;
|
|
1038
1046
|
};
|
|
1039
1047
|
outputFormat: "json";
|
|
1040
|
-
status:
|
|
1048
|
+
status: 404;
|
|
1041
1049
|
input: {
|
|
1042
1050
|
param: {
|
|
1043
1051
|
name: string;
|
|
@@ -1050,7 +1058,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1050
1058
|
remediation?: string | undefined;
|
|
1051
1059
|
};
|
|
1052
1060
|
outputFormat: "json";
|
|
1053
|
-
status:
|
|
1061
|
+
status: 409;
|
|
1054
1062
|
input: {
|
|
1055
1063
|
param: {
|
|
1056
1064
|
name: string;
|
|
@@ -1063,7 +1071,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1063
1071
|
remediation?: string | undefined;
|
|
1064
1072
|
};
|
|
1065
1073
|
outputFormat: "json";
|
|
1066
|
-
status:
|
|
1074
|
+
status: 503;
|
|
1067
1075
|
input: {
|
|
1068
1076
|
param: {
|
|
1069
1077
|
name: string;
|
|
@@ -1071,15 +1079,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1071
1079
|
};
|
|
1072
1080
|
} | {
|
|
1073
1081
|
output: {
|
|
1074
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
authorizationUrl: string;
|
|
1078
|
-
state: string;
|
|
1079
|
-
expiresAt: string;
|
|
1082
|
+
error: string;
|
|
1083
|
+
code: string;
|
|
1084
|
+
remediation?: string | undefined;
|
|
1080
1085
|
};
|
|
1081
1086
|
outputFormat: "json";
|
|
1082
|
-
status:
|
|
1087
|
+
status: 504;
|
|
1083
1088
|
input: {
|
|
1084
1089
|
param: {
|
|
1085
1090
|
name: string;
|
|
@@ -1090,6 +1095,15 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1090
1095
|
} & {
|
|
1091
1096
|
"/v1/mcp-servers/:name/authorization": {
|
|
1092
1097
|
$delete: {
|
|
1098
|
+
output: {};
|
|
1099
|
+
outputFormat: string;
|
|
1100
|
+
status: 204;
|
|
1101
|
+
input: {
|
|
1102
|
+
param: {
|
|
1103
|
+
name: string;
|
|
1104
|
+
};
|
|
1105
|
+
};
|
|
1106
|
+
} | {
|
|
1093
1107
|
output: {
|
|
1094
1108
|
error: string;
|
|
1095
1109
|
code: string;
|
|
@@ -1102,27 +1116,16 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1102
1116
|
name: string;
|
|
1103
1117
|
};
|
|
1104
1118
|
};
|
|
1105
|
-
} | {
|
|
1106
|
-
output: {};
|
|
1107
|
-
outputFormat: string;
|
|
1108
|
-
status: 204;
|
|
1109
|
-
input: {
|
|
1110
|
-
param: {
|
|
1111
|
-
name: string;
|
|
1112
|
-
};
|
|
1113
|
-
};
|
|
1114
1119
|
};
|
|
1115
1120
|
};
|
|
1116
1121
|
} & {
|
|
1117
1122
|
"/v1/mcp-oauth/callback": {
|
|
1118
1123
|
$post: {
|
|
1119
1124
|
output: {
|
|
1120
|
-
|
|
1121
|
-
code: string;
|
|
1122
|
-
remediation?: string | undefined;
|
|
1125
|
+
accepted: true;
|
|
1123
1126
|
};
|
|
1124
1127
|
outputFormat: "json";
|
|
1125
|
-
status:
|
|
1128
|
+
status: 202;
|
|
1126
1129
|
input: {
|
|
1127
1130
|
json: {
|
|
1128
1131
|
state: string;
|
|
@@ -1138,7 +1141,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1138
1141
|
remediation?: string | undefined;
|
|
1139
1142
|
};
|
|
1140
1143
|
outputFormat: "json";
|
|
1141
|
-
status:
|
|
1144
|
+
status: 400;
|
|
1142
1145
|
input: {
|
|
1143
1146
|
json: {
|
|
1144
1147
|
state: string;
|
|
@@ -1149,10 +1152,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1149
1152
|
};
|
|
1150
1153
|
} | {
|
|
1151
1154
|
output: {
|
|
1152
|
-
|
|
1155
|
+
error: string;
|
|
1156
|
+
code: string;
|
|
1157
|
+
remediation?: string | undefined;
|
|
1153
1158
|
};
|
|
1154
1159
|
outputFormat: "json";
|
|
1155
|
-
status:
|
|
1160
|
+
status: 404;
|
|
1156
1161
|
input: {
|
|
1157
1162
|
json: {
|
|
1158
1163
|
state: string;
|
|
@@ -1167,12 +1172,10 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1167
1172
|
"/v1/god-messages": {
|
|
1168
1173
|
$post: {
|
|
1169
1174
|
output: {
|
|
1170
|
-
|
|
1171
|
-
code: string;
|
|
1172
|
-
remediation?: string | undefined;
|
|
1175
|
+
sessionId: string;
|
|
1173
1176
|
};
|
|
1174
1177
|
outputFormat: "json";
|
|
1175
|
-
status:
|
|
1178
|
+
status: 202;
|
|
1176
1179
|
input: {
|
|
1177
1180
|
json: {
|
|
1178
1181
|
content: ({
|
|
@@ -1212,7 +1215,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1212
1215
|
remediation?: string | undefined;
|
|
1213
1216
|
};
|
|
1214
1217
|
outputFormat: "json";
|
|
1215
|
-
status:
|
|
1218
|
+
status: 400;
|
|
1216
1219
|
input: {
|
|
1217
1220
|
json: {
|
|
1218
1221
|
content: ({
|
|
@@ -1252,7 +1255,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1252
1255
|
remediation?: string | undefined;
|
|
1253
1256
|
};
|
|
1254
1257
|
outputFormat: "json";
|
|
1255
|
-
status:
|
|
1258
|
+
status: 409;
|
|
1256
1259
|
input: {
|
|
1257
1260
|
json: {
|
|
1258
1261
|
content: ({
|
|
@@ -1292,7 +1295,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1292
1295
|
remediation?: string | undefined;
|
|
1293
1296
|
};
|
|
1294
1297
|
outputFormat: "json";
|
|
1295
|
-
status:
|
|
1298
|
+
status: 500;
|
|
1296
1299
|
input: {
|
|
1297
1300
|
json: {
|
|
1298
1301
|
content: ({
|
|
@@ -1327,10 +1330,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1327
1330
|
};
|
|
1328
1331
|
} | {
|
|
1329
1332
|
output: {
|
|
1330
|
-
|
|
1333
|
+
error: string;
|
|
1334
|
+
code: string;
|
|
1335
|
+
remediation?: string | undefined;
|
|
1331
1336
|
};
|
|
1332
1337
|
outputFormat: "json";
|
|
1333
|
-
status:
|
|
1338
|
+
status: 503;
|
|
1334
1339
|
input: {
|
|
1335
1340
|
json: {
|
|
1336
1341
|
content: ({
|
|
@@ -1368,15 +1373,6 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1368
1373
|
} & {
|
|
1369
1374
|
"/v1/god-messages/session": {
|
|
1370
1375
|
$get: {
|
|
1371
|
-
output: {
|
|
1372
|
-
error: string;
|
|
1373
|
-
code: string;
|
|
1374
|
-
remediation?: string | undefined;
|
|
1375
|
-
};
|
|
1376
|
-
outputFormat: "json";
|
|
1377
|
-
status: 404;
|
|
1378
|
-
input: {};
|
|
1379
|
-
} | {
|
|
1380
1376
|
output: {
|
|
1381
1377
|
name: string;
|
|
1382
1378
|
extensionIdentifier?: string | undefined;
|
|
@@ -1431,18 +1427,33 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1431
1427
|
outputFormat: "json";
|
|
1432
1428
|
status: 200;
|
|
1433
1429
|
input: {};
|
|
1430
|
+
} | {
|
|
1431
|
+
output: {
|
|
1432
|
+
error: string;
|
|
1433
|
+
code: string;
|
|
1434
|
+
remediation?: string | undefined;
|
|
1435
|
+
};
|
|
1436
|
+
outputFormat: "json";
|
|
1437
|
+
status: 404;
|
|
1438
|
+
input: {};
|
|
1434
1439
|
};
|
|
1435
1440
|
};
|
|
1436
1441
|
} & {
|
|
1437
1442
|
"/v1/god-messages/messages": {
|
|
1438
1443
|
$get: {
|
|
1439
1444
|
output: {
|
|
1440
|
-
|
|
1441
|
-
|
|
1442
|
-
|
|
1445
|
+
messages: {
|
|
1446
|
+
id: string;
|
|
1447
|
+
role: string;
|
|
1448
|
+
parts: {
|
|
1449
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
1450
|
+
}[];
|
|
1451
|
+
}[];
|
|
1452
|
+
nextCursor: string | null;
|
|
1453
|
+
hasMore: boolean;
|
|
1443
1454
|
};
|
|
1444
1455
|
outputFormat: "json";
|
|
1445
|
-
status:
|
|
1456
|
+
status: 200;
|
|
1446
1457
|
input: {
|
|
1447
1458
|
query: {
|
|
1448
1459
|
limit?: unknown;
|
|
@@ -1456,7 +1467,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1456
1467
|
remediation?: string | undefined;
|
|
1457
1468
|
};
|
|
1458
1469
|
outputFormat: "json";
|
|
1459
|
-
status:
|
|
1470
|
+
status: 400;
|
|
1460
1471
|
input: {
|
|
1461
1472
|
query: {
|
|
1462
1473
|
limit?: unknown;
|
|
@@ -1465,18 +1476,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1465
1476
|
};
|
|
1466
1477
|
} | {
|
|
1467
1478
|
output: {
|
|
1468
|
-
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
parts: {
|
|
1472
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
1473
|
-
}[];
|
|
1474
|
-
}[];
|
|
1475
|
-
nextCursor: string | null;
|
|
1476
|
-
hasMore: boolean;
|
|
1479
|
+
error: string;
|
|
1480
|
+
code: string;
|
|
1481
|
+
remediation?: string | undefined;
|
|
1477
1482
|
};
|
|
1478
1483
|
outputFormat: "json";
|
|
1479
|
-
status:
|
|
1484
|
+
status: 500;
|
|
1480
1485
|
input: {
|
|
1481
1486
|
query: {
|
|
1482
1487
|
limit?: unknown;
|
|
@@ -1488,6 +1493,13 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1488
1493
|
} & {
|
|
1489
1494
|
"/v1/god-messages/reset": {
|
|
1490
1495
|
$post: {
|
|
1496
|
+
output: {
|
|
1497
|
+
sessionId: string;
|
|
1498
|
+
};
|
|
1499
|
+
outputFormat: "json";
|
|
1500
|
+
status: 200;
|
|
1501
|
+
input: {};
|
|
1502
|
+
} | {
|
|
1491
1503
|
output: {
|
|
1492
1504
|
error: string;
|
|
1493
1505
|
code: string;
|
|
@@ -1514,52 +1526,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1514
1526
|
outputFormat: "json";
|
|
1515
1527
|
status: 500;
|
|
1516
1528
|
input: {};
|
|
1517
|
-
} | {
|
|
1518
|
-
output: {
|
|
1519
|
-
sessionId: string;
|
|
1520
|
-
};
|
|
1521
|
-
outputFormat: "json";
|
|
1522
|
-
status: 200;
|
|
1523
|
-
input: {};
|
|
1524
1529
|
};
|
|
1525
1530
|
};
|
|
1526
1531
|
} & {
|
|
1527
1532
|
"/v1/sessions": {
|
|
1528
1533
|
$get: {
|
|
1529
|
-
output: {
|
|
1530
|
-
error: string;
|
|
1531
|
-
code: string;
|
|
1532
|
-
remediation?: string | undefined;
|
|
1533
|
-
};
|
|
1534
|
-
outputFormat: "json";
|
|
1535
|
-
status: 400;
|
|
1536
|
-
input: {
|
|
1537
|
-
query: {
|
|
1538
|
-
kind?: "child" | "default" | "god" | undefined;
|
|
1539
|
-
parentInstanceId?: string | undefined;
|
|
1540
|
-
live?: "false" | "true" | undefined;
|
|
1541
|
-
limit?: unknown;
|
|
1542
|
-
cursor?: string | undefined;
|
|
1543
|
-
};
|
|
1544
|
-
};
|
|
1545
|
-
} | {
|
|
1546
|
-
output: {
|
|
1547
|
-
error: string;
|
|
1548
|
-
code: string;
|
|
1549
|
-
remediation?: string | undefined;
|
|
1550
|
-
};
|
|
1551
|
-
outputFormat: "json";
|
|
1552
|
-
status: 500;
|
|
1553
|
-
input: {
|
|
1554
|
-
query: {
|
|
1555
|
-
kind?: "child" | "default" | "god" | undefined;
|
|
1556
|
-
parentInstanceId?: string | undefined;
|
|
1557
|
-
live?: "false" | "true" | undefined;
|
|
1558
|
-
limit?: unknown;
|
|
1559
|
-
cursor?: string | undefined;
|
|
1560
|
-
};
|
|
1561
|
-
};
|
|
1562
|
-
} | {
|
|
1563
1534
|
output: {
|
|
1564
1535
|
sessions: {
|
|
1565
1536
|
instanceId: string;
|
|
@@ -1591,21 +1562,21 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1591
1562
|
cursor?: string | undefined;
|
|
1592
1563
|
};
|
|
1593
1564
|
};
|
|
1594
|
-
}
|
|
1595
|
-
};
|
|
1596
|
-
} & {
|
|
1597
|
-
"/v1/sessions/:instanceId": {
|
|
1598
|
-
$get: {
|
|
1565
|
+
} | {
|
|
1599
1566
|
output: {
|
|
1600
1567
|
error: string;
|
|
1601
1568
|
code: string;
|
|
1602
1569
|
remediation?: string | undefined;
|
|
1603
1570
|
};
|
|
1604
1571
|
outputFormat: "json";
|
|
1605
|
-
status:
|
|
1572
|
+
status: 400;
|
|
1606
1573
|
input: {
|
|
1607
|
-
|
|
1608
|
-
|
|
1574
|
+
query: {
|
|
1575
|
+
kind?: "child" | "default" | "god" | undefined;
|
|
1576
|
+
parentInstanceId?: string | undefined;
|
|
1577
|
+
live?: "false" | "true" | undefined;
|
|
1578
|
+
limit?: unknown;
|
|
1579
|
+
cursor?: string | undefined;
|
|
1609
1580
|
};
|
|
1610
1581
|
};
|
|
1611
1582
|
} | {
|
|
@@ -1617,11 +1588,19 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1617
1588
|
outputFormat: "json";
|
|
1618
1589
|
status: 500;
|
|
1619
1590
|
input: {
|
|
1620
|
-
|
|
1621
|
-
|
|
1591
|
+
query: {
|
|
1592
|
+
kind?: "child" | "default" | "god" | undefined;
|
|
1593
|
+
parentInstanceId?: string | undefined;
|
|
1594
|
+
live?: "false" | "true" | undefined;
|
|
1595
|
+
limit?: unknown;
|
|
1596
|
+
cursor?: string | undefined;
|
|
1622
1597
|
};
|
|
1623
1598
|
};
|
|
1624
|
-
}
|
|
1599
|
+
};
|
|
1600
|
+
};
|
|
1601
|
+
} & {
|
|
1602
|
+
"/v1/sessions/:instanceId": {
|
|
1603
|
+
$get: {
|
|
1625
1604
|
output: {
|
|
1626
1605
|
instanceId: string;
|
|
1627
1606
|
sessionId: string;
|
|
@@ -1645,29 +1624,6 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1645
1624
|
instanceId: string;
|
|
1646
1625
|
};
|
|
1647
1626
|
};
|
|
1648
|
-
};
|
|
1649
|
-
};
|
|
1650
|
-
} & {
|
|
1651
|
-
"/v1/sessions/:instanceId/messages": {
|
|
1652
|
-
$get: {
|
|
1653
|
-
output: {
|
|
1654
|
-
error: string;
|
|
1655
|
-
code: string;
|
|
1656
|
-
remediation?: string | undefined;
|
|
1657
|
-
};
|
|
1658
|
-
outputFormat: "json";
|
|
1659
|
-
status: 400;
|
|
1660
|
-
input: {
|
|
1661
|
-
param: {
|
|
1662
|
-
instanceId: string;
|
|
1663
|
-
};
|
|
1664
|
-
} & {
|
|
1665
|
-
query: {
|
|
1666
|
-
limit?: unknown;
|
|
1667
|
-
cursor?: unknown;
|
|
1668
|
-
includeProviderMetadata?: "false" | "true" | undefined;
|
|
1669
|
-
};
|
|
1670
|
-
};
|
|
1671
1627
|
} | {
|
|
1672
1628
|
output: {
|
|
1673
1629
|
error: string;
|
|
@@ -1680,12 +1636,6 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1680
1636
|
param: {
|
|
1681
1637
|
instanceId: string;
|
|
1682
1638
|
};
|
|
1683
|
-
} & {
|
|
1684
|
-
query: {
|
|
1685
|
-
limit?: unknown;
|
|
1686
|
-
cursor?: unknown;
|
|
1687
|
-
includeProviderMetadata?: "false" | "true" | undefined;
|
|
1688
|
-
};
|
|
1689
1639
|
};
|
|
1690
1640
|
} | {
|
|
1691
1641
|
output: {
|
|
@@ -1699,14 +1649,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1699
1649
|
param: {
|
|
1700
1650
|
instanceId: string;
|
|
1701
1651
|
};
|
|
1702
|
-
} & {
|
|
1703
|
-
query: {
|
|
1704
|
-
limit?: unknown;
|
|
1705
|
-
cursor?: unknown;
|
|
1706
|
-
includeProviderMetadata?: "false" | "true" | undefined;
|
|
1707
|
-
};
|
|
1708
1652
|
};
|
|
1709
|
-
}
|
|
1653
|
+
};
|
|
1654
|
+
};
|
|
1655
|
+
} & {
|
|
1656
|
+
"/v1/sessions/:instanceId/messages": {
|
|
1657
|
+
$get: {
|
|
1710
1658
|
output: {
|
|
1711
1659
|
messages: {
|
|
1712
1660
|
id: string;
|
|
@@ -1736,11 +1684,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1736
1684
|
includeProviderMetadata?: "false" | "true" | undefined;
|
|
1737
1685
|
};
|
|
1738
1686
|
};
|
|
1739
|
-
}
|
|
1740
|
-
};
|
|
1741
|
-
} & {
|
|
1742
|
-
"/v1/usage": {
|
|
1743
|
-
$get: {
|
|
1687
|
+
} | {
|
|
1744
1688
|
output: {
|
|
1745
1689
|
error: string;
|
|
1746
1690
|
code: string;
|
|
@@ -1749,12 +1693,14 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1749
1693
|
outputFormat: "json";
|
|
1750
1694
|
status: 400;
|
|
1751
1695
|
input: {
|
|
1696
|
+
param: {
|
|
1697
|
+
instanceId: string;
|
|
1698
|
+
};
|
|
1699
|
+
} & {
|
|
1752
1700
|
query: {
|
|
1753
|
-
splitBy?: "endpoint" | "model" | "none" | "provider" | undefined;
|
|
1754
|
-
from?: string | undefined;
|
|
1755
|
-
to?: string | undefined;
|
|
1756
|
-
granularity?: "daily" | "event" | "hourly" | "weekly" | undefined;
|
|
1757
1701
|
limit?: unknown;
|
|
1702
|
+
cursor?: unknown;
|
|
1703
|
+
includeProviderMetadata?: "false" | "true" | undefined;
|
|
1758
1704
|
};
|
|
1759
1705
|
};
|
|
1760
1706
|
} | {
|
|
@@ -1764,17 +1710,42 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1764
1710
|
remediation?: string | undefined;
|
|
1765
1711
|
};
|
|
1766
1712
|
outputFormat: "json";
|
|
1767
|
-
status:
|
|
1713
|
+
status: 404;
|
|
1768
1714
|
input: {
|
|
1715
|
+
param: {
|
|
1716
|
+
instanceId: string;
|
|
1717
|
+
};
|
|
1718
|
+
} & {
|
|
1769
1719
|
query: {
|
|
1770
|
-
splitBy?: "endpoint" | "model" | "none" | "provider" | undefined;
|
|
1771
|
-
from?: string | undefined;
|
|
1772
|
-
to?: string | undefined;
|
|
1773
|
-
granularity?: "daily" | "event" | "hourly" | "weekly" | undefined;
|
|
1774
1720
|
limit?: unknown;
|
|
1721
|
+
cursor?: unknown;
|
|
1722
|
+
includeProviderMetadata?: "false" | "true" | undefined;
|
|
1775
1723
|
};
|
|
1776
1724
|
};
|
|
1777
1725
|
} | {
|
|
1726
|
+
output: {
|
|
1727
|
+
error: string;
|
|
1728
|
+
code: string;
|
|
1729
|
+
remediation?: string | undefined;
|
|
1730
|
+
};
|
|
1731
|
+
outputFormat: "json";
|
|
1732
|
+
status: 500;
|
|
1733
|
+
input: {
|
|
1734
|
+
param: {
|
|
1735
|
+
instanceId: string;
|
|
1736
|
+
};
|
|
1737
|
+
} & {
|
|
1738
|
+
query: {
|
|
1739
|
+
limit?: unknown;
|
|
1740
|
+
cursor?: unknown;
|
|
1741
|
+
includeProviderMetadata?: "false" | "true" | undefined;
|
|
1742
|
+
};
|
|
1743
|
+
};
|
|
1744
|
+
};
|
|
1745
|
+
};
|
|
1746
|
+
} & {
|
|
1747
|
+
"/v1/usage": {
|
|
1748
|
+
$get: {
|
|
1778
1749
|
output: {
|
|
1779
1750
|
dataPoints: {
|
|
1780
1751
|
bucket: string | null;
|
|
@@ -1812,19 +1783,23 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1812
1783
|
limit?: unknown;
|
|
1813
1784
|
};
|
|
1814
1785
|
};
|
|
1815
|
-
}
|
|
1816
|
-
};
|
|
1817
|
-
} & {
|
|
1818
|
-
"/v1/skills": {
|
|
1819
|
-
$get: {
|
|
1786
|
+
} | {
|
|
1820
1787
|
output: {
|
|
1821
1788
|
error: string;
|
|
1822
1789
|
code: string;
|
|
1823
1790
|
remediation?: string | undefined;
|
|
1824
1791
|
};
|
|
1825
1792
|
outputFormat: "json";
|
|
1826
|
-
status:
|
|
1827
|
-
input: {
|
|
1793
|
+
status: 400;
|
|
1794
|
+
input: {
|
|
1795
|
+
query: {
|
|
1796
|
+
splitBy?: "endpoint" | "model" | "none" | "provider" | undefined;
|
|
1797
|
+
from?: string | undefined;
|
|
1798
|
+
to?: string | undefined;
|
|
1799
|
+
granularity?: "daily" | "event" | "hourly" | "weekly" | undefined;
|
|
1800
|
+
limit?: unknown;
|
|
1801
|
+
};
|
|
1802
|
+
};
|
|
1828
1803
|
} | {
|
|
1829
1804
|
output: {
|
|
1830
1805
|
error: string;
|
|
@@ -1832,35 +1807,71 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1832
1807
|
remediation?: string | undefined;
|
|
1833
1808
|
};
|
|
1834
1809
|
outputFormat: "json";
|
|
1835
|
-
status:
|
|
1836
|
-
input: {
|
|
1837
|
-
|
|
1838
|
-
|
|
1839
|
-
|
|
1840
|
-
|
|
1841
|
-
|
|
1842
|
-
|
|
1843
|
-
|
|
1844
|
-
|
|
1845
|
-
|
|
1846
|
-
|
|
1810
|
+
status: 500;
|
|
1811
|
+
input: {
|
|
1812
|
+
query: {
|
|
1813
|
+
splitBy?: "endpoint" | "model" | "none" | "provider" | undefined;
|
|
1814
|
+
from?: string | undefined;
|
|
1815
|
+
to?: string | undefined;
|
|
1816
|
+
granularity?: "daily" | "event" | "hourly" | "weekly" | undefined;
|
|
1817
|
+
limit?: unknown;
|
|
1818
|
+
};
|
|
1819
|
+
};
|
|
1820
|
+
};
|
|
1821
|
+
};
|
|
1822
|
+
} & {
|
|
1823
|
+
"/v1/skills": {
|
|
1824
|
+
$get: {
|
|
1825
|
+
output: {
|
|
1826
|
+
skills: {
|
|
1827
|
+
name: string;
|
|
1828
|
+
description: string;
|
|
1829
|
+
origin: "learned";
|
|
1830
|
+
createdAt?: string | undefined;
|
|
1831
|
+
updatedAt?: string | undefined;
|
|
1832
|
+
lastReadAt?: string | null | undefined;
|
|
1833
|
+
readCount?: number | undefined;
|
|
1847
1834
|
}[];
|
|
1848
1835
|
};
|
|
1849
1836
|
outputFormat: "json";
|
|
1850
1837
|
status: 200;
|
|
1851
1838
|
input: {};
|
|
1839
|
+
} | {
|
|
1840
|
+
output: {
|
|
1841
|
+
error: string;
|
|
1842
|
+
code: string;
|
|
1843
|
+
remediation?: string | undefined;
|
|
1844
|
+
};
|
|
1845
|
+
outputFormat: "json";
|
|
1846
|
+
status: 500;
|
|
1847
|
+
input: {};
|
|
1848
|
+
} | {
|
|
1849
|
+
output: {
|
|
1850
|
+
error: string;
|
|
1851
|
+
code: string;
|
|
1852
|
+
remediation?: string | undefined;
|
|
1853
|
+
};
|
|
1854
|
+
outputFormat: "json";
|
|
1855
|
+
status: 503;
|
|
1856
|
+
input: {};
|
|
1852
1857
|
};
|
|
1853
1858
|
};
|
|
1854
1859
|
} & {
|
|
1855
1860
|
"/v1/skills/:name": {
|
|
1856
1861
|
$get: {
|
|
1857
1862
|
output: {
|
|
1858
|
-
|
|
1859
|
-
|
|
1860
|
-
|
|
1863
|
+
name: string;
|
|
1864
|
+
description: string;
|
|
1865
|
+
origin: "learned";
|
|
1866
|
+
createdAt?: string | undefined;
|
|
1867
|
+
updatedAt?: string | undefined;
|
|
1868
|
+
lastReadAt?: string | null | undefined;
|
|
1869
|
+
readCount?: number | undefined;
|
|
1870
|
+
body: string;
|
|
1871
|
+
sourceEpisodes?: string[] | undefined;
|
|
1861
1872
|
};
|
|
1862
1873
|
outputFormat: "json";
|
|
1863
|
-
status:
|
|
1874
|
+
status: 200;
|
|
1864
1875
|
input: {
|
|
1865
1876
|
param: {
|
|
1866
1877
|
name: string;
|
|
@@ -1873,7 +1884,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1873
1884
|
remediation?: string | undefined;
|
|
1874
1885
|
};
|
|
1875
1886
|
outputFormat: "json";
|
|
1876
|
-
status:
|
|
1887
|
+
status: 404;
|
|
1877
1888
|
input: {
|
|
1878
1889
|
param: {
|
|
1879
1890
|
name: string;
|
|
@@ -1886,7 +1897,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1886
1897
|
remediation?: string | undefined;
|
|
1887
1898
|
};
|
|
1888
1899
|
outputFormat: "json";
|
|
1889
|
-
status:
|
|
1900
|
+
status: 500;
|
|
1890
1901
|
input: {
|
|
1891
1902
|
param: {
|
|
1892
1903
|
name: string;
|
|
@@ -1894,18 +1905,12 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1894
1905
|
};
|
|
1895
1906
|
} | {
|
|
1896
1907
|
output: {
|
|
1897
|
-
|
|
1898
|
-
|
|
1899
|
-
|
|
1900
|
-
createdAt?: string | undefined;
|
|
1901
|
-
updatedAt?: string | undefined;
|
|
1902
|
-
lastReadAt?: string | null | undefined;
|
|
1903
|
-
readCount?: number | undefined;
|
|
1904
|
-
body: string;
|
|
1905
|
-
sourceEpisodes?: string[] | undefined;
|
|
1908
|
+
error: string;
|
|
1909
|
+
code: string;
|
|
1910
|
+
remediation?: string | undefined;
|
|
1906
1911
|
};
|
|
1907
1912
|
outputFormat: "json";
|
|
1908
|
-
status:
|
|
1913
|
+
status: 503;
|
|
1909
1914
|
input: {
|
|
1910
1915
|
param: {
|
|
1911
1916
|
name: string;
|
|
@@ -1924,6 +1929,8 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1924
1929
|
documentationUrl?: string | undefined;
|
|
1925
1930
|
capabilities: {
|
|
1926
1931
|
modelDiscovery: boolean;
|
|
1932
|
+
voiceDiscovery: boolean;
|
|
1933
|
+
voicePreview: boolean;
|
|
1927
1934
|
connectivityTest: boolean;
|
|
1928
1935
|
customModels: boolean;
|
|
1929
1936
|
};
|
|
@@ -1941,6 +1948,57 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1941
1948
|
} & {
|
|
1942
1949
|
"/v1/provider-types/:type/can-add": {
|
|
1943
1950
|
$post: {
|
|
1951
|
+
output: {
|
|
1952
|
+
ok: boolean;
|
|
1953
|
+
code?: string | undefined;
|
|
1954
|
+
message?: string | undefined;
|
|
1955
|
+
provider?: {
|
|
1956
|
+
id: string;
|
|
1957
|
+
type: "alibaba-qwen" | "amazon-bedrock" | "anthropic" | "anthropic-messages" | "azure-openai" | "chat-completions" | "chatgpt-codex-subscription" | "deepseek" | "glm-coding-plan" | "google-gemini" | "google-generative" | "google-vertex" | "minimax" | "minimax-coding-plan" | "mistral" | "moonshot" | "ollama" | "openai" | "opencode-go" | "opencode-zen" | "openrouter" | "responses" | "xai" | "xiaomi-mimo" | "zai";
|
|
1958
|
+
metadata: {
|
|
1959
|
+
displayName: string;
|
|
1960
|
+
description: string;
|
|
1961
|
+
logoSvg?: string | undefined;
|
|
1962
|
+
documentationUrl?: string | undefined;
|
|
1963
|
+
capabilities: {
|
|
1964
|
+
modelDiscovery: boolean;
|
|
1965
|
+
voiceDiscovery: boolean;
|
|
1966
|
+
voicePreview: boolean;
|
|
1967
|
+
connectivityTest: boolean;
|
|
1968
|
+
customModels: boolean;
|
|
1969
|
+
};
|
|
1970
|
+
};
|
|
1971
|
+
settings: {
|
|
1972
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
1973
|
+
};
|
|
1974
|
+
operations: {
|
|
1975
|
+
update: {
|
|
1976
|
+
available: boolean;
|
|
1977
|
+
code?: string | undefined;
|
|
1978
|
+
message?: string | undefined;
|
|
1979
|
+
remediation?: string | undefined;
|
|
1980
|
+
};
|
|
1981
|
+
remove: {
|
|
1982
|
+
available: boolean;
|
|
1983
|
+
code?: string | undefined;
|
|
1984
|
+
message?: string | undefined;
|
|
1985
|
+
remediation?: string | undefined;
|
|
1986
|
+
};
|
|
1987
|
+
};
|
|
1988
|
+
} | undefined;
|
|
1989
|
+
};
|
|
1990
|
+
outputFormat: "json";
|
|
1991
|
+
status: 200;
|
|
1992
|
+
input: {
|
|
1993
|
+
param: {
|
|
1994
|
+
type: "alibaba-qwen" | "amazon-bedrock" | "anthropic" | "anthropic-messages" | "azure-openai" | "chat-completions" | "chatgpt-codex-subscription" | "deepseek" | "glm-coding-plan" | "google-gemini" | "google-generative" | "google-vertex" | "minimax" | "minimax-coding-plan" | "mistral" | "moonshot" | "ollama" | "openai" | "opencode-go" | "opencode-zen" | "openrouter" | "responses" | "xai" | "xiaomi-mimo" | "zai";
|
|
1995
|
+
};
|
|
1996
|
+
} & {
|
|
1997
|
+
json: {
|
|
1998
|
+
settings: Record<string, unknown>;
|
|
1999
|
+
};
|
|
2000
|
+
};
|
|
2001
|
+
} | {
|
|
1944
2002
|
output: {
|
|
1945
2003
|
error: string;
|
|
1946
2004
|
code: string;
|
|
@@ -1974,12 +2032,13 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1974
2032
|
settings: Record<string, unknown>;
|
|
1975
2033
|
};
|
|
1976
2034
|
};
|
|
1977
|
-
}
|
|
2035
|
+
};
|
|
2036
|
+
};
|
|
2037
|
+
} & {
|
|
2038
|
+
"/v1/providers": {
|
|
2039
|
+
$get: {
|
|
1978
2040
|
output: {
|
|
1979
|
-
|
|
1980
|
-
code?: string | undefined;
|
|
1981
|
-
message?: string | undefined;
|
|
1982
|
-
provider?: {
|
|
2041
|
+
providers: {
|
|
1983
2042
|
id: string;
|
|
1984
2043
|
type: "alibaba-qwen" | "amazon-bedrock" | "anthropic" | "anthropic-messages" | "azure-openai" | "chat-completions" | "chatgpt-codex-subscription" | "deepseek" | "glm-coding-plan" | "google-gemini" | "google-generative" | "google-vertex" | "minimax" | "minimax-coding-plan" | "mistral" | "moonshot" | "ollama" | "openai" | "opencode-go" | "opencode-zen" | "openrouter" | "responses" | "xai" | "xiaomi-mimo" | "zai";
|
|
1985
2044
|
metadata: {
|
|
@@ -1989,6 +2048,8 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
1989
2048
|
documentationUrl?: string | undefined;
|
|
1990
2049
|
capabilities: {
|
|
1991
2050
|
modelDiscovery: boolean;
|
|
2051
|
+
voiceDiscovery: boolean;
|
|
2052
|
+
voicePreview: boolean;
|
|
1992
2053
|
connectivityTest: boolean;
|
|
1993
2054
|
customModels: boolean;
|
|
1994
2055
|
};
|
|
@@ -2010,26 +2071,21 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2010
2071
|
remediation?: string | undefined;
|
|
2011
2072
|
};
|
|
2012
2073
|
};
|
|
2013
|
-
}
|
|
2074
|
+
}[];
|
|
2014
2075
|
};
|
|
2015
2076
|
outputFormat: "json";
|
|
2016
2077
|
status: 200;
|
|
2017
|
-
input: {
|
|
2018
|
-
param: {
|
|
2019
|
-
type: "alibaba-qwen" | "amazon-bedrock" | "anthropic" | "anthropic-messages" | "azure-openai" | "chat-completions" | "chatgpt-codex-subscription" | "deepseek" | "glm-coding-plan" | "google-gemini" | "google-generative" | "google-vertex" | "minimax" | "minimax-coding-plan" | "mistral" | "moonshot" | "ollama" | "openai" | "opencode-go" | "opencode-zen" | "openrouter" | "responses" | "xai" | "xiaomi-mimo" | "zai";
|
|
2020
|
-
};
|
|
2021
|
-
} & {
|
|
2022
|
-
json: {
|
|
2023
|
-
settings: Record<string, unknown>;
|
|
2024
|
-
};
|
|
2025
|
-
};
|
|
2078
|
+
input: {};
|
|
2026
2079
|
};
|
|
2027
2080
|
};
|
|
2028
2081
|
} & {
|
|
2029
2082
|
"/v1/providers": {
|
|
2030
|
-
$
|
|
2083
|
+
$post: {
|
|
2031
2084
|
output: {
|
|
2032
|
-
|
|
2085
|
+
ok: boolean;
|
|
2086
|
+
code?: string | undefined;
|
|
2087
|
+
message?: string | undefined;
|
|
2088
|
+
provider?: {
|
|
2033
2089
|
id: string;
|
|
2034
2090
|
type: "alibaba-qwen" | "amazon-bedrock" | "anthropic" | "anthropic-messages" | "azure-openai" | "chat-completions" | "chatgpt-codex-subscription" | "deepseek" | "glm-coding-plan" | "google-gemini" | "google-generative" | "google-vertex" | "minimax" | "minimax-coding-plan" | "mistral" | "moonshot" | "ollama" | "openai" | "opencode-go" | "opencode-zen" | "openrouter" | "responses" | "xai" | "xiaomi-mimo" | "zai";
|
|
2035
2091
|
metadata: {
|
|
@@ -2039,6 +2095,8 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2039
2095
|
documentationUrl?: string | undefined;
|
|
2040
2096
|
capabilities: {
|
|
2041
2097
|
modelDiscovery: boolean;
|
|
2098
|
+
voiceDiscovery: boolean;
|
|
2099
|
+
voicePreview: boolean;
|
|
2042
2100
|
connectivityTest: boolean;
|
|
2043
2101
|
customModels: boolean;
|
|
2044
2102
|
};
|
|
@@ -2060,16 +2118,18 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2060
2118
|
remediation?: string | undefined;
|
|
2061
2119
|
};
|
|
2062
2120
|
};
|
|
2063
|
-
}
|
|
2121
|
+
} | undefined;
|
|
2064
2122
|
};
|
|
2065
2123
|
outputFormat: "json";
|
|
2066
|
-
status:
|
|
2067
|
-
input: {
|
|
2068
|
-
|
|
2069
|
-
|
|
2070
|
-
|
|
2071
|
-
|
|
2072
|
-
|
|
2124
|
+
status: 201;
|
|
2125
|
+
input: {
|
|
2126
|
+
json: {
|
|
2127
|
+
id: string;
|
|
2128
|
+
type: "alibaba-qwen" | "amazon-bedrock" | "anthropic" | "anthropic-messages" | "azure-openai" | "chat-completions" | "chatgpt-codex-subscription" | "deepseek" | "glm-coding-plan" | "google-gemini" | "google-generative" | "google-vertex" | "minimax" | "minimax-coding-plan" | "mistral" | "moonshot" | "ollama" | "openai" | "opencode-go" | "opencode-zen" | "openrouter" | "responses" | "xai" | "xiaomi-mimo" | "zai";
|
|
2129
|
+
settings: Record<string, unknown>;
|
|
2130
|
+
};
|
|
2131
|
+
};
|
|
2132
|
+
} | {
|
|
2073
2133
|
output: {
|
|
2074
2134
|
error: string;
|
|
2075
2135
|
code: string;
|
|
@@ -2114,7 +2174,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2114
2174
|
settings: Record<string, unknown>;
|
|
2115
2175
|
};
|
|
2116
2176
|
};
|
|
2117
|
-
}
|
|
2177
|
+
};
|
|
2178
|
+
};
|
|
2179
|
+
} & {
|
|
2180
|
+
"/v1/providers/:id": {
|
|
2181
|
+
$patch: {
|
|
2118
2182
|
output: {
|
|
2119
2183
|
ok: boolean;
|
|
2120
2184
|
code?: string | undefined;
|
|
@@ -2129,6 +2193,8 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2129
2193
|
documentationUrl?: string | undefined;
|
|
2130
2194
|
capabilities: {
|
|
2131
2195
|
modelDiscovery: boolean;
|
|
2196
|
+
voiceDiscovery: boolean;
|
|
2197
|
+
voicePreview: boolean;
|
|
2132
2198
|
connectivityTest: boolean;
|
|
2133
2199
|
customModels: boolean;
|
|
2134
2200
|
};
|
|
@@ -2153,19 +2219,17 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2153
2219
|
} | undefined;
|
|
2154
2220
|
};
|
|
2155
2221
|
outputFormat: "json";
|
|
2156
|
-
status:
|
|
2222
|
+
status: 200;
|
|
2157
2223
|
input: {
|
|
2158
|
-
|
|
2224
|
+
param: {
|
|
2159
2225
|
id: string;
|
|
2160
|
-
|
|
2161
|
-
|
|
2226
|
+
};
|
|
2227
|
+
} & {
|
|
2228
|
+
json: {
|
|
2229
|
+
settings?: Record<string, unknown> | undefined;
|
|
2162
2230
|
};
|
|
2163
2231
|
};
|
|
2164
|
-
}
|
|
2165
|
-
};
|
|
2166
|
-
} & {
|
|
2167
|
-
"/v1/providers/:id": {
|
|
2168
|
-
$patch: {
|
|
2232
|
+
} | {
|
|
2169
2233
|
output: {
|
|
2170
2234
|
error: string;
|
|
2171
2235
|
code: string;
|
|
@@ -2216,7 +2280,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2216
2280
|
settings?: Record<string, unknown> | undefined;
|
|
2217
2281
|
};
|
|
2218
2282
|
};
|
|
2219
|
-
}
|
|
2283
|
+
};
|
|
2284
|
+
};
|
|
2285
|
+
} & {
|
|
2286
|
+
"/v1/providers/:id": {
|
|
2287
|
+
$delete: {
|
|
2220
2288
|
output: {
|
|
2221
2289
|
ok: boolean;
|
|
2222
2290
|
code?: string | undefined;
|
|
@@ -2231,6 +2299,8 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2231
2299
|
documentationUrl?: string | undefined;
|
|
2232
2300
|
capabilities: {
|
|
2233
2301
|
modelDiscovery: boolean;
|
|
2302
|
+
voiceDiscovery: boolean;
|
|
2303
|
+
voicePreview: boolean;
|
|
2234
2304
|
connectivityTest: boolean;
|
|
2235
2305
|
customModels: boolean;
|
|
2236
2306
|
};
|
|
@@ -2260,16 +2330,76 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2260
2330
|
param: {
|
|
2261
2331
|
id: string;
|
|
2262
2332
|
};
|
|
2263
|
-
}
|
|
2264
|
-
|
|
2265
|
-
|
|
2333
|
+
};
|
|
2334
|
+
} | {
|
|
2335
|
+
output: {
|
|
2336
|
+
error: string;
|
|
2337
|
+
code: string;
|
|
2338
|
+
remediation?: string | undefined;
|
|
2339
|
+
};
|
|
2340
|
+
outputFormat: "json";
|
|
2341
|
+
status: 400;
|
|
2342
|
+
input: {
|
|
2343
|
+
param: {
|
|
2344
|
+
id: string;
|
|
2345
|
+
};
|
|
2346
|
+
};
|
|
2347
|
+
} | {
|
|
2348
|
+
output: {
|
|
2349
|
+
error: string;
|
|
2350
|
+
code: string;
|
|
2351
|
+
remediation?: string | undefined;
|
|
2352
|
+
};
|
|
2353
|
+
outputFormat: "json";
|
|
2354
|
+
status: 404;
|
|
2355
|
+
input: {
|
|
2356
|
+
param: {
|
|
2357
|
+
id: string;
|
|
2358
|
+
};
|
|
2359
|
+
};
|
|
2360
|
+
} | {
|
|
2361
|
+
output: {
|
|
2362
|
+
error: string;
|
|
2363
|
+
code: string;
|
|
2364
|
+
remediation?: string | undefined;
|
|
2365
|
+
};
|
|
2366
|
+
outputFormat: "json";
|
|
2367
|
+
status: 409;
|
|
2368
|
+
input: {
|
|
2369
|
+
param: {
|
|
2370
|
+
id: string;
|
|
2371
|
+
};
|
|
2372
|
+
};
|
|
2373
|
+
} | {
|
|
2374
|
+
output: {
|
|
2375
|
+
error: string;
|
|
2376
|
+
code: string;
|
|
2377
|
+
remediation?: string | undefined;
|
|
2378
|
+
};
|
|
2379
|
+
outputFormat: "json";
|
|
2380
|
+
status: 500;
|
|
2381
|
+
input: {
|
|
2382
|
+
param: {
|
|
2383
|
+
id: string;
|
|
2266
2384
|
};
|
|
2267
2385
|
};
|
|
2268
2386
|
};
|
|
2269
2387
|
};
|
|
2270
2388
|
} & {
|
|
2271
|
-
"/v1/providers/:id": {
|
|
2272
|
-
$
|
|
2389
|
+
"/v1/providers/:id/test": {
|
|
2390
|
+
$post: {
|
|
2391
|
+
output: {
|
|
2392
|
+
latencyMs: number;
|
|
2393
|
+
target?: string | undefined;
|
|
2394
|
+
};
|
|
2395
|
+
outputFormat: "json";
|
|
2396
|
+
status: 200;
|
|
2397
|
+
input: {
|
|
2398
|
+
param: {
|
|
2399
|
+
id: string;
|
|
2400
|
+
};
|
|
2401
|
+
};
|
|
2402
|
+
} | {
|
|
2273
2403
|
output: {
|
|
2274
2404
|
error: string;
|
|
2275
2405
|
code: string;
|
|
@@ -2302,12 +2432,100 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2302
2432
|
remediation?: string | undefined;
|
|
2303
2433
|
};
|
|
2304
2434
|
outputFormat: "json";
|
|
2305
|
-
status:
|
|
2435
|
+
status: 500;
|
|
2306
2436
|
input: {
|
|
2307
2437
|
param: {
|
|
2308
2438
|
id: string;
|
|
2309
2439
|
};
|
|
2310
2440
|
};
|
|
2441
|
+
};
|
|
2442
|
+
};
|
|
2443
|
+
} & {
|
|
2444
|
+
"/v1/providers/:id/models": {
|
|
2445
|
+
$get: {
|
|
2446
|
+
output: {
|
|
2447
|
+
models: {
|
|
2448
|
+
modelId: string;
|
|
2449
|
+
kind?: "embedding" | "image-generation" | "language" | "moderation" | "reranking" | "speech-to-speech" | "speech-to-text" | "text-to-speech" | "unknown" | undefined;
|
|
2450
|
+
displayName?: string | undefined;
|
|
2451
|
+
contextSize?: number | undefined;
|
|
2452
|
+
capabilities?: {
|
|
2453
|
+
input?: {
|
|
2454
|
+
image?: {
|
|
2455
|
+
mediaTypes?: string[] | undefined;
|
|
2456
|
+
maxBytes?: number | undefined;
|
|
2457
|
+
maxWidth?: number | undefined;
|
|
2458
|
+
maxHeight?: number | undefined;
|
|
2459
|
+
maxTotalPixels?: number | undefined;
|
|
2460
|
+
} | undefined;
|
|
2461
|
+
audio?: {
|
|
2462
|
+
mediaTypes?: string[] | undefined;
|
|
2463
|
+
maxBytes?: number | undefined;
|
|
2464
|
+
maxLengthSeconds?: number | undefined;
|
|
2465
|
+
} | undefined;
|
|
2466
|
+
} | undefined;
|
|
2467
|
+
voice?: {
|
|
2468
|
+
sts?: boolean | undefined;
|
|
2469
|
+
tts?: boolean | undefined;
|
|
2470
|
+
stt?: boolean | undefined;
|
|
2471
|
+
} | undefined;
|
|
2472
|
+
tools?: boolean | undefined;
|
|
2473
|
+
reasoning?: boolean | undefined;
|
|
2474
|
+
} | undefined;
|
|
2475
|
+
createdAt?: string | undefined;
|
|
2476
|
+
source: "discovered" | "manual" | "merged";
|
|
2477
|
+
provenance?: {
|
|
2478
|
+
source: "discovered" | "provider-exact" | "provider-family" | "shared-catalog" | "user";
|
|
2479
|
+
documentationUrl?: string | undefined;
|
|
2480
|
+
reviewedAt?: string | undefined;
|
|
2481
|
+
}[] | undefined;
|
|
2482
|
+
}[];
|
|
2483
|
+
};
|
|
2484
|
+
outputFormat: "json";
|
|
2485
|
+
status: 200;
|
|
2486
|
+
input: {
|
|
2487
|
+
param: {
|
|
2488
|
+
id: string;
|
|
2489
|
+
};
|
|
2490
|
+
} & {
|
|
2491
|
+
query: {
|
|
2492
|
+
refresh?: "false" | "true" | undefined;
|
|
2493
|
+
};
|
|
2494
|
+
};
|
|
2495
|
+
} | {
|
|
2496
|
+
output: {
|
|
2497
|
+
error: string;
|
|
2498
|
+
code: string;
|
|
2499
|
+
remediation?: string | undefined;
|
|
2500
|
+
};
|
|
2501
|
+
outputFormat: "json";
|
|
2502
|
+
status: 400;
|
|
2503
|
+
input: {
|
|
2504
|
+
param: {
|
|
2505
|
+
id: string;
|
|
2506
|
+
};
|
|
2507
|
+
} & {
|
|
2508
|
+
query: {
|
|
2509
|
+
refresh?: "false" | "true" | undefined;
|
|
2510
|
+
};
|
|
2511
|
+
};
|
|
2512
|
+
} | {
|
|
2513
|
+
output: {
|
|
2514
|
+
error: string;
|
|
2515
|
+
code: string;
|
|
2516
|
+
remediation?: string | undefined;
|
|
2517
|
+
};
|
|
2518
|
+
outputFormat: "json";
|
|
2519
|
+
status: 404;
|
|
2520
|
+
input: {
|
|
2521
|
+
param: {
|
|
2522
|
+
id: string;
|
|
2523
|
+
};
|
|
2524
|
+
} & {
|
|
2525
|
+
query: {
|
|
2526
|
+
refresh?: "false" | "true" | undefined;
|
|
2527
|
+
};
|
|
2528
|
+
};
|
|
2311
2529
|
} | {
|
|
2312
2530
|
output: {
|
|
2313
2531
|
error: string;
|
|
@@ -2320,68 +2538,109 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2320
2538
|
param: {
|
|
2321
2539
|
id: string;
|
|
2322
2540
|
};
|
|
2541
|
+
} & {
|
|
2542
|
+
query: {
|
|
2543
|
+
refresh?: "false" | "true" | undefined;
|
|
2544
|
+
};
|
|
2545
|
+
};
|
|
2546
|
+
};
|
|
2547
|
+
};
|
|
2548
|
+
} & {
|
|
2549
|
+
"/v1/providers/:id/voices": {
|
|
2550
|
+
$get: {
|
|
2551
|
+
output: {
|
|
2552
|
+
defaultVoiceId?: string | undefined;
|
|
2553
|
+
stale?: boolean | undefined;
|
|
2554
|
+
voices: {
|
|
2555
|
+
voiceId: string;
|
|
2556
|
+
displayName: string;
|
|
2557
|
+
description?: string | undefined;
|
|
2558
|
+
isPreviewAvailable: boolean;
|
|
2559
|
+
}[];
|
|
2560
|
+
};
|
|
2561
|
+
outputFormat: "json";
|
|
2562
|
+
status: 200;
|
|
2563
|
+
input: {
|
|
2564
|
+
param: {
|
|
2565
|
+
id: string;
|
|
2566
|
+
};
|
|
2567
|
+
} & {
|
|
2568
|
+
query: {
|
|
2569
|
+
modelId: string;
|
|
2570
|
+
refresh?: "false" | "true" | undefined;
|
|
2571
|
+
};
|
|
2323
2572
|
};
|
|
2324
2573
|
} | {
|
|
2325
2574
|
output: {
|
|
2326
|
-
|
|
2327
|
-
code
|
|
2328
|
-
|
|
2329
|
-
|
|
2575
|
+
error: string;
|
|
2576
|
+
code: string;
|
|
2577
|
+
remediation?: string | undefined;
|
|
2578
|
+
};
|
|
2579
|
+
outputFormat: "json";
|
|
2580
|
+
status: 400;
|
|
2581
|
+
input: {
|
|
2582
|
+
param: {
|
|
2330
2583
|
id: string;
|
|
2331
|
-
|
|
2332
|
-
|
|
2333
|
-
|
|
2334
|
-
|
|
2335
|
-
|
|
2336
|
-
|
|
2337
|
-
|
|
2338
|
-
|
|
2339
|
-
|
|
2340
|
-
|
|
2341
|
-
|
|
2342
|
-
|
|
2343
|
-
|
|
2344
|
-
|
|
2345
|
-
|
|
2346
|
-
|
|
2347
|
-
|
|
2348
|
-
|
|
2349
|
-
|
|
2350
|
-
|
|
2351
|
-
|
|
2352
|
-
|
|
2353
|
-
|
|
2354
|
-
|
|
2355
|
-
|
|
2356
|
-
|
|
2357
|
-
|
|
2358
|
-
|
|
2359
|
-
|
|
2360
|
-
|
|
2584
|
+
};
|
|
2585
|
+
} & {
|
|
2586
|
+
query: {
|
|
2587
|
+
modelId: string;
|
|
2588
|
+
refresh?: "false" | "true" | undefined;
|
|
2589
|
+
};
|
|
2590
|
+
};
|
|
2591
|
+
} | {
|
|
2592
|
+
output: {
|
|
2593
|
+
error: string;
|
|
2594
|
+
code: string;
|
|
2595
|
+
remediation?: string | undefined;
|
|
2596
|
+
};
|
|
2597
|
+
outputFormat: "json";
|
|
2598
|
+
status: 404;
|
|
2599
|
+
input: {
|
|
2600
|
+
param: {
|
|
2601
|
+
id: string;
|
|
2602
|
+
};
|
|
2603
|
+
} & {
|
|
2604
|
+
query: {
|
|
2605
|
+
modelId: string;
|
|
2606
|
+
refresh?: "false" | "true" | undefined;
|
|
2607
|
+
};
|
|
2608
|
+
};
|
|
2609
|
+
} | {
|
|
2610
|
+
output: {
|
|
2611
|
+
error: string;
|
|
2612
|
+
code: string;
|
|
2613
|
+
remediation?: string | undefined;
|
|
2361
2614
|
};
|
|
2362
2615
|
outputFormat: "json";
|
|
2363
|
-
status:
|
|
2616
|
+
status: 429;
|
|
2364
2617
|
input: {
|
|
2365
2618
|
param: {
|
|
2366
2619
|
id: string;
|
|
2367
2620
|
};
|
|
2621
|
+
} & {
|
|
2622
|
+
query: {
|
|
2623
|
+
modelId: string;
|
|
2624
|
+
refresh?: "false" | "true" | undefined;
|
|
2625
|
+
};
|
|
2368
2626
|
};
|
|
2369
|
-
}
|
|
2370
|
-
};
|
|
2371
|
-
} & {
|
|
2372
|
-
"/v1/providers/:id/test": {
|
|
2373
|
-
$post: {
|
|
2627
|
+
} | {
|
|
2374
2628
|
output: {
|
|
2375
2629
|
error: string;
|
|
2376
2630
|
code: string;
|
|
2377
2631
|
remediation?: string | undefined;
|
|
2378
2632
|
};
|
|
2379
2633
|
outputFormat: "json";
|
|
2380
|
-
status:
|
|
2634
|
+
status: 500;
|
|
2381
2635
|
input: {
|
|
2382
2636
|
param: {
|
|
2383
2637
|
id: string;
|
|
2384
2638
|
};
|
|
2639
|
+
} & {
|
|
2640
|
+
query: {
|
|
2641
|
+
modelId: string;
|
|
2642
|
+
refresh?: "false" | "true" | undefined;
|
|
2643
|
+
};
|
|
2385
2644
|
};
|
|
2386
2645
|
} | {
|
|
2387
2646
|
output: {
|
|
@@ -2390,56 +2649,73 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2390
2649
|
remediation?: string | undefined;
|
|
2391
2650
|
};
|
|
2392
2651
|
outputFormat: "json";
|
|
2393
|
-
status:
|
|
2652
|
+
status: 502;
|
|
2394
2653
|
input: {
|
|
2395
2654
|
param: {
|
|
2396
2655
|
id: string;
|
|
2397
2656
|
};
|
|
2657
|
+
} & {
|
|
2658
|
+
query: {
|
|
2659
|
+
modelId: string;
|
|
2660
|
+
refresh?: "false" | "true" | undefined;
|
|
2661
|
+
};
|
|
2398
2662
|
};
|
|
2399
|
-
}
|
|
2663
|
+
};
|
|
2664
|
+
};
|
|
2665
|
+
} & {
|
|
2666
|
+
"/v1/providers/:id/voices/preview": {
|
|
2667
|
+
$post: {
|
|
2400
2668
|
output: {
|
|
2401
2669
|
error: string;
|
|
2402
2670
|
code: string;
|
|
2403
2671
|
remediation?: string | undefined;
|
|
2404
2672
|
};
|
|
2405
2673
|
outputFormat: "json";
|
|
2406
|
-
status:
|
|
2674
|
+
status: 400;
|
|
2407
2675
|
input: {
|
|
2408
2676
|
param: {
|
|
2409
2677
|
id: string;
|
|
2410
2678
|
};
|
|
2679
|
+
} & {
|
|
2680
|
+
json: {
|
|
2681
|
+
modelId: string;
|
|
2682
|
+
voiceId: string;
|
|
2683
|
+
};
|
|
2411
2684
|
};
|
|
2412
2685
|
} | {
|
|
2413
2686
|
output: {
|
|
2414
|
-
|
|
2415
|
-
|
|
2687
|
+
error: string;
|
|
2688
|
+
code: string;
|
|
2689
|
+
remediation?: string | undefined;
|
|
2416
2690
|
};
|
|
2417
2691
|
outputFormat: "json";
|
|
2418
|
-
status:
|
|
2692
|
+
status: 404;
|
|
2419
2693
|
input: {
|
|
2420
2694
|
param: {
|
|
2421
2695
|
id: string;
|
|
2422
2696
|
};
|
|
2697
|
+
} & {
|
|
2698
|
+
json: {
|
|
2699
|
+
modelId: string;
|
|
2700
|
+
voiceId: string;
|
|
2701
|
+
};
|
|
2423
2702
|
};
|
|
2424
|
-
}
|
|
2425
|
-
};
|
|
2426
|
-
} & {
|
|
2427
|
-
"/v1/providers/:id/models": {
|
|
2428
|
-
$get: {
|
|
2703
|
+
} | {
|
|
2429
2704
|
output: {
|
|
2430
2705
|
error: string;
|
|
2431
2706
|
code: string;
|
|
2432
2707
|
remediation?: string | undefined;
|
|
2433
2708
|
};
|
|
2434
2709
|
outputFormat: "json";
|
|
2435
|
-
status:
|
|
2710
|
+
status: 429;
|
|
2436
2711
|
input: {
|
|
2437
2712
|
param: {
|
|
2438
2713
|
id: string;
|
|
2439
2714
|
};
|
|
2440
2715
|
} & {
|
|
2441
|
-
|
|
2442
|
-
|
|
2716
|
+
json: {
|
|
2717
|
+
modelId: string;
|
|
2718
|
+
voiceId: string;
|
|
2443
2719
|
};
|
|
2444
2720
|
};
|
|
2445
2721
|
} | {
|
|
@@ -2449,14 +2725,15 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2449
2725
|
remediation?: string | undefined;
|
|
2450
2726
|
};
|
|
2451
2727
|
outputFormat: "json";
|
|
2452
|
-
status:
|
|
2728
|
+
status: 500;
|
|
2453
2729
|
input: {
|
|
2454
2730
|
param: {
|
|
2455
2731
|
id: string;
|
|
2456
2732
|
};
|
|
2457
2733
|
} & {
|
|
2458
|
-
|
|
2459
|
-
|
|
2734
|
+
json: {
|
|
2735
|
+
modelId: string;
|
|
2736
|
+
voiceId: string;
|
|
2460
2737
|
};
|
|
2461
2738
|
};
|
|
2462
2739
|
} | {
|
|
@@ -2466,17 +2743,36 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2466
2743
|
remediation?: string | undefined;
|
|
2467
2744
|
};
|
|
2468
2745
|
outputFormat: "json";
|
|
2469
|
-
status:
|
|
2746
|
+
status: 502;
|
|
2470
2747
|
input: {
|
|
2471
2748
|
param: {
|
|
2472
2749
|
id: string;
|
|
2473
2750
|
};
|
|
2474
2751
|
} & {
|
|
2475
|
-
|
|
2476
|
-
|
|
2752
|
+
json: {
|
|
2753
|
+
modelId: string;
|
|
2754
|
+
voiceId: string;
|
|
2477
2755
|
};
|
|
2478
2756
|
};
|
|
2479
2757
|
} | {
|
|
2758
|
+
output: Response;
|
|
2759
|
+
outputFormat: "json";
|
|
2760
|
+
status: import("hono/utils/http-status").StatusCode;
|
|
2761
|
+
input: {
|
|
2762
|
+
param: {
|
|
2763
|
+
id: string;
|
|
2764
|
+
};
|
|
2765
|
+
} & {
|
|
2766
|
+
json: {
|
|
2767
|
+
modelId: string;
|
|
2768
|
+
voiceId: string;
|
|
2769
|
+
};
|
|
2770
|
+
};
|
|
2771
|
+
};
|
|
2772
|
+
};
|
|
2773
|
+
} & {
|
|
2774
|
+
"/v1/providers/:id/models": {
|
|
2775
|
+
$post: {
|
|
2480
2776
|
output: {
|
|
2481
2777
|
models: {
|
|
2482
2778
|
modelId: string;
|
|
@@ -2522,15 +2818,37 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2522
2818
|
id: string;
|
|
2523
2819
|
};
|
|
2524
2820
|
} & {
|
|
2525
|
-
|
|
2526
|
-
|
|
2821
|
+
json: {
|
|
2822
|
+
modelId: string;
|
|
2823
|
+
kind?: "embedding" | "image-generation" | "language" | "moderation" | "reranking" | "speech-to-speech" | "speech-to-text" | "text-to-speech" | "unknown" | undefined;
|
|
2824
|
+
displayName?: string | undefined;
|
|
2825
|
+
contextSize?: number | undefined;
|
|
2826
|
+
capabilities?: {
|
|
2827
|
+
input?: {
|
|
2828
|
+
image?: {
|
|
2829
|
+
mediaTypes?: string[] | undefined;
|
|
2830
|
+
maxBytes?: number | undefined;
|
|
2831
|
+
maxWidth?: number | undefined;
|
|
2832
|
+
maxHeight?: number | undefined;
|
|
2833
|
+
maxTotalPixels?: number | undefined;
|
|
2834
|
+
} | undefined;
|
|
2835
|
+
audio?: {
|
|
2836
|
+
mediaTypes?: string[] | undefined;
|
|
2837
|
+
maxBytes?: number | undefined;
|
|
2838
|
+
maxLengthSeconds?: number | undefined;
|
|
2839
|
+
} | undefined;
|
|
2840
|
+
} | undefined;
|
|
2841
|
+
voice?: {
|
|
2842
|
+
sts?: boolean | undefined;
|
|
2843
|
+
tts?: boolean | undefined;
|
|
2844
|
+
stt?: boolean | undefined;
|
|
2845
|
+
} | undefined;
|
|
2846
|
+
tools?: boolean | undefined;
|
|
2847
|
+
reasoning?: boolean | undefined;
|
|
2848
|
+
} | undefined;
|
|
2527
2849
|
};
|
|
2528
2850
|
};
|
|
2529
|
-
}
|
|
2530
|
-
};
|
|
2531
|
-
} & {
|
|
2532
|
-
"/v1/providers/:id/models": {
|
|
2533
|
-
$post: {
|
|
2851
|
+
} | {
|
|
2534
2852
|
output: {
|
|
2535
2853
|
error: string;
|
|
2536
2854
|
code: string;
|
|
@@ -2702,7 +3020,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2702
3020
|
} | undefined;
|
|
2703
3021
|
};
|
|
2704
3022
|
};
|
|
2705
|
-
}
|
|
3023
|
+
};
|
|
3024
|
+
};
|
|
3025
|
+
} & {
|
|
3026
|
+
"/v1/providers/:id/models/:modelId": {
|
|
3027
|
+
$patch: {
|
|
2706
3028
|
output: {
|
|
2707
3029
|
models: {
|
|
2708
3030
|
modelId: string;
|
|
@@ -2746,10 +3068,10 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2746
3068
|
input: {
|
|
2747
3069
|
param: {
|
|
2748
3070
|
id: string;
|
|
3071
|
+
modelId: string;
|
|
2749
3072
|
};
|
|
2750
3073
|
} & {
|
|
2751
3074
|
json: {
|
|
2752
|
-
modelId: string;
|
|
2753
3075
|
kind?: "embedding" | "image-generation" | "language" | "moderation" | "reranking" | "speech-to-speech" | "speech-to-text" | "text-to-speech" | "unknown" | undefined;
|
|
2754
3076
|
displayName?: string | undefined;
|
|
2755
3077
|
contextSize?: number | undefined;
|
|
@@ -2778,11 +3100,7 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2778
3100
|
} | undefined;
|
|
2779
3101
|
};
|
|
2780
3102
|
};
|
|
2781
|
-
}
|
|
2782
|
-
};
|
|
2783
|
-
} & {
|
|
2784
|
-
"/v1/providers/:id/models/:modelId": {
|
|
2785
|
-
$patch: {
|
|
3103
|
+
} | {
|
|
2786
3104
|
output: {
|
|
2787
3105
|
error: string;
|
|
2788
3106
|
code: string;
|
|
@@ -2911,7 +3229,11 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2911
3229
|
} | undefined;
|
|
2912
3230
|
};
|
|
2913
3231
|
};
|
|
2914
|
-
}
|
|
3232
|
+
};
|
|
3233
|
+
};
|
|
3234
|
+
} & {
|
|
3235
|
+
"/v1/providers/:id/models/:modelId": {
|
|
3236
|
+
$delete: {
|
|
2915
3237
|
output: {
|
|
2916
3238
|
models: {
|
|
2917
3239
|
modelId: string;
|
|
@@ -2957,41 +3279,8 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
2957
3279
|
id: string;
|
|
2958
3280
|
modelId: string;
|
|
2959
3281
|
};
|
|
2960
|
-
} & {
|
|
2961
|
-
json: {
|
|
2962
|
-
kind?: "embedding" | "image-generation" | "language" | "moderation" | "reranking" | "speech-to-speech" | "speech-to-text" | "text-to-speech" | "unknown" | undefined;
|
|
2963
|
-
displayName?: string | undefined;
|
|
2964
|
-
contextSize?: number | undefined;
|
|
2965
|
-
capabilities?: {
|
|
2966
|
-
input?: {
|
|
2967
|
-
image?: {
|
|
2968
|
-
mediaTypes?: string[] | undefined;
|
|
2969
|
-
maxBytes?: number | undefined;
|
|
2970
|
-
maxWidth?: number | undefined;
|
|
2971
|
-
maxHeight?: number | undefined;
|
|
2972
|
-
maxTotalPixels?: number | undefined;
|
|
2973
|
-
} | undefined;
|
|
2974
|
-
audio?: {
|
|
2975
|
-
mediaTypes?: string[] | undefined;
|
|
2976
|
-
maxBytes?: number | undefined;
|
|
2977
|
-
maxLengthSeconds?: number | undefined;
|
|
2978
|
-
} | undefined;
|
|
2979
|
-
} | undefined;
|
|
2980
|
-
voice?: {
|
|
2981
|
-
sts?: boolean | undefined;
|
|
2982
|
-
tts?: boolean | undefined;
|
|
2983
|
-
stt?: boolean | undefined;
|
|
2984
|
-
} | undefined;
|
|
2985
|
-
tools?: boolean | undefined;
|
|
2986
|
-
reasoning?: boolean | undefined;
|
|
2987
|
-
} | undefined;
|
|
2988
|
-
};
|
|
2989
3282
|
};
|
|
2990
|
-
}
|
|
2991
|
-
};
|
|
2992
|
-
} & {
|
|
2993
|
-
"/v1/providers/:id/models/:modelId": {
|
|
2994
|
-
$delete: {
|
|
3283
|
+
} | {
|
|
2995
3284
|
output: {
|
|
2996
3285
|
error: string;
|
|
2997
3286
|
code: string;
|
|
@@ -3047,58 +3336,30 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
3047
3336
|
modelId: string;
|
|
3048
3337
|
};
|
|
3049
3338
|
};
|
|
3050
|
-
}
|
|
3339
|
+
};
|
|
3340
|
+
};
|
|
3341
|
+
} & {
|
|
3342
|
+
"/v1/introspect/:path": {
|
|
3343
|
+
$get: {
|
|
3051
3344
|
output: {
|
|
3052
|
-
|
|
3053
|
-
|
|
3054
|
-
|
|
3055
|
-
|
|
3056
|
-
|
|
3057
|
-
|
|
3058
|
-
|
|
3059
|
-
|
|
3060
|
-
mediaTypes?: string[] | undefined;
|
|
3061
|
-
maxBytes?: number | undefined;
|
|
3062
|
-
maxWidth?: number | undefined;
|
|
3063
|
-
maxHeight?: number | undefined;
|
|
3064
|
-
maxTotalPixels?: number | undefined;
|
|
3065
|
-
} | undefined;
|
|
3066
|
-
audio?: {
|
|
3067
|
-
mediaTypes?: string[] | undefined;
|
|
3068
|
-
maxBytes?: number | undefined;
|
|
3069
|
-
maxLengthSeconds?: number | undefined;
|
|
3070
|
-
} | undefined;
|
|
3071
|
-
} | undefined;
|
|
3072
|
-
voice?: {
|
|
3073
|
-
sts?: boolean | undefined;
|
|
3074
|
-
tts?: boolean | undefined;
|
|
3075
|
-
stt?: boolean | undefined;
|
|
3076
|
-
} | undefined;
|
|
3077
|
-
tools?: boolean | undefined;
|
|
3078
|
-
reasoning?: boolean | undefined;
|
|
3079
|
-
} | undefined;
|
|
3080
|
-
createdAt?: string | undefined;
|
|
3081
|
-
source: "discovered" | "manual" | "merged";
|
|
3082
|
-
provenance?: {
|
|
3083
|
-
source: "discovered" | "provider-exact" | "provider-family" | "shared-catalog" | "user";
|
|
3084
|
-
documentationUrl?: string | undefined;
|
|
3085
|
-
reviewedAt?: string | undefined;
|
|
3086
|
-
}[] | undefined;
|
|
3345
|
+
path: string[];
|
|
3346
|
+
state: {
|
|
3347
|
+
[x: string]: import("hono/utils/types").JSONValue;
|
|
3348
|
+
} | null;
|
|
3349
|
+
children: {
|
|
3350
|
+
id: string;
|
|
3351
|
+
hasState: boolean;
|
|
3352
|
+
hasChildren: boolean;
|
|
3087
3353
|
}[];
|
|
3088
3354
|
};
|
|
3089
3355
|
outputFormat: "json";
|
|
3090
3356
|
status: 200;
|
|
3091
3357
|
input: {
|
|
3092
3358
|
param: {
|
|
3093
|
-
|
|
3094
|
-
modelId: string;
|
|
3359
|
+
path: string;
|
|
3095
3360
|
};
|
|
3096
3361
|
};
|
|
3097
|
-
}
|
|
3098
|
-
};
|
|
3099
|
-
} & {
|
|
3100
|
-
"/v1/introspect/:path": {
|
|
3101
|
-
$get: {
|
|
3362
|
+
} | {
|
|
3102
3363
|
output: {
|
|
3103
3364
|
error: string;
|
|
3104
3365
|
code: string;
|
|
@@ -3137,25 +3398,6 @@ export type AdminApi = import("hono/hono-base").HonoBase<any, {
|
|
|
3137
3398
|
path: string;
|
|
3138
3399
|
};
|
|
3139
3400
|
};
|
|
3140
|
-
} | {
|
|
3141
|
-
output: {
|
|
3142
|
-
path: string[];
|
|
3143
|
-
state: {
|
|
3144
|
-
[x: string]: import("hono/utils/types").JSONValue;
|
|
3145
|
-
} | null;
|
|
3146
|
-
children: {
|
|
3147
|
-
id: string;
|
|
3148
|
-
hasState: boolean;
|
|
3149
|
-
hasChildren: boolean;
|
|
3150
|
-
}[];
|
|
3151
|
-
};
|
|
3152
|
-
outputFormat: "json";
|
|
3153
|
-
status: 200;
|
|
3154
|
-
input: {
|
|
3155
|
-
param: {
|
|
3156
|
-
path: string;
|
|
3157
|
-
};
|
|
3158
|
-
};
|
|
3159
3401
|
};
|
|
3160
3402
|
};
|
|
3161
3403
|
}, "/", "/v1/introspect/:path">;
|