@bodhiapp/ts-client 0.1.26 → 0.1.28

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.
Files changed (33) hide show
  1. package/dist/anthropic.d.ts +1 -0
  2. package/dist/anthropic.js +20 -0
  3. package/dist/anthropic.mjs +2 -0
  4. package/dist/gemini.d.ts +1 -0
  5. package/dist/gemini.js +20 -0
  6. package/dist/gemini.mjs +2 -0
  7. package/dist/index.d.ts +3 -0
  8. package/dist/openai.d.ts +1 -0
  9. package/dist/openai.js +20 -0
  10. package/dist/openai.mjs +2 -0
  11. package/dist/openapi-typescript/openapi-schema-anthropic.d.ts +3391 -0
  12. package/dist/openapi-typescript/openapi-schema-anthropic.ts +3392 -0
  13. package/dist/openapi-typescript/openapi-schema-gemini.d.ts +3708 -0
  14. package/dist/openapi-typescript/openapi-schema-gemini.ts +3709 -0
  15. package/dist/openapi-typescript/openapi-schema-oai.d.ts +4371 -0
  16. package/dist/openapi-typescript/openapi-schema-oai.ts +4372 -0
  17. package/dist/openapi-typescript/openapi-schema.d.ts +1453 -3111
  18. package/dist/openapi-typescript/openapi-schema.ts +1453 -3111
  19. package/dist/types/types.gen.d.ts +477 -1731
  20. package/dist/types/types.gen.ts +516 -1903
  21. package/dist/types-anthropic/index.d.ts +1 -0
  22. package/dist/types-anthropic/index.ts +2 -0
  23. package/dist/types-anthropic/types.gen.d.ts +2241 -0
  24. package/dist/types-anthropic/types.gen.ts +2416 -0
  25. package/dist/types-gemini/index.d.ts +1 -0
  26. package/dist/types-gemini/index.ts +2 -0
  27. package/dist/types-gemini/types.gen.d.ts +4622 -0
  28. package/dist/types-gemini/types.gen.ts +4849 -0
  29. package/dist/types-oai/index.d.ts +1 -0
  30. package/dist/types-oai/index.ts +2 -0
  31. package/dist/types-oai/types.gen.d.ts +4428 -0
  32. package/dist/types-oai/types.gen.ts +4810 -0
  33. package/package.json +39 -7
@@ -85,15 +85,53 @@ export type Alias = (UserAlias & {
85
85
  * Uses untagged serialization - each variant has its own "source" field
86
86
  */
87
87
  export type AliasResponse = UserAliasResponse | ModelAliasResponse | ApiAliasResponse;
88
+ /**
89
+ * Mirrors Anthropic's `ModelInfo` schema — full model metadata returned by
90
+ * `GET /anthropic/v1/models` and stored alongside model IDs in `ApiAlias.models`.
91
+ *
92
+ * **IMPORTANT**: Do NOT add `#[serde(skip_serializing_if = "Option::is_none")]` on the
93
+ * `Option` fields below. The Anthropic API spec marks `capabilities`, `max_input_tokens`,
94
+ * and `max_tokens` as **required** (nullable via `anyOf [T, null]`). They must serialize
95
+ * as `null` when absent, not be omitted from the JSON output.
96
+ */
97
+ export type AnthropicModel = {
98
+ id: string;
99
+ display_name: string;
100
+ /**
101
+ * RFC 3339 datetime string representing the model's release date.
102
+ */
103
+ created_at: string;
104
+ capabilities?: null | AnthropicModelCapabilities;
105
+ max_input_tokens?: number | null;
106
+ max_tokens?: number | null;
107
+ /**
108
+ * Always `"model"` — included for Anthropic API compatibility.
109
+ */
110
+ type: string;
111
+ };
112
+ /**
113
+ * Model capability information (Anthropic ModelCapabilities schema).
114
+ */
115
+ export type AnthropicModelCapabilities = {
116
+ batch: CapabilitySupport;
117
+ citations: CapabilitySupport;
118
+ code_execution: CapabilitySupport;
119
+ context_management: ContextManagementCapability;
120
+ effort: EffortCapability;
121
+ image_input: CapabilitySupport;
122
+ pdf_input: CapabilitySupport;
123
+ structured_outputs: CapabilitySupport;
124
+ thinking: ThinkingCapability;
125
+ };
88
126
  export type ApiAlias = {
89
127
  id: string;
90
128
  api_format: ApiFormat;
91
129
  base_url: string;
92
- models: JsonVec;
130
+ models: ApiModelVec;
93
131
  prefix?: string | null;
94
132
  forward_all_with_prefix: boolean;
95
- models_cache: JsonVec;
96
- cache_fetched_at: string;
133
+ extra_headers?: unknown;
134
+ extra_body?: unknown;
97
135
  created_at: string;
98
136
  updated_at: string;
99
137
  };
@@ -107,18 +145,20 @@ export type ApiAliasResponse = {
107
145
  base_url: string;
108
146
  has_api_key: boolean;
109
147
  /**
110
- * Models available through this alias (merged from cache for forward_all)
148
+ * Models available through this alias with full provider metadata
111
149
  */
112
- models: Array<string>;
150
+ models: Array<ApiModel>;
113
151
  prefix?: string | null;
114
152
  forward_all_with_prefix: boolean;
153
+ extra_headers?: unknown;
154
+ extra_body?: unknown;
115
155
  created_at: string;
116
156
  updated_at: string;
117
157
  };
118
158
  /**
119
159
  * API format/protocol specification
120
160
  */
121
- export type ApiFormat = 'openai' | 'placeholder';
161
+ export type ApiFormat = 'openai' | 'openai_responses' | 'anthropic' | 'anthropic_oauth' | 'gemini';
122
162
  /**
123
163
  * Response containing available API formats
124
164
  */
@@ -141,6 +181,17 @@ export type ApiKeyUpdate = {
141
181
  value: ApiKey;
142
182
  action: 'set';
143
183
  };
184
+ /**
185
+ * Discriminated union of provider-specific model metadata.
186
+ * Stored as JSON in `api_model_aliases.models`.
187
+ */
188
+ export type ApiModel = (Model & {
189
+ provider: 'openai';
190
+ }) | (AnthropicModel & {
191
+ provider: 'anthropic';
192
+ }) | (GeminiModel & {
193
+ provider: 'gemini';
194
+ });
144
195
  /**
145
196
  * Input request for creating or updating an API model configuration.
146
197
  */
@@ -169,7 +220,20 @@ export type ApiModelRequest = {
169
220
  * Whether to forward all requests with this prefix (true) or only selected models (false)
170
221
  */
171
222
  forward_all_with_prefix?: boolean;
223
+ /**
224
+ * Optional extra HTTP headers to send upstream. Cannot include `Authorization`
225
+ * or `x-api-key` — those are owned by provider clients.
226
+ */
227
+ extra_headers?: unknown;
228
+ /**
229
+ * Optional extra fields to merge into the request body sent upstream
230
+ */
231
+ extra_body?: unknown;
172
232
  };
233
+ /**
234
+ * DB-storable `Vec<ApiModel>` — stored as JSON binary in SeaORM columns.
235
+ */
236
+ export type ApiModelVec = Array<ApiModel>;
173
237
  export type AppAccessRequestStatus = 'draft' | 'approved' | 'denied' | 'failed' | 'expired';
174
238
  /**
175
239
  * Application information and status
@@ -263,473 +327,59 @@ export type AuthInitiateRequest = {
263
327
  */
264
328
  client_id: string;
265
329
  };
266
- /**
267
- * Change user role request
268
- */
269
- export type ChangeRoleRequest = {
270
- /**
271
- * Role to assign to the user
272
- */
273
- role: ResourceRole;
274
- };
275
- export type ChatChoice = {
276
- /**
277
- * The index of the choice in the list of choices.
278
- */
279
- index: number;
280
- message: ChatCompletionResponseMessage;
281
- finish_reason?: null | FinishReason;
282
- logprobs?: null | ChatChoiceLogprobs;
283
- };
284
- export type ChatChoiceLogprobs = {
285
- /**
286
- * A list of message content tokens with log probability information.
287
- */
288
- content?: Array<ChatCompletionTokenLogprob> | null;
289
- refusal?: Array<ChatCompletionTokenLogprob> | null;
290
- };
291
- export type ChatChoiceStream = {
292
- /**
293
- * The index of the choice in the list of choices.
294
- */
295
- index: number;
296
- delta: ChatCompletionStreamResponseDelta;
297
- finish_reason?: null | FinishReason;
298
- logprobs?: null | ChatChoiceLogprobs;
299
- };
300
- export type ChatCompletionAllowedTools = {
301
- /**
302
- * Constrains the tools available to the model to a pre-defined set.
303
- *
304
- * `auto` allows the model to pick from among the allowed tools and generate a
305
- * message.
306
- *
307
- * `required` requires the model to call one or more of the allowed tools.
308
- */
309
- mode: ToolChoiceAllowedMode;
310
- /**
311
- * A list of tool definitions that the model should be allowed to call.
312
- *
313
- * For the Chat Completions API, the list of tool definitions might look like:
314
- * ```json
315
- * [
316
- * { "type": "function", "function": { "name": "get_weather" } },
317
- * { "type": "function", "function": { "name": "get_time" } }
318
- * ]
319
- * ```
320
- */
321
- tools: Array<unknown>;
322
- };
323
- export type ChatCompletionAllowedToolsChoice = {
324
- allowed_tools: Array<ChatCompletionAllowedTools>;
325
- };
326
- export type ChatCompletionAudio = {
327
- /**
328
- * The voice the model uses to respond. Supported built-in voices are `alloy`, `ash`,
329
- * `ballad`, `coral`, `echo`, `fable`, `nova`, `onyx`, `sage`, `shimmer`, `marin`, and `cedar`.
330
- */
331
- voice: ChatCompletionAudioVoice;
332
- /**
333
- * Specifies the output audio format. Must be one of `wav`, `aac`, `mp3`, `flac`, `opus`, or `pcm16`.
334
- */
335
- format: ChatCompletionAudioFormat;
336
- };
337
- export type ChatCompletionAudioFormat = 'wav' | 'aac' | 'mp3' | 'flac' | 'opus' | 'pcm16';
338
- export type ChatCompletionAudioVoice = 'alloy' | 'ash' | 'ballad' | 'coral' | 'echo' | 'fable' | 'nova' | 'onyx' | 'sage' | 'shimmer' | {
339
- other: string;
340
- };
341
- export type ChatCompletionFunctionCall = 'none' | 'auto' | {
342
- /**
343
- * Forces the model to call the specified function.
344
- */
345
- Function: {
346
- name: string;
347
- };
348
- };
349
- export type ChatCompletionFunctions = {
350
- /**
351
- * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
352
- */
353
- name: string;
354
- /**
355
- * A description of what the function does, used by the model to choose when and how to call the function.
356
- */
357
- description?: string | null;
358
- /**
359
- * The parameters the functions accepts, described as a JSON Schema object. See the [guide](https://platform.openai.com/docs/guides/text-generation/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
360
- *
361
- * Omitting `parameters` defines a function with an empty parameter list.
362
- */
363
- parameters: unknown;
364
- };
365
- export type ChatCompletionMessageCustomToolCall = {
366
- /**
367
- * The ID of the tool call.
368
- */
369
- id: string;
370
- /**
371
- * The custom tool that the model called.
372
- */
373
- custom_tool: CustomTool;
374
- };
375
- export type ChatCompletionMessageToolCall = {
376
- /**
377
- * The ID of the tool call.
378
- */
379
- id: string;
380
- /**
381
- * The function that the model called.
382
- */
383
- function: FunctionCall;
384
- };
385
- export type ChatCompletionMessageToolCallChunk = {
386
- index: number;
387
- /**
388
- * The ID of the tool call.
389
- */
390
- id?: string | null;
391
- type?: null | FunctionType;
392
- function?: null | FunctionCallStream;
393
- };
394
- export type ChatCompletionMessageToolCalls = (ChatCompletionMessageToolCall & {
395
- type: 'function';
396
- }) | (ChatCompletionMessageCustomToolCall & {
397
- type: 'custom';
398
- });
399
- /**
400
- * Specifies a tool the model should use. Use to force the model to call a specific function.
401
- */
402
- export type ChatCompletionNamedToolChoice = {
403
- function: FunctionName;
404
- };
405
- export type ChatCompletionNamedToolChoiceCustom = {
406
- custom: CustomName;
407
- };
408
- export type ChatCompletionRequestAssistantMessage = {
409
- content?: null | ChatCompletionRequestAssistantMessageContent;
410
- /**
411
- * The refusal message by the assistant.
412
- */
413
- refusal?: string | null;
414
- /**
415
- * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
416
- */
417
- name?: string | null;
418
- audio?: null | ChatCompletionRequestAssistantMessageAudio;
419
- tool_calls?: Array<ChatCompletionMessageToolCalls> | null;
420
- function_call?: null | FunctionCall;
421
- };
422
- export type ChatCompletionRequestAssistantMessageAudio = {
423
- /**
424
- * Unique identifier for a previous audio response from the model.
425
- */
426
- id: string;
427
- };
428
- export type ChatCompletionRequestAssistantMessageContent = string | Array<ChatCompletionRequestAssistantMessageContentPart>;
429
- export type ChatCompletionRequestAssistantMessageContentPart = (ChatCompletionRequestMessageContentPartText & {
430
- type: 'text';
431
- }) | (ChatCompletionRequestMessageContentPartRefusal & {
432
- type: 'refusal';
433
- });
434
- export type ChatCompletionRequestDeveloperMessage = {
435
- /**
436
- * The contents of the developer message.
437
- */
438
- content: ChatCompletionRequestDeveloperMessageContent;
439
- /**
440
- * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
441
- */
442
- name?: string | null;
443
- };
444
- export type ChatCompletionRequestDeveloperMessageContent = string | Array<ChatCompletionRequestDeveloperMessageContentPart>;
445
- export type ChatCompletionRequestDeveloperMessageContentPart = ChatCompletionRequestMessageContentPartText & {
446
- type: 'text';
447
- };
448
- export type ChatCompletionRequestFunctionMessage = {
449
- /**
450
- * The return value from the function call, to return to the model.
451
- */
452
- content?: string | null;
330
+ export type BodhiApiError = {
453
331
  /**
454
- * The name of the function to call.
455
- */
456
- name: string;
457
- };
458
- export type ChatCompletionRequestMessage = (ChatCompletionRequestDeveloperMessage & {
459
- role: 'developer';
460
- }) | (ChatCompletionRequestSystemMessage & {
461
- role: 'system';
462
- }) | (ChatCompletionRequestUserMessage & {
463
- role: 'user';
464
- }) | (ChatCompletionRequestAssistantMessage & {
465
- role: 'assistant';
466
- }) | (ChatCompletionRequestToolMessage & {
467
- role: 'tool';
468
- }) | (ChatCompletionRequestFunctionMessage & {
469
- role: 'function';
470
- });
471
- /**
472
- * Learn about [audio inputs](https://platform.openai.com/docs/guides/audio).
473
- */
474
- export type ChatCompletionRequestMessageContentPartAudio = {
475
- input_audio: InputAudio;
476
- };
477
- export type ChatCompletionRequestMessageContentPartFile = {
478
- file: FileObject;
479
- };
480
- export type ChatCompletionRequestMessageContentPartImage = {
481
- image_url: ImageUrl;
482
- };
483
- export type ChatCompletionRequestMessageContentPartRefusal = {
484
- /**
485
- * The refusal message generated by the model.
486
- */
487
- refusal: string;
488
- };
489
- export type ChatCompletionRequestMessageContentPartText = {
490
- text: string;
491
- };
492
- export type ChatCompletionRequestSystemMessage = {
493
- /**
494
- * The contents of the system message.
495
- */
496
- content: ChatCompletionRequestSystemMessageContent;
497
- /**
498
- * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
499
- */
500
- name?: string | null;
501
- };
502
- export type ChatCompletionRequestSystemMessageContent = string | Array<ChatCompletionRequestSystemMessageContentPart>;
503
- export type ChatCompletionRequestSystemMessageContentPart = ChatCompletionRequestMessageContentPartText & {
504
- type: 'text';
505
- };
506
- /**
507
- * Tool message
508
- */
509
- export type ChatCompletionRequestToolMessage = {
510
- /**
511
- * The contents of the tool message.
512
- */
513
- content: ChatCompletionRequestToolMessageContent;
514
- tool_call_id: string;
515
- };
516
- export type ChatCompletionRequestToolMessageContent = string | Array<ChatCompletionRequestToolMessageContentPart>;
517
- export type ChatCompletionRequestToolMessageContentPart = ChatCompletionRequestMessageContentPartText & {
518
- type: 'text';
519
- };
520
- export type ChatCompletionRequestUserMessage = {
521
- /**
522
- * The contents of the user message.
523
- */
524
- content: ChatCompletionRequestUserMessageContent;
525
- /**
526
- * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
527
- */
528
- name?: string | null;
529
- };
530
- export type ChatCompletionRequestUserMessageContent = string | Array<ChatCompletionRequestUserMessageContentPart>;
531
- export type ChatCompletionRequestUserMessageContentPart = (ChatCompletionRequestMessageContentPartText & {
532
- type: 'text';
533
- }) | (ChatCompletionRequestMessageContentPartImage & {
534
- type: 'image_url';
535
- }) | (ChatCompletionRequestMessageContentPartAudio & {
536
- type: 'input_audio';
537
- }) | (ChatCompletionRequestMessageContentPartFile & {
538
- type: 'file';
539
- });
540
- /**
541
- * A chat completion message generated by the model.
542
- */
543
- export type ChatCompletionResponseMessage = {
544
- /**
545
- * The contents of the message.
546
- */
547
- content?: string | null;
548
- /**
549
- * The refusal message generated by the model.
550
- */
551
- refusal?: string | null;
552
- /**
553
- * The tool calls generated by the model, such as function calls.
554
- */
555
- tool_calls?: Array<ChatCompletionMessageToolCalls> | null;
556
- annotations?: Array<ChatCompletionResponseMessageAnnotation> | null;
557
- /**
558
- * The role of the author of this message.
559
- */
560
- role: Role;
561
- function_call?: null | FunctionCall;
562
- audio?: null | ChatCompletionResponseMessageAudio;
563
- /**
564
- * The contents of the reasoning message.
565
- */
566
- reasoning_content?: string | null;
567
- };
568
- export type ChatCompletionResponseMessageAnnotation = {
569
- url_citation: UrlCitation;
570
- type: 'url_citation';
571
- };
572
- export type ChatCompletionResponseMessageAudio = {
573
- /**
574
- * Unique identifier for this audio response.
575
- */
576
- id: string;
577
- /**
578
- * The Unix timestamp (in seconds) for when this audio response will no longer be accessible on the server for use in multi-turn conversations.
579
- */
580
- expires_at: number;
581
- /**
582
- * Base64 encoded audio bytes generated by the model, in the format specified in the request.
583
- */
584
- data: string;
585
- /**
586
- * Transcript of the audio generated by the model.
587
- */
588
- transcript: string;
589
- };
590
- /**
591
- * Options for streaming response. Only set this when you set `stream: true`.
592
- */
593
- export type ChatCompletionStreamOptions = {
594
- /**
595
- * If set, an additional chunk will be streamed before the `data: [DONE]`
596
- * message. The `usage` field on this chunk shows the token usage statistics
597
- * for the entire request, and the `choices` field will always be an empty
598
- * array.
599
- *
600
- * All other chunks will also include a `usage` field, but with a null
601
- * value. **NOTE:** If the stream is interrupted, you may not receive the
602
- * final usage chunk which contains the total token usage for the request.
603
- */
604
- include_usage?: boolean | null;
605
- /**
606
- * When true, stream obfuscation will be enabled. Stream obfuscation adds
607
- * random characters to an `obfuscation` field on streaming delta events to
608
- * normalize payload sizes as a mitigation to certain side-channel attacks.
609
- * These obfuscation fields are included by default, but add a small amount
610
- * of overhead to the data stream. You can set `include_obfuscation` to
611
- * false to optimize for bandwidth if you trust the network links between
612
- * your application and the OpenAI API.
613
- */
614
- include_obfuscation?: boolean | null;
615
- };
616
- /**
617
- * A chat completion delta generated by streamed model responses.
618
- */
619
- export type ChatCompletionStreamResponseDelta = {
620
- /**
621
- * The contents of the chunk message.
622
- */
623
- content?: string | null;
624
- function_call?: null | FunctionCallStream;
625
- tool_calls?: Array<ChatCompletionMessageToolCallChunk> | null;
626
- role?: null | Role;
627
- /**
628
- * The refusal message generated by the model.
629
- */
630
- refusal?: string | null;
631
- /**
632
- * The contents of the chunk reasoning message.
332
+ * Error details following OpenAI API error format
633
333
  */
634
- reasoning_content?: string | null;
334
+ error: BodhiErrorBody;
635
335
  };
636
- export type ChatCompletionTokenLogprob = {
336
+ export type BodhiErrorBody = {
637
337
  /**
638
- * The token.
338
+ * Human-readable error message describing what went wrong
639
339
  */
640
- token: string;
340
+ message: string;
641
341
  /**
642
- * The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value `-9999.0` is used to signify that the token is very unlikely.
342
+ * Error type categorizing the kind of error that occurred
643
343
  */
644
- logprob: number;
344
+ type: string;
645
345
  /**
646
- * A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be `null` if there is no bytes representation for the token.
346
+ * Specific error code for programmatic error handling
647
347
  */
648
- bytes?: Array<number> | null;
348
+ code?: string | null;
649
349
  /**
650
- * List of the most likely tokens and their log probability, at this token position. In rare cases, there may be fewer than the number of requested `top_logprobs` returned.
350
+ * Additional error parameters as key-value pairs (for validation errors)
651
351
  */
652
- top_logprobs: Array<TopLogprobs>;
653
- };
654
- export type ChatCompletionTool = {
655
- function: FunctionObject;
352
+ param?: {
353
+ [key: string]: string;
354
+ } | null;
656
355
  };
657
356
  /**
658
- * Controls which (if any) tool is called by the model.
659
- * `none` means the model will not call any tool and instead generates a message.
660
- * `auto` means the model can pick between generating a message or calling one or more tools.
661
- * `required` means the model must call one or more tools.
662
- * Specifying a particular tool via `{"type": "function", "function": {"name": "my_function"}}` forces the model to call that tool.
663
- *
664
- * `none` is the default when no tools are present. `auto` is the default if tools are present.
357
+ * Whether a single capability is supported by the model.
665
358
  */
666
- export type ChatCompletionToolChoiceOption = (ChatCompletionAllowedToolsChoice & {
667
- type: 'allowed_tools';
668
- }) | (ChatCompletionNamedToolChoice & {
669
- type: 'function';
670
- }) | (ChatCompletionNamedToolChoiceCustom & {
671
- type: 'custom';
672
- }) | (ToolChoiceOptions & {
673
- type: 'mode';
674
- });
675
- export type ChatCompletionTools = (ChatCompletionTool & {
676
- type: 'function';
677
- }) | (CustomToolChatCompletions & {
678
- type: 'custom';
679
- });
680
- export type ChatRequest = {
681
- model: string;
682
- messages: Array<Message>;
683
- stream?: boolean | null;
684
- format?: string | null;
685
- keep_alive?: null | Duration;
686
- options?: null | Options;
359
+ export type CapabilitySupport = {
360
+ supported: boolean;
687
361
  };
688
362
  /**
689
- * Breakdown of tokens used in a completion.
690
- */
691
- export type CompletionTokensDetails = {
692
- accepted_prediction_tokens?: number | null;
693
- /**
694
- * Audio input tokens generated by the model.
695
- */
696
- audio_tokens?: number | null;
697
- /**
698
- * Tokens generated by the model for reasoning.
699
- */
700
- reasoning_tokens?: number | null;
701
- /**
702
- * When using Predicted Outputs, the number of tokens in the
703
- * prediction that did not appear in the completion. However, like
704
- * reasoning tokens, these tokens are still counted in the total
705
- * completion tokens for purposes of billing, output, and context
706
- * window limits.
707
- */
708
- rejected_prediction_tokens?: number | null;
709
- };
710
- /**
711
- * Usage statistics for the completion request.
363
+ * Change user role request
712
364
  */
713
- export type CompletionUsage = {
714
- /**
715
- * Number of tokens in the prompt.
716
- */
717
- prompt_tokens: number;
718
- /**
719
- * Number of tokens in the generated completion.
720
- */
721
- completion_tokens: number;
365
+ export type ChangeRoleRequest = {
722
366
  /**
723
- * Total number of tokens used in the request (prompt + completion).
367
+ * Role to assign to the user
724
368
  */
725
- total_tokens: number;
726
- prompt_tokens_details?: null | PromptTokensDetails;
727
- completion_tokens_details?: null | CompletionTokensDetails;
369
+ role: ResourceRole;
728
370
  };
729
371
  export type ContextLimits = {
730
372
  max_input_tokens?: number | null;
731
373
  max_output_tokens?: number | null;
732
374
  };
375
+ /**
376
+ * Context management capability details.
377
+ */
378
+ export type ContextManagementCapability = {
379
+ clear_thinking_20251015?: null | CapabilitySupport;
380
+ clear_tool_uses_20250919?: null | CapabilitySupport;
381
+ compact_20260112?: null | CapabilitySupport;
382
+ };
733
383
  export type CopyAliasRequest = {
734
384
  alias: string;
735
385
  };
@@ -778,298 +428,6 @@ export type CreateAccessRequestResponse = {
778
428
  export type CreateAuthConfig = CreateMcpAuthConfigRequest & {
779
429
  mcp_server_id: string;
780
430
  };
781
- export type CreateChatCompletionRequest = {
782
- /**
783
- * A list of messages comprising the conversation so far. Depending on the
784
- * [model](https://platform.openai.com/docs/models) you use, different message types (modalities)
785
- * are supported, like [text](https://platform.openai.com/docs/guides/text-generation),
786
- * [images](https://platform.openai.com/docs/guides/vision), and
787
- * [audio](https://platform.openai.com/docs/guides/audio).
788
- */
789
- messages: Array<ChatCompletionRequestMessage>;
790
- /**
791
- * Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI
792
- * offers a wide range of models with different capabilities, performance
793
- * characteristics, and price points. Refer to the
794
- * [model guide](https://platform.openai.com/docs/models)
795
- * to browse and compare available models.
796
- */
797
- model: string;
798
- /**
799
- * Output types that you would like the model to generate. Most models are capable of generating
800
- * text, which is the default:
801
- *
802
- * `["text"]`
803
- * The `gpt-4o-audio-preview` model can also be used to
804
- * [generate audio](https://platform.openai.com/docs/guides/audio). To request that this model
805
- * generate both text and audio responses, you can use:
806
- *
807
- * `["text", "audio"]`
808
- */
809
- modalities?: Array<ResponseModalities> | null;
810
- verbosity?: null | Verbosity;
811
- reasoning_effort?: null | ReasoningEffort;
812
- /**
813
- * An upper bound for the number of tokens that can be generated for a completion, including
814
- * visible output tokens and [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
815
- */
816
- max_completion_tokens?: number | null;
817
- /**
818
- * Number between -2.0 and 2.0. Positive values penalize new tokens based on
819
- * their existing frequency in the text so far, decreasing the model's
820
- * likelihood to repeat the same line verbatim.
821
- */
822
- frequency_penalty?: number | null;
823
- /**
824
- * Number between -2.0 and 2.0. Positive values penalize new tokens based on
825
- * whether they appear in the text so far, increasing the model's likelihood
826
- * to talk about new topics.
827
- */
828
- presence_penalty?: number | null;
829
- web_search_options?: null | WebSearchOptions;
830
- /**
831
- * An integer between 0 and 20 specifying the number of most likely tokens to
832
- * return at each token position, each with an associated log probability.
833
- * `logprobs` must be set to `true` if this parameter is used.
834
- */
835
- top_logprobs?: number | null;
836
- response_format?: null | ResponseFormat;
837
- audio?: null | ChatCompletionAudio;
838
- /**
839
- * Whether or not to store the output of this chat completion request for
840
- * use in our [model distillation](https://platform.openai.com/docs/guides/distillation) or
841
- * [evals](https://platform.openai.com/docs/guides/evals) products.
842
- *
843
- * Supports text and image inputs. Note: image inputs over 8MB will be dropped.
844
- */
845
- store?: boolean | null;
846
- /**
847
- * If set to true, the model response data will be streamed to the client
848
- * as it is generated using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
849
- * See the [Streaming section below](https://platform.openai.com/docs/api-reference/chat/streaming)
850
- * for more information, along with the [streaming responses](https://platform.openai.com/docs/guides/streaming-responses)
851
- * guide for more information on how to handle the streaming events.
852
- */
853
- stream?: boolean | null;
854
- stop?: null | StopConfiguration;
855
- /**
856
- * Modify the likelihood of specified tokens appearing in the completion.
857
- *
858
- * Accepts a json object that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100.
859
- * Mathematically, the bias is added to the logits generated by the model prior to sampling.
860
- * The exact effect will vary per model, but values between -1 and 1 should decrease or increase likelihood of selection;
861
- * values like -100 or 100 should result in a ban or exclusive selection of the relevant token.
862
- */
863
- logit_bias?: {
864
- [key: string]: number;
865
- } | null;
866
- /**
867
- * Whether to return log probabilities of the output tokens or not. If true,
868
- * returns the log probabilities of each output token returned in the `content` of `message`.
869
- */
870
- logprobs?: boolean | null;
871
- /**
872
- * The maximum number of [tokens](https://platform.openai.com/tokenizer) that can be generated in
873
- * the chat completion. This value can be used to control [costs](https://openai.com/api/pricing/) for text generated via API.
874
- * This value is now deprecated in favor of `max_completion_tokens`, and is
875
- * not compatible with [o-series models](https://platform.openai.com/docs/guides/reasoning).
876
- * @deprecated
877
- */
878
- max_tokens?: number | null;
879
- /**
880
- * How many chat completion choices to generate for each input message. Note that you will be
881
- * charged based on the number of generated tokens across all of the choices. Keep `n` as `1` to
882
- * minimize costs.
883
- */
884
- n?: number | null;
885
- prediction?: null | PredictionContent;
886
- /**
887
- * This feature is in Beta.
888
- *
889
- * If specified, our system will make a best effort to sample deterministically, such that
890
- * repeated requests with the same `seed` and parameters should return the same result.
891
- *
892
- * Determinism is not guaranteed, and you should refer to the `system_fingerprint` response
893
- * parameter to monitor changes in the backend.
894
- * @deprecated
895
- */
896
- seed?: number | null;
897
- stream_options?: null | ChatCompletionStreamOptions;
898
- service_tier?: null | ServiceTier;
899
- /**
900
- * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random,
901
- * while lower values like 0.2 will make it more focused and deterministic.
902
- *
903
- * We generally recommend altering this or `top_p` but not both.
904
- */
905
- temperature?: number | null;
906
- /**
907
- * An alternative to sampling with temperature, called nucleus sampling,
908
- * where the model considers the results of the tokens with top_p probability mass.
909
- * So 0.1 means only the tokens comprising the top 10% probability mass are considered.
910
- *
911
- * We generally recommend altering this or `temperature` but not both.
912
- */
913
- top_p?: number | null;
914
- /**
915
- * A list of tools the model may call. You can provide either
916
- * [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools) or
917
- * [function tools](https://platform.openai.com/docs/guides/function-calling).
918
- */
919
- tools?: Array<ChatCompletionTools> | null;
920
- tool_choice?: null | ChatCompletionToolChoiceOption;
921
- /**
922
- * Whether to enable [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
923
- * during tool use.
924
- */
925
- parallel_tool_calls?: boolean | null;
926
- /**
927
- * This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use `prompt_cache_key`
928
- * instead to maintain caching optimizations.
929
- * A stable identifier for your end-users.
930
- * Used to boost cache hit rates by better bucketing similar requests and to help OpenAI detect and
931
- * prevent abuse. [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
932
- * @deprecated
933
- */
934
- user?: string | null;
935
- /**
936
- * A stable identifier used to help detect users of your application that may be violating OpenAI's
937
- * usage policies.
938
- *
939
- * The IDs should be a string that uniquely identifies each user. We recommend hashing their username
940
- * or email address, in order to avoid sending us any identifying information. [Learn
941
- * more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
942
- */
943
- safety_identifier?: string | null;
944
- /**
945
- * Used by OpenAI to cache responses for similar requests to optimize your cache hit rates. Replaces
946
- * the `user` field. [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
947
- */
948
- prompt_cache_key?: string | null;
949
- function_call?: null | ChatCompletionFunctionCall;
950
- /**
951
- * Deprecated in favor of `tools`.
952
- *
953
- * A list of functions the model may generate JSON inputs for.
954
- * @deprecated
955
- */
956
- functions?: Array<ChatCompletionFunctions> | null;
957
- metadata?: null | Metadata;
958
- /**
959
- * llama.cpp compatible extra params in request
960
- */
961
- chat_template_kwargs?: {} | null;
962
- };
963
- /**
964
- * Represents a chat completion response returned by model, based on the provided input.
965
- */
966
- export type CreateChatCompletionResponse = {
967
- /**
968
- * A unique identifier for the chat completion.
969
- */
970
- id: string;
971
- /**
972
- * A list of chat completion choices. Can be more than one if `n` is greater than 1.
973
- */
974
- choices: Array<ChatChoice>;
975
- /**
976
- * The Unix timestamp (in seconds) of when the chat completion was created.
977
- */
978
- created: number;
979
- /**
980
- * The model used for the chat completion.
981
- */
982
- model: string;
983
- service_tier?: null | ServiceTier;
984
- /**
985
- * This fingerprint represents the backend configuration that the model runs with.
986
- *
987
- * Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
988
- * @deprecated
989
- */
990
- system_fingerprint?: string | null;
991
- /**
992
- * The object type, which is always `chat.completion`.
993
- */
994
- object: string;
995
- usage?: null | CompletionUsage;
996
- };
997
- /**
998
- * Represents a streamed chunk of a chat completion response returned by the model, based on the provided input. [Learn more](https://platform.openai.com/docs/guides/streaming-responses).
999
- */
1000
- export type CreateChatCompletionStreamResponse = {
1001
- /**
1002
- * A unique identifier for the chat completion. Each chunk has the same ID.
1003
- */
1004
- id: string;
1005
- /**
1006
- * A list of chat completion choices. Can contain more than one elements if `n` is greater than 1. Can also be empty for the last chunk if you set `stream_options: {"include_usage": true}`.
1007
- */
1008
- choices: Array<ChatChoiceStream>;
1009
- /**
1010
- * The Unix timestamp (in seconds) of when the chat completion was created. Each chunk has the same timestamp.
1011
- */
1012
- created: number;
1013
- /**
1014
- * The model to generate the completion.
1015
- */
1016
- model: string;
1017
- service_tier?: null | ServiceTier;
1018
- /**
1019
- * This fingerprint represents the backend configuration that the model runs with.
1020
- * Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
1021
- * @deprecated
1022
- */
1023
- system_fingerprint?: string | null;
1024
- /**
1025
- * The object type, which is always `chat.completion.chunk`.
1026
- */
1027
- object: string;
1028
- usage?: null | CompletionUsage;
1029
- };
1030
- export type CreateEmbeddingRequest = {
1031
- /**
1032
- * ID of the model to use. You can use the [List models](https://platform.openai.com/docs/api-reference/models/list)
1033
- * API to see all of your available models, or see our [Model overview](https://platform.openai.com/docs/models)
1034
- * for descriptions of them.
1035
- */
1036
- model: string;
1037
- /**
1038
- * Input text to embed, encoded as a string or array of tokens. To embed multiple inputs in a single
1039
- * request, pass an array of strings or array of token arrays. The input must not exceed the max
1040
- * input tokens for the model (8192 tokens for all embedding models), cannot be an empty string, and
1041
- * any array must be 2048 dimensions or less. [Example Python
1042
- * code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken) for counting tokens.
1043
- * In addition to the per-input token limit, all embedding models enforce a maximum of 300,000
1044
- * tokens summed across all inputs in a single request.
1045
- */
1046
- input: EmbeddingInput;
1047
- encoding_format?: null | EncodingFormat;
1048
- /**
1049
- * A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.
1050
- * [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
1051
- */
1052
- user?: string | null;
1053
- /**
1054
- * The number of dimensions the resulting output embeddings should have. Only supported in `text-embedding-3` and later models.
1055
- */
1056
- dimensions?: number | null;
1057
- };
1058
- export type CreateEmbeddingResponse = {
1059
- object: string;
1060
- /**
1061
- * The name of the model used to generate the embedding.
1062
- */
1063
- model: string;
1064
- /**
1065
- * The list of embeddings generated by the model.
1066
- */
1067
- data: Array<Embedding>;
1068
- /**
1069
- * The usage information for the request.
1070
- */
1071
- usage: EmbeddingUsage;
1072
- };
1073
431
  /**
1074
432
  * Discriminated union for creating any type of MCP auth config.
1075
433
  * The JSON `"type"` field determines the variant: `"header"` or `"oauth"`.
@@ -1112,55 +470,6 @@ export type CreateTokenRequest = {
1112
470
  */
1113
471
  scope: TokenScope;
1114
472
  };
1115
- export type CustomGrammarFormatParam = {
1116
- /**
1117
- * The grammar definition.
1118
- */
1119
- definition: string;
1120
- /**
1121
- * The syntax of the grammar definition. One of `lark` or `regex`.
1122
- */
1123
- syntax: GrammarSyntax;
1124
- };
1125
- export type CustomName = {
1126
- /**
1127
- * The name of the custom tool to call.
1128
- */
1129
- name: string;
1130
- };
1131
- export type CustomTool = {
1132
- /**
1133
- * The name of the custom tool to call.
1134
- */
1135
- name: string;
1136
- /**
1137
- * The input for the custom tool call generated by the model.
1138
- */
1139
- input: string;
1140
- };
1141
- export type CustomToolChatCompletions = {
1142
- custom: CustomToolProperties;
1143
- };
1144
- export type CustomToolProperties = {
1145
- /**
1146
- * The name of the custom tool, used to identify it in tool calls.
1147
- */
1148
- name: string;
1149
- /**
1150
- * Optional description of the custom tool, used to provide more context.
1151
- */
1152
- description?: string | null;
1153
- /**
1154
- * The input format for the custom tool. Default is unconstrained text.
1155
- */
1156
- format: CustomToolPropertiesFormat;
1157
- };
1158
- export type CustomToolPropertiesFormat = {
1159
- type: 'text';
1160
- } | {
1161
- grammar: CustomGrammarFormatParam;
1162
- type: 'grammar';
1163
- };
1164
473
  /**
1165
474
  * Dashboard user information from a validated dashboard session token
1166
475
  */
@@ -1184,7 +493,6 @@ export type DownloadRequest = {
1184
493
  updated_at: string;
1185
494
  };
1186
495
  export type DownloadStatus = 'pending' | 'completed' | 'error';
1187
- export type Duration = string;
1188
496
  export type DynamicRegisterRequest = {
1189
497
  registration_endpoint: string;
1190
498
  redirect_uri: string;
@@ -1198,54 +506,12 @@ export type DynamicRegisterResponse = {
1198
506
  registration_access_token?: string | null;
1199
507
  };
1200
508
  /**
1201
- * Represents an embedding vector returned by embedding endpoint.
509
+ * Effort (reasoning_effort) capability details.
1202
510
  */
1203
- export type Embedding = {
1204
- /**
1205
- * The index of the embedding in the list of embeddings.
1206
- */
1207
- index: number;
1208
- /**
1209
- * The object type, which is always "embedding".
1210
- */
1211
- object: string;
1212
- /**
1213
- * The embedding vector, which is a list of floats. The length of vector
1214
- * depends on the model as listed in the [embedding guide](https://platform.openai.com/docs/guides/embeddings).
1215
- */
1216
- embedding: Array<number>;
1217
- };
1218
- export type EmbeddingInput = string | Array<string> | Array<number> | Array<Array<number>>;
1219
- export type EmbeddingUsage = {
1220
- /**
1221
- * The number of tokens used by the prompt.
1222
- */
1223
- prompt_tokens: number;
1224
- /**
1225
- * The total number of tokens used by the request.
1226
- */
1227
- total_tokens: number;
1228
- };
1229
- export type EncodingFormat = 'float' | 'base64';
1230
- export type ErrorBody = {
1231
- /**
1232
- * Human-readable error message describing what went wrong
1233
- */
1234
- message: string;
1235
- /**
1236
- * Error type categorizing the kind of error that occurred
1237
- */
1238
- type: string;
1239
- /**
1240
- * Specific error code for programmatic error handling
1241
- */
1242
- code?: string | null;
1243
- /**
1244
- * Additional error parameters as key-value pairs (for validation errors)
1245
- */
1246
- param?: {
1247
- [key: string]: string;
1248
- } | null;
511
+ export type EffortCapability = {
512
+ high: CapabilitySupport;
513
+ low: CapabilitySupport;
514
+ max: CapabilitySupport;
1249
515
  };
1250
516
  /**
1251
517
  * Request to fetch available models from provider
@@ -1259,104 +525,44 @@ export type FetchModelsRequest = {
1259
525
  * API base URL (required - always needed to know where to fetch models from)
1260
526
  */
1261
527
  base_url: string;
1262
- };
1263
- /**
1264
- * Response containing available models from provider
1265
- */
1266
- export type FetchModelsResponse = {
1267
- models: Array<string>;
1268
- };
1269
- export type FileObject = {
1270
528
  /**
1271
- * The base64 encoded file data, used when passing the file to the model
1272
- * as a string.
529
+ * API format to use for fetching models (defaults to OpenAI Chat Completions)
1273
530
  */
1274
- file_data?: string | null;
531
+ api_format?: ApiFormat;
1275
532
  /**
1276
- * The ID of an uploaded file to use as input.
533
+ * Optional extra HTTP headers. `Authorization` / `x-api-key` are forbidden.
1277
534
  */
1278
- file_id?: string | null;
535
+ extra_headers?: unknown;
1279
536
  /**
1280
- * The name of the file, used when passing the file to the model as a
1281
- * string.
537
+ * Optional extra fields to merge into the request body
1282
538
  */
1283
- filename?: string | null;
539
+ extra_body?: unknown;
1284
540
  };
1285
- export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
1286
- export type FlowType = 'redirect' | 'popup';
1287
541
  /**
1288
- * The name and arguments of a function that should be called, as generated by the model.
542
+ * Returns model IDs only (not full metadata) to minimize information exposure
543
+ * the endpoint accepts an API key parameter. Full metadata is stored on create/update.
1289
544
  */
1290
- export type FunctionCall = {
1291
- /**
1292
- * The name of the function to call.
1293
- */
1294
- name: string;
1295
- /**
1296
- * The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.
1297
- */
1298
- arguments: string;
1299
- };
1300
- export type FunctionCallStream = {
1301
- /**
1302
- * The name of the function to call.
1303
- */
1304
- name?: string | null;
1305
- /**
1306
- * The arguments to call the function with, as generated by the model in JSON format.
1307
- * Note that the model does not always generate valid JSON, and may hallucinate
1308
- * parameters not defined by your function schema. Validate the arguments in your
1309
- * code before calling your function.
1310
- */
1311
- arguments?: string | null;
1312
- };
1313
- export type FunctionName = {
1314
- /**
1315
- * The name of the function to call.
1316
- */
1317
- name: string;
545
+ export type FetchModelsResponse = {
546
+ models: Array<string>;
1318
547
  };
1319
- export type FunctionObject = {
1320
- /**
1321
- * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
1322
- */
548
+ export type FlowType = 'redirect' | 'popup';
549
+ /**
550
+ * Gemini `Model` schema (see `openapi-gemini.json`).
551
+ */
552
+ export type GeminiModel = {
1323
553
  name: string;
1324
- /**
1325
- * A description of what the function does, used by the model to choose when and how to call the function.
1326
- */
554
+ version?: string;
555
+ displayName?: string | null;
1327
556
  description?: string | null;
1328
- /**
1329
- * The parameters the functions accepts, described as a JSON Schema object. See the [guide](https://platform.openai.com/docs/guides/text-generation/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
1330
- *
1331
- * Omitting `parameters` defines a function with an empty parameter list.
1332
- */
1333
- parameters?: unknown;
1334
- /**
1335
- * Whether to enable strict schema adherence when generating the function call. If set to true, the model will follow the exact schema defined in the `parameters` field. Only a subset of JSON Schema is supported when `strict` is `true`. Learn more about Structured Outputs in the [function calling guide](https://platform.openai.com/docs/guides/function-calling).
1336
- */
1337
- strict?: boolean | null;
1338
- };
1339
- export type FunctionType = 'function';
1340
- export type GrammarSyntax = 'lark' | 'regex';
1341
- export type ImageDetail = 'auto' | 'low' | 'high';
1342
- export type ImageUrl = {
1343
- /**
1344
- * Either a URL of the image or the base64 encoded image data.
1345
- */
1346
- url: string;
1347
- detail?: null | ImageDetail;
1348
- };
1349
- export type InputAudio = {
1350
- /**
1351
- * Base64 encoded audio data.
1352
- */
1353
- data: string;
1354
- /**
1355
- * The format of the encoded audio data. Currently supports "wav" and "mp3".
1356
- */
1357
- format: InputAudioFormat;
557
+ inputTokenLimit?: number | null;
558
+ outputTokenLimit?: number | null;
559
+ supportedGenerationMethods?: Array<string>;
560
+ temperature?: number | null;
561
+ maxTemperature?: number | null;
562
+ topP?: number | null;
563
+ topK?: number | null;
564
+ thinking?: boolean | null;
1358
565
  };
1359
- export type InputAudioFormat = 'wav' | 'mp3';
1360
566
  export type JsonVec = Array<string>;
1361
567
  export type ListMcpServersResponse = {
1362
568
  mcp_servers: Array<McpServerResponse>;
@@ -1364,10 +570,6 @@ export type ListMcpServersResponse = {
1364
570
  export type ListMcpsResponse = {
1365
571
  mcps: Array<Mcp>;
1366
572
  };
1367
- export type ListModelResponse = {
1368
- object: string;
1369
- data: Array<Model>;
1370
- };
1371
573
  /**
1372
574
  * List users query parameters. Intentionally omits sort fields (unlike PaginationSortParams)
1373
575
  * because user listing is fetched from the auth service which handles its own ordering.
@@ -1637,21 +839,7 @@ export type McpServerReviewInfo = {
1637
839
  * User's MCP instances connected to this server URL
1638
840
  */
1639
841
  instances: Array<Mcp>;
1640
- };
1641
- export type Message = {
1642
- role: string;
1643
- content: string;
1644
- images?: Array<string> | null;
1645
- };
1646
- /**
1647
- * Set of 16 key-value pairs that can be attached to an object.
1648
- * This can be useful for storing additional information about the
1649
- * object in a structured format, and querying for objects via API
1650
- * or the dashboard. Keys are strings with a maximum length of 64
1651
- * characters. Values are strings with a maximum length of 512
1652
- * characters.
1653
- */
1654
- export type Metadata = unknown;
842
+ };
1655
843
  /**
1656
844
  * Describes an OpenAI model offering that can be used with the API.
1657
845
  */
@@ -1702,14 +890,6 @@ export type ModelCapabilities = {
1702
890
  thinking?: boolean | null;
1703
891
  tools: ToolCapabilities;
1704
892
  };
1705
- export type ModelDetails = {
1706
- parent_model?: string | null;
1707
- format: string;
1708
- family: string;
1709
- families?: Array<string> | null;
1710
- parameter_size: string;
1711
- quantization_level: string;
1712
- };
1713
893
  /**
1714
894
  * Model metadata for API responses
1715
895
  */
@@ -1719,9 +899,6 @@ export type ModelMetadata = {
1719
899
  architecture: ModelArchitecture;
1720
900
  chat_template?: string | null;
1721
901
  };
1722
- export type ModelsResponse = {
1723
- models: Array<OllamaModel>;
1724
- };
1725
902
  /**
1726
903
  * Request for creating a new download request
1727
904
  */
@@ -1787,53 +964,6 @@ export type OAuthTokenResponse = {
1787
964
  created_at: string;
1788
965
  updated_at: string;
1789
966
  };
1790
- export type OllamaError = {
1791
- error: string;
1792
- };
1793
- export type OllamaModel = {
1794
- model: string;
1795
- modified_at: number;
1796
- size: number;
1797
- digest: string;
1798
- details: ModelDetails;
1799
- };
1800
- export type OpenAiApiError = {
1801
- /**
1802
- * Error details following OpenAI API error format
1803
- */
1804
- error: ErrorBody;
1805
- };
1806
- export type Options = {
1807
- num_keep?: number | null;
1808
- seed?: number | null;
1809
- num_predict?: number | null;
1810
- top_k?: number | null;
1811
- top_p?: number | null;
1812
- tfs_z?: number | null;
1813
- typical_p?: number | null;
1814
- repeat_last_n?: number | null;
1815
- temperature?: number | null;
1816
- repeat_penalty?: number | null;
1817
- presence_penalty?: number | null;
1818
- frequency_penalty?: number | null;
1819
- mirostat?: number | null;
1820
- mirostat_tau?: number | null;
1821
- mirostat_eta?: number | null;
1822
- penalize_newline?: boolean | null;
1823
- stop?: Array<string> | null;
1824
- numa?: boolean | null;
1825
- num_ctx?: number | null;
1826
- num_batch?: number | null;
1827
- num_gpu?: number | null;
1828
- main_gpu?: number | null;
1829
- low_vram?: boolean | null;
1830
- f16_kv?: boolean | null;
1831
- logits_all?: boolean | null;
1832
- vocab_only?: boolean | null;
1833
- use_mmap?: boolean | null;
1834
- use_mlock?: boolean | null;
1835
- num_thread?: number | null;
1836
- };
1837
967
  /**
1838
968
  * Paginated list of all model aliases (user, model, and API)
1839
969
  */
@@ -1927,35 +1057,6 @@ export type PingResponse = {
1927
1057
  */
1928
1058
  message: string;
1929
1059
  };
1930
- /**
1931
- * The type of the predicted content you want to provide. This type is
1932
- * currently always `content`.
1933
- */
1934
- export type PredictionContent = {
1935
- /**
1936
- * The type of the predicted content you want to provide. This type is
1937
- * currently always `content`.
1938
- */
1939
- content: PredictionContentContent;
1940
- type: 'content';
1941
- };
1942
- /**
1943
- * The content that should be matched when generating a model response. If generated tokens would match this content, the entire model response can be returned much more quickly.
1944
- */
1945
- export type PredictionContentContent = string | Array<ChatCompletionRequestMessageContentPartText>;
1946
- /**
1947
- * Breakdown of tokens used in a completion.
1948
- */
1949
- export type PromptTokensDetails = {
1950
- /**
1951
- * Audio input tokens present in the prompt.
1952
- */
1953
- audio_tokens?: number | null;
1954
- /**
1955
- * Cached tokens present in the prompt.
1956
- */
1957
- cached_tokens?: number | null;
1958
- };
1959
1060
  /**
1960
1061
  * Response for queue status operations
1961
1062
  */
@@ -1965,7 +1066,6 @@ export type QueueStatusResponse = {
1965
1066
  */
1966
1067
  status: string;
1967
1068
  };
1968
- export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
1969
1069
  export type RedirectResponse = {
1970
1070
  /**
1971
1071
  * The URL to redirect to (OAuth authorization URL or application home page)
@@ -2027,48 +1127,6 @@ export type RequestedResourcesV1 = {
2027
1127
  mcp_servers?: Array<RequestedMcpServer>;
2028
1128
  };
2029
1129
  export type ResourceRole = 'resource_anonymous' | 'resource_guest' | 'resource_user' | 'resource_power_user' | 'resource_manager' | 'resource_admin';
2030
- export type ResponseFormat = {
2031
- type: 'text';
2032
- } | {
2033
- type: 'json_object';
2034
- } | {
2035
- json_schema: ResponseFormatJsonSchema;
2036
- type: 'json_schema';
2037
- };
2038
- export type ResponseFormatJsonSchema = {
2039
- /**
2040
- * A description of what the response format is for, used by the model to determine how to respond in the format.
2041
- */
2042
- description?: string | null;
2043
- /**
2044
- * The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
2045
- */
2046
- name: string;
2047
- /**
2048
- * The schema for the response format, described as a JSON Schema object.
2049
- * Learn how to build JSON schemas [here](https://json-schema.org/).
2050
- */
2051
- schema?: unknown;
2052
- /**
2053
- * Whether to enable strict schema adherence when generating the output.
2054
- * If set to true, the model will always follow the exact schema defined
2055
- * in the `schema` field. Only a subset of JSON Schema is supported when
2056
- * `strict` is `true`. To learn more, read the [Structured Outputs
2057
- * guide](https://platform.openai.com/docs/guides/structured-outputs).
2058
- */
2059
- strict?: boolean | null;
2060
- };
2061
- /**
2062
- * Output types that you would like the model to generate for this request.
2063
- *
2064
- * Most models are capable of generating text, which is the default: `["text"]`
2065
- *
2066
- * The `gpt-4o-audio-preview` model can also be used to [generate
2067
- * audio](https://platform.openai.com/docs/guides/audio). To request that this model generate both text and audio responses, you can use: `["text", "audio"]`
2068
- */
2069
- export type ResponseModalities = 'text' | 'audio';
2070
- export type Role = 'system' | 'user' | 'assistant' | 'tool' | 'function';
2071
- export type ServiceTier = 'auto' | 'default' | 'flex' | 'scale' | 'priority';
2072
1130
  export type SettingInfo = {
2073
1131
  key: string;
2074
1132
  current_value: unknown;
@@ -2111,19 +1169,6 @@ export type SetupResponse = {
2111
1169
  */
2112
1170
  status: AppStatus;
2113
1171
  };
2114
- export type ShowRequest = {
2115
- name: string;
2116
- };
2117
- export type ShowResponse = {
2118
- details: ModelDetails;
2119
- license: string;
2120
- model_info: {};
2121
- modelfile: string;
2122
- modified_at: number;
2123
- parameters: string;
2124
- template: string;
2125
- };
2126
- export type StopConfiguration = string | Array<string>;
2127
1172
  export type TenantListItem = {
2128
1173
  client_id: string;
2129
1174
  name: string;
@@ -2171,6 +1216,18 @@ export type TestPromptRequest = {
2171
1216
  * Test prompt (max 30 characters for cost control)
2172
1217
  */
2173
1218
  prompt: string;
1219
+ /**
1220
+ * API format to use for the test request (defaults to OpenAI Chat Completions)
1221
+ */
1222
+ api_format?: ApiFormat;
1223
+ /**
1224
+ * Optional extra HTTP headers. `Authorization` / `x-api-key` are forbidden.
1225
+ */
1226
+ extra_headers?: unknown;
1227
+ /**
1228
+ * Optional extra fields to merge into the request body
1229
+ */
1230
+ extra_body?: unknown;
2174
1231
  };
2175
1232
  /**
2176
1233
  * Response from testing API connectivity
@@ -2180,6 +1237,20 @@ export type TestPromptResponse = {
2180
1237
  response?: string | null;
2181
1238
  error?: string | null;
2182
1239
  };
1240
+ /**
1241
+ * Thinking capability and supported type configurations.
1242
+ */
1243
+ export type ThinkingCapability = {
1244
+ supported: boolean;
1245
+ types: ThinkingTypes;
1246
+ };
1247
+ /**
1248
+ * Supported thinking type configurations.
1249
+ */
1250
+ export type ThinkingTypes = {
1251
+ adaptive: CapabilitySupport;
1252
+ enabled: CapabilitySupport;
1253
+ };
2183
1254
  export type TokenCreated = {
2184
1255
  /**
2185
1256
  * API token with bodhiapp_ prefix for programmatic access
@@ -2208,22 +1279,6 @@ export type ToolCapabilities = {
2208
1279
  function_calling?: boolean | null;
2209
1280
  structured_output?: boolean | null;
2210
1281
  };
2211
- export type ToolChoiceAllowedMode = 'auto' | 'required';
2212
- export type ToolChoiceOptions = 'none' | 'auto' | 'required';
2213
- export type TopLogprobs = {
2214
- /**
2215
- * The token.
2216
- */
2217
- token: string;
2218
- /**
2219
- * The log probability of this token.
2220
- */
2221
- logprob: number;
2222
- /**
2223
- * A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be `null` if there is no bytes representation for the token.
2224
- */
2225
- bytes?: Array<number> | null;
2226
- };
2227
1282
  /**
2228
1283
  * Request to update a setting value
2229
1284
  */
@@ -2243,24 +1298,6 @@ export type UpdateTokenRequest = {
2243
1298
  */
2244
1299
  status: TokenStatus;
2245
1300
  };
2246
- export type UrlCitation = {
2247
- /**
2248
- * The index of the last character of the URL citation in the message.
2249
- */
2250
- end_index: number;
2251
- /**
2252
- * The index of the first character of the URL citation in the message.
2253
- */
2254
- start_index: number;
2255
- /**
2256
- * The title of the web resource.
2257
- */
2258
- title: string;
2259
- /**
2260
- * The URL of the web resource.
2261
- */
2262
- url: string;
2263
- };
2264
1301
  /**
2265
1302
  * User access request output type for API responses
2266
1303
  */
@@ -2383,156 +1420,6 @@ export type UserResponse = {
2383
1420
  auth_status: 'api_token';
2384
1421
  });
2385
1422
  export type UserScope = 'scope_user_user' | 'scope_user_power_user';
2386
- /**
2387
- * Constrains the verbosity of the model's response. Lower values will result in more concise responses, while higher values will result in more verbose responses. Currently supported values are `low`, `medium`, and `high`.
2388
- */
2389
- export type Verbosity = 'low' | 'medium' | 'high';
2390
- /**
2391
- * The amount of context window space to use for the search.
2392
- */
2393
- export type WebSearchContextSize = 'low' | 'medium' | 'high';
2394
- /**
2395
- * Approximate location parameters for the search.
2396
- */
2397
- export type WebSearchLocation = {
2398
- /**
2399
- * The two-letter [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1) of the user, e.g. `US`.
2400
- */
2401
- country?: string | null;
2402
- /**
2403
- * Free text input for the region of the user, e.g. `California`.
2404
- */
2405
- region?: string | null;
2406
- /**
2407
- * Free text input for the city of the user, e.g. `San Francisco`.
2408
- */
2409
- city?: string | null;
2410
- /**
2411
- * The [IANA timezone](https://timeapi.io/documentation/iana-timezones) of the user, e.g. `America/Los_Angeles`.
2412
- */
2413
- timezone?: string | null;
2414
- };
2415
- /**
2416
- * Options for the web search tool.
2417
- */
2418
- export type WebSearchOptions = {
2419
- search_context_size?: null | WebSearchContextSize;
2420
- user_location?: null | WebSearchUserLocation;
2421
- };
2422
- export type WebSearchUserLocation = {
2423
- type: WebSearchUserLocationType;
2424
- approximate: WebSearchLocation;
2425
- };
2426
- export type WebSearchUserLocationType = 'approximate';
2427
- export type ChatOllamaModelData = {
2428
- /**
2429
- * Chat request in Ollama format
2430
- */
2431
- body: ChatRequest;
2432
- path?: never;
2433
- query?: never;
2434
- url: '/api/chat';
2435
- };
2436
- export type ChatOllamaModelErrors = {
2437
- /**
2438
- * Invalid request parameters
2439
- */
2440
- 400: OpenAiApiError;
2441
- /**
2442
- * Not authenticated
2443
- */
2444
- 401: OpenAiApiError;
2445
- /**
2446
- * Insufficient permissions
2447
- */
2448
- 403: OpenAiApiError;
2449
- /**
2450
- * Model not found
2451
- */
2452
- 404: OllamaError;
2453
- /**
2454
- * Internal server error
2455
- */
2456
- 500: OpenAiApiError;
2457
- };
2458
- export type ChatOllamaModelError = ChatOllamaModelErrors[keyof ChatOllamaModelErrors];
2459
- export type ChatOllamaModelResponses = {
2460
- /**
2461
- * Chat response
2462
- */
2463
- 200: unknown;
2464
- };
2465
- export type ShowOllamaModelData = {
2466
- /**
2467
- * Model name to get details for
2468
- */
2469
- body: ShowRequest;
2470
- path?: never;
2471
- query?: never;
2472
- url: '/api/show';
2473
- };
2474
- export type ShowOllamaModelErrors = {
2475
- /**
2476
- * Invalid request parameters
2477
- */
2478
- 400: OpenAiApiError;
2479
- /**
2480
- * Not authenticated
2481
- */
2482
- 401: OpenAiApiError;
2483
- /**
2484
- * Insufficient permissions
2485
- */
2486
- 403: OpenAiApiError;
2487
- /**
2488
- * Model not found
2489
- */
2490
- 404: OllamaError;
2491
- /**
2492
- * Internal server error
2493
- */
2494
- 500: OpenAiApiError;
2495
- };
2496
- export type ShowOllamaModelError = ShowOllamaModelErrors[keyof ShowOllamaModelErrors];
2497
- export type ShowOllamaModelResponses = {
2498
- /**
2499
- * Model details
2500
- */
2501
- 200: ShowResponse;
2502
- };
2503
- export type ShowOllamaModelResponse = ShowOllamaModelResponses[keyof ShowOllamaModelResponses];
2504
- export type ListOllamaModelsData = {
2505
- body?: never;
2506
- path?: never;
2507
- query?: never;
2508
- url: '/api/tags';
2509
- };
2510
- export type ListOllamaModelsErrors = {
2511
- /**
2512
- * Invalid request parameters
2513
- */
2514
- 400: OpenAiApiError;
2515
- /**
2516
- * Not authenticated
2517
- */
2518
- 401: OpenAiApiError;
2519
- /**
2520
- * Insufficient permissions
2521
- */
2522
- 403: OpenAiApiError;
2523
- /**
2524
- * Internal server error
2525
- */
2526
- 500: OpenAiApiError;
2527
- };
2528
- export type ListOllamaModelsError = ListOllamaModelsErrors[keyof ListOllamaModelsErrors];
2529
- export type ListOllamaModelsResponses = {
2530
- /**
2531
- * List of available models
2532
- */
2533
- 200: ModelsResponse;
2534
- };
2535
- export type ListOllamaModelsResponse = ListOllamaModelsResponses[keyof ListOllamaModelsResponses];
2536
1423
  export type ListAllAccessRequestsData = {
2537
1424
  body?: never;
2538
1425
  path?: never;
@@ -2560,19 +1447,19 @@ export type ListAllAccessRequestsErrors = {
2560
1447
  /**
2561
1448
  * Invalid request parameters
2562
1449
  */
2563
- 400: OpenAiApiError;
1450
+ 400: BodhiApiError;
2564
1451
  /**
2565
1452
  * Not authenticated
2566
1453
  */
2567
- 401: OpenAiApiError;
1454
+ 401: BodhiApiError;
2568
1455
  /**
2569
1456
  * Insufficient permissions
2570
1457
  */
2571
- 403: OpenAiApiError;
1458
+ 403: BodhiApiError;
2572
1459
  /**
2573
1460
  * Internal server error
2574
1461
  */
2575
- 500: OpenAiApiError;
1462
+ 500: BodhiApiError;
2576
1463
  };
2577
1464
  export type ListAllAccessRequestsError = ListAllAccessRequestsErrors[keyof ListAllAccessRequestsErrors];
2578
1465
  export type ListAllAccessRequestsResponses = {
@@ -2609,19 +1496,19 @@ export type ListPendingAccessRequestsErrors = {
2609
1496
  /**
2610
1497
  * Invalid request parameters
2611
1498
  */
2612
- 400: OpenAiApiError;
1499
+ 400: BodhiApiError;
2613
1500
  /**
2614
1501
  * Not authenticated
2615
1502
  */
2616
- 401: OpenAiApiError;
1503
+ 401: BodhiApiError;
2617
1504
  /**
2618
1505
  * Insufficient permissions
2619
1506
  */
2620
- 403: OpenAiApiError;
1507
+ 403: BodhiApiError;
2621
1508
  /**
2622
1509
  * Internal server error
2623
1510
  */
2624
- 500: OpenAiApiError;
1511
+ 500: BodhiApiError;
2625
1512
  };
2626
1513
  export type ListPendingAccessRequestsError = ListPendingAccessRequestsErrors[keyof ListPendingAccessRequestsErrors];
2627
1514
  export type ListPendingAccessRequestsResponses = {
@@ -2649,23 +1536,23 @@ export type ApproveAccessRequestErrors = {
2649
1536
  /**
2650
1537
  * Invalid request parameters
2651
1538
  */
2652
- 400: OpenAiApiError;
1539
+ 400: BodhiApiError;
2653
1540
  /**
2654
1541
  * Not authenticated
2655
1542
  */
2656
- 401: OpenAiApiError;
1543
+ 401: BodhiApiError;
2657
1544
  /**
2658
1545
  * Insufficient permissions
2659
1546
  */
2660
- 403: OpenAiApiError;
1547
+ 403: BodhiApiError;
2661
1548
  /**
2662
1549
  * Request not found
2663
1550
  */
2664
- 404: OpenAiApiError;
1551
+ 404: BodhiApiError;
2665
1552
  /**
2666
1553
  * Internal server error
2667
1554
  */
2668
- 500: OpenAiApiError;
1555
+ 500: BodhiApiError;
2669
1556
  };
2670
1557
  export type ApproveAccessRequestError = ApproveAccessRequestErrors[keyof ApproveAccessRequestErrors];
2671
1558
  export type ApproveAccessRequestResponses = {
@@ -2692,27 +1579,27 @@ export type ApproveAppsAccessRequestErrors = {
2692
1579
  /**
2693
1580
  * Invalid request parameters
2694
1581
  */
2695
- 400: OpenAiApiError;
1582
+ 400: BodhiApiError;
2696
1583
  /**
2697
1584
  * Not authenticated
2698
1585
  */
2699
- 401: OpenAiApiError;
1586
+ 401: BodhiApiError;
2700
1587
  /**
2701
1588
  * Insufficient permissions
2702
1589
  */
2703
- 403: OpenAiApiError;
1590
+ 403: BodhiApiError;
2704
1591
  /**
2705
1592
  * Not found
2706
1593
  */
2707
- 404: OpenAiApiError;
1594
+ 404: BodhiApiError;
2708
1595
  /**
2709
1596
  * Already processed
2710
1597
  */
2711
- 409: OpenAiApiError;
1598
+ 409: BodhiApiError;
2712
1599
  /**
2713
1600
  * Internal server error
2714
1601
  */
2715
- 500: OpenAiApiError;
1602
+ 500: BodhiApiError;
2716
1603
  };
2717
1604
  export type ApproveAppsAccessRequestError = ApproveAppsAccessRequestErrors[keyof ApproveAppsAccessRequestErrors];
2718
1605
  export type ApproveAppsAccessRequestResponses = {
@@ -2737,27 +1624,27 @@ export type DenyAccessRequestErrors = {
2737
1624
  /**
2738
1625
  * Invalid request parameters
2739
1626
  */
2740
- 400: OpenAiApiError;
1627
+ 400: BodhiApiError;
2741
1628
  /**
2742
1629
  * Not authenticated
2743
1630
  */
2744
- 401: OpenAiApiError;
1631
+ 401: BodhiApiError;
2745
1632
  /**
2746
1633
  * Insufficient permissions
2747
1634
  */
2748
- 403: OpenAiApiError;
1635
+ 403: BodhiApiError;
2749
1636
  /**
2750
1637
  * Not found
2751
1638
  */
2752
- 404: OpenAiApiError;
1639
+ 404: BodhiApiError;
2753
1640
  /**
2754
1641
  * Already processed
2755
1642
  */
2756
- 409: OpenAiApiError;
1643
+ 409: BodhiApiError;
2757
1644
  /**
2758
1645
  * Internal server error
2759
1646
  */
2760
- 500: OpenAiApiError;
1647
+ 500: BodhiApiError;
2761
1648
  };
2762
1649
  export type DenyAccessRequestError = DenyAccessRequestErrors[keyof DenyAccessRequestErrors];
2763
1650
  export type DenyAccessRequestResponses = {
@@ -2782,23 +1669,23 @@ export type RejectAccessRequestErrors = {
2782
1669
  /**
2783
1670
  * Invalid request parameters
2784
1671
  */
2785
- 400: OpenAiApiError;
1672
+ 400: BodhiApiError;
2786
1673
  /**
2787
1674
  * Not authenticated
2788
1675
  */
2789
- 401: OpenAiApiError;
1676
+ 401: BodhiApiError;
2790
1677
  /**
2791
1678
  * Insufficient permissions
2792
1679
  */
2793
- 403: OpenAiApiError;
1680
+ 403: BodhiApiError;
2794
1681
  /**
2795
1682
  * Request not found
2796
1683
  */
2797
- 404: OpenAiApiError;
1684
+ 404: BodhiApiError;
2798
1685
  /**
2799
1686
  * Internal server error
2800
1687
  */
2801
- 500: OpenAiApiError;
1688
+ 500: BodhiApiError;
2802
1689
  };
2803
1690
  export type RejectAccessRequestError = RejectAccessRequestErrors[keyof RejectAccessRequestErrors];
2804
1691
  export type RejectAccessRequestResponses = {
@@ -2822,27 +1709,27 @@ export type GetAccessRequestReviewErrors = {
2822
1709
  /**
2823
1710
  * Invalid request parameters
2824
1711
  */
2825
- 400: OpenAiApiError;
1712
+ 400: BodhiApiError;
2826
1713
  /**
2827
1714
  * Not authenticated
2828
1715
  */
2829
- 401: OpenAiApiError;
1716
+ 401: BodhiApiError;
2830
1717
  /**
2831
1718
  * Insufficient permissions
2832
1719
  */
2833
- 403: OpenAiApiError;
1720
+ 403: BodhiApiError;
2834
1721
  /**
2835
1722
  * Not found
2836
1723
  */
2837
- 404: OpenAiApiError;
1724
+ 404: BodhiApiError;
2838
1725
  /**
2839
1726
  * Request expired
2840
1727
  */
2841
- 410: OpenAiApiError;
1728
+ 410: BodhiApiError;
2842
1729
  /**
2843
1730
  * Internal server error
2844
1731
  */
2845
- 500: OpenAiApiError;
1732
+ 500: BodhiApiError;
2846
1733
  };
2847
1734
  export type GetAccessRequestReviewError = GetAccessRequestReviewErrors[keyof GetAccessRequestReviewErrors];
2848
1735
  export type GetAccessRequestReviewResponses = {
@@ -2872,23 +1759,23 @@ export type GetAccessRequestStatusErrors = {
2872
1759
  /**
2873
1760
  * Invalid request parameters
2874
1761
  */
2875
- 400: OpenAiApiError;
1762
+ 400: BodhiApiError;
2876
1763
  /**
2877
1764
  * Not authenticated
2878
1765
  */
2879
- 401: OpenAiApiError;
1766
+ 401: BodhiApiError;
2880
1767
  /**
2881
1768
  * Insufficient permissions
2882
1769
  */
2883
- 403: OpenAiApiError;
1770
+ 403: BodhiApiError;
2884
1771
  /**
2885
1772
  * Not found or app_client_id mismatch
2886
1773
  */
2887
- 404: OpenAiApiError;
1774
+ 404: BodhiApiError;
2888
1775
  /**
2889
1776
  * Internal server error
2890
1777
  */
2891
- 500: OpenAiApiError;
1778
+ 500: BodhiApiError;
2892
1779
  };
2893
1780
  export type GetAccessRequestStatusError = GetAccessRequestStatusErrors[keyof GetAccessRequestStatusErrors];
2894
1781
  export type GetAccessRequestStatusResponses = {
@@ -2908,19 +1795,19 @@ export type AppsListMcpsErrors = {
2908
1795
  /**
2909
1796
  * Invalid request parameters
2910
1797
  */
2911
- 400: OpenAiApiError;
1798
+ 400: BodhiApiError;
2912
1799
  /**
2913
1800
  * Not authenticated
2914
1801
  */
2915
- 401: OpenAiApiError;
1802
+ 401: BodhiApiError;
2916
1803
  /**
2917
1804
  * Insufficient permissions
2918
1805
  */
2919
- 403: OpenAiApiError;
1806
+ 403: BodhiApiError;
2920
1807
  /**
2921
1808
  * Internal server error
2922
1809
  */
2923
- 500: OpenAiApiError;
1810
+ 500: BodhiApiError;
2924
1811
  };
2925
1812
  export type AppsListMcpsError = AppsListMcpsErrors[keyof AppsListMcpsErrors];
2926
1813
  export type AppsListMcpsResponses = {
@@ -2945,15 +1832,15 @@ export type AppsGetMcpErrors = {
2945
1832
  /**
2946
1833
  * Invalid request parameters
2947
1834
  */
2948
- 400: OpenAiApiError;
1835
+ 400: BodhiApiError;
2949
1836
  /**
2950
1837
  * Not authenticated
2951
1838
  */
2952
- 401: OpenAiApiError;
1839
+ 401: BodhiApiError;
2953
1840
  /**
2954
1841
  * Insufficient permissions
2955
1842
  */
2956
- 403: OpenAiApiError;
1843
+ 403: BodhiApiError;
2957
1844
  /**
2958
1845
  * MCP not found
2959
1846
  */
@@ -2961,7 +1848,7 @@ export type AppsGetMcpErrors = {
2961
1848
  /**
2962
1849
  * Internal server error
2963
1850
  */
2964
- 500: OpenAiApiError;
1851
+ 500: BodhiApiError;
2965
1852
  };
2966
1853
  export type AppsGetMcpError = AppsGetMcpErrors[keyof AppsGetMcpErrors];
2967
1854
  export type AppsGetMcpResponses = {
@@ -2986,19 +1873,19 @@ export type McpProxyErrors = {
2986
1873
  /**
2987
1874
  * Invalid request parameters
2988
1875
  */
2989
- 400: OpenAiApiError;
1876
+ 400: BodhiApiError;
2990
1877
  /**
2991
1878
  * Not authenticated
2992
1879
  */
2993
- 401: OpenAiApiError;
1880
+ 401: BodhiApiError;
2994
1881
  /**
2995
1882
  * Insufficient permissions
2996
1883
  */
2997
- 403: OpenAiApiError;
1884
+ 403: BodhiApiError;
2998
1885
  /**
2999
1886
  * Internal server error
3000
1887
  */
3001
- 500: OpenAiApiError;
1888
+ 500: BodhiApiError;
3002
1889
  };
3003
1890
  export type McpProxyError = McpProxyErrors[keyof McpProxyErrors];
3004
1891
  export type McpProxyResponses = {
@@ -3020,23 +1907,23 @@ export type CreateAccessRequestErrors = {
3020
1907
  /**
3021
1908
  * Invalid request parameters
3022
1909
  */
3023
- 400: OpenAiApiError;
1910
+ 400: BodhiApiError;
3024
1911
  /**
3025
1912
  * Not authenticated
3026
1913
  */
3027
- 401: OpenAiApiError;
1914
+ 401: BodhiApiError;
3028
1915
  /**
3029
1916
  * Insufficient permissions
3030
1917
  */
3031
- 403: OpenAiApiError;
1918
+ 403: BodhiApiError;
3032
1919
  /**
3033
1920
  * App client not found
3034
1921
  */
3035
- 404: OpenAiApiError;
1922
+ 404: BodhiApiError;
3036
1923
  /**
3037
1924
  * Internal server error
3038
1925
  */
3039
- 500: OpenAiApiError;
1926
+ 500: BodhiApiError;
3040
1927
  };
3041
1928
  export type CreateAccessRequestError = CreateAccessRequestErrors[keyof CreateAccessRequestErrors];
3042
1929
  export type CreateAccessRequestResponses = {
@@ -3059,23 +1946,23 @@ export type CompleteOAuthFlowErrors = {
3059
1946
  /**
3060
1947
  * Invalid request parameters
3061
1948
  */
3062
- 400: OpenAiApiError;
1949
+ 400: BodhiApiError;
3063
1950
  /**
3064
1951
  * Not authenticated
3065
1952
  */
3066
- 401: OpenAiApiError;
1953
+ 401: BodhiApiError;
3067
1954
  /**
3068
1955
  * Insufficient permissions
3069
1956
  */
3070
- 403: OpenAiApiError;
1957
+ 403: BodhiApiError;
3071
1958
  /**
3072
1959
  * OAuth error, invalid request parameters, or state mismatch
3073
1960
  */
3074
- 422: OpenAiApiError;
1961
+ 422: BodhiApiError;
3075
1962
  /**
3076
1963
  * Internal server error
3077
1964
  */
3078
- 500: OpenAiApiError;
1965
+ 500: BodhiApiError;
3079
1966
  };
3080
1967
  export type CompleteOAuthFlowError = CompleteOAuthFlowErrors[keyof CompleteOAuthFlowErrors];
3081
1968
  export type CompleteOAuthFlowResponses = {
@@ -3098,19 +1985,19 @@ export type CompleteDashboardOAuthFlowErrors = {
3098
1985
  /**
3099
1986
  * Invalid request parameters
3100
1987
  */
3101
- 400: OpenAiApiError;
1988
+ 400: BodhiApiError;
3102
1989
  /**
3103
1990
  * Not authenticated
3104
1991
  */
3105
- 401: OpenAiApiError;
1992
+ 401: BodhiApiError;
3106
1993
  /**
3107
1994
  * Insufficient permissions
3108
1995
  */
3109
- 403: OpenAiApiError;
1996
+ 403: BodhiApiError;
3110
1997
  /**
3111
1998
  * Internal server error
3112
1999
  */
3113
- 500: OpenAiApiError;
2000
+ 500: BodhiApiError;
3114
2001
  };
3115
2002
  export type CompleteDashboardOAuthFlowError = CompleteDashboardOAuthFlowErrors[keyof CompleteDashboardOAuthFlowErrors];
3116
2003
  export type CompleteDashboardOAuthFlowResponses = {
@@ -3130,19 +2017,19 @@ export type InitiateDashboardOAuthFlowErrors = {
3130
2017
  /**
3131
2018
  * Invalid request parameters
3132
2019
  */
3133
- 400: OpenAiApiError;
2020
+ 400: BodhiApiError;
3134
2021
  /**
3135
2022
  * Not authenticated
3136
2023
  */
3137
- 401: OpenAiApiError;
2024
+ 401: BodhiApiError;
3138
2025
  /**
3139
2026
  * Insufficient permissions
3140
2027
  */
3141
- 403: OpenAiApiError;
2028
+ 403: BodhiApiError;
3142
2029
  /**
3143
2030
  * Internal server error
3144
2031
  */
3145
- 500: OpenAiApiError;
2032
+ 500: BodhiApiError;
3146
2033
  };
3147
2034
  export type InitiateDashboardOAuthFlowError = InitiateDashboardOAuthFlowErrors[keyof InitiateDashboardOAuthFlowErrors];
3148
2035
  export type InitiateDashboardOAuthFlowResponses = {
@@ -3169,19 +2056,19 @@ export type InitiateOAuthFlowErrors = {
3169
2056
  /**
3170
2057
  * Invalid request parameters
3171
2058
  */
3172
- 400: OpenAiApiError;
2059
+ 400: BodhiApiError;
3173
2060
  /**
3174
2061
  * Not authenticated
3175
2062
  */
3176
- 401: OpenAiApiError;
2063
+ 401: BodhiApiError;
3177
2064
  /**
3178
2065
  * Insufficient permissions
3179
2066
  */
3180
- 403: OpenAiApiError;
2067
+ 403: BodhiApiError;
3181
2068
  /**
3182
2069
  * Internal server error
3183
2070
  */
3184
- 500: OpenAiApiError;
2071
+ 500: BodhiApiError;
3185
2072
  };
3186
2073
  export type InitiateOAuthFlowError = InitiateOAuthFlowErrors[keyof InitiateOAuthFlowErrors];
3187
2074
  export type InitiateOAuthFlowResponses = {
@@ -3205,11 +2092,11 @@ export type GetAppInfoErrors = {
3205
2092
  /**
3206
2093
  * Invalid request parameters
3207
2094
  */
3208
- 400: OpenAiApiError;
2095
+ 400: BodhiApiError;
3209
2096
  /**
3210
2097
  * Internal server error
3211
2098
  */
3212
- 500: OpenAiApiError;
2099
+ 500: BodhiApiError;
3213
2100
  };
3214
2101
  export type GetAppInfoError = GetAppInfoErrors[keyof GetAppInfoErrors];
3215
2102
  export type GetAppInfoResponses = {
@@ -3229,19 +2116,19 @@ export type LogoutUserErrors = {
3229
2116
  /**
3230
2117
  * Invalid request parameters
3231
2118
  */
3232
- 400: OpenAiApiError;
2119
+ 400: BodhiApiError;
3233
2120
  /**
3234
2121
  * Not authenticated
3235
2122
  */
3236
- 401: OpenAiApiError;
2123
+ 401: BodhiApiError;
3237
2124
  /**
3238
2125
  * Insufficient permissions
3239
2126
  */
3240
- 403: OpenAiApiError;
2127
+ 403: BodhiApiError;
3241
2128
  /**
3242
2129
  * Internal server error
3243
2130
  */
3244
- 500: OpenAiApiError;
2131
+ 500: BodhiApiError;
3245
2132
  };
3246
2133
  export type LogoutUserError = LogoutUserErrors[keyof LogoutUserErrors];
3247
2134
  export type LogoutUserResponses = {
@@ -3261,19 +2148,19 @@ export type ListMcpsErrors = {
3261
2148
  /**
3262
2149
  * Invalid request parameters
3263
2150
  */
3264
- 400: OpenAiApiError;
2151
+ 400: BodhiApiError;
3265
2152
  /**
3266
2153
  * Not authenticated
3267
2154
  */
3268
- 401: OpenAiApiError;
2155
+ 401: BodhiApiError;
3269
2156
  /**
3270
2157
  * Insufficient permissions
3271
2158
  */
3272
- 403: OpenAiApiError;
2159
+ 403: BodhiApiError;
3273
2160
  /**
3274
2161
  * Internal server error
3275
2162
  */
3276
- 500: OpenAiApiError;
2163
+ 500: BodhiApiError;
3277
2164
  };
3278
2165
  export type ListMcpsError = ListMcpsErrors[keyof ListMcpsErrors];
3279
2166
  export type ListMcpsResponses = {
@@ -3293,19 +2180,19 @@ export type CreateMcpErrors = {
3293
2180
  /**
3294
2181
  * Invalid request parameters
3295
2182
  */
3296
- 400: OpenAiApiError;
2183
+ 400: BodhiApiError;
3297
2184
  /**
3298
2185
  * Not authenticated
3299
2186
  */
3300
- 401: OpenAiApiError;
2187
+ 401: BodhiApiError;
3301
2188
  /**
3302
2189
  * Insufficient permissions
3303
2190
  */
3304
- 403: OpenAiApiError;
2191
+ 403: BodhiApiError;
3305
2192
  /**
3306
2193
  * Internal server error
3307
2194
  */
3308
- 500: OpenAiApiError;
2195
+ 500: BodhiApiError;
3309
2196
  };
3310
2197
  export type CreateMcpError = CreateMcpErrors[keyof CreateMcpErrors];
3311
2198
  export type CreateMcpResponses = {
@@ -3327,19 +2214,19 @@ export type ListMcpAuthConfigsErrors = {
3327
2214
  /**
3328
2215
  * Invalid request parameters
3329
2216
  */
3330
- 400: OpenAiApiError;
2217
+ 400: BodhiApiError;
3331
2218
  /**
3332
2219
  * Not authenticated
3333
2220
  */
3334
- 401: OpenAiApiError;
2221
+ 401: BodhiApiError;
3335
2222
  /**
3336
2223
  * Insufficient permissions
3337
2224
  */
3338
- 403: OpenAiApiError;
2225
+ 403: BodhiApiError;
3339
2226
  /**
3340
2227
  * Internal server error
3341
2228
  */
3342
- 500: OpenAiApiError;
2229
+ 500: BodhiApiError;
3343
2230
  };
3344
2231
  export type ListMcpAuthConfigsError = ListMcpAuthConfigsErrors[keyof ListMcpAuthConfigsErrors];
3345
2232
  export type ListMcpAuthConfigsResponses = {
@@ -3359,19 +2246,19 @@ export type CreateMcpAuthConfigErrors = {
3359
2246
  /**
3360
2247
  * Invalid request parameters
3361
2248
  */
3362
- 400: OpenAiApiError;
2249
+ 400: BodhiApiError;
3363
2250
  /**
3364
2251
  * Not authenticated
3365
2252
  */
3366
- 401: OpenAiApiError;
2253
+ 401: BodhiApiError;
3367
2254
  /**
3368
2255
  * Insufficient permissions
3369
2256
  */
3370
- 403: OpenAiApiError;
2257
+ 403: BodhiApiError;
3371
2258
  /**
3372
2259
  * Internal server error
3373
2260
  */
3374
- 500: OpenAiApiError;
2261
+ 500: BodhiApiError;
3375
2262
  };
3376
2263
  export type CreateMcpAuthConfigError = CreateMcpAuthConfigErrors[keyof CreateMcpAuthConfigErrors];
3377
2264
  export type CreateMcpAuthConfigResponses = {
@@ -3396,15 +2283,15 @@ export type DeleteMcpAuthConfigErrors = {
3396
2283
  /**
3397
2284
  * Invalid request parameters
3398
2285
  */
3399
- 400: OpenAiApiError;
2286
+ 400: BodhiApiError;
3400
2287
  /**
3401
2288
  * Not authenticated
3402
2289
  */
3403
- 401: OpenAiApiError;
2290
+ 401: BodhiApiError;
3404
2291
  /**
3405
2292
  * Insufficient permissions
3406
2293
  */
3407
- 403: OpenAiApiError;
2294
+ 403: BodhiApiError;
3408
2295
  /**
3409
2296
  * Not found
3410
2297
  */
@@ -3412,7 +2299,7 @@ export type DeleteMcpAuthConfigErrors = {
3412
2299
  /**
3413
2300
  * Internal server error
3414
2301
  */
3415
- 500: OpenAiApiError;
2302
+ 500: BodhiApiError;
3416
2303
  };
3417
2304
  export type DeleteMcpAuthConfigError = DeleteMcpAuthConfigErrors[keyof DeleteMcpAuthConfigErrors];
3418
2305
  export type DeleteMcpAuthConfigResponses = {
@@ -3437,15 +2324,15 @@ export type GetMcpAuthConfigErrors = {
3437
2324
  /**
3438
2325
  * Invalid request parameters
3439
2326
  */
3440
- 400: OpenAiApiError;
2327
+ 400: BodhiApiError;
3441
2328
  /**
3442
2329
  * Not authenticated
3443
2330
  */
3444
- 401: OpenAiApiError;
2331
+ 401: BodhiApiError;
3445
2332
  /**
3446
2333
  * Insufficient permissions
3447
2334
  */
3448
- 403: OpenAiApiError;
2335
+ 403: BodhiApiError;
3449
2336
  /**
3450
2337
  * Not found
3451
2338
  */
@@ -3453,7 +2340,7 @@ export type GetMcpAuthConfigErrors = {
3453
2340
  /**
3454
2341
  * Internal server error
3455
2342
  */
3456
- 500: OpenAiApiError;
2343
+ 500: BodhiApiError;
3457
2344
  };
3458
2345
  export type GetMcpAuthConfigError = GetMcpAuthConfigErrors[keyof GetMcpAuthConfigErrors];
3459
2346
  export type GetMcpAuthConfigResponses = {
@@ -3478,15 +2365,15 @@ export type McpOAuthLoginErrors = {
3478
2365
  /**
3479
2366
  * Invalid request parameters
3480
2367
  */
3481
- 400: OpenAiApiError;
2368
+ 400: BodhiApiError;
3482
2369
  /**
3483
2370
  * Not authenticated
3484
2371
  */
3485
- 401: OpenAiApiError;
2372
+ 401: BodhiApiError;
3486
2373
  /**
3487
2374
  * Insufficient permissions
3488
2375
  */
3489
- 403: OpenAiApiError;
2376
+ 403: BodhiApiError;
3490
2377
  /**
3491
2378
  * Auth config not found
3492
2379
  */
@@ -3494,7 +2381,7 @@ export type McpOAuthLoginErrors = {
3494
2381
  /**
3495
2382
  * Internal server error
3496
2383
  */
3497
- 500: OpenAiApiError;
2384
+ 500: BodhiApiError;
3498
2385
  };
3499
2386
  export type McpOAuthLoginError = McpOAuthLoginErrors[keyof McpOAuthLoginErrors];
3500
2387
  export type McpOAuthLoginResponses = {
@@ -3519,15 +2406,15 @@ export type McpOAuthTokenExchangeErrors = {
3519
2406
  /**
3520
2407
  * Invalid request parameters
3521
2408
  */
3522
- 400: OpenAiApiError;
2409
+ 400: BodhiApiError;
3523
2410
  /**
3524
2411
  * Not authenticated
3525
2412
  */
3526
- 401: OpenAiApiError;
2413
+ 401: BodhiApiError;
3527
2414
  /**
3528
2415
  * Insufficient permissions
3529
2416
  */
3530
- 403: OpenAiApiError;
2417
+ 403: BodhiApiError;
3531
2418
  /**
3532
2419
  * Auth config not found
3533
2420
  */
@@ -3535,7 +2422,7 @@ export type McpOAuthTokenExchangeErrors = {
3535
2422
  /**
3536
2423
  * Internal server error
3537
2424
  */
3538
- 500: OpenAiApiError;
2425
+ 500: BodhiApiError;
3539
2426
  };
3540
2427
  export type McpOAuthTokenExchangeError = McpOAuthTokenExchangeErrors[keyof McpOAuthTokenExchangeErrors];
3541
2428
  export type McpOAuthTokenExchangeResponses = {
@@ -3560,15 +2447,15 @@ export type DeleteMcpOAuthTokenErrors = {
3560
2447
  /**
3561
2448
  * Invalid request parameters
3562
2449
  */
3563
- 400: OpenAiApiError;
2450
+ 400: BodhiApiError;
3564
2451
  /**
3565
2452
  * Not authenticated
3566
2453
  */
3567
- 401: OpenAiApiError;
2454
+ 401: BodhiApiError;
3568
2455
  /**
3569
2456
  * Insufficient permissions
3570
2457
  */
3571
- 403: OpenAiApiError;
2458
+ 403: BodhiApiError;
3572
2459
  /**
3573
2460
  * Not found
3574
2461
  */
@@ -3576,7 +2463,7 @@ export type DeleteMcpOAuthTokenErrors = {
3576
2463
  /**
3577
2464
  * Internal server error
3578
2465
  */
3579
- 500: OpenAiApiError;
2466
+ 500: BodhiApiError;
3580
2467
  };
3581
2468
  export type DeleteMcpOAuthTokenError = DeleteMcpOAuthTokenErrors[keyof DeleteMcpOAuthTokenErrors];
3582
2469
  export type DeleteMcpOAuthTokenResponses = {
@@ -3601,15 +2488,15 @@ export type GetMcpOAuthTokenErrors = {
3601
2488
  /**
3602
2489
  * Invalid request parameters
3603
2490
  */
3604
- 400: OpenAiApiError;
2491
+ 400: BodhiApiError;
3605
2492
  /**
3606
2493
  * Not authenticated
3607
2494
  */
3608
- 401: OpenAiApiError;
2495
+ 401: BodhiApiError;
3609
2496
  /**
3610
2497
  * Insufficient permissions
3611
2498
  */
3612
- 403: OpenAiApiError;
2499
+ 403: BodhiApiError;
3613
2500
  /**
3614
2501
  * Not found
3615
2502
  */
@@ -3617,7 +2504,7 @@ export type GetMcpOAuthTokenErrors = {
3617
2504
  /**
3618
2505
  * Internal server error
3619
2506
  */
3620
- 500: OpenAiApiError;
2507
+ 500: BodhiApiError;
3621
2508
  };
3622
2509
  export type GetMcpOAuthTokenError = GetMcpOAuthTokenErrors[keyof GetMcpOAuthTokenErrors];
3623
2510
  export type GetMcpOAuthTokenResponses = {
@@ -3637,19 +2524,19 @@ export type McpOAuthDiscoverAsErrors = {
3637
2524
  /**
3638
2525
  * Invalid request parameters
3639
2526
  */
3640
- 400: OpenAiApiError;
2527
+ 400: BodhiApiError;
3641
2528
  /**
3642
2529
  * Not authenticated
3643
2530
  */
3644
- 401: OpenAiApiError;
2531
+ 401: BodhiApiError;
3645
2532
  /**
3646
2533
  * Insufficient permissions
3647
2534
  */
3648
- 403: OpenAiApiError;
2535
+ 403: BodhiApiError;
3649
2536
  /**
3650
2537
  * Internal server error
3651
2538
  */
3652
- 500: OpenAiApiError;
2539
+ 500: BodhiApiError;
3653
2540
  };
3654
2541
  export type McpOAuthDiscoverAsError = McpOAuthDiscoverAsErrors[keyof McpOAuthDiscoverAsErrors];
3655
2542
  export type McpOAuthDiscoverAsResponses = {
@@ -3669,19 +2556,19 @@ export type McpOAuthDiscoverMcpErrors = {
3669
2556
  /**
3670
2557
  * Invalid request parameters
3671
2558
  */
3672
- 400: OpenAiApiError;
2559
+ 400: BodhiApiError;
3673
2560
  /**
3674
2561
  * Not authenticated
3675
2562
  */
3676
- 401: OpenAiApiError;
2563
+ 401: BodhiApiError;
3677
2564
  /**
3678
2565
  * Insufficient permissions
3679
2566
  */
3680
- 403: OpenAiApiError;
2567
+ 403: BodhiApiError;
3681
2568
  /**
3682
2569
  * Internal server error
3683
2570
  */
3684
- 500: OpenAiApiError;
2571
+ 500: BodhiApiError;
3685
2572
  };
3686
2573
  export type McpOAuthDiscoverMcpError = McpOAuthDiscoverMcpErrors[keyof McpOAuthDiscoverMcpErrors];
3687
2574
  export type McpOAuthDiscoverMcpResponses = {
@@ -3701,19 +2588,19 @@ export type McpOAuthDynamicRegisterStandaloneErrors = {
3701
2588
  /**
3702
2589
  * Invalid request parameters
3703
2590
  */
3704
- 400: OpenAiApiError;
2591
+ 400: BodhiApiError;
3705
2592
  /**
3706
2593
  * Not authenticated
3707
2594
  */
3708
- 401: OpenAiApiError;
2595
+ 401: BodhiApiError;
3709
2596
  /**
3710
2597
  * Insufficient permissions
3711
2598
  */
3712
- 403: OpenAiApiError;
2599
+ 403: BodhiApiError;
3713
2600
  /**
3714
2601
  * Internal server error
3715
2602
  */
3716
- 500: OpenAiApiError;
2603
+ 500: BodhiApiError;
3717
2604
  };
3718
2605
  export type McpOAuthDynamicRegisterStandaloneError = McpOAuthDynamicRegisterStandaloneErrors[keyof McpOAuthDynamicRegisterStandaloneErrors];
3719
2606
  export type McpOAuthDynamicRegisterStandaloneResponses = {
@@ -3738,19 +2625,19 @@ export type ListMcpServersErrors = {
3738
2625
  /**
3739
2626
  * Invalid request parameters
3740
2627
  */
3741
- 400: OpenAiApiError;
2628
+ 400: BodhiApiError;
3742
2629
  /**
3743
2630
  * Not authenticated
3744
2631
  */
3745
- 401: OpenAiApiError;
2632
+ 401: BodhiApiError;
3746
2633
  /**
3747
2634
  * Insufficient permissions
3748
2635
  */
3749
- 403: OpenAiApiError;
2636
+ 403: BodhiApiError;
3750
2637
  /**
3751
2638
  * Internal server error
3752
2639
  */
3753
- 500: OpenAiApiError;
2640
+ 500: BodhiApiError;
3754
2641
  };
3755
2642
  export type ListMcpServersError = ListMcpServersErrors[keyof ListMcpServersErrors];
3756
2643
  export type ListMcpServersResponses = {
@@ -3770,15 +2657,15 @@ export type CreateMcpServerErrors = {
3770
2657
  /**
3771
2658
  * Invalid request parameters
3772
2659
  */
3773
- 400: OpenAiApiError;
2660
+ 400: BodhiApiError;
3774
2661
  /**
3775
2662
  * Not authenticated
3776
2663
  */
3777
- 401: OpenAiApiError;
2664
+ 401: BodhiApiError;
3778
2665
  /**
3779
2666
  * Insufficient permissions
3780
2667
  */
3781
- 403: OpenAiApiError;
2668
+ 403: BodhiApiError;
3782
2669
  /**
3783
2670
  * URL already exists
3784
2671
  */
@@ -3786,7 +2673,7 @@ export type CreateMcpServerErrors = {
3786
2673
  /**
3787
2674
  * Internal server error
3788
2675
  */
3789
- 500: OpenAiApiError;
2676
+ 500: BodhiApiError;
3790
2677
  };
3791
2678
  export type CreateMcpServerError = CreateMcpServerErrors[keyof CreateMcpServerErrors];
3792
2679
  export type CreateMcpServerResponses = {
@@ -3811,15 +2698,15 @@ export type GetMcpServerErrors = {
3811
2698
  /**
3812
2699
  * Invalid request parameters
3813
2700
  */
3814
- 400: OpenAiApiError;
2701
+ 400: BodhiApiError;
3815
2702
  /**
3816
2703
  * Not authenticated
3817
2704
  */
3818
- 401: OpenAiApiError;
2705
+ 401: BodhiApiError;
3819
2706
  /**
3820
2707
  * Insufficient permissions
3821
2708
  */
3822
- 403: OpenAiApiError;
2709
+ 403: BodhiApiError;
3823
2710
  /**
3824
2711
  * Not found
3825
2712
  */
@@ -3827,7 +2714,7 @@ export type GetMcpServerErrors = {
3827
2714
  /**
3828
2715
  * Internal server error
3829
2716
  */
3830
- 500: OpenAiApiError;
2717
+ 500: BodhiApiError;
3831
2718
  };
3832
2719
  export type GetMcpServerError = GetMcpServerErrors[keyof GetMcpServerErrors];
3833
2720
  export type GetMcpServerResponses = {
@@ -3852,15 +2739,15 @@ export type UpdateMcpServerErrors = {
3852
2739
  /**
3853
2740
  * Invalid request parameters
3854
2741
  */
3855
- 400: OpenAiApiError;
2742
+ 400: BodhiApiError;
3856
2743
  /**
3857
2744
  * Not authenticated
3858
2745
  */
3859
- 401: OpenAiApiError;
2746
+ 401: BodhiApiError;
3860
2747
  /**
3861
2748
  * Insufficient permissions
3862
2749
  */
3863
- 403: OpenAiApiError;
2750
+ 403: BodhiApiError;
3864
2751
  /**
3865
2752
  * Not found
3866
2753
  */
@@ -3872,7 +2759,7 @@ export type UpdateMcpServerErrors = {
3872
2759
  /**
3873
2760
  * Internal server error
3874
2761
  */
3875
- 500: OpenAiApiError;
2762
+ 500: BodhiApiError;
3876
2763
  };
3877
2764
  export type UpdateMcpServerError = UpdateMcpServerErrors[keyof UpdateMcpServerErrors];
3878
2765
  export type UpdateMcpServerResponses = {
@@ -3897,15 +2784,15 @@ export type DeleteMcpErrors = {
3897
2784
  /**
3898
2785
  * Invalid request parameters
3899
2786
  */
3900
- 400: OpenAiApiError;
2787
+ 400: BodhiApiError;
3901
2788
  /**
3902
2789
  * Not authenticated
3903
2790
  */
3904
- 401: OpenAiApiError;
2791
+ 401: BodhiApiError;
3905
2792
  /**
3906
2793
  * Insufficient permissions
3907
2794
  */
3908
- 403: OpenAiApiError;
2795
+ 403: BodhiApiError;
3909
2796
  /**
3910
2797
  * MCP not found
3911
2798
  */
@@ -3913,7 +2800,7 @@ export type DeleteMcpErrors = {
3913
2800
  /**
3914
2801
  * Internal server error
3915
2802
  */
3916
- 500: OpenAiApiError;
2803
+ 500: BodhiApiError;
3917
2804
  };
3918
2805
  export type DeleteMcpError = DeleteMcpErrors[keyof DeleteMcpErrors];
3919
2806
  export type DeleteMcpResponses = {
@@ -3938,15 +2825,15 @@ export type GetMcpErrors = {
3938
2825
  /**
3939
2826
  * Invalid request parameters
3940
2827
  */
3941
- 400: OpenAiApiError;
2828
+ 400: BodhiApiError;
3942
2829
  /**
3943
2830
  * Not authenticated
3944
2831
  */
3945
- 401: OpenAiApiError;
2832
+ 401: BodhiApiError;
3946
2833
  /**
3947
2834
  * Insufficient permissions
3948
2835
  */
3949
- 403: OpenAiApiError;
2836
+ 403: BodhiApiError;
3950
2837
  /**
3951
2838
  * MCP not found
3952
2839
  */
@@ -3954,7 +2841,7 @@ export type GetMcpErrors = {
3954
2841
  /**
3955
2842
  * Internal server error
3956
2843
  */
3957
- 500: OpenAiApiError;
2844
+ 500: BodhiApiError;
3958
2845
  };
3959
2846
  export type GetMcpError = GetMcpErrors[keyof GetMcpErrors];
3960
2847
  export type GetMcpResponses = {
@@ -3979,15 +2866,15 @@ export type UpdateMcpErrors = {
3979
2866
  /**
3980
2867
  * Invalid request parameters
3981
2868
  */
3982
- 400: OpenAiApiError;
2869
+ 400: BodhiApiError;
3983
2870
  /**
3984
2871
  * Not authenticated
3985
2872
  */
3986
- 401: OpenAiApiError;
2873
+ 401: BodhiApiError;
3987
2874
  /**
3988
2875
  * Insufficient permissions
3989
2876
  */
3990
- 403: OpenAiApiError;
2877
+ 403: BodhiApiError;
3991
2878
  /**
3992
2879
  * MCP not found
3993
2880
  */
@@ -3995,7 +2882,7 @@ export type UpdateMcpErrors = {
3995
2882
  /**
3996
2883
  * Internal server error
3997
2884
  */
3998
- 500: OpenAiApiError;
2885
+ 500: BodhiApiError;
3999
2886
  };
4000
2887
  export type UpdateMcpError = UpdateMcpErrors[keyof UpdateMcpErrors];
4001
2888
  export type UpdateMcpResponses = {
@@ -4032,19 +2919,19 @@ export type ListAllModelsErrors = {
4032
2919
  /**
4033
2920
  * Invalid request parameters
4034
2921
  */
4035
- 400: OpenAiApiError;
2922
+ 400: BodhiApiError;
4036
2923
  /**
4037
2924
  * Not authenticated
4038
2925
  */
4039
- 401: OpenAiApiError;
2926
+ 401: BodhiApiError;
4040
2927
  /**
4041
2928
  * Insufficient permissions
4042
2929
  */
4043
- 403: OpenAiApiError;
2930
+ 403: BodhiApiError;
4044
2931
  /**
4045
2932
  * Internal server error
4046
2933
  */
4047
- 500: OpenAiApiError;
2934
+ 500: BodhiApiError;
4048
2935
  };
4049
2936
  export type ListAllModelsError = ListAllModelsErrors[keyof ListAllModelsErrors];
4050
2937
  export type ListAllModelsResponses = {
@@ -4064,19 +2951,19 @@ export type ModelsAliasCreateErrors = {
4064
2951
  /**
4065
2952
  * Invalid request parameters
4066
2953
  */
4067
- 400: OpenAiApiError;
2954
+ 400: BodhiApiError;
4068
2955
  /**
4069
2956
  * Not authenticated
4070
2957
  */
4071
- 401: OpenAiApiError;
2958
+ 401: BodhiApiError;
4072
2959
  /**
4073
2960
  * Insufficient permissions
4074
2961
  */
4075
- 403: OpenAiApiError;
2962
+ 403: BodhiApiError;
4076
2963
  /**
4077
2964
  * Internal server error
4078
2965
  */
4079
- 500: OpenAiApiError;
2966
+ 500: BodhiApiError;
4080
2967
  };
4081
2968
  export type ModelsAliasCreateError = ModelsAliasCreateErrors[keyof ModelsAliasCreateErrors];
4082
2969
  export type ModelsAliasCreateResponses = {
@@ -4101,15 +2988,15 @@ export type ModelsAliasDestroyErrors = {
4101
2988
  /**
4102
2989
  * Invalid request parameters
4103
2990
  */
4104
- 400: OpenAiApiError;
2991
+ 400: BodhiApiError;
4105
2992
  /**
4106
2993
  * Not authenticated
4107
2994
  */
4108
- 401: OpenAiApiError;
2995
+ 401: BodhiApiError;
4109
2996
  /**
4110
2997
  * Insufficient permissions
4111
2998
  */
4112
- 403: OpenAiApiError;
2999
+ 403: BodhiApiError;
4113
3000
  /**
4114
3001
  * Alias not found
4115
3002
  */
@@ -4117,7 +3004,7 @@ export type ModelsAliasDestroyErrors = {
4117
3004
  /**
4118
3005
  * Internal server error
4119
3006
  */
4120
- 500: OpenAiApiError;
3007
+ 500: BodhiApiError;
4121
3008
  };
4122
3009
  export type ModelsAliasDestroyError = ModelsAliasDestroyErrors[keyof ModelsAliasDestroyErrors];
4123
3010
  export type ModelsAliasDestroyResponses = {
@@ -4141,19 +3028,19 @@ export type ModelsAliasUpdateErrors = {
4141
3028
  /**
4142
3029
  * Invalid request parameters
4143
3030
  */
4144
- 400: OpenAiApiError;
3031
+ 400: BodhiApiError;
4145
3032
  /**
4146
3033
  * Not authenticated
4147
3034
  */
4148
- 401: OpenAiApiError;
3035
+ 401: BodhiApiError;
4149
3036
  /**
4150
3037
  * Insufficient permissions
4151
3038
  */
4152
- 403: OpenAiApiError;
3039
+ 403: BodhiApiError;
4153
3040
  /**
4154
3041
  * Internal server error
4155
3042
  */
4156
- 500: OpenAiApiError;
3043
+ 500: BodhiApiError;
4157
3044
  };
4158
3045
  export type ModelsAliasUpdateError = ModelsAliasUpdateErrors[keyof ModelsAliasUpdateErrors];
4159
3046
  export type ModelsAliasUpdateResponses = {
@@ -4178,15 +3065,15 @@ export type ModelsAliasCopyErrors = {
4178
3065
  /**
4179
3066
  * Invalid request parameters
4180
3067
  */
4181
- 400: OpenAiApiError;
3068
+ 400: BodhiApiError;
4182
3069
  /**
4183
3070
  * Not authenticated
4184
3071
  */
4185
- 401: OpenAiApiError;
3072
+ 401: BodhiApiError;
4186
3073
  /**
4187
3074
  * Insufficient permissions
4188
3075
  */
4189
- 403: OpenAiApiError;
3076
+ 403: BodhiApiError;
4190
3077
  /**
4191
3078
  * Source alias not found
4192
3079
  */
@@ -4194,7 +3081,7 @@ export type ModelsAliasCopyErrors = {
4194
3081
  /**
4195
3082
  * Internal server error
4196
3083
  */
4197
- 500: OpenAiApiError;
3084
+ 500: BodhiApiError;
4198
3085
  };
4199
3086
  export type ModelsAliasCopyError = ModelsAliasCopyErrors[keyof ModelsAliasCopyErrors];
4200
3087
  export type ModelsAliasCopyResponses = {
@@ -4214,23 +3101,23 @@ export type CreateApiModelErrors = {
4214
3101
  /**
4215
3102
  * Invalid request parameters
4216
3103
  */
4217
- 400: OpenAiApiError;
3104
+ 400: BodhiApiError;
4218
3105
  /**
4219
3106
  * Not authenticated
4220
3107
  */
4221
- 401: OpenAiApiError;
3108
+ 401: BodhiApiError;
4222
3109
  /**
4223
3110
  * Insufficient permissions
4224
3111
  */
4225
- 403: OpenAiApiError;
3112
+ 403: BodhiApiError;
4226
3113
  /**
4227
3114
  * Alias already exists
4228
3115
  */
4229
- 409: OpenAiApiError;
3116
+ 409: BodhiApiError;
4230
3117
  /**
4231
3118
  * Internal server error
4232
3119
  */
4233
- 500: OpenAiApiError;
3120
+ 500: BodhiApiError;
4234
3121
  };
4235
3122
  export type CreateApiModelError = CreateApiModelErrors[keyof CreateApiModelErrors];
4236
3123
  export type CreateApiModelResponses = {
@@ -4250,19 +3137,19 @@ export type FetchApiModelsErrors = {
4250
3137
  /**
4251
3138
  * Invalid request parameters
4252
3139
  */
4253
- 400: OpenAiApiError;
3140
+ 400: BodhiApiError;
4254
3141
  /**
4255
3142
  * Not authenticated
4256
3143
  */
4257
- 401: OpenAiApiError;
3144
+ 401: BodhiApiError;
4258
3145
  /**
4259
3146
  * Insufficient permissions
4260
3147
  */
4261
- 403: OpenAiApiError;
3148
+ 403: BodhiApiError;
4262
3149
  /**
4263
3150
  * Internal server error
4264
3151
  */
4265
- 500: OpenAiApiError;
3152
+ 500: BodhiApiError;
4266
3153
  };
4267
3154
  export type FetchApiModelsError = FetchApiModelsErrors[keyof FetchApiModelsErrors];
4268
3155
  export type FetchApiModelsResponses = {
@@ -4282,19 +3169,19 @@ export type GetApiFormatsErrors = {
4282
3169
  /**
4283
3170
  * Invalid request parameters
4284
3171
  */
4285
- 400: OpenAiApiError;
3172
+ 400: BodhiApiError;
4286
3173
  /**
4287
3174
  * Not authenticated
4288
3175
  */
4289
- 401: OpenAiApiError;
3176
+ 401: BodhiApiError;
4290
3177
  /**
4291
3178
  * Insufficient permissions
4292
3179
  */
4293
- 403: OpenAiApiError;
3180
+ 403: BodhiApiError;
4294
3181
  /**
4295
3182
  * Internal server error
4296
3183
  */
4297
- 500: OpenAiApiError;
3184
+ 500: BodhiApiError;
4298
3185
  };
4299
3186
  export type GetApiFormatsError = GetApiFormatsErrors[keyof GetApiFormatsErrors];
4300
3187
  export type GetApiFormatsResponses = {
@@ -4314,19 +3201,19 @@ export type TestApiModelErrors = {
4314
3201
  /**
4315
3202
  * Invalid request parameters
4316
3203
  */
4317
- 400: OpenAiApiError;
3204
+ 400: BodhiApiError;
4318
3205
  /**
4319
3206
  * Not authenticated
4320
3207
  */
4321
- 401: OpenAiApiError;
3208
+ 401: BodhiApiError;
4322
3209
  /**
4323
3210
  * Insufficient permissions
4324
3211
  */
4325
- 403: OpenAiApiError;
3212
+ 403: BodhiApiError;
4326
3213
  /**
4327
3214
  * Internal server error
4328
3215
  */
4329
- 500: OpenAiApiError;
3216
+ 500: BodhiApiError;
4330
3217
  };
4331
3218
  export type TestApiModelError = TestApiModelErrors[keyof TestApiModelErrors];
4332
3219
  export type TestApiModelResponses = {
@@ -4351,23 +3238,23 @@ export type DeleteApiModelErrors = {
4351
3238
  /**
4352
3239
  * Invalid request parameters
4353
3240
  */
4354
- 400: OpenAiApiError;
3241
+ 400: BodhiApiError;
4355
3242
  /**
4356
3243
  * Not authenticated
4357
3244
  */
4358
- 401: OpenAiApiError;
3245
+ 401: BodhiApiError;
4359
3246
  /**
4360
3247
  * Insufficient permissions
4361
3248
  */
4362
- 403: OpenAiApiError;
3249
+ 403: BodhiApiError;
4363
3250
  /**
4364
3251
  * API model not found
4365
3252
  */
4366
- 404: OpenAiApiError;
3253
+ 404: BodhiApiError;
4367
3254
  /**
4368
3255
  * Internal server error
4369
3256
  */
4370
- 500: OpenAiApiError;
3257
+ 500: BodhiApiError;
4371
3258
  };
4372
3259
  export type DeleteApiModelError = DeleteApiModelErrors[keyof DeleteApiModelErrors];
4373
3260
  export type DeleteApiModelResponses = {
@@ -4392,23 +3279,23 @@ export type GetApiModelErrors = {
4392
3279
  /**
4393
3280
  * Invalid request parameters
4394
3281
  */
4395
- 400: OpenAiApiError;
3282
+ 400: BodhiApiError;
4396
3283
  /**
4397
3284
  * Not authenticated
4398
3285
  */
4399
- 401: OpenAiApiError;
3286
+ 401: BodhiApiError;
4400
3287
  /**
4401
3288
  * Insufficient permissions
4402
3289
  */
4403
- 403: OpenAiApiError;
3290
+ 403: BodhiApiError;
4404
3291
  /**
4405
3292
  * API model with specified ID not found
4406
3293
  */
4407
- 404: OpenAiApiError;
3294
+ 404: BodhiApiError;
4408
3295
  /**
4409
3296
  * Internal server error
4410
3297
  */
4411
- 500: OpenAiApiError;
3298
+ 500: BodhiApiError;
4412
3299
  };
4413
3300
  export type GetApiModelError = GetApiModelErrors[keyof GetApiModelErrors];
4414
3301
  export type GetApiModelResponses = {
@@ -4433,23 +3320,23 @@ export type UpdateApiModelErrors = {
4433
3320
  /**
4434
3321
  * Invalid request parameters
4435
3322
  */
4436
- 400: OpenAiApiError;
3323
+ 400: BodhiApiError;
4437
3324
  /**
4438
3325
  * Not authenticated
4439
3326
  */
4440
- 401: OpenAiApiError;
3327
+ 401: BodhiApiError;
4441
3328
  /**
4442
3329
  * Insufficient permissions
4443
3330
  */
4444
- 403: OpenAiApiError;
3331
+ 403: BodhiApiError;
4445
3332
  /**
4446
3333
  * API model not found
4447
3334
  */
4448
- 404: OpenAiApiError;
3335
+ 404: BodhiApiError;
4449
3336
  /**
4450
3337
  * Internal server error
4451
3338
  */
4452
- 500: OpenAiApiError;
3339
+ 500: BodhiApiError;
4453
3340
  };
4454
3341
  export type UpdateApiModelError = UpdateApiModelErrors[keyof UpdateApiModelErrors];
4455
3342
  export type UpdateApiModelResponses = {
@@ -4474,15 +3361,15 @@ export type SyncModelsErrors = {
4474
3361
  /**
4475
3362
  * Invalid request parameters
4476
3363
  */
4477
- 400: OpenAiApiError;
3364
+ 400: BodhiApiError;
4478
3365
  /**
4479
3366
  * Not authenticated
4480
3367
  */
4481
- 401: OpenAiApiError;
3368
+ 401: BodhiApiError;
4482
3369
  /**
4483
3370
  * Insufficient permissions
4484
3371
  */
4485
- 403: OpenAiApiError;
3372
+ 403: BodhiApiError;
4486
3373
  /**
4487
3374
  * API model not found
4488
3375
  */
@@ -4490,7 +3377,7 @@ export type SyncModelsErrors = {
4490
3377
  /**
4491
3378
  * Internal server error
4492
3379
  */
4493
- 500: OpenAiApiError;
3380
+ 500: BodhiApiError;
4494
3381
  };
4495
3382
  export type SyncModelsError = SyncModelsErrors[keyof SyncModelsErrors];
4496
3383
  export type SyncModelsResponses = {
@@ -4527,19 +3414,19 @@ export type ListModelFilesErrors = {
4527
3414
  /**
4528
3415
  * Invalid request parameters
4529
3416
  */
4530
- 400: OpenAiApiError;
3417
+ 400: BodhiApiError;
4531
3418
  /**
4532
3419
  * Not authenticated
4533
3420
  */
4534
- 401: OpenAiApiError;
3421
+ 401: BodhiApiError;
4535
3422
  /**
4536
3423
  * Insufficient permissions
4537
3424
  */
4538
- 403: OpenAiApiError;
3425
+ 403: BodhiApiError;
4539
3426
  /**
4540
3427
  * Internal server error
4541
3428
  */
4542
- 500: OpenAiApiError;
3429
+ 500: BodhiApiError;
4543
3430
  };
4544
3431
  export type ListModelFilesError = ListModelFilesErrors[keyof ListModelFilesErrors];
4545
3432
  export type ListModelFilesResponses = {
@@ -4576,19 +3463,19 @@ export type ListDownloadsErrors = {
4576
3463
  /**
4577
3464
  * Invalid request parameters
4578
3465
  */
4579
- 400: OpenAiApiError;
3466
+ 400: BodhiApiError;
4580
3467
  /**
4581
3468
  * Not authenticated
4582
3469
  */
4583
- 401: OpenAiApiError;
3470
+ 401: BodhiApiError;
4584
3471
  /**
4585
3472
  * Insufficient permissions
4586
3473
  */
4587
- 403: OpenAiApiError;
3474
+ 403: BodhiApiError;
4588
3475
  /**
4589
3476
  * Internal server error
4590
3477
  */
4591
- 500: OpenAiApiError;
3478
+ 500: BodhiApiError;
4592
3479
  };
4593
3480
  export type ListDownloadsError = ListDownloadsErrors[keyof ListDownloadsErrors];
4594
3481
  export type ListDownloadsResponses = {
@@ -4611,19 +3498,19 @@ export type PullModelFileErrors = {
4611
3498
  /**
4612
3499
  * Invalid request parameters
4613
3500
  */
4614
- 400: OpenAiApiError;
3501
+ 400: BodhiApiError;
4615
3502
  /**
4616
3503
  * Not authenticated
4617
3504
  */
4618
- 401: OpenAiApiError;
3505
+ 401: BodhiApiError;
4619
3506
  /**
4620
3507
  * Insufficient permissions
4621
3508
  */
4622
- 403: OpenAiApiError;
3509
+ 403: BodhiApiError;
4623
3510
  /**
4624
3511
  * Internal server error
4625
3512
  */
4626
- 500: OpenAiApiError;
3513
+ 500: BodhiApiError;
4627
3514
  };
4628
3515
  export type PullModelFileError = PullModelFileErrors[keyof PullModelFileErrors];
4629
3516
  export type PullModelFileResponses = {
@@ -4652,23 +3539,23 @@ export type GetDownloadStatusErrors = {
4652
3539
  /**
4653
3540
  * Invalid request parameters
4654
3541
  */
4655
- 400: OpenAiApiError;
3542
+ 400: BodhiApiError;
4656
3543
  /**
4657
3544
  * Not authenticated
4658
3545
  */
4659
- 401: OpenAiApiError;
3546
+ 401: BodhiApiError;
4660
3547
  /**
4661
3548
  * Insufficient permissions
4662
3549
  */
4663
- 403: OpenAiApiError;
3550
+ 403: BodhiApiError;
4664
3551
  /**
4665
3552
  * Download request not found
4666
3553
  */
4667
- 404: OpenAiApiError;
3554
+ 404: BodhiApiError;
4668
3555
  /**
4669
3556
  * Internal server error
4670
3557
  */
4671
- 500: OpenAiApiError;
3558
+ 500: BodhiApiError;
4672
3559
  };
4673
3560
  export type GetDownloadStatusError = GetDownloadStatusErrors[keyof GetDownloadStatusErrors];
4674
3561
  export type GetDownloadStatusResponses = {
@@ -4691,15 +3578,15 @@ export type RefreshModelMetadataErrors = {
4691
3578
  /**
4692
3579
  * Invalid request parameters
4693
3580
  */
4694
- 400: OpenAiApiError;
3581
+ 400: BodhiApiError;
4695
3582
  /**
4696
3583
  * Not authenticated
4697
3584
  */
4698
- 401: OpenAiApiError;
3585
+ 401: BodhiApiError;
4699
3586
  /**
4700
3587
  * Insufficient permissions
4701
3588
  */
4702
- 403: OpenAiApiError;
3589
+ 403: BodhiApiError;
4703
3590
  /**
4704
3591
  * Model alias not found for specified repo/filename/snapshot
4705
3592
  */
@@ -4707,7 +3594,7 @@ export type RefreshModelMetadataErrors = {
4707
3594
  /**
4708
3595
  * Internal server error
4709
3596
  */
4710
- 500: OpenAiApiError;
3597
+ 500: BodhiApiError;
4711
3598
  };
4712
3599
  export type RefreshModelMetadataError = RefreshModelMetadataErrors[keyof RefreshModelMetadataErrors];
4713
3600
  export type RefreshModelMetadataResponses = {
@@ -4736,23 +3623,23 @@ export type GetAliasErrors = {
4736
3623
  /**
4737
3624
  * Invalid request parameters
4738
3625
  */
4739
- 400: OpenAiApiError;
3626
+ 400: BodhiApiError;
4740
3627
  /**
4741
3628
  * Not authenticated
4742
3629
  */
4743
- 401: OpenAiApiError;
3630
+ 401: BodhiApiError;
4744
3631
  /**
4745
3632
  * Insufficient permissions
4746
3633
  */
4747
- 403: OpenAiApiError;
3634
+ 403: BodhiApiError;
4748
3635
  /**
4749
3636
  * Alias not found
4750
3637
  */
4751
- 404: OpenAiApiError;
3638
+ 404: BodhiApiError;
4752
3639
  /**
4753
3640
  * Internal server error
4754
3641
  */
4755
- 500: OpenAiApiError;
3642
+ 500: BodhiApiError;
4756
3643
  };
4757
3644
  export type GetAliasError = GetAliasErrors[keyof GetAliasErrors];
4758
3645
  export type GetAliasResponses = {
@@ -4772,19 +3659,19 @@ export type GetQueueStatusErrors = {
4772
3659
  /**
4773
3660
  * Invalid request parameters
4774
3661
  */
4775
- 400: OpenAiApiError;
3662
+ 400: BodhiApiError;
4776
3663
  /**
4777
3664
  * Not authenticated
4778
3665
  */
4779
- 401: OpenAiApiError;
3666
+ 401: BodhiApiError;
4780
3667
  /**
4781
3668
  * Insufficient permissions
4782
3669
  */
4783
- 403: OpenAiApiError;
3670
+ 403: BodhiApiError;
4784
3671
  /**
4785
3672
  * Internal server error
4786
3673
  */
4787
- 500: OpenAiApiError;
3674
+ 500: BodhiApiError;
4788
3675
  };
4789
3676
  export type GetQueueStatusError = GetQueueStatusErrors[keyof GetQueueStatusErrors];
4790
3677
  export type GetQueueStatusResponses = {
@@ -4804,19 +3691,19 @@ export type ListSettingsErrors = {
4804
3691
  /**
4805
3692
  * Invalid request parameters
4806
3693
  */
4807
- 400: OpenAiApiError;
3694
+ 400: BodhiApiError;
4808
3695
  /**
4809
3696
  * Not authenticated
4810
3697
  */
4811
- 401: OpenAiApiError;
3698
+ 401: BodhiApiError;
4812
3699
  /**
4813
3700
  * Insufficient permissions
4814
3701
  */
4815
- 403: OpenAiApiError;
3702
+ 403: BodhiApiError;
4816
3703
  /**
4817
3704
  * Internal server error
4818
3705
  */
4819
- 500: OpenAiApiError;
3706
+ 500: BodhiApiError;
4820
3707
  };
4821
3708
  export type ListSettingsError = ListSettingsErrors[keyof ListSettingsErrors];
4822
3709
  export type ListSettingsResponses = {
@@ -4841,23 +3728,23 @@ export type DeleteSettingErrors = {
4841
3728
  /**
4842
3729
  * Invalid request parameters
4843
3730
  */
4844
- 400: OpenAiApiError;
3731
+ 400: BodhiApiError;
4845
3732
  /**
4846
3733
  * Not authenticated
4847
3734
  */
4848
- 401: OpenAiApiError;
3735
+ 401: BodhiApiError;
4849
3736
  /**
4850
3737
  * Insufficient permissions
4851
3738
  */
4852
- 403: OpenAiApiError;
3739
+ 403: BodhiApiError;
4853
3740
  /**
4854
3741
  * Setting not found
4855
3742
  */
4856
- 404: OpenAiApiError;
3743
+ 404: BodhiApiError;
4857
3744
  /**
4858
3745
  * Internal server error
4859
3746
  */
4860
- 500: OpenAiApiError;
3747
+ 500: BodhiApiError;
4861
3748
  };
4862
3749
  export type DeleteSettingError = DeleteSettingErrors[keyof DeleteSettingErrors];
4863
3750
  export type DeleteSettingResponses = {
@@ -4890,23 +3777,23 @@ export type UpdateSettingErrors = {
4890
3777
  /**
4891
3778
  * Invalid request parameters
4892
3779
  */
4893
- 400: OpenAiApiError;
3780
+ 400: BodhiApiError;
4894
3781
  /**
4895
3782
  * Not authenticated
4896
3783
  */
4897
- 401: OpenAiApiError;
3784
+ 401: BodhiApiError;
4898
3785
  /**
4899
3786
  * Insufficient permissions
4900
3787
  */
4901
- 403: OpenAiApiError;
3788
+ 403: BodhiApiError;
4902
3789
  /**
4903
3790
  * Setting not found
4904
3791
  */
4905
- 404: OpenAiApiError;
3792
+ 404: BodhiApiError;
4906
3793
  /**
4907
3794
  * Internal server error
4908
3795
  */
4909
- 500: OpenAiApiError;
3796
+ 500: BodhiApiError;
4910
3797
  };
4911
3798
  export type UpdateSettingError = UpdateSettingErrors[keyof UpdateSettingErrors];
4912
3799
  export type UpdateSettingResponses = {
@@ -4929,11 +3816,11 @@ export type SetupAppErrors = {
4929
3816
  /**
4930
3817
  * Invalid request parameters
4931
3818
  */
4932
- 400: OpenAiApiError;
3819
+ 400: BodhiApiError;
4933
3820
  /**
4934
3821
  * Internal server error
4935
3822
  */
4936
- 500: OpenAiApiError;
3823
+ 500: BodhiApiError;
4937
3824
  };
4938
3825
  export type SetupAppError = SetupAppErrors[keyof SetupAppErrors];
4939
3826
  export type SetupAppResponses = {
@@ -4953,19 +3840,19 @@ export type TenantsListErrors = {
4953
3840
  /**
4954
3841
  * Invalid request parameters
4955
3842
  */
4956
- 400: OpenAiApiError;
3843
+ 400: BodhiApiError;
4957
3844
  /**
4958
3845
  * Not authenticated
4959
3846
  */
4960
- 401: OpenAiApiError;
3847
+ 401: BodhiApiError;
4961
3848
  /**
4962
3849
  * Insufficient permissions
4963
3850
  */
4964
- 403: OpenAiApiError;
3851
+ 403: BodhiApiError;
4965
3852
  /**
4966
3853
  * Internal server error
4967
3854
  */
4968
- 500: OpenAiApiError;
3855
+ 500: BodhiApiError;
4969
3856
  };
4970
3857
  export type TenantsListError = TenantsListErrors[keyof TenantsListErrors];
4971
3858
  export type TenantsListResponses = {
@@ -4988,19 +3875,19 @@ export type TenantsCreateErrors = {
4988
3875
  /**
4989
3876
  * Invalid request parameters
4990
3877
  */
4991
- 400: OpenAiApiError;
3878
+ 400: BodhiApiError;
4992
3879
  /**
4993
3880
  * Not authenticated
4994
3881
  */
4995
- 401: OpenAiApiError;
3882
+ 401: BodhiApiError;
4996
3883
  /**
4997
3884
  * Insufficient permissions
4998
3885
  */
4999
- 403: OpenAiApiError;
3886
+ 403: BodhiApiError;
5000
3887
  /**
5001
3888
  * Internal server error
5002
3889
  */
5003
- 500: OpenAiApiError;
3890
+ 500: BodhiApiError;
5004
3891
  };
5005
3892
  export type TenantsCreateError = TenantsCreateErrors[keyof TenantsCreateErrors];
5006
3893
  export type TenantsCreateResponses = {
@@ -5025,19 +3912,19 @@ export type TenantsActivateErrors = {
5025
3912
  /**
5026
3913
  * Invalid request parameters
5027
3914
  */
5028
- 400: OpenAiApiError;
3915
+ 400: BodhiApiError;
5029
3916
  /**
5030
3917
  * Not authenticated
5031
3918
  */
5032
- 401: OpenAiApiError;
3919
+ 401: BodhiApiError;
5033
3920
  /**
5034
3921
  * Insufficient permissions
5035
3922
  */
5036
- 403: OpenAiApiError;
3923
+ 403: BodhiApiError;
5037
3924
  /**
5038
3925
  * Internal server error
5039
3926
  */
5040
- 500: OpenAiApiError;
3927
+ 500: BodhiApiError;
5041
3928
  };
5042
3929
  export type TenantsActivateError = TenantsActivateErrors[keyof TenantsActivateErrors];
5043
3930
  export type TenantsActivateResponses = {
@@ -5073,19 +3960,19 @@ export type ListApiTokensErrors = {
5073
3960
  /**
5074
3961
  * Invalid request parameters
5075
3962
  */
5076
- 400: OpenAiApiError;
3963
+ 400: BodhiApiError;
5077
3964
  /**
5078
3965
  * Not authenticated
5079
3966
  */
5080
- 401: OpenAiApiError;
3967
+ 401: BodhiApiError;
5081
3968
  /**
5082
3969
  * Insufficient permissions
5083
3970
  */
5084
- 403: OpenAiApiError;
3971
+ 403: BodhiApiError;
5085
3972
  /**
5086
3973
  * Internal server error
5087
3974
  */
5088
- 500: OpenAiApiError;
3975
+ 500: BodhiApiError;
5089
3976
  };
5090
3977
  export type ListApiTokensError = ListApiTokensErrors[keyof ListApiTokensErrors];
5091
3978
  export type ListApiTokensResponses = {
@@ -5108,19 +3995,19 @@ export type CreateApiTokenErrors = {
5108
3995
  /**
5109
3996
  * Invalid request parameters
5110
3997
  */
5111
- 400: OpenAiApiError;
3998
+ 400: BodhiApiError;
5112
3999
  /**
5113
4000
  * Not authenticated
5114
4001
  */
5115
- 401: OpenAiApiError;
4002
+ 401: BodhiApiError;
5116
4003
  /**
5117
4004
  * Insufficient permissions
5118
4005
  */
5119
- 403: OpenAiApiError;
4006
+ 403: BodhiApiError;
5120
4007
  /**
5121
4008
  * Internal server error
5122
4009
  */
5123
- 500: OpenAiApiError;
4010
+ 500: BodhiApiError;
5124
4011
  };
5125
4012
  export type CreateApiTokenError = CreateApiTokenErrors[keyof CreateApiTokenErrors];
5126
4013
  export type CreateApiTokenResponses = {
@@ -5148,23 +4035,23 @@ export type UpdateApiTokenErrors = {
5148
4035
  /**
5149
4036
  * Invalid request parameters
5150
4037
  */
5151
- 400: OpenAiApiError;
4038
+ 400: BodhiApiError;
5152
4039
  /**
5153
4040
  * Not authenticated
5154
4041
  */
5155
- 401: OpenAiApiError;
4042
+ 401: BodhiApiError;
5156
4043
  /**
5157
4044
  * Insufficient permissions
5158
4045
  */
5159
- 403: OpenAiApiError;
4046
+ 403: BodhiApiError;
5160
4047
  /**
5161
4048
  * Token not found
5162
4049
  */
5163
- 404: OpenAiApiError;
4050
+ 404: BodhiApiError;
5164
4051
  /**
5165
4052
  * Internal server error
5166
4053
  */
5167
- 500: OpenAiApiError;
4054
+ 500: BodhiApiError;
5168
4055
  };
5169
4056
  export type UpdateApiTokenError = UpdateApiTokenErrors[keyof UpdateApiTokenErrors];
5170
4057
  export type UpdateApiTokenResponses = {
@@ -5184,19 +4071,19 @@ export type GetCurrentUserErrors = {
5184
4071
  /**
5185
4072
  * Invalid request parameters
5186
4073
  */
5187
- 400: OpenAiApiError;
4074
+ 400: BodhiApiError;
5188
4075
  /**
5189
4076
  * Not authenticated
5190
4077
  */
5191
- 401: OpenAiApiError;
4078
+ 401: BodhiApiError;
5192
4079
  /**
5193
4080
  * Insufficient permissions
5194
4081
  */
5195
- 403: OpenAiApiError;
4082
+ 403: BodhiApiError;
5196
4083
  /**
5197
4084
  * Internal server error
5198
4085
  */
5199
- 500: OpenAiApiError;
4086
+ 500: BodhiApiError;
5200
4087
  };
5201
4088
  export type GetCurrentUserError = GetCurrentUserErrors[keyof GetCurrentUserErrors];
5202
4089
  export type GetCurrentUserResponses = {
@@ -5216,27 +4103,27 @@ export type RequestUserAccessErrors = {
5216
4103
  /**
5217
4104
  * Invalid request parameters
5218
4105
  */
5219
- 400: OpenAiApiError;
4106
+ 400: BodhiApiError;
5220
4107
  /**
5221
4108
  * Not authenticated
5222
4109
  */
5223
- 401: OpenAiApiError;
4110
+ 401: BodhiApiError;
5224
4111
  /**
5225
4112
  * Insufficient permissions
5226
4113
  */
5227
- 403: OpenAiApiError;
4114
+ 403: BodhiApiError;
5228
4115
  /**
5229
4116
  * Pending request already exists
5230
4117
  */
5231
- 409: OpenAiApiError;
4118
+ 409: BodhiApiError;
5232
4119
  /**
5233
4120
  * User already has role
5234
4121
  */
5235
- 422: OpenAiApiError;
4122
+ 422: BodhiApiError;
5236
4123
  /**
5237
4124
  * Internal server error
5238
4125
  */
5239
- 500: OpenAiApiError;
4126
+ 500: BodhiApiError;
5240
4127
  };
5241
4128
  export type RequestUserAccessError = RequestUserAccessErrors[keyof RequestUserAccessErrors];
5242
4129
  export type RequestUserAccessResponses = {
@@ -5255,23 +4142,23 @@ export type GetUserAccessStatusErrors = {
5255
4142
  /**
5256
4143
  * Invalid request parameters
5257
4144
  */
5258
- 400: OpenAiApiError;
4145
+ 400: BodhiApiError;
5259
4146
  /**
5260
4147
  * Not authenticated
5261
4148
  */
5262
- 401: OpenAiApiError;
4149
+ 401: BodhiApiError;
5263
4150
  /**
5264
4151
  * Insufficient permissions
5265
4152
  */
5266
- 403: OpenAiApiError;
4153
+ 403: BodhiApiError;
5267
4154
  /**
5268
4155
  * Request not found
5269
4156
  */
5270
- 404: OpenAiApiError;
4157
+ 404: BodhiApiError;
5271
4158
  /**
5272
4159
  * Internal server error
5273
4160
  */
5274
- 500: OpenAiApiError;
4161
+ 500: BodhiApiError;
5275
4162
  };
5276
4163
  export type GetUserAccessStatusError = GetUserAccessStatusErrors[keyof GetUserAccessStatusErrors];
5277
4164
  export type GetUserAccessStatusResponses = {
@@ -5300,19 +4187,19 @@ export type ListUsersErrors = {
5300
4187
  /**
5301
4188
  * Invalid request parameters
5302
4189
  */
5303
- 400: OpenAiApiError;
4190
+ 400: BodhiApiError;
5304
4191
  /**
5305
4192
  * Not authenticated
5306
4193
  */
5307
- 401: OpenAiApiError;
4194
+ 401: BodhiApiError;
5308
4195
  /**
5309
4196
  * Insufficient permissions
5310
4197
  */
5311
- 403: OpenAiApiError;
4198
+ 403: BodhiApiError;
5312
4199
  /**
5313
4200
  * Internal server error
5314
4201
  */
5315
- 500: OpenAiApiError;
4202
+ 500: BodhiApiError;
5316
4203
  };
5317
4204
  export type ListUsersError = ListUsersErrors[keyof ListUsersErrors];
5318
4205
  export type ListUsersResponses = {
@@ -5337,23 +4224,23 @@ export type RemoveUserErrors = {
5337
4224
  /**
5338
4225
  * Invalid request parameters
5339
4226
  */
5340
- 400: OpenAiApiError;
4227
+ 400: BodhiApiError;
5341
4228
  /**
5342
4229
  * Not authenticated
5343
4230
  */
5344
- 401: OpenAiApiError;
4231
+ 401: BodhiApiError;
5345
4232
  /**
5346
4233
  * Insufficient permissions
5347
4234
  */
5348
- 403: OpenAiApiError;
4235
+ 403: BodhiApiError;
5349
4236
  /**
5350
4237
  * User not found
5351
4238
  */
5352
- 404: OpenAiApiError;
4239
+ 404: BodhiApiError;
5353
4240
  /**
5354
4241
  * Internal server error
5355
4242
  */
5356
- 500: OpenAiApiError;
4243
+ 500: BodhiApiError;
5357
4244
  };
5358
4245
  export type RemoveUserError = RemoveUserErrors[keyof RemoveUserErrors];
5359
4246
  export type RemoveUserResponses = {
@@ -5377,23 +4264,23 @@ export type ChangeUserRoleErrors = {
5377
4264
  /**
5378
4265
  * Invalid request parameters
5379
4266
  */
5380
- 400: OpenAiApiError;
4267
+ 400: BodhiApiError;
5381
4268
  /**
5382
4269
  * Not authenticated
5383
4270
  */
5384
- 401: OpenAiApiError;
4271
+ 401: BodhiApiError;
5385
4272
  /**
5386
4273
  * Insufficient permissions
5387
4274
  */
5388
- 403: OpenAiApiError;
4275
+ 403: BodhiApiError;
5389
4276
  /**
5390
4277
  * User not found
5391
4278
  */
5392
- 404: OpenAiApiError;
4279
+ 404: BodhiApiError;
5393
4280
  /**
5394
4281
  * Internal server error
5395
4282
  */
5396
- 500: OpenAiApiError;
4283
+ 500: BodhiApiError;
5397
4284
  };
5398
4285
  export type ChangeUserRoleError = ChangeUserRoleErrors[keyof ChangeUserRoleErrors];
5399
4286
  export type ChangeUserRoleResponses = {
@@ -5412,11 +4299,11 @@ export type HealthCheckErrors = {
5412
4299
  /**
5413
4300
  * Invalid request parameters
5414
4301
  */
5415
- 400: OpenAiApiError;
4302
+ 400: BodhiApiError;
5416
4303
  /**
5417
4304
  * Internal server error
5418
4305
  */
5419
- 500: OpenAiApiError;
4306
+ 500: BodhiApiError;
5420
4307
  };
5421
4308
  export type HealthCheckError = HealthCheckErrors[keyof HealthCheckErrors];
5422
4309
  export type HealthCheckResponses = {
@@ -5436,11 +4323,11 @@ export type PingServerErrors = {
5436
4323
  /**
5437
4324
  * Invalid request parameters
5438
4325
  */
5439
- 400: OpenAiApiError;
4326
+ 400: BodhiApiError;
5440
4327
  /**
5441
4328
  * Internal server error
5442
4329
  */
5443
- 500: OpenAiApiError;
4330
+ 500: BodhiApiError;
5444
4331
  };
5445
4332
  export type PingServerError = PingServerErrors[keyof PingServerErrors];
5446
4333
  export type PingServerResponses = {
@@ -5450,147 +4337,6 @@ export type PingServerResponses = {
5450
4337
  200: PingResponse;
5451
4338
  };
5452
4339
  export type PingServerResponse = PingServerResponses[keyof PingServerResponses];
5453
- export type CreateChatCompletionData = {
5454
- body: CreateChatCompletionRequest;
5455
- path?: never;
5456
- query?: never;
5457
- url: '/v1/chat/completions';
5458
- };
5459
- export type CreateChatCompletionErrors = {
5460
- /**
5461
- * Invalid request parameters
5462
- */
5463
- 400: OpenAiApiError;
5464
- /**
5465
- * Not authenticated
5466
- */
5467
- 401: OpenAiApiError;
5468
- /**
5469
- * Insufficient permissions
5470
- */
5471
- 403: OpenAiApiError;
5472
- /**
5473
- * Internal server error
5474
- */
5475
- 500: OpenAiApiError;
5476
- };
5477
- export type CreateChatCompletionError = CreateChatCompletionErrors[keyof CreateChatCompletionErrors];
5478
- export type CreateChatCompletionResponses = {
5479
- /**
5480
- * Chat completion response
5481
- */
5482
- 200: CreateChatCompletionResponse;
5483
- /**
5484
- * Chat completion stream, the status is 200, using 201 to avoid OpenAPI format limitation.
5485
- */
5486
- 201: CreateChatCompletionStreamResponse;
5487
- };
5488
- export type CreateChatCompletionResponse2 = CreateChatCompletionResponses[keyof CreateChatCompletionResponses];
5489
- export type CreateEmbeddingData = {
5490
- body: CreateEmbeddingRequest;
5491
- path?: never;
5492
- query?: never;
5493
- url: '/v1/embeddings';
5494
- };
5495
- export type CreateEmbeddingErrors = {
5496
- /**
5497
- * Invalid request parameters
5498
- */
5499
- 400: OpenAiApiError;
5500
- /**
5501
- * Not authenticated
5502
- */
5503
- 401: OpenAiApiError;
5504
- /**
5505
- * Insufficient permissions
5506
- */
5507
- 403: OpenAiApiError;
5508
- /**
5509
- * Internal server error
5510
- */
5511
- 500: OpenAiApiError;
5512
- };
5513
- export type CreateEmbeddingError = CreateEmbeddingErrors[keyof CreateEmbeddingErrors];
5514
- export type CreateEmbeddingResponses = {
5515
- /**
5516
- * Embedding response
5517
- */
5518
- 200: CreateEmbeddingResponse;
5519
- };
5520
- export type CreateEmbeddingResponse2 = CreateEmbeddingResponses[keyof CreateEmbeddingResponses];
5521
- export type ListModelsData = {
5522
- body?: never;
5523
- path?: never;
5524
- query?: never;
5525
- url: '/v1/models';
5526
- };
5527
- export type ListModelsErrors = {
5528
- /**
5529
- * Invalid request parameters
5530
- */
5531
- 400: OpenAiApiError;
5532
- /**
5533
- * Not authenticated
5534
- */
5535
- 401: OpenAiApiError;
5536
- /**
5537
- * Insufficient permissions
5538
- */
5539
- 403: OpenAiApiError;
5540
- /**
5541
- * Internal server error
5542
- */
5543
- 500: OpenAiApiError;
5544
- };
5545
- export type ListModelsError = ListModelsErrors[keyof ListModelsErrors];
5546
- export type ListModelsResponses = {
5547
- /**
5548
- * List of available models
5549
- */
5550
- 200: ListModelResponse;
5551
- };
5552
- export type ListModelsResponse = ListModelsResponses[keyof ListModelsResponses];
5553
- export type GetModelData = {
5554
- body?: never;
5555
- path: {
5556
- /**
5557
- * Model identifier - can be user alias (e.g., 'llama2:chat'), model alias, or API provider alias
5558
- */
5559
- id: string;
5560
- };
5561
- query?: never;
5562
- url: '/v1/models/{id}';
5563
- };
5564
- export type GetModelErrors = {
5565
- /**
5566
- * Invalid request parameters
5567
- */
5568
- 400: OpenAiApiError;
5569
- /**
5570
- * Not authenticated
5571
- */
5572
- 401: OpenAiApiError;
5573
- /**
5574
- * Insufficient permissions
5575
- */
5576
- 403: OpenAiApiError;
5577
- /**
5578
- * Model not found
5579
- */
5580
- 404: OpenAiApiError;
5581
- /**
5582
- * Internal server error
5583
- */
5584
- 500: OpenAiApiError;
5585
- };
5586
- export type GetModelError = GetModelErrors[keyof GetModelErrors];
5587
- export type GetModelResponses = {
5588
- /**
5589
- * Model details
5590
- */
5591
- 200: Model;
5592
- };
5593
- export type GetModelResponse = GetModelResponses[keyof GetModelResponses];
5594
4340
  export type ClientOptions = {
5595
4341
  baseUrl: 'http://localhost:1135' | (string & {});
5596
4342
  };