@bodhiapp/ts-client 0.1.26 → 0.1.27

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.
@@ -118,7 +118,7 @@ export type ApiAliasResponse = {
118
118
  /**
119
119
  * API format/protocol specification
120
120
  */
121
- export type ApiFormat = 'openai' | 'placeholder';
121
+ export type ApiFormat = 'openai' | 'openai_responses' | 'placeholder';
122
122
  /**
123
123
  * Response containing available API formats
124
124
  */
@@ -263,468 +263,40 @@ export type AuthInitiateRequest = {
263
263
  */
264
264
  client_id: string;
265
265
  };
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 = {
266
+ export type BodhiApiError = {
350
267
  /**
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;
453
- /**
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.
268
+ * Error details following OpenAI API error format
633
269
  */
634
- reasoning_content?: string | null;
270
+ error: BodhiErrorBody;
635
271
  };
636
- export type ChatCompletionTokenLogprob = {
637
- /**
638
- * The token.
639
- */
640
- token: string;
641
- /**
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.
643
- */
644
- logprob: number;
272
+ export type BodhiErrorBody = {
645
273
  /**
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.
647
- */
648
- bytes?: Array<number> | null;
649
- /**
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.
274
+ * Human-readable error message describing what went wrong
651
275
  */
652
- top_logprobs: Array<TopLogprobs>;
653
- };
654
- export type ChatCompletionTool = {
655
- function: FunctionObject;
656
- };
657
- /**
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.
665
- */
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;
687
- };
688
- /**
689
- * Breakdown of tokens used in a completion.
690
- */
691
- export type CompletionTokensDetails = {
692
- accepted_prediction_tokens?: number | null;
276
+ message: string;
693
277
  /**
694
- * Audio input tokens generated by the model.
278
+ * Error type categorizing the kind of error that occurred
695
279
  */
696
- audio_tokens?: number | null;
280
+ type: string;
697
281
  /**
698
- * Tokens generated by the model for reasoning.
282
+ * Specific error code for programmatic error handling
699
283
  */
700
- reasoning_tokens?: number | null;
284
+ code?: string | null;
701
285
  /**
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.
286
+ * Additional error parameters as key-value pairs (for validation errors)
707
287
  */
708
- rejected_prediction_tokens?: number | null;
288
+ param?: {
289
+ [key: string]: string;
290
+ } | null;
709
291
  };
710
292
  /**
711
- * Usage statistics for the completion request.
293
+ * Change user role request
712
294
  */
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;
295
+ export type ChangeRoleRequest = {
722
296
  /**
723
- * Total number of tokens used in the request (prompt + completion).
297
+ * Role to assign to the user
724
298
  */
725
- total_tokens: number;
726
- prompt_tokens_details?: null | PromptTokensDetails;
727
- completion_tokens_details?: null | CompletionTokensDetails;
299
+ role: ResourceRole;
728
300
  };
729
301
  export type ContextLimits = {
730
302
  max_input_tokens?: number | null;
@@ -778,298 +350,6 @@ export type CreateAccessRequestResponse = {
778
350
  export type CreateAuthConfig = CreateMcpAuthConfigRequest & {
779
351
  mcp_server_id: string;
780
352
  };
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
353
  /**
1074
354
  * Discriminated union for creating any type of MCP auth config.
1075
355
  * The JSON `"type"` field determines the variant: `"header"` or `"oauth"`.
@@ -1112,55 +392,6 @@ export type CreateTokenRequest = {
1112
392
  */
1113
393
  scope: TokenScope;
1114
394
  };
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
395
  /**
1165
396
  * Dashboard user information from a validated dashboard session token
1166
397
  */
@@ -1184,7 +415,6 @@ export type DownloadRequest = {
1184
415
  updated_at: string;
1185
416
  };
1186
417
  export type DownloadStatus = 'pending' | 'completed' | 'error';
1187
- export type Duration = string;
1188
418
  export type DynamicRegisterRequest = {
1189
419
  registration_endpoint: string;
1190
420
  redirect_uri: string;
@@ -1197,56 +427,6 @@ export type DynamicRegisterResponse = {
1197
427
  token_endpoint_auth_method?: string | null;
1198
428
  registration_access_token?: string | null;
1199
429
  };
1200
- /**
1201
- * Represents an embedding vector returned by embedding endpoint.
1202
- */
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;
1249
- };
1250
430
  /**
1251
431
  * Request to fetch available models from provider
1252
432
  */
@@ -1266,97 +446,7 @@ export type FetchModelsRequest = {
1266
446
  export type FetchModelsResponse = {
1267
447
  models: Array<string>;
1268
448
  };
1269
- export type FileObject = {
1270
- /**
1271
- * The base64 encoded file data, used when passing the file to the model
1272
- * as a string.
1273
- */
1274
- file_data?: string | null;
1275
- /**
1276
- * The ID of an uploaded file to use as input.
1277
- */
1278
- file_id?: string | null;
1279
- /**
1280
- * The name of the file, used when passing the file to the model as a
1281
- * string.
1282
- */
1283
- filename?: string | null;
1284
- };
1285
- export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
1286
449
  export type FlowType = 'redirect' | 'popup';
1287
- /**
1288
- * The name and arguments of a function that should be called, as generated by the model.
1289
- */
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;
1318
- };
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
- */
1323
- 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
- */
1327
- 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;
1358
- };
1359
- export type InputAudioFormat = 'wav' | 'mp3';
1360
450
  export type JsonVec = Array<string>;
1361
451
  export type ListMcpServersResponse = {
1362
452
  mcp_servers: Array<McpServerResponse>;
@@ -1364,10 +454,6 @@ export type ListMcpServersResponse = {
1364
454
  export type ListMcpsResponse = {
1365
455
  mcps: Array<Mcp>;
1366
456
  };
1367
- export type ListModelResponse = {
1368
- object: string;
1369
- data: Array<Model>;
1370
- };
1371
457
  /**
1372
458
  * List users query parameters. Intentionally omits sort fields (unlike PaginationSortParams)
1373
459
  * because user listing is fetched from the auth service which handles its own ordering.
@@ -1620,58 +706,23 @@ export type McpServerRequest = {
1620
706
  enabled: boolean;
1621
707
  auth_config?: null | CreateMcpAuthConfigRequest;
1622
708
  };
1623
- /**
1624
- * MCP server response with computed mcp counts and optional auth config.
1625
- */
1626
- export type McpServerResponse = McpServer & {
1627
- enabled_mcp_count: number;
1628
- disabled_mcp_count: number;
1629
- auth_config?: null | McpAuthConfigResponse;
1630
- };
1631
- export type McpServerReviewInfo = {
1632
- /**
1633
- * Requested MCP server URL
1634
- */
1635
- url: string;
1636
- /**
1637
- * User's MCP instances connected to this server URL
1638
- */
1639
- 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;
1655
- /**
1656
- * Describes an OpenAI model offering that can be used with the API.
1657
- */
1658
- export type Model = {
1659
- /**
1660
- * The model identifier, which can be referenced in the API endpoints.
1661
- */
1662
- id: string;
1663
- /**
1664
- * The object type, which is always "model".
1665
- */
1666
- object: string;
709
+ /**
710
+ * MCP server response with computed mcp counts and optional auth config.
711
+ */
712
+ export type McpServerResponse = McpServer & {
713
+ enabled_mcp_count: number;
714
+ disabled_mcp_count: number;
715
+ auth_config?: null | McpAuthConfigResponse;
716
+ };
717
+ export type McpServerReviewInfo = {
1667
718
  /**
1668
- * The Unix timestamp (in seconds) when the model was created.
719
+ * Requested MCP server URL
1669
720
  */
1670
- created: number;
721
+ url: string;
1671
722
  /**
1672
- * The organization that owns the model.
723
+ * User's MCP instances connected to this server URL
1673
724
  */
1674
- owned_by: string;
725
+ instances: Array<Mcp>;
1675
726
  };
1676
727
  export type ModelAlias = {
1677
728
  alias: string;
@@ -1702,14 +753,6 @@ export type ModelCapabilities = {
1702
753
  thinking?: boolean | null;
1703
754
  tools: ToolCapabilities;
1704
755
  };
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
756
  /**
1714
757
  * Model metadata for API responses
1715
758
  */
@@ -1719,9 +762,6 @@ export type ModelMetadata = {
1719
762
  architecture: ModelArchitecture;
1720
763
  chat_template?: string | null;
1721
764
  };
1722
- export type ModelsResponse = {
1723
- models: Array<OllamaModel>;
1724
- };
1725
765
  /**
1726
766
  * Request for creating a new download request
1727
767
  */
@@ -1787,53 +827,6 @@ export type OAuthTokenResponse = {
1787
827
  created_at: string;
1788
828
  updated_at: string;
1789
829
  };
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
830
  /**
1838
831
  * Paginated list of all model aliases (user, model, and API)
1839
832
  */
@@ -1927,35 +920,6 @@ export type PingResponse = {
1927
920
  */
1928
921
  message: string;
1929
922
  };
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
923
  /**
1960
924
  * Response for queue status operations
1961
925
  */
@@ -1965,7 +929,6 @@ export type QueueStatusResponse = {
1965
929
  */
1966
930
  status: string;
1967
931
  };
1968
- export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
1969
932
  export type RedirectResponse = {
1970
933
  /**
1971
934
  * The URL to redirect to (OAuth authorization URL or application home page)
@@ -2027,48 +990,6 @@ export type RequestedResourcesV1 = {
2027
990
  mcp_servers?: Array<RequestedMcpServer>;
2028
991
  };
2029
992
  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
993
  export type SettingInfo = {
2073
994
  key: string;
2074
995
  current_value: unknown;
@@ -2111,19 +1032,6 @@ export type SetupResponse = {
2111
1032
  */
2112
1033
  status: AppStatus;
2113
1034
  };
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
1035
  export type TenantListItem = {
2128
1036
  client_id: string;
2129
1037
  name: string;
@@ -2171,6 +1079,10 @@ export type TestPromptRequest = {
2171
1079
  * Test prompt (max 30 characters for cost control)
2172
1080
  */
2173
1081
  prompt: string;
1082
+ /**
1083
+ * API format to use for the test request (defaults to OpenAI Chat Completions)
1084
+ */
1085
+ api_format?: ApiFormat;
2174
1086
  };
2175
1087
  /**
2176
1088
  * Response from testing API connectivity
@@ -2208,22 +1120,6 @@ export type ToolCapabilities = {
2208
1120
  function_calling?: boolean | null;
2209
1121
  structured_output?: boolean | null;
2210
1122
  };
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
1123
  /**
2228
1124
  * Request to update a setting value
2229
1125
  */
@@ -2243,24 +1139,6 @@ export type UpdateTokenRequest = {
2243
1139
  */
2244
1140
  status: TokenStatus;
2245
1141
  };
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
1142
  /**
2265
1143
  * User access request output type for API responses
2266
1144
  */
@@ -2383,156 +1261,6 @@ export type UserResponse = {
2383
1261
  auth_status: 'api_token';
2384
1262
  });
2385
1263
  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
1264
  export type ListAllAccessRequestsData = {
2537
1265
  body?: never;
2538
1266
  path?: never;
@@ -2560,19 +1288,19 @@ export type ListAllAccessRequestsErrors = {
2560
1288
  /**
2561
1289
  * Invalid request parameters
2562
1290
  */
2563
- 400: OpenAiApiError;
1291
+ 400: BodhiApiError;
2564
1292
  /**
2565
1293
  * Not authenticated
2566
1294
  */
2567
- 401: OpenAiApiError;
1295
+ 401: BodhiApiError;
2568
1296
  /**
2569
1297
  * Insufficient permissions
2570
1298
  */
2571
- 403: OpenAiApiError;
1299
+ 403: BodhiApiError;
2572
1300
  /**
2573
1301
  * Internal server error
2574
1302
  */
2575
- 500: OpenAiApiError;
1303
+ 500: BodhiApiError;
2576
1304
  };
2577
1305
  export type ListAllAccessRequestsError = ListAllAccessRequestsErrors[keyof ListAllAccessRequestsErrors];
2578
1306
  export type ListAllAccessRequestsResponses = {
@@ -2609,19 +1337,19 @@ export type ListPendingAccessRequestsErrors = {
2609
1337
  /**
2610
1338
  * Invalid request parameters
2611
1339
  */
2612
- 400: OpenAiApiError;
1340
+ 400: BodhiApiError;
2613
1341
  /**
2614
1342
  * Not authenticated
2615
1343
  */
2616
- 401: OpenAiApiError;
1344
+ 401: BodhiApiError;
2617
1345
  /**
2618
1346
  * Insufficient permissions
2619
1347
  */
2620
- 403: OpenAiApiError;
1348
+ 403: BodhiApiError;
2621
1349
  /**
2622
1350
  * Internal server error
2623
1351
  */
2624
- 500: OpenAiApiError;
1352
+ 500: BodhiApiError;
2625
1353
  };
2626
1354
  export type ListPendingAccessRequestsError = ListPendingAccessRequestsErrors[keyof ListPendingAccessRequestsErrors];
2627
1355
  export type ListPendingAccessRequestsResponses = {
@@ -2649,23 +1377,23 @@ export type ApproveAccessRequestErrors = {
2649
1377
  /**
2650
1378
  * Invalid request parameters
2651
1379
  */
2652
- 400: OpenAiApiError;
1380
+ 400: BodhiApiError;
2653
1381
  /**
2654
1382
  * Not authenticated
2655
1383
  */
2656
- 401: OpenAiApiError;
1384
+ 401: BodhiApiError;
2657
1385
  /**
2658
1386
  * Insufficient permissions
2659
1387
  */
2660
- 403: OpenAiApiError;
1388
+ 403: BodhiApiError;
2661
1389
  /**
2662
1390
  * Request not found
2663
1391
  */
2664
- 404: OpenAiApiError;
1392
+ 404: BodhiApiError;
2665
1393
  /**
2666
1394
  * Internal server error
2667
1395
  */
2668
- 500: OpenAiApiError;
1396
+ 500: BodhiApiError;
2669
1397
  };
2670
1398
  export type ApproveAccessRequestError = ApproveAccessRequestErrors[keyof ApproveAccessRequestErrors];
2671
1399
  export type ApproveAccessRequestResponses = {
@@ -2692,27 +1420,27 @@ export type ApproveAppsAccessRequestErrors = {
2692
1420
  /**
2693
1421
  * Invalid request parameters
2694
1422
  */
2695
- 400: OpenAiApiError;
1423
+ 400: BodhiApiError;
2696
1424
  /**
2697
1425
  * Not authenticated
2698
1426
  */
2699
- 401: OpenAiApiError;
1427
+ 401: BodhiApiError;
2700
1428
  /**
2701
1429
  * Insufficient permissions
2702
1430
  */
2703
- 403: OpenAiApiError;
1431
+ 403: BodhiApiError;
2704
1432
  /**
2705
1433
  * Not found
2706
1434
  */
2707
- 404: OpenAiApiError;
1435
+ 404: BodhiApiError;
2708
1436
  /**
2709
1437
  * Already processed
2710
1438
  */
2711
- 409: OpenAiApiError;
1439
+ 409: BodhiApiError;
2712
1440
  /**
2713
1441
  * Internal server error
2714
1442
  */
2715
- 500: OpenAiApiError;
1443
+ 500: BodhiApiError;
2716
1444
  };
2717
1445
  export type ApproveAppsAccessRequestError = ApproveAppsAccessRequestErrors[keyof ApproveAppsAccessRequestErrors];
2718
1446
  export type ApproveAppsAccessRequestResponses = {
@@ -2737,27 +1465,27 @@ export type DenyAccessRequestErrors = {
2737
1465
  /**
2738
1466
  * Invalid request parameters
2739
1467
  */
2740
- 400: OpenAiApiError;
1468
+ 400: BodhiApiError;
2741
1469
  /**
2742
1470
  * Not authenticated
2743
1471
  */
2744
- 401: OpenAiApiError;
1472
+ 401: BodhiApiError;
2745
1473
  /**
2746
1474
  * Insufficient permissions
2747
1475
  */
2748
- 403: OpenAiApiError;
1476
+ 403: BodhiApiError;
2749
1477
  /**
2750
1478
  * Not found
2751
1479
  */
2752
- 404: OpenAiApiError;
1480
+ 404: BodhiApiError;
2753
1481
  /**
2754
1482
  * Already processed
2755
1483
  */
2756
- 409: OpenAiApiError;
1484
+ 409: BodhiApiError;
2757
1485
  /**
2758
1486
  * Internal server error
2759
1487
  */
2760
- 500: OpenAiApiError;
1488
+ 500: BodhiApiError;
2761
1489
  };
2762
1490
  export type DenyAccessRequestError = DenyAccessRequestErrors[keyof DenyAccessRequestErrors];
2763
1491
  export type DenyAccessRequestResponses = {
@@ -2782,23 +1510,23 @@ export type RejectAccessRequestErrors = {
2782
1510
  /**
2783
1511
  * Invalid request parameters
2784
1512
  */
2785
- 400: OpenAiApiError;
1513
+ 400: BodhiApiError;
2786
1514
  /**
2787
1515
  * Not authenticated
2788
1516
  */
2789
- 401: OpenAiApiError;
1517
+ 401: BodhiApiError;
2790
1518
  /**
2791
1519
  * Insufficient permissions
2792
1520
  */
2793
- 403: OpenAiApiError;
1521
+ 403: BodhiApiError;
2794
1522
  /**
2795
1523
  * Request not found
2796
1524
  */
2797
- 404: OpenAiApiError;
1525
+ 404: BodhiApiError;
2798
1526
  /**
2799
1527
  * Internal server error
2800
1528
  */
2801
- 500: OpenAiApiError;
1529
+ 500: BodhiApiError;
2802
1530
  };
2803
1531
  export type RejectAccessRequestError = RejectAccessRequestErrors[keyof RejectAccessRequestErrors];
2804
1532
  export type RejectAccessRequestResponses = {
@@ -2822,27 +1550,27 @@ export type GetAccessRequestReviewErrors = {
2822
1550
  /**
2823
1551
  * Invalid request parameters
2824
1552
  */
2825
- 400: OpenAiApiError;
1553
+ 400: BodhiApiError;
2826
1554
  /**
2827
1555
  * Not authenticated
2828
1556
  */
2829
- 401: OpenAiApiError;
1557
+ 401: BodhiApiError;
2830
1558
  /**
2831
1559
  * Insufficient permissions
2832
1560
  */
2833
- 403: OpenAiApiError;
1561
+ 403: BodhiApiError;
2834
1562
  /**
2835
1563
  * Not found
2836
1564
  */
2837
- 404: OpenAiApiError;
1565
+ 404: BodhiApiError;
2838
1566
  /**
2839
1567
  * Request expired
2840
1568
  */
2841
- 410: OpenAiApiError;
1569
+ 410: BodhiApiError;
2842
1570
  /**
2843
1571
  * Internal server error
2844
1572
  */
2845
- 500: OpenAiApiError;
1573
+ 500: BodhiApiError;
2846
1574
  };
2847
1575
  export type GetAccessRequestReviewError = GetAccessRequestReviewErrors[keyof GetAccessRequestReviewErrors];
2848
1576
  export type GetAccessRequestReviewResponses = {
@@ -2872,23 +1600,23 @@ export type GetAccessRequestStatusErrors = {
2872
1600
  /**
2873
1601
  * Invalid request parameters
2874
1602
  */
2875
- 400: OpenAiApiError;
1603
+ 400: BodhiApiError;
2876
1604
  /**
2877
1605
  * Not authenticated
2878
1606
  */
2879
- 401: OpenAiApiError;
1607
+ 401: BodhiApiError;
2880
1608
  /**
2881
1609
  * Insufficient permissions
2882
1610
  */
2883
- 403: OpenAiApiError;
1611
+ 403: BodhiApiError;
2884
1612
  /**
2885
1613
  * Not found or app_client_id mismatch
2886
1614
  */
2887
- 404: OpenAiApiError;
1615
+ 404: BodhiApiError;
2888
1616
  /**
2889
1617
  * Internal server error
2890
1618
  */
2891
- 500: OpenAiApiError;
1619
+ 500: BodhiApiError;
2892
1620
  };
2893
1621
  export type GetAccessRequestStatusError = GetAccessRequestStatusErrors[keyof GetAccessRequestStatusErrors];
2894
1622
  export type GetAccessRequestStatusResponses = {
@@ -2908,19 +1636,19 @@ export type AppsListMcpsErrors = {
2908
1636
  /**
2909
1637
  * Invalid request parameters
2910
1638
  */
2911
- 400: OpenAiApiError;
1639
+ 400: BodhiApiError;
2912
1640
  /**
2913
1641
  * Not authenticated
2914
1642
  */
2915
- 401: OpenAiApiError;
1643
+ 401: BodhiApiError;
2916
1644
  /**
2917
1645
  * Insufficient permissions
2918
1646
  */
2919
- 403: OpenAiApiError;
1647
+ 403: BodhiApiError;
2920
1648
  /**
2921
1649
  * Internal server error
2922
1650
  */
2923
- 500: OpenAiApiError;
1651
+ 500: BodhiApiError;
2924
1652
  };
2925
1653
  export type AppsListMcpsError = AppsListMcpsErrors[keyof AppsListMcpsErrors];
2926
1654
  export type AppsListMcpsResponses = {
@@ -2945,15 +1673,15 @@ export type AppsGetMcpErrors = {
2945
1673
  /**
2946
1674
  * Invalid request parameters
2947
1675
  */
2948
- 400: OpenAiApiError;
1676
+ 400: BodhiApiError;
2949
1677
  /**
2950
1678
  * Not authenticated
2951
1679
  */
2952
- 401: OpenAiApiError;
1680
+ 401: BodhiApiError;
2953
1681
  /**
2954
1682
  * Insufficient permissions
2955
1683
  */
2956
- 403: OpenAiApiError;
1684
+ 403: BodhiApiError;
2957
1685
  /**
2958
1686
  * MCP not found
2959
1687
  */
@@ -2961,7 +1689,7 @@ export type AppsGetMcpErrors = {
2961
1689
  /**
2962
1690
  * Internal server error
2963
1691
  */
2964
- 500: OpenAiApiError;
1692
+ 500: BodhiApiError;
2965
1693
  };
2966
1694
  export type AppsGetMcpError = AppsGetMcpErrors[keyof AppsGetMcpErrors];
2967
1695
  export type AppsGetMcpResponses = {
@@ -2986,19 +1714,19 @@ export type McpProxyErrors = {
2986
1714
  /**
2987
1715
  * Invalid request parameters
2988
1716
  */
2989
- 400: OpenAiApiError;
1717
+ 400: BodhiApiError;
2990
1718
  /**
2991
1719
  * Not authenticated
2992
1720
  */
2993
- 401: OpenAiApiError;
1721
+ 401: BodhiApiError;
2994
1722
  /**
2995
1723
  * Insufficient permissions
2996
1724
  */
2997
- 403: OpenAiApiError;
1725
+ 403: BodhiApiError;
2998
1726
  /**
2999
1727
  * Internal server error
3000
1728
  */
3001
- 500: OpenAiApiError;
1729
+ 500: BodhiApiError;
3002
1730
  };
3003
1731
  export type McpProxyError = McpProxyErrors[keyof McpProxyErrors];
3004
1732
  export type McpProxyResponses = {
@@ -3020,23 +1748,23 @@ export type CreateAccessRequestErrors = {
3020
1748
  /**
3021
1749
  * Invalid request parameters
3022
1750
  */
3023
- 400: OpenAiApiError;
1751
+ 400: BodhiApiError;
3024
1752
  /**
3025
1753
  * Not authenticated
3026
1754
  */
3027
- 401: OpenAiApiError;
1755
+ 401: BodhiApiError;
3028
1756
  /**
3029
1757
  * Insufficient permissions
3030
1758
  */
3031
- 403: OpenAiApiError;
1759
+ 403: BodhiApiError;
3032
1760
  /**
3033
1761
  * App client not found
3034
1762
  */
3035
- 404: OpenAiApiError;
1763
+ 404: BodhiApiError;
3036
1764
  /**
3037
1765
  * Internal server error
3038
1766
  */
3039
- 500: OpenAiApiError;
1767
+ 500: BodhiApiError;
3040
1768
  };
3041
1769
  export type CreateAccessRequestError = CreateAccessRequestErrors[keyof CreateAccessRequestErrors];
3042
1770
  export type CreateAccessRequestResponses = {
@@ -3059,23 +1787,23 @@ export type CompleteOAuthFlowErrors = {
3059
1787
  /**
3060
1788
  * Invalid request parameters
3061
1789
  */
3062
- 400: OpenAiApiError;
1790
+ 400: BodhiApiError;
3063
1791
  /**
3064
1792
  * Not authenticated
3065
1793
  */
3066
- 401: OpenAiApiError;
1794
+ 401: BodhiApiError;
3067
1795
  /**
3068
1796
  * Insufficient permissions
3069
1797
  */
3070
- 403: OpenAiApiError;
1798
+ 403: BodhiApiError;
3071
1799
  /**
3072
1800
  * OAuth error, invalid request parameters, or state mismatch
3073
1801
  */
3074
- 422: OpenAiApiError;
1802
+ 422: BodhiApiError;
3075
1803
  /**
3076
1804
  * Internal server error
3077
1805
  */
3078
- 500: OpenAiApiError;
1806
+ 500: BodhiApiError;
3079
1807
  };
3080
1808
  export type CompleteOAuthFlowError = CompleteOAuthFlowErrors[keyof CompleteOAuthFlowErrors];
3081
1809
  export type CompleteOAuthFlowResponses = {
@@ -3098,19 +1826,19 @@ export type CompleteDashboardOAuthFlowErrors = {
3098
1826
  /**
3099
1827
  * Invalid request parameters
3100
1828
  */
3101
- 400: OpenAiApiError;
1829
+ 400: BodhiApiError;
3102
1830
  /**
3103
1831
  * Not authenticated
3104
1832
  */
3105
- 401: OpenAiApiError;
1833
+ 401: BodhiApiError;
3106
1834
  /**
3107
1835
  * Insufficient permissions
3108
1836
  */
3109
- 403: OpenAiApiError;
1837
+ 403: BodhiApiError;
3110
1838
  /**
3111
1839
  * Internal server error
3112
1840
  */
3113
- 500: OpenAiApiError;
1841
+ 500: BodhiApiError;
3114
1842
  };
3115
1843
  export type CompleteDashboardOAuthFlowError = CompleteDashboardOAuthFlowErrors[keyof CompleteDashboardOAuthFlowErrors];
3116
1844
  export type CompleteDashboardOAuthFlowResponses = {
@@ -3130,19 +1858,19 @@ export type InitiateDashboardOAuthFlowErrors = {
3130
1858
  /**
3131
1859
  * Invalid request parameters
3132
1860
  */
3133
- 400: OpenAiApiError;
1861
+ 400: BodhiApiError;
3134
1862
  /**
3135
1863
  * Not authenticated
3136
1864
  */
3137
- 401: OpenAiApiError;
1865
+ 401: BodhiApiError;
3138
1866
  /**
3139
1867
  * Insufficient permissions
3140
1868
  */
3141
- 403: OpenAiApiError;
1869
+ 403: BodhiApiError;
3142
1870
  /**
3143
1871
  * Internal server error
3144
1872
  */
3145
- 500: OpenAiApiError;
1873
+ 500: BodhiApiError;
3146
1874
  };
3147
1875
  export type InitiateDashboardOAuthFlowError = InitiateDashboardOAuthFlowErrors[keyof InitiateDashboardOAuthFlowErrors];
3148
1876
  export type InitiateDashboardOAuthFlowResponses = {
@@ -3169,19 +1897,19 @@ export type InitiateOAuthFlowErrors = {
3169
1897
  /**
3170
1898
  * Invalid request parameters
3171
1899
  */
3172
- 400: OpenAiApiError;
1900
+ 400: BodhiApiError;
3173
1901
  /**
3174
1902
  * Not authenticated
3175
1903
  */
3176
- 401: OpenAiApiError;
1904
+ 401: BodhiApiError;
3177
1905
  /**
3178
1906
  * Insufficient permissions
3179
1907
  */
3180
- 403: OpenAiApiError;
1908
+ 403: BodhiApiError;
3181
1909
  /**
3182
1910
  * Internal server error
3183
1911
  */
3184
- 500: OpenAiApiError;
1912
+ 500: BodhiApiError;
3185
1913
  };
3186
1914
  export type InitiateOAuthFlowError = InitiateOAuthFlowErrors[keyof InitiateOAuthFlowErrors];
3187
1915
  export type InitiateOAuthFlowResponses = {
@@ -3205,11 +1933,11 @@ export type GetAppInfoErrors = {
3205
1933
  /**
3206
1934
  * Invalid request parameters
3207
1935
  */
3208
- 400: OpenAiApiError;
1936
+ 400: BodhiApiError;
3209
1937
  /**
3210
1938
  * Internal server error
3211
1939
  */
3212
- 500: OpenAiApiError;
1940
+ 500: BodhiApiError;
3213
1941
  };
3214
1942
  export type GetAppInfoError = GetAppInfoErrors[keyof GetAppInfoErrors];
3215
1943
  export type GetAppInfoResponses = {
@@ -3229,19 +1957,19 @@ export type LogoutUserErrors = {
3229
1957
  /**
3230
1958
  * Invalid request parameters
3231
1959
  */
3232
- 400: OpenAiApiError;
1960
+ 400: BodhiApiError;
3233
1961
  /**
3234
1962
  * Not authenticated
3235
1963
  */
3236
- 401: OpenAiApiError;
1964
+ 401: BodhiApiError;
3237
1965
  /**
3238
1966
  * Insufficient permissions
3239
1967
  */
3240
- 403: OpenAiApiError;
1968
+ 403: BodhiApiError;
3241
1969
  /**
3242
1970
  * Internal server error
3243
1971
  */
3244
- 500: OpenAiApiError;
1972
+ 500: BodhiApiError;
3245
1973
  };
3246
1974
  export type LogoutUserError = LogoutUserErrors[keyof LogoutUserErrors];
3247
1975
  export type LogoutUserResponses = {
@@ -3261,19 +1989,19 @@ export type ListMcpsErrors = {
3261
1989
  /**
3262
1990
  * Invalid request parameters
3263
1991
  */
3264
- 400: OpenAiApiError;
1992
+ 400: BodhiApiError;
3265
1993
  /**
3266
1994
  * Not authenticated
3267
1995
  */
3268
- 401: OpenAiApiError;
1996
+ 401: BodhiApiError;
3269
1997
  /**
3270
1998
  * Insufficient permissions
3271
1999
  */
3272
- 403: OpenAiApiError;
2000
+ 403: BodhiApiError;
3273
2001
  /**
3274
2002
  * Internal server error
3275
2003
  */
3276
- 500: OpenAiApiError;
2004
+ 500: BodhiApiError;
3277
2005
  };
3278
2006
  export type ListMcpsError = ListMcpsErrors[keyof ListMcpsErrors];
3279
2007
  export type ListMcpsResponses = {
@@ -3293,19 +2021,19 @@ export type CreateMcpErrors = {
3293
2021
  /**
3294
2022
  * Invalid request parameters
3295
2023
  */
3296
- 400: OpenAiApiError;
2024
+ 400: BodhiApiError;
3297
2025
  /**
3298
2026
  * Not authenticated
3299
2027
  */
3300
- 401: OpenAiApiError;
2028
+ 401: BodhiApiError;
3301
2029
  /**
3302
2030
  * Insufficient permissions
3303
2031
  */
3304
- 403: OpenAiApiError;
2032
+ 403: BodhiApiError;
3305
2033
  /**
3306
2034
  * Internal server error
3307
2035
  */
3308
- 500: OpenAiApiError;
2036
+ 500: BodhiApiError;
3309
2037
  };
3310
2038
  export type CreateMcpError = CreateMcpErrors[keyof CreateMcpErrors];
3311
2039
  export type CreateMcpResponses = {
@@ -3327,19 +2055,19 @@ export type ListMcpAuthConfigsErrors = {
3327
2055
  /**
3328
2056
  * Invalid request parameters
3329
2057
  */
3330
- 400: OpenAiApiError;
2058
+ 400: BodhiApiError;
3331
2059
  /**
3332
2060
  * Not authenticated
3333
2061
  */
3334
- 401: OpenAiApiError;
2062
+ 401: BodhiApiError;
3335
2063
  /**
3336
2064
  * Insufficient permissions
3337
2065
  */
3338
- 403: OpenAiApiError;
2066
+ 403: BodhiApiError;
3339
2067
  /**
3340
2068
  * Internal server error
3341
2069
  */
3342
- 500: OpenAiApiError;
2070
+ 500: BodhiApiError;
3343
2071
  };
3344
2072
  export type ListMcpAuthConfigsError = ListMcpAuthConfigsErrors[keyof ListMcpAuthConfigsErrors];
3345
2073
  export type ListMcpAuthConfigsResponses = {
@@ -3359,19 +2087,19 @@ export type CreateMcpAuthConfigErrors = {
3359
2087
  /**
3360
2088
  * Invalid request parameters
3361
2089
  */
3362
- 400: OpenAiApiError;
2090
+ 400: BodhiApiError;
3363
2091
  /**
3364
2092
  * Not authenticated
3365
2093
  */
3366
- 401: OpenAiApiError;
2094
+ 401: BodhiApiError;
3367
2095
  /**
3368
2096
  * Insufficient permissions
3369
2097
  */
3370
- 403: OpenAiApiError;
2098
+ 403: BodhiApiError;
3371
2099
  /**
3372
2100
  * Internal server error
3373
2101
  */
3374
- 500: OpenAiApiError;
2102
+ 500: BodhiApiError;
3375
2103
  };
3376
2104
  export type CreateMcpAuthConfigError = CreateMcpAuthConfigErrors[keyof CreateMcpAuthConfigErrors];
3377
2105
  export type CreateMcpAuthConfigResponses = {
@@ -3396,15 +2124,15 @@ export type DeleteMcpAuthConfigErrors = {
3396
2124
  /**
3397
2125
  * Invalid request parameters
3398
2126
  */
3399
- 400: OpenAiApiError;
2127
+ 400: BodhiApiError;
3400
2128
  /**
3401
2129
  * Not authenticated
3402
2130
  */
3403
- 401: OpenAiApiError;
2131
+ 401: BodhiApiError;
3404
2132
  /**
3405
2133
  * Insufficient permissions
3406
2134
  */
3407
- 403: OpenAiApiError;
2135
+ 403: BodhiApiError;
3408
2136
  /**
3409
2137
  * Not found
3410
2138
  */
@@ -3412,7 +2140,7 @@ export type DeleteMcpAuthConfigErrors = {
3412
2140
  /**
3413
2141
  * Internal server error
3414
2142
  */
3415
- 500: OpenAiApiError;
2143
+ 500: BodhiApiError;
3416
2144
  };
3417
2145
  export type DeleteMcpAuthConfigError = DeleteMcpAuthConfigErrors[keyof DeleteMcpAuthConfigErrors];
3418
2146
  export type DeleteMcpAuthConfigResponses = {
@@ -3437,15 +2165,15 @@ export type GetMcpAuthConfigErrors = {
3437
2165
  /**
3438
2166
  * Invalid request parameters
3439
2167
  */
3440
- 400: OpenAiApiError;
2168
+ 400: BodhiApiError;
3441
2169
  /**
3442
2170
  * Not authenticated
3443
2171
  */
3444
- 401: OpenAiApiError;
2172
+ 401: BodhiApiError;
3445
2173
  /**
3446
2174
  * Insufficient permissions
3447
2175
  */
3448
- 403: OpenAiApiError;
2176
+ 403: BodhiApiError;
3449
2177
  /**
3450
2178
  * Not found
3451
2179
  */
@@ -3453,7 +2181,7 @@ export type GetMcpAuthConfigErrors = {
3453
2181
  /**
3454
2182
  * Internal server error
3455
2183
  */
3456
- 500: OpenAiApiError;
2184
+ 500: BodhiApiError;
3457
2185
  };
3458
2186
  export type GetMcpAuthConfigError = GetMcpAuthConfigErrors[keyof GetMcpAuthConfigErrors];
3459
2187
  export type GetMcpAuthConfigResponses = {
@@ -3478,15 +2206,15 @@ export type McpOAuthLoginErrors = {
3478
2206
  /**
3479
2207
  * Invalid request parameters
3480
2208
  */
3481
- 400: OpenAiApiError;
2209
+ 400: BodhiApiError;
3482
2210
  /**
3483
2211
  * Not authenticated
3484
2212
  */
3485
- 401: OpenAiApiError;
2213
+ 401: BodhiApiError;
3486
2214
  /**
3487
2215
  * Insufficient permissions
3488
2216
  */
3489
- 403: OpenAiApiError;
2217
+ 403: BodhiApiError;
3490
2218
  /**
3491
2219
  * Auth config not found
3492
2220
  */
@@ -3494,7 +2222,7 @@ export type McpOAuthLoginErrors = {
3494
2222
  /**
3495
2223
  * Internal server error
3496
2224
  */
3497
- 500: OpenAiApiError;
2225
+ 500: BodhiApiError;
3498
2226
  };
3499
2227
  export type McpOAuthLoginError = McpOAuthLoginErrors[keyof McpOAuthLoginErrors];
3500
2228
  export type McpOAuthLoginResponses = {
@@ -3519,15 +2247,15 @@ export type McpOAuthTokenExchangeErrors = {
3519
2247
  /**
3520
2248
  * Invalid request parameters
3521
2249
  */
3522
- 400: OpenAiApiError;
2250
+ 400: BodhiApiError;
3523
2251
  /**
3524
2252
  * Not authenticated
3525
2253
  */
3526
- 401: OpenAiApiError;
2254
+ 401: BodhiApiError;
3527
2255
  /**
3528
2256
  * Insufficient permissions
3529
2257
  */
3530
- 403: OpenAiApiError;
2258
+ 403: BodhiApiError;
3531
2259
  /**
3532
2260
  * Auth config not found
3533
2261
  */
@@ -3535,7 +2263,7 @@ export type McpOAuthTokenExchangeErrors = {
3535
2263
  /**
3536
2264
  * Internal server error
3537
2265
  */
3538
- 500: OpenAiApiError;
2266
+ 500: BodhiApiError;
3539
2267
  };
3540
2268
  export type McpOAuthTokenExchangeError = McpOAuthTokenExchangeErrors[keyof McpOAuthTokenExchangeErrors];
3541
2269
  export type McpOAuthTokenExchangeResponses = {
@@ -3560,15 +2288,15 @@ export type DeleteMcpOAuthTokenErrors = {
3560
2288
  /**
3561
2289
  * Invalid request parameters
3562
2290
  */
3563
- 400: OpenAiApiError;
2291
+ 400: BodhiApiError;
3564
2292
  /**
3565
2293
  * Not authenticated
3566
2294
  */
3567
- 401: OpenAiApiError;
2295
+ 401: BodhiApiError;
3568
2296
  /**
3569
2297
  * Insufficient permissions
3570
2298
  */
3571
- 403: OpenAiApiError;
2299
+ 403: BodhiApiError;
3572
2300
  /**
3573
2301
  * Not found
3574
2302
  */
@@ -3576,7 +2304,7 @@ export type DeleteMcpOAuthTokenErrors = {
3576
2304
  /**
3577
2305
  * Internal server error
3578
2306
  */
3579
- 500: OpenAiApiError;
2307
+ 500: BodhiApiError;
3580
2308
  };
3581
2309
  export type DeleteMcpOAuthTokenError = DeleteMcpOAuthTokenErrors[keyof DeleteMcpOAuthTokenErrors];
3582
2310
  export type DeleteMcpOAuthTokenResponses = {
@@ -3601,15 +2329,15 @@ export type GetMcpOAuthTokenErrors = {
3601
2329
  /**
3602
2330
  * Invalid request parameters
3603
2331
  */
3604
- 400: OpenAiApiError;
2332
+ 400: BodhiApiError;
3605
2333
  /**
3606
2334
  * Not authenticated
3607
2335
  */
3608
- 401: OpenAiApiError;
2336
+ 401: BodhiApiError;
3609
2337
  /**
3610
2338
  * Insufficient permissions
3611
2339
  */
3612
- 403: OpenAiApiError;
2340
+ 403: BodhiApiError;
3613
2341
  /**
3614
2342
  * Not found
3615
2343
  */
@@ -3617,7 +2345,7 @@ export type GetMcpOAuthTokenErrors = {
3617
2345
  /**
3618
2346
  * Internal server error
3619
2347
  */
3620
- 500: OpenAiApiError;
2348
+ 500: BodhiApiError;
3621
2349
  };
3622
2350
  export type GetMcpOAuthTokenError = GetMcpOAuthTokenErrors[keyof GetMcpOAuthTokenErrors];
3623
2351
  export type GetMcpOAuthTokenResponses = {
@@ -3637,19 +2365,19 @@ export type McpOAuthDiscoverAsErrors = {
3637
2365
  /**
3638
2366
  * Invalid request parameters
3639
2367
  */
3640
- 400: OpenAiApiError;
2368
+ 400: BodhiApiError;
3641
2369
  /**
3642
2370
  * Not authenticated
3643
2371
  */
3644
- 401: OpenAiApiError;
2372
+ 401: BodhiApiError;
3645
2373
  /**
3646
2374
  * Insufficient permissions
3647
2375
  */
3648
- 403: OpenAiApiError;
2376
+ 403: BodhiApiError;
3649
2377
  /**
3650
2378
  * Internal server error
3651
2379
  */
3652
- 500: OpenAiApiError;
2380
+ 500: BodhiApiError;
3653
2381
  };
3654
2382
  export type McpOAuthDiscoverAsError = McpOAuthDiscoverAsErrors[keyof McpOAuthDiscoverAsErrors];
3655
2383
  export type McpOAuthDiscoverAsResponses = {
@@ -3669,19 +2397,19 @@ export type McpOAuthDiscoverMcpErrors = {
3669
2397
  /**
3670
2398
  * Invalid request parameters
3671
2399
  */
3672
- 400: OpenAiApiError;
2400
+ 400: BodhiApiError;
3673
2401
  /**
3674
2402
  * Not authenticated
3675
2403
  */
3676
- 401: OpenAiApiError;
2404
+ 401: BodhiApiError;
3677
2405
  /**
3678
2406
  * Insufficient permissions
3679
2407
  */
3680
- 403: OpenAiApiError;
2408
+ 403: BodhiApiError;
3681
2409
  /**
3682
2410
  * Internal server error
3683
2411
  */
3684
- 500: OpenAiApiError;
2412
+ 500: BodhiApiError;
3685
2413
  };
3686
2414
  export type McpOAuthDiscoverMcpError = McpOAuthDiscoverMcpErrors[keyof McpOAuthDiscoverMcpErrors];
3687
2415
  export type McpOAuthDiscoverMcpResponses = {
@@ -3701,19 +2429,19 @@ export type McpOAuthDynamicRegisterStandaloneErrors = {
3701
2429
  /**
3702
2430
  * Invalid request parameters
3703
2431
  */
3704
- 400: OpenAiApiError;
2432
+ 400: BodhiApiError;
3705
2433
  /**
3706
2434
  * Not authenticated
3707
2435
  */
3708
- 401: OpenAiApiError;
2436
+ 401: BodhiApiError;
3709
2437
  /**
3710
2438
  * Insufficient permissions
3711
2439
  */
3712
- 403: OpenAiApiError;
2440
+ 403: BodhiApiError;
3713
2441
  /**
3714
2442
  * Internal server error
3715
2443
  */
3716
- 500: OpenAiApiError;
2444
+ 500: BodhiApiError;
3717
2445
  };
3718
2446
  export type McpOAuthDynamicRegisterStandaloneError = McpOAuthDynamicRegisterStandaloneErrors[keyof McpOAuthDynamicRegisterStandaloneErrors];
3719
2447
  export type McpOAuthDynamicRegisterStandaloneResponses = {
@@ -3738,19 +2466,19 @@ export type ListMcpServersErrors = {
3738
2466
  /**
3739
2467
  * Invalid request parameters
3740
2468
  */
3741
- 400: OpenAiApiError;
2469
+ 400: BodhiApiError;
3742
2470
  /**
3743
2471
  * Not authenticated
3744
2472
  */
3745
- 401: OpenAiApiError;
2473
+ 401: BodhiApiError;
3746
2474
  /**
3747
2475
  * Insufficient permissions
3748
2476
  */
3749
- 403: OpenAiApiError;
2477
+ 403: BodhiApiError;
3750
2478
  /**
3751
2479
  * Internal server error
3752
2480
  */
3753
- 500: OpenAiApiError;
2481
+ 500: BodhiApiError;
3754
2482
  };
3755
2483
  export type ListMcpServersError = ListMcpServersErrors[keyof ListMcpServersErrors];
3756
2484
  export type ListMcpServersResponses = {
@@ -3770,15 +2498,15 @@ export type CreateMcpServerErrors = {
3770
2498
  /**
3771
2499
  * Invalid request parameters
3772
2500
  */
3773
- 400: OpenAiApiError;
2501
+ 400: BodhiApiError;
3774
2502
  /**
3775
2503
  * Not authenticated
3776
2504
  */
3777
- 401: OpenAiApiError;
2505
+ 401: BodhiApiError;
3778
2506
  /**
3779
2507
  * Insufficient permissions
3780
2508
  */
3781
- 403: OpenAiApiError;
2509
+ 403: BodhiApiError;
3782
2510
  /**
3783
2511
  * URL already exists
3784
2512
  */
@@ -3786,7 +2514,7 @@ export type CreateMcpServerErrors = {
3786
2514
  /**
3787
2515
  * Internal server error
3788
2516
  */
3789
- 500: OpenAiApiError;
2517
+ 500: BodhiApiError;
3790
2518
  };
3791
2519
  export type CreateMcpServerError = CreateMcpServerErrors[keyof CreateMcpServerErrors];
3792
2520
  export type CreateMcpServerResponses = {
@@ -3811,15 +2539,15 @@ export type GetMcpServerErrors = {
3811
2539
  /**
3812
2540
  * Invalid request parameters
3813
2541
  */
3814
- 400: OpenAiApiError;
2542
+ 400: BodhiApiError;
3815
2543
  /**
3816
2544
  * Not authenticated
3817
2545
  */
3818
- 401: OpenAiApiError;
2546
+ 401: BodhiApiError;
3819
2547
  /**
3820
2548
  * Insufficient permissions
3821
2549
  */
3822
- 403: OpenAiApiError;
2550
+ 403: BodhiApiError;
3823
2551
  /**
3824
2552
  * Not found
3825
2553
  */
@@ -3827,7 +2555,7 @@ export type GetMcpServerErrors = {
3827
2555
  /**
3828
2556
  * Internal server error
3829
2557
  */
3830
- 500: OpenAiApiError;
2558
+ 500: BodhiApiError;
3831
2559
  };
3832
2560
  export type GetMcpServerError = GetMcpServerErrors[keyof GetMcpServerErrors];
3833
2561
  export type GetMcpServerResponses = {
@@ -3852,15 +2580,15 @@ export type UpdateMcpServerErrors = {
3852
2580
  /**
3853
2581
  * Invalid request parameters
3854
2582
  */
3855
- 400: OpenAiApiError;
2583
+ 400: BodhiApiError;
3856
2584
  /**
3857
2585
  * Not authenticated
3858
2586
  */
3859
- 401: OpenAiApiError;
2587
+ 401: BodhiApiError;
3860
2588
  /**
3861
2589
  * Insufficient permissions
3862
2590
  */
3863
- 403: OpenAiApiError;
2591
+ 403: BodhiApiError;
3864
2592
  /**
3865
2593
  * Not found
3866
2594
  */
@@ -3872,7 +2600,7 @@ export type UpdateMcpServerErrors = {
3872
2600
  /**
3873
2601
  * Internal server error
3874
2602
  */
3875
- 500: OpenAiApiError;
2603
+ 500: BodhiApiError;
3876
2604
  };
3877
2605
  export type UpdateMcpServerError = UpdateMcpServerErrors[keyof UpdateMcpServerErrors];
3878
2606
  export type UpdateMcpServerResponses = {
@@ -3897,15 +2625,15 @@ export type DeleteMcpErrors = {
3897
2625
  /**
3898
2626
  * Invalid request parameters
3899
2627
  */
3900
- 400: OpenAiApiError;
2628
+ 400: BodhiApiError;
3901
2629
  /**
3902
2630
  * Not authenticated
3903
2631
  */
3904
- 401: OpenAiApiError;
2632
+ 401: BodhiApiError;
3905
2633
  /**
3906
2634
  * Insufficient permissions
3907
2635
  */
3908
- 403: OpenAiApiError;
2636
+ 403: BodhiApiError;
3909
2637
  /**
3910
2638
  * MCP not found
3911
2639
  */
@@ -3913,7 +2641,7 @@ export type DeleteMcpErrors = {
3913
2641
  /**
3914
2642
  * Internal server error
3915
2643
  */
3916
- 500: OpenAiApiError;
2644
+ 500: BodhiApiError;
3917
2645
  };
3918
2646
  export type DeleteMcpError = DeleteMcpErrors[keyof DeleteMcpErrors];
3919
2647
  export type DeleteMcpResponses = {
@@ -3938,15 +2666,15 @@ export type GetMcpErrors = {
3938
2666
  /**
3939
2667
  * Invalid request parameters
3940
2668
  */
3941
- 400: OpenAiApiError;
2669
+ 400: BodhiApiError;
3942
2670
  /**
3943
2671
  * Not authenticated
3944
2672
  */
3945
- 401: OpenAiApiError;
2673
+ 401: BodhiApiError;
3946
2674
  /**
3947
2675
  * Insufficient permissions
3948
2676
  */
3949
- 403: OpenAiApiError;
2677
+ 403: BodhiApiError;
3950
2678
  /**
3951
2679
  * MCP not found
3952
2680
  */
@@ -3954,7 +2682,7 @@ export type GetMcpErrors = {
3954
2682
  /**
3955
2683
  * Internal server error
3956
2684
  */
3957
- 500: OpenAiApiError;
2685
+ 500: BodhiApiError;
3958
2686
  };
3959
2687
  export type GetMcpError = GetMcpErrors[keyof GetMcpErrors];
3960
2688
  export type GetMcpResponses = {
@@ -3979,15 +2707,15 @@ export type UpdateMcpErrors = {
3979
2707
  /**
3980
2708
  * Invalid request parameters
3981
2709
  */
3982
- 400: OpenAiApiError;
2710
+ 400: BodhiApiError;
3983
2711
  /**
3984
2712
  * Not authenticated
3985
2713
  */
3986
- 401: OpenAiApiError;
2714
+ 401: BodhiApiError;
3987
2715
  /**
3988
2716
  * Insufficient permissions
3989
2717
  */
3990
- 403: OpenAiApiError;
2718
+ 403: BodhiApiError;
3991
2719
  /**
3992
2720
  * MCP not found
3993
2721
  */
@@ -3995,7 +2723,7 @@ export type UpdateMcpErrors = {
3995
2723
  /**
3996
2724
  * Internal server error
3997
2725
  */
3998
- 500: OpenAiApiError;
2726
+ 500: BodhiApiError;
3999
2727
  };
4000
2728
  export type UpdateMcpError = UpdateMcpErrors[keyof UpdateMcpErrors];
4001
2729
  export type UpdateMcpResponses = {
@@ -4032,19 +2760,19 @@ export type ListAllModelsErrors = {
4032
2760
  /**
4033
2761
  * Invalid request parameters
4034
2762
  */
4035
- 400: OpenAiApiError;
2763
+ 400: BodhiApiError;
4036
2764
  /**
4037
2765
  * Not authenticated
4038
2766
  */
4039
- 401: OpenAiApiError;
2767
+ 401: BodhiApiError;
4040
2768
  /**
4041
2769
  * Insufficient permissions
4042
2770
  */
4043
- 403: OpenAiApiError;
2771
+ 403: BodhiApiError;
4044
2772
  /**
4045
2773
  * Internal server error
4046
2774
  */
4047
- 500: OpenAiApiError;
2775
+ 500: BodhiApiError;
4048
2776
  };
4049
2777
  export type ListAllModelsError = ListAllModelsErrors[keyof ListAllModelsErrors];
4050
2778
  export type ListAllModelsResponses = {
@@ -4064,19 +2792,19 @@ export type ModelsAliasCreateErrors = {
4064
2792
  /**
4065
2793
  * Invalid request parameters
4066
2794
  */
4067
- 400: OpenAiApiError;
2795
+ 400: BodhiApiError;
4068
2796
  /**
4069
2797
  * Not authenticated
4070
2798
  */
4071
- 401: OpenAiApiError;
2799
+ 401: BodhiApiError;
4072
2800
  /**
4073
2801
  * Insufficient permissions
4074
2802
  */
4075
- 403: OpenAiApiError;
2803
+ 403: BodhiApiError;
4076
2804
  /**
4077
2805
  * Internal server error
4078
2806
  */
4079
- 500: OpenAiApiError;
2807
+ 500: BodhiApiError;
4080
2808
  };
4081
2809
  export type ModelsAliasCreateError = ModelsAliasCreateErrors[keyof ModelsAliasCreateErrors];
4082
2810
  export type ModelsAliasCreateResponses = {
@@ -4101,15 +2829,15 @@ export type ModelsAliasDestroyErrors = {
4101
2829
  /**
4102
2830
  * Invalid request parameters
4103
2831
  */
4104
- 400: OpenAiApiError;
2832
+ 400: BodhiApiError;
4105
2833
  /**
4106
2834
  * Not authenticated
4107
2835
  */
4108
- 401: OpenAiApiError;
2836
+ 401: BodhiApiError;
4109
2837
  /**
4110
2838
  * Insufficient permissions
4111
2839
  */
4112
- 403: OpenAiApiError;
2840
+ 403: BodhiApiError;
4113
2841
  /**
4114
2842
  * Alias not found
4115
2843
  */
@@ -4117,7 +2845,7 @@ export type ModelsAliasDestroyErrors = {
4117
2845
  /**
4118
2846
  * Internal server error
4119
2847
  */
4120
- 500: OpenAiApiError;
2848
+ 500: BodhiApiError;
4121
2849
  };
4122
2850
  export type ModelsAliasDestroyError = ModelsAliasDestroyErrors[keyof ModelsAliasDestroyErrors];
4123
2851
  export type ModelsAliasDestroyResponses = {
@@ -4141,19 +2869,19 @@ export type ModelsAliasUpdateErrors = {
4141
2869
  /**
4142
2870
  * Invalid request parameters
4143
2871
  */
4144
- 400: OpenAiApiError;
2872
+ 400: BodhiApiError;
4145
2873
  /**
4146
2874
  * Not authenticated
4147
2875
  */
4148
- 401: OpenAiApiError;
2876
+ 401: BodhiApiError;
4149
2877
  /**
4150
2878
  * Insufficient permissions
4151
2879
  */
4152
- 403: OpenAiApiError;
2880
+ 403: BodhiApiError;
4153
2881
  /**
4154
2882
  * Internal server error
4155
2883
  */
4156
- 500: OpenAiApiError;
2884
+ 500: BodhiApiError;
4157
2885
  };
4158
2886
  export type ModelsAliasUpdateError = ModelsAliasUpdateErrors[keyof ModelsAliasUpdateErrors];
4159
2887
  export type ModelsAliasUpdateResponses = {
@@ -4178,15 +2906,15 @@ export type ModelsAliasCopyErrors = {
4178
2906
  /**
4179
2907
  * Invalid request parameters
4180
2908
  */
4181
- 400: OpenAiApiError;
2909
+ 400: BodhiApiError;
4182
2910
  /**
4183
2911
  * Not authenticated
4184
2912
  */
4185
- 401: OpenAiApiError;
2913
+ 401: BodhiApiError;
4186
2914
  /**
4187
2915
  * Insufficient permissions
4188
2916
  */
4189
- 403: OpenAiApiError;
2917
+ 403: BodhiApiError;
4190
2918
  /**
4191
2919
  * Source alias not found
4192
2920
  */
@@ -4194,7 +2922,7 @@ export type ModelsAliasCopyErrors = {
4194
2922
  /**
4195
2923
  * Internal server error
4196
2924
  */
4197
- 500: OpenAiApiError;
2925
+ 500: BodhiApiError;
4198
2926
  };
4199
2927
  export type ModelsAliasCopyError = ModelsAliasCopyErrors[keyof ModelsAliasCopyErrors];
4200
2928
  export type ModelsAliasCopyResponses = {
@@ -4214,23 +2942,23 @@ export type CreateApiModelErrors = {
4214
2942
  /**
4215
2943
  * Invalid request parameters
4216
2944
  */
4217
- 400: OpenAiApiError;
2945
+ 400: BodhiApiError;
4218
2946
  /**
4219
2947
  * Not authenticated
4220
2948
  */
4221
- 401: OpenAiApiError;
2949
+ 401: BodhiApiError;
4222
2950
  /**
4223
2951
  * Insufficient permissions
4224
2952
  */
4225
- 403: OpenAiApiError;
2953
+ 403: BodhiApiError;
4226
2954
  /**
4227
2955
  * Alias already exists
4228
2956
  */
4229
- 409: OpenAiApiError;
2957
+ 409: BodhiApiError;
4230
2958
  /**
4231
2959
  * Internal server error
4232
2960
  */
4233
- 500: OpenAiApiError;
2961
+ 500: BodhiApiError;
4234
2962
  };
4235
2963
  export type CreateApiModelError = CreateApiModelErrors[keyof CreateApiModelErrors];
4236
2964
  export type CreateApiModelResponses = {
@@ -4250,19 +2978,19 @@ export type FetchApiModelsErrors = {
4250
2978
  /**
4251
2979
  * Invalid request parameters
4252
2980
  */
4253
- 400: OpenAiApiError;
2981
+ 400: BodhiApiError;
4254
2982
  /**
4255
2983
  * Not authenticated
4256
2984
  */
4257
- 401: OpenAiApiError;
2985
+ 401: BodhiApiError;
4258
2986
  /**
4259
2987
  * Insufficient permissions
4260
2988
  */
4261
- 403: OpenAiApiError;
2989
+ 403: BodhiApiError;
4262
2990
  /**
4263
2991
  * Internal server error
4264
2992
  */
4265
- 500: OpenAiApiError;
2993
+ 500: BodhiApiError;
4266
2994
  };
4267
2995
  export type FetchApiModelsError = FetchApiModelsErrors[keyof FetchApiModelsErrors];
4268
2996
  export type FetchApiModelsResponses = {
@@ -4282,19 +3010,19 @@ export type GetApiFormatsErrors = {
4282
3010
  /**
4283
3011
  * Invalid request parameters
4284
3012
  */
4285
- 400: OpenAiApiError;
3013
+ 400: BodhiApiError;
4286
3014
  /**
4287
3015
  * Not authenticated
4288
3016
  */
4289
- 401: OpenAiApiError;
3017
+ 401: BodhiApiError;
4290
3018
  /**
4291
3019
  * Insufficient permissions
4292
3020
  */
4293
- 403: OpenAiApiError;
3021
+ 403: BodhiApiError;
4294
3022
  /**
4295
3023
  * Internal server error
4296
3024
  */
4297
- 500: OpenAiApiError;
3025
+ 500: BodhiApiError;
4298
3026
  };
4299
3027
  export type GetApiFormatsError = GetApiFormatsErrors[keyof GetApiFormatsErrors];
4300
3028
  export type GetApiFormatsResponses = {
@@ -4314,19 +3042,19 @@ export type TestApiModelErrors = {
4314
3042
  /**
4315
3043
  * Invalid request parameters
4316
3044
  */
4317
- 400: OpenAiApiError;
3045
+ 400: BodhiApiError;
4318
3046
  /**
4319
3047
  * Not authenticated
4320
3048
  */
4321
- 401: OpenAiApiError;
3049
+ 401: BodhiApiError;
4322
3050
  /**
4323
3051
  * Insufficient permissions
4324
3052
  */
4325
- 403: OpenAiApiError;
3053
+ 403: BodhiApiError;
4326
3054
  /**
4327
3055
  * Internal server error
4328
3056
  */
4329
- 500: OpenAiApiError;
3057
+ 500: BodhiApiError;
4330
3058
  };
4331
3059
  export type TestApiModelError = TestApiModelErrors[keyof TestApiModelErrors];
4332
3060
  export type TestApiModelResponses = {
@@ -4351,23 +3079,23 @@ export type DeleteApiModelErrors = {
4351
3079
  /**
4352
3080
  * Invalid request parameters
4353
3081
  */
4354
- 400: OpenAiApiError;
3082
+ 400: BodhiApiError;
4355
3083
  /**
4356
3084
  * Not authenticated
4357
3085
  */
4358
- 401: OpenAiApiError;
3086
+ 401: BodhiApiError;
4359
3087
  /**
4360
3088
  * Insufficient permissions
4361
3089
  */
4362
- 403: OpenAiApiError;
3090
+ 403: BodhiApiError;
4363
3091
  /**
4364
3092
  * API model not found
4365
3093
  */
4366
- 404: OpenAiApiError;
3094
+ 404: BodhiApiError;
4367
3095
  /**
4368
3096
  * Internal server error
4369
3097
  */
4370
- 500: OpenAiApiError;
3098
+ 500: BodhiApiError;
4371
3099
  };
4372
3100
  export type DeleteApiModelError = DeleteApiModelErrors[keyof DeleteApiModelErrors];
4373
3101
  export type DeleteApiModelResponses = {
@@ -4392,23 +3120,23 @@ export type GetApiModelErrors = {
4392
3120
  /**
4393
3121
  * Invalid request parameters
4394
3122
  */
4395
- 400: OpenAiApiError;
3123
+ 400: BodhiApiError;
4396
3124
  /**
4397
3125
  * Not authenticated
4398
3126
  */
4399
- 401: OpenAiApiError;
3127
+ 401: BodhiApiError;
4400
3128
  /**
4401
3129
  * Insufficient permissions
4402
3130
  */
4403
- 403: OpenAiApiError;
3131
+ 403: BodhiApiError;
4404
3132
  /**
4405
3133
  * API model with specified ID not found
4406
3134
  */
4407
- 404: OpenAiApiError;
3135
+ 404: BodhiApiError;
4408
3136
  /**
4409
3137
  * Internal server error
4410
3138
  */
4411
- 500: OpenAiApiError;
3139
+ 500: BodhiApiError;
4412
3140
  };
4413
3141
  export type GetApiModelError = GetApiModelErrors[keyof GetApiModelErrors];
4414
3142
  export type GetApiModelResponses = {
@@ -4433,23 +3161,23 @@ export type UpdateApiModelErrors = {
4433
3161
  /**
4434
3162
  * Invalid request parameters
4435
3163
  */
4436
- 400: OpenAiApiError;
3164
+ 400: BodhiApiError;
4437
3165
  /**
4438
3166
  * Not authenticated
4439
3167
  */
4440
- 401: OpenAiApiError;
3168
+ 401: BodhiApiError;
4441
3169
  /**
4442
3170
  * Insufficient permissions
4443
3171
  */
4444
- 403: OpenAiApiError;
3172
+ 403: BodhiApiError;
4445
3173
  /**
4446
3174
  * API model not found
4447
3175
  */
4448
- 404: OpenAiApiError;
3176
+ 404: BodhiApiError;
4449
3177
  /**
4450
3178
  * Internal server error
4451
3179
  */
4452
- 500: OpenAiApiError;
3180
+ 500: BodhiApiError;
4453
3181
  };
4454
3182
  export type UpdateApiModelError = UpdateApiModelErrors[keyof UpdateApiModelErrors];
4455
3183
  export type UpdateApiModelResponses = {
@@ -4474,15 +3202,15 @@ export type SyncModelsErrors = {
4474
3202
  /**
4475
3203
  * Invalid request parameters
4476
3204
  */
4477
- 400: OpenAiApiError;
3205
+ 400: BodhiApiError;
4478
3206
  /**
4479
3207
  * Not authenticated
4480
3208
  */
4481
- 401: OpenAiApiError;
3209
+ 401: BodhiApiError;
4482
3210
  /**
4483
3211
  * Insufficient permissions
4484
3212
  */
4485
- 403: OpenAiApiError;
3213
+ 403: BodhiApiError;
4486
3214
  /**
4487
3215
  * API model not found
4488
3216
  */
@@ -4490,7 +3218,7 @@ export type SyncModelsErrors = {
4490
3218
  /**
4491
3219
  * Internal server error
4492
3220
  */
4493
- 500: OpenAiApiError;
3221
+ 500: BodhiApiError;
4494
3222
  };
4495
3223
  export type SyncModelsError = SyncModelsErrors[keyof SyncModelsErrors];
4496
3224
  export type SyncModelsResponses = {
@@ -4527,19 +3255,19 @@ export type ListModelFilesErrors = {
4527
3255
  /**
4528
3256
  * Invalid request parameters
4529
3257
  */
4530
- 400: OpenAiApiError;
3258
+ 400: BodhiApiError;
4531
3259
  /**
4532
3260
  * Not authenticated
4533
3261
  */
4534
- 401: OpenAiApiError;
3262
+ 401: BodhiApiError;
4535
3263
  /**
4536
3264
  * Insufficient permissions
4537
3265
  */
4538
- 403: OpenAiApiError;
3266
+ 403: BodhiApiError;
4539
3267
  /**
4540
3268
  * Internal server error
4541
3269
  */
4542
- 500: OpenAiApiError;
3270
+ 500: BodhiApiError;
4543
3271
  };
4544
3272
  export type ListModelFilesError = ListModelFilesErrors[keyof ListModelFilesErrors];
4545
3273
  export type ListModelFilesResponses = {
@@ -4576,19 +3304,19 @@ export type ListDownloadsErrors = {
4576
3304
  /**
4577
3305
  * Invalid request parameters
4578
3306
  */
4579
- 400: OpenAiApiError;
3307
+ 400: BodhiApiError;
4580
3308
  /**
4581
3309
  * Not authenticated
4582
3310
  */
4583
- 401: OpenAiApiError;
3311
+ 401: BodhiApiError;
4584
3312
  /**
4585
3313
  * Insufficient permissions
4586
3314
  */
4587
- 403: OpenAiApiError;
3315
+ 403: BodhiApiError;
4588
3316
  /**
4589
3317
  * Internal server error
4590
3318
  */
4591
- 500: OpenAiApiError;
3319
+ 500: BodhiApiError;
4592
3320
  };
4593
3321
  export type ListDownloadsError = ListDownloadsErrors[keyof ListDownloadsErrors];
4594
3322
  export type ListDownloadsResponses = {
@@ -4611,19 +3339,19 @@ export type PullModelFileErrors = {
4611
3339
  /**
4612
3340
  * Invalid request parameters
4613
3341
  */
4614
- 400: OpenAiApiError;
3342
+ 400: BodhiApiError;
4615
3343
  /**
4616
3344
  * Not authenticated
4617
3345
  */
4618
- 401: OpenAiApiError;
3346
+ 401: BodhiApiError;
4619
3347
  /**
4620
3348
  * Insufficient permissions
4621
3349
  */
4622
- 403: OpenAiApiError;
3350
+ 403: BodhiApiError;
4623
3351
  /**
4624
3352
  * Internal server error
4625
3353
  */
4626
- 500: OpenAiApiError;
3354
+ 500: BodhiApiError;
4627
3355
  };
4628
3356
  export type PullModelFileError = PullModelFileErrors[keyof PullModelFileErrors];
4629
3357
  export type PullModelFileResponses = {
@@ -4652,23 +3380,23 @@ export type GetDownloadStatusErrors = {
4652
3380
  /**
4653
3381
  * Invalid request parameters
4654
3382
  */
4655
- 400: OpenAiApiError;
3383
+ 400: BodhiApiError;
4656
3384
  /**
4657
3385
  * Not authenticated
4658
3386
  */
4659
- 401: OpenAiApiError;
3387
+ 401: BodhiApiError;
4660
3388
  /**
4661
3389
  * Insufficient permissions
4662
3390
  */
4663
- 403: OpenAiApiError;
3391
+ 403: BodhiApiError;
4664
3392
  /**
4665
3393
  * Download request not found
4666
3394
  */
4667
- 404: OpenAiApiError;
3395
+ 404: BodhiApiError;
4668
3396
  /**
4669
3397
  * Internal server error
4670
3398
  */
4671
- 500: OpenAiApiError;
3399
+ 500: BodhiApiError;
4672
3400
  };
4673
3401
  export type GetDownloadStatusError = GetDownloadStatusErrors[keyof GetDownloadStatusErrors];
4674
3402
  export type GetDownloadStatusResponses = {
@@ -4691,15 +3419,15 @@ export type RefreshModelMetadataErrors = {
4691
3419
  /**
4692
3420
  * Invalid request parameters
4693
3421
  */
4694
- 400: OpenAiApiError;
3422
+ 400: BodhiApiError;
4695
3423
  /**
4696
3424
  * Not authenticated
4697
3425
  */
4698
- 401: OpenAiApiError;
3426
+ 401: BodhiApiError;
4699
3427
  /**
4700
3428
  * Insufficient permissions
4701
3429
  */
4702
- 403: OpenAiApiError;
3430
+ 403: BodhiApiError;
4703
3431
  /**
4704
3432
  * Model alias not found for specified repo/filename/snapshot
4705
3433
  */
@@ -4707,7 +3435,7 @@ export type RefreshModelMetadataErrors = {
4707
3435
  /**
4708
3436
  * Internal server error
4709
3437
  */
4710
- 500: OpenAiApiError;
3438
+ 500: BodhiApiError;
4711
3439
  };
4712
3440
  export type RefreshModelMetadataError = RefreshModelMetadataErrors[keyof RefreshModelMetadataErrors];
4713
3441
  export type RefreshModelMetadataResponses = {
@@ -4736,23 +3464,23 @@ export type GetAliasErrors = {
4736
3464
  /**
4737
3465
  * Invalid request parameters
4738
3466
  */
4739
- 400: OpenAiApiError;
3467
+ 400: BodhiApiError;
4740
3468
  /**
4741
3469
  * Not authenticated
4742
3470
  */
4743
- 401: OpenAiApiError;
3471
+ 401: BodhiApiError;
4744
3472
  /**
4745
3473
  * Insufficient permissions
4746
3474
  */
4747
- 403: OpenAiApiError;
3475
+ 403: BodhiApiError;
4748
3476
  /**
4749
3477
  * Alias not found
4750
3478
  */
4751
- 404: OpenAiApiError;
3479
+ 404: BodhiApiError;
4752
3480
  /**
4753
3481
  * Internal server error
4754
3482
  */
4755
- 500: OpenAiApiError;
3483
+ 500: BodhiApiError;
4756
3484
  };
4757
3485
  export type GetAliasError = GetAliasErrors[keyof GetAliasErrors];
4758
3486
  export type GetAliasResponses = {
@@ -4772,19 +3500,19 @@ export type GetQueueStatusErrors = {
4772
3500
  /**
4773
3501
  * Invalid request parameters
4774
3502
  */
4775
- 400: OpenAiApiError;
3503
+ 400: BodhiApiError;
4776
3504
  /**
4777
3505
  * Not authenticated
4778
3506
  */
4779
- 401: OpenAiApiError;
3507
+ 401: BodhiApiError;
4780
3508
  /**
4781
3509
  * Insufficient permissions
4782
3510
  */
4783
- 403: OpenAiApiError;
3511
+ 403: BodhiApiError;
4784
3512
  /**
4785
3513
  * Internal server error
4786
3514
  */
4787
- 500: OpenAiApiError;
3515
+ 500: BodhiApiError;
4788
3516
  };
4789
3517
  export type GetQueueStatusError = GetQueueStatusErrors[keyof GetQueueStatusErrors];
4790
3518
  export type GetQueueStatusResponses = {
@@ -4804,19 +3532,19 @@ export type ListSettingsErrors = {
4804
3532
  /**
4805
3533
  * Invalid request parameters
4806
3534
  */
4807
- 400: OpenAiApiError;
3535
+ 400: BodhiApiError;
4808
3536
  /**
4809
3537
  * Not authenticated
4810
3538
  */
4811
- 401: OpenAiApiError;
3539
+ 401: BodhiApiError;
4812
3540
  /**
4813
3541
  * Insufficient permissions
4814
3542
  */
4815
- 403: OpenAiApiError;
3543
+ 403: BodhiApiError;
4816
3544
  /**
4817
3545
  * Internal server error
4818
3546
  */
4819
- 500: OpenAiApiError;
3547
+ 500: BodhiApiError;
4820
3548
  };
4821
3549
  export type ListSettingsError = ListSettingsErrors[keyof ListSettingsErrors];
4822
3550
  export type ListSettingsResponses = {
@@ -4841,23 +3569,23 @@ export type DeleteSettingErrors = {
4841
3569
  /**
4842
3570
  * Invalid request parameters
4843
3571
  */
4844
- 400: OpenAiApiError;
3572
+ 400: BodhiApiError;
4845
3573
  /**
4846
3574
  * Not authenticated
4847
3575
  */
4848
- 401: OpenAiApiError;
3576
+ 401: BodhiApiError;
4849
3577
  /**
4850
3578
  * Insufficient permissions
4851
3579
  */
4852
- 403: OpenAiApiError;
3580
+ 403: BodhiApiError;
4853
3581
  /**
4854
3582
  * Setting not found
4855
3583
  */
4856
- 404: OpenAiApiError;
3584
+ 404: BodhiApiError;
4857
3585
  /**
4858
3586
  * Internal server error
4859
3587
  */
4860
- 500: OpenAiApiError;
3588
+ 500: BodhiApiError;
4861
3589
  };
4862
3590
  export type DeleteSettingError = DeleteSettingErrors[keyof DeleteSettingErrors];
4863
3591
  export type DeleteSettingResponses = {
@@ -4890,23 +3618,23 @@ export type UpdateSettingErrors = {
4890
3618
  /**
4891
3619
  * Invalid request parameters
4892
3620
  */
4893
- 400: OpenAiApiError;
3621
+ 400: BodhiApiError;
4894
3622
  /**
4895
3623
  * Not authenticated
4896
3624
  */
4897
- 401: OpenAiApiError;
3625
+ 401: BodhiApiError;
4898
3626
  /**
4899
3627
  * Insufficient permissions
4900
3628
  */
4901
- 403: OpenAiApiError;
3629
+ 403: BodhiApiError;
4902
3630
  /**
4903
3631
  * Setting not found
4904
3632
  */
4905
- 404: OpenAiApiError;
3633
+ 404: BodhiApiError;
4906
3634
  /**
4907
3635
  * Internal server error
4908
3636
  */
4909
- 500: OpenAiApiError;
3637
+ 500: BodhiApiError;
4910
3638
  };
4911
3639
  export type UpdateSettingError = UpdateSettingErrors[keyof UpdateSettingErrors];
4912
3640
  export type UpdateSettingResponses = {
@@ -4929,11 +3657,11 @@ export type SetupAppErrors = {
4929
3657
  /**
4930
3658
  * Invalid request parameters
4931
3659
  */
4932
- 400: OpenAiApiError;
3660
+ 400: BodhiApiError;
4933
3661
  /**
4934
3662
  * Internal server error
4935
3663
  */
4936
- 500: OpenAiApiError;
3664
+ 500: BodhiApiError;
4937
3665
  };
4938
3666
  export type SetupAppError = SetupAppErrors[keyof SetupAppErrors];
4939
3667
  export type SetupAppResponses = {
@@ -4953,19 +3681,19 @@ export type TenantsListErrors = {
4953
3681
  /**
4954
3682
  * Invalid request parameters
4955
3683
  */
4956
- 400: OpenAiApiError;
3684
+ 400: BodhiApiError;
4957
3685
  /**
4958
3686
  * Not authenticated
4959
3687
  */
4960
- 401: OpenAiApiError;
3688
+ 401: BodhiApiError;
4961
3689
  /**
4962
3690
  * Insufficient permissions
4963
3691
  */
4964
- 403: OpenAiApiError;
3692
+ 403: BodhiApiError;
4965
3693
  /**
4966
3694
  * Internal server error
4967
3695
  */
4968
- 500: OpenAiApiError;
3696
+ 500: BodhiApiError;
4969
3697
  };
4970
3698
  export type TenantsListError = TenantsListErrors[keyof TenantsListErrors];
4971
3699
  export type TenantsListResponses = {
@@ -4988,19 +3716,19 @@ export type TenantsCreateErrors = {
4988
3716
  /**
4989
3717
  * Invalid request parameters
4990
3718
  */
4991
- 400: OpenAiApiError;
3719
+ 400: BodhiApiError;
4992
3720
  /**
4993
3721
  * Not authenticated
4994
3722
  */
4995
- 401: OpenAiApiError;
3723
+ 401: BodhiApiError;
4996
3724
  /**
4997
3725
  * Insufficient permissions
4998
3726
  */
4999
- 403: OpenAiApiError;
3727
+ 403: BodhiApiError;
5000
3728
  /**
5001
3729
  * Internal server error
5002
3730
  */
5003
- 500: OpenAiApiError;
3731
+ 500: BodhiApiError;
5004
3732
  };
5005
3733
  export type TenantsCreateError = TenantsCreateErrors[keyof TenantsCreateErrors];
5006
3734
  export type TenantsCreateResponses = {
@@ -5025,19 +3753,19 @@ export type TenantsActivateErrors = {
5025
3753
  /**
5026
3754
  * Invalid request parameters
5027
3755
  */
5028
- 400: OpenAiApiError;
3756
+ 400: BodhiApiError;
5029
3757
  /**
5030
3758
  * Not authenticated
5031
3759
  */
5032
- 401: OpenAiApiError;
3760
+ 401: BodhiApiError;
5033
3761
  /**
5034
3762
  * Insufficient permissions
5035
3763
  */
5036
- 403: OpenAiApiError;
3764
+ 403: BodhiApiError;
5037
3765
  /**
5038
3766
  * Internal server error
5039
3767
  */
5040
- 500: OpenAiApiError;
3768
+ 500: BodhiApiError;
5041
3769
  };
5042
3770
  export type TenantsActivateError = TenantsActivateErrors[keyof TenantsActivateErrors];
5043
3771
  export type TenantsActivateResponses = {
@@ -5073,19 +3801,19 @@ export type ListApiTokensErrors = {
5073
3801
  /**
5074
3802
  * Invalid request parameters
5075
3803
  */
5076
- 400: OpenAiApiError;
3804
+ 400: BodhiApiError;
5077
3805
  /**
5078
3806
  * Not authenticated
5079
3807
  */
5080
- 401: OpenAiApiError;
3808
+ 401: BodhiApiError;
5081
3809
  /**
5082
3810
  * Insufficient permissions
5083
3811
  */
5084
- 403: OpenAiApiError;
3812
+ 403: BodhiApiError;
5085
3813
  /**
5086
3814
  * Internal server error
5087
3815
  */
5088
- 500: OpenAiApiError;
3816
+ 500: BodhiApiError;
5089
3817
  };
5090
3818
  export type ListApiTokensError = ListApiTokensErrors[keyof ListApiTokensErrors];
5091
3819
  export type ListApiTokensResponses = {
@@ -5108,19 +3836,19 @@ export type CreateApiTokenErrors = {
5108
3836
  /**
5109
3837
  * Invalid request parameters
5110
3838
  */
5111
- 400: OpenAiApiError;
3839
+ 400: BodhiApiError;
5112
3840
  /**
5113
3841
  * Not authenticated
5114
3842
  */
5115
- 401: OpenAiApiError;
3843
+ 401: BodhiApiError;
5116
3844
  /**
5117
3845
  * Insufficient permissions
5118
3846
  */
5119
- 403: OpenAiApiError;
3847
+ 403: BodhiApiError;
5120
3848
  /**
5121
3849
  * Internal server error
5122
3850
  */
5123
- 500: OpenAiApiError;
3851
+ 500: BodhiApiError;
5124
3852
  };
5125
3853
  export type CreateApiTokenError = CreateApiTokenErrors[keyof CreateApiTokenErrors];
5126
3854
  export type CreateApiTokenResponses = {
@@ -5148,23 +3876,23 @@ export type UpdateApiTokenErrors = {
5148
3876
  /**
5149
3877
  * Invalid request parameters
5150
3878
  */
5151
- 400: OpenAiApiError;
3879
+ 400: BodhiApiError;
5152
3880
  /**
5153
3881
  * Not authenticated
5154
3882
  */
5155
- 401: OpenAiApiError;
3883
+ 401: BodhiApiError;
5156
3884
  /**
5157
3885
  * Insufficient permissions
5158
3886
  */
5159
- 403: OpenAiApiError;
3887
+ 403: BodhiApiError;
5160
3888
  /**
5161
3889
  * Token not found
5162
3890
  */
5163
- 404: OpenAiApiError;
3891
+ 404: BodhiApiError;
5164
3892
  /**
5165
3893
  * Internal server error
5166
3894
  */
5167
- 500: OpenAiApiError;
3895
+ 500: BodhiApiError;
5168
3896
  };
5169
3897
  export type UpdateApiTokenError = UpdateApiTokenErrors[keyof UpdateApiTokenErrors];
5170
3898
  export type UpdateApiTokenResponses = {
@@ -5184,19 +3912,19 @@ export type GetCurrentUserErrors = {
5184
3912
  /**
5185
3913
  * Invalid request parameters
5186
3914
  */
5187
- 400: OpenAiApiError;
3915
+ 400: BodhiApiError;
5188
3916
  /**
5189
3917
  * Not authenticated
5190
3918
  */
5191
- 401: OpenAiApiError;
3919
+ 401: BodhiApiError;
5192
3920
  /**
5193
3921
  * Insufficient permissions
5194
3922
  */
5195
- 403: OpenAiApiError;
3923
+ 403: BodhiApiError;
5196
3924
  /**
5197
3925
  * Internal server error
5198
3926
  */
5199
- 500: OpenAiApiError;
3927
+ 500: BodhiApiError;
5200
3928
  };
5201
3929
  export type GetCurrentUserError = GetCurrentUserErrors[keyof GetCurrentUserErrors];
5202
3930
  export type GetCurrentUserResponses = {
@@ -5216,27 +3944,27 @@ export type RequestUserAccessErrors = {
5216
3944
  /**
5217
3945
  * Invalid request parameters
5218
3946
  */
5219
- 400: OpenAiApiError;
3947
+ 400: BodhiApiError;
5220
3948
  /**
5221
3949
  * Not authenticated
5222
3950
  */
5223
- 401: OpenAiApiError;
3951
+ 401: BodhiApiError;
5224
3952
  /**
5225
3953
  * Insufficient permissions
5226
3954
  */
5227
- 403: OpenAiApiError;
3955
+ 403: BodhiApiError;
5228
3956
  /**
5229
3957
  * Pending request already exists
5230
3958
  */
5231
- 409: OpenAiApiError;
3959
+ 409: BodhiApiError;
5232
3960
  /**
5233
3961
  * User already has role
5234
3962
  */
5235
- 422: OpenAiApiError;
3963
+ 422: BodhiApiError;
5236
3964
  /**
5237
3965
  * Internal server error
5238
3966
  */
5239
- 500: OpenAiApiError;
3967
+ 500: BodhiApiError;
5240
3968
  };
5241
3969
  export type RequestUserAccessError = RequestUserAccessErrors[keyof RequestUserAccessErrors];
5242
3970
  export type RequestUserAccessResponses = {
@@ -5255,23 +3983,23 @@ export type GetUserAccessStatusErrors = {
5255
3983
  /**
5256
3984
  * Invalid request parameters
5257
3985
  */
5258
- 400: OpenAiApiError;
3986
+ 400: BodhiApiError;
5259
3987
  /**
5260
3988
  * Not authenticated
5261
3989
  */
5262
- 401: OpenAiApiError;
3990
+ 401: BodhiApiError;
5263
3991
  /**
5264
3992
  * Insufficient permissions
5265
3993
  */
5266
- 403: OpenAiApiError;
3994
+ 403: BodhiApiError;
5267
3995
  /**
5268
3996
  * Request not found
5269
3997
  */
5270
- 404: OpenAiApiError;
3998
+ 404: BodhiApiError;
5271
3999
  /**
5272
4000
  * Internal server error
5273
4001
  */
5274
- 500: OpenAiApiError;
4002
+ 500: BodhiApiError;
5275
4003
  };
5276
4004
  export type GetUserAccessStatusError = GetUserAccessStatusErrors[keyof GetUserAccessStatusErrors];
5277
4005
  export type GetUserAccessStatusResponses = {
@@ -5300,19 +4028,19 @@ export type ListUsersErrors = {
5300
4028
  /**
5301
4029
  * Invalid request parameters
5302
4030
  */
5303
- 400: OpenAiApiError;
4031
+ 400: BodhiApiError;
5304
4032
  /**
5305
4033
  * Not authenticated
5306
4034
  */
5307
- 401: OpenAiApiError;
4035
+ 401: BodhiApiError;
5308
4036
  /**
5309
4037
  * Insufficient permissions
5310
4038
  */
5311
- 403: OpenAiApiError;
4039
+ 403: BodhiApiError;
5312
4040
  /**
5313
4041
  * Internal server error
5314
4042
  */
5315
- 500: OpenAiApiError;
4043
+ 500: BodhiApiError;
5316
4044
  };
5317
4045
  export type ListUsersError = ListUsersErrors[keyof ListUsersErrors];
5318
4046
  export type ListUsersResponses = {
@@ -5337,23 +4065,23 @@ export type RemoveUserErrors = {
5337
4065
  /**
5338
4066
  * Invalid request parameters
5339
4067
  */
5340
- 400: OpenAiApiError;
4068
+ 400: BodhiApiError;
5341
4069
  /**
5342
4070
  * Not authenticated
5343
4071
  */
5344
- 401: OpenAiApiError;
4072
+ 401: BodhiApiError;
5345
4073
  /**
5346
4074
  * Insufficient permissions
5347
4075
  */
5348
- 403: OpenAiApiError;
4076
+ 403: BodhiApiError;
5349
4077
  /**
5350
4078
  * User not found
5351
4079
  */
5352
- 404: OpenAiApiError;
4080
+ 404: BodhiApiError;
5353
4081
  /**
5354
4082
  * Internal server error
5355
4083
  */
5356
- 500: OpenAiApiError;
4084
+ 500: BodhiApiError;
5357
4085
  };
5358
4086
  export type RemoveUserError = RemoveUserErrors[keyof RemoveUserErrors];
5359
4087
  export type RemoveUserResponses = {
@@ -5377,23 +4105,23 @@ export type ChangeUserRoleErrors = {
5377
4105
  /**
5378
4106
  * Invalid request parameters
5379
4107
  */
5380
- 400: OpenAiApiError;
4108
+ 400: BodhiApiError;
5381
4109
  /**
5382
4110
  * Not authenticated
5383
4111
  */
5384
- 401: OpenAiApiError;
4112
+ 401: BodhiApiError;
5385
4113
  /**
5386
4114
  * Insufficient permissions
5387
4115
  */
5388
- 403: OpenAiApiError;
4116
+ 403: BodhiApiError;
5389
4117
  /**
5390
4118
  * User not found
5391
4119
  */
5392
- 404: OpenAiApiError;
4120
+ 404: BodhiApiError;
5393
4121
  /**
5394
4122
  * Internal server error
5395
4123
  */
5396
- 500: OpenAiApiError;
4124
+ 500: BodhiApiError;
5397
4125
  };
5398
4126
  export type ChangeUserRoleError = ChangeUserRoleErrors[keyof ChangeUserRoleErrors];
5399
4127
  export type ChangeUserRoleResponses = {
@@ -5412,11 +4140,11 @@ export type HealthCheckErrors = {
5412
4140
  /**
5413
4141
  * Invalid request parameters
5414
4142
  */
5415
- 400: OpenAiApiError;
4143
+ 400: BodhiApiError;
5416
4144
  /**
5417
4145
  * Internal server error
5418
4146
  */
5419
- 500: OpenAiApiError;
4147
+ 500: BodhiApiError;
5420
4148
  };
5421
4149
  export type HealthCheckError = HealthCheckErrors[keyof HealthCheckErrors];
5422
4150
  export type HealthCheckResponses = {
@@ -5436,11 +4164,11 @@ export type PingServerErrors = {
5436
4164
  /**
5437
4165
  * Invalid request parameters
5438
4166
  */
5439
- 400: OpenAiApiError;
4167
+ 400: BodhiApiError;
5440
4168
  /**
5441
4169
  * Internal server error
5442
4170
  */
5443
- 500: OpenAiApiError;
4171
+ 500: BodhiApiError;
5444
4172
  };
5445
4173
  export type PingServerError = PingServerErrors[keyof PingServerErrors];
5446
4174
  export type PingServerResponses = {
@@ -5450,147 +4178,6 @@ export type PingServerResponses = {
5450
4178
  200: PingResponse;
5451
4179
  };
5452
4180
  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
4181
  export type ClientOptions = {
5595
4182
  baseUrl: 'http://localhost:1135' | (string & {});
5596
4183
  };