@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.
@@ -127,7 +127,7 @@ export type ApiAliasResponse = {
127
127
  /**
128
128
  * API format/protocol specification
129
129
  */
130
- export type ApiFormat = 'openai' | 'placeholder';
130
+ export type ApiFormat = 'openai' | 'openai_responses' | 'placeholder';
131
131
 
132
132
  /**
133
133
  * Response containing available API formats
@@ -288,519 +288,42 @@ export type AuthInitiateRequest = {
288
288
  client_id: string;
289
289
  };
290
290
 
291
- /**
292
- * Change user role request
293
- */
294
- export type ChangeRoleRequest = {
295
- /**
296
- * Role to assign to the user
297
- */
298
- role: ResourceRole;
299
- };
300
-
301
- export type ChatChoice = {
302
- /**
303
- * The index of the choice in the list of choices.
304
- */
305
- index: number;
306
- message: ChatCompletionResponseMessage;
307
- finish_reason?: null | FinishReason;
308
- logprobs?: null | ChatChoiceLogprobs;
309
- };
310
-
311
- export type ChatChoiceLogprobs = {
312
- /**
313
- * A list of message content tokens with log probability information.
314
- */
315
- content?: Array<ChatCompletionTokenLogprob> | null;
316
- refusal?: Array<ChatCompletionTokenLogprob> | null;
317
- };
318
-
319
- export type ChatChoiceStream = {
320
- /**
321
- * The index of the choice in the list of choices.
322
- */
323
- index: number;
324
- delta: ChatCompletionStreamResponseDelta;
325
- finish_reason?: null | FinishReason;
326
- logprobs?: null | ChatChoiceLogprobs;
327
- };
328
-
329
- export type ChatCompletionAllowedTools = {
330
- /**
331
- * Constrains the tools available to the model to a pre-defined set.
332
- *
333
- * `auto` allows the model to pick from among the allowed tools and generate a
334
- * message.
335
- *
336
- * `required` requires the model to call one or more of the allowed tools.
337
- */
338
- mode: ToolChoiceAllowedMode;
339
- /**
340
- * A list of tool definitions that the model should be allowed to call.
341
- *
342
- * For the Chat Completions API, the list of tool definitions might look like:
343
- * ```json
344
- * [
345
- * { "type": "function", "function": { "name": "get_weather" } },
346
- * { "type": "function", "function": { "name": "get_time" } }
347
- * ]
348
- * ```
349
- */
350
- tools: Array<unknown>;
351
- };
352
-
353
- export type ChatCompletionAllowedToolsChoice = {
354
- allowed_tools: Array<ChatCompletionAllowedTools>;
355
- };
356
-
357
- export type ChatCompletionAudio = {
358
- /**
359
- * The voice the model uses to respond. Supported built-in voices are `alloy`, `ash`,
360
- * `ballad`, `coral`, `echo`, `fable`, `nova`, `onyx`, `sage`, `shimmer`, `marin`, and `cedar`.
361
- */
362
- voice: ChatCompletionAudioVoice;
363
- /**
364
- * Specifies the output audio format. Must be one of `wav`, `aac`, `mp3`, `flac`, `opus`, or `pcm16`.
365
- */
366
- format: ChatCompletionAudioFormat;
367
- };
368
-
369
- export type ChatCompletionAudioFormat = 'wav' | 'aac' | 'mp3' | 'flac' | 'opus' | 'pcm16';
370
-
371
- export type ChatCompletionAudioVoice = 'alloy' | 'ash' | 'ballad' | 'coral' | 'echo' | 'fable' | 'nova' | 'onyx' | 'sage' | 'shimmer' | {
372
- other: string;
373
- };
374
-
375
- export type ChatCompletionFunctionCall = 'none' | 'auto' | {
376
- /**
377
- * Forces the model to call the specified function.
378
- */
379
- Function: {
380
- name: string;
381
- };
382
- };
383
-
384
- export type ChatCompletionFunctions = {
385
- /**
386
- * 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.
387
- */
388
- name: string;
389
- /**
390
- * A description of what the function does, used by the model to choose when and how to call the function.
391
- */
392
- description?: string | null;
393
- /**
394
- * 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.
395
- *
396
- * Omitting `parameters` defines a function with an empty parameter list.
397
- */
398
- parameters: unknown;
399
- };
400
-
401
- export type ChatCompletionMessageCustomToolCall = {
402
- /**
403
- * The ID of the tool call.
404
- */
405
- id: string;
406
- /**
407
- * The custom tool that the model called.
408
- */
409
- custom_tool: CustomTool;
410
- };
411
-
412
- export type ChatCompletionMessageToolCall = {
413
- /**
414
- * The ID of the tool call.
415
- */
416
- id: string;
417
- /**
418
- * The function that the model called.
419
- */
420
- function: FunctionCall;
421
- };
422
-
423
- export type ChatCompletionMessageToolCallChunk = {
424
- index: number;
425
- /**
426
- * The ID of the tool call.
427
- */
428
- id?: string | null;
429
- type?: null | FunctionType;
430
- function?: null | FunctionCallStream;
431
- };
432
-
433
- export type ChatCompletionMessageToolCalls = (ChatCompletionMessageToolCall & {
434
- type: 'function';
435
- }) | (ChatCompletionMessageCustomToolCall & {
436
- type: 'custom';
437
- });
438
-
439
- /**
440
- * Specifies a tool the model should use. Use to force the model to call a specific function.
441
- */
442
- export type ChatCompletionNamedToolChoice = {
443
- function: FunctionName;
444
- };
445
-
446
- export type ChatCompletionNamedToolChoiceCustom = {
447
- custom: CustomName;
448
- };
449
-
450
- export type ChatCompletionRequestAssistantMessage = {
451
- content?: null | ChatCompletionRequestAssistantMessageContent;
452
- /**
453
- * The refusal message by the assistant.
454
- */
455
- refusal?: string | null;
456
- /**
457
- * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
458
- */
459
- name?: string | null;
460
- audio?: null | ChatCompletionRequestAssistantMessageAudio;
461
- tool_calls?: Array<ChatCompletionMessageToolCalls> | null;
462
- function_call?: null | FunctionCall;
463
- };
464
-
465
- export type ChatCompletionRequestAssistantMessageAudio = {
466
- /**
467
- * Unique identifier for a previous audio response from the model.
468
- */
469
- id: string;
470
- };
471
-
472
- export type ChatCompletionRequestAssistantMessageContent = string | Array<ChatCompletionRequestAssistantMessageContentPart>;
473
-
474
- export type ChatCompletionRequestAssistantMessageContentPart = (ChatCompletionRequestMessageContentPartText & {
475
- type: 'text';
476
- }) | (ChatCompletionRequestMessageContentPartRefusal & {
477
- type: 'refusal';
478
- });
479
-
480
- export type ChatCompletionRequestDeveloperMessage = {
481
- /**
482
- * The contents of the developer message.
483
- */
484
- content: ChatCompletionRequestDeveloperMessageContent;
485
- /**
486
- * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
487
- */
488
- name?: string | null;
489
- };
490
-
491
- export type ChatCompletionRequestDeveloperMessageContent = string | Array<ChatCompletionRequestDeveloperMessageContentPart>;
492
-
493
- export type ChatCompletionRequestDeveloperMessageContentPart = ChatCompletionRequestMessageContentPartText & {
494
- type: 'text';
495
- };
496
-
497
- export type ChatCompletionRequestFunctionMessage = {
498
- /**
499
- * The return value from the function call, to return to the model.
500
- */
501
- content?: string | null;
502
- /**
503
- * The name of the function to call.
504
- */
505
- name: string;
506
- };
507
-
508
- export type ChatCompletionRequestMessage = (ChatCompletionRequestDeveloperMessage & {
509
- role: 'developer';
510
- }) | (ChatCompletionRequestSystemMessage & {
511
- role: 'system';
512
- }) | (ChatCompletionRequestUserMessage & {
513
- role: 'user';
514
- }) | (ChatCompletionRequestAssistantMessage & {
515
- role: 'assistant';
516
- }) | (ChatCompletionRequestToolMessage & {
517
- role: 'tool';
518
- }) | (ChatCompletionRequestFunctionMessage & {
519
- role: 'function';
520
- });
521
-
522
- /**
523
- * Learn about [audio inputs](https://platform.openai.com/docs/guides/audio).
524
- */
525
- export type ChatCompletionRequestMessageContentPartAudio = {
526
- input_audio: InputAudio;
527
- };
528
-
529
- export type ChatCompletionRequestMessageContentPartFile = {
530
- file: FileObject;
531
- };
532
-
533
- export type ChatCompletionRequestMessageContentPartImage = {
534
- image_url: ImageUrl;
535
- };
536
-
537
- export type ChatCompletionRequestMessageContentPartRefusal = {
538
- /**
539
- * The refusal message generated by the model.
540
- */
541
- refusal: string;
542
- };
543
-
544
- export type ChatCompletionRequestMessageContentPartText = {
545
- text: string;
546
- };
547
-
548
- export type ChatCompletionRequestSystemMessage = {
549
- /**
550
- * The contents of the system message.
551
- */
552
- content: ChatCompletionRequestSystemMessageContent;
553
- /**
554
- * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
555
- */
556
- name?: string | null;
557
- };
558
-
559
- export type ChatCompletionRequestSystemMessageContent = string | Array<ChatCompletionRequestSystemMessageContentPart>;
560
-
561
- export type ChatCompletionRequestSystemMessageContentPart = ChatCompletionRequestMessageContentPartText & {
562
- type: 'text';
563
- };
564
-
565
- /**
566
- * Tool message
567
- */
568
- export type ChatCompletionRequestToolMessage = {
569
- /**
570
- * The contents of the tool message.
571
- */
572
- content: ChatCompletionRequestToolMessageContent;
573
- tool_call_id: string;
574
- };
575
-
576
- export type ChatCompletionRequestToolMessageContent = string | Array<ChatCompletionRequestToolMessageContentPart>;
577
-
578
- export type ChatCompletionRequestToolMessageContentPart = ChatCompletionRequestMessageContentPartText & {
579
- type: 'text';
580
- };
581
-
582
- export type ChatCompletionRequestUserMessage = {
583
- /**
584
- * The contents of the user message.
585
- */
586
- content: ChatCompletionRequestUserMessageContent;
587
- /**
588
- * An optional name for the participant. Provides the model information to differentiate between participants of the same role.
589
- */
590
- name?: string | null;
591
- };
592
-
593
- export type ChatCompletionRequestUserMessageContent = string | Array<ChatCompletionRequestUserMessageContentPart>;
594
-
595
- export type ChatCompletionRequestUserMessageContentPart = (ChatCompletionRequestMessageContentPartText & {
596
- type: 'text';
597
- }) | (ChatCompletionRequestMessageContentPartImage & {
598
- type: 'image_url';
599
- }) | (ChatCompletionRequestMessageContentPartAudio & {
600
- type: 'input_audio';
601
- }) | (ChatCompletionRequestMessageContentPartFile & {
602
- type: 'file';
603
- });
604
-
605
- /**
606
- * A chat completion message generated by the model.
607
- */
608
- export type ChatCompletionResponseMessage = {
609
- /**
610
- * The contents of the message.
611
- */
612
- content?: string | null;
613
- /**
614
- * The refusal message generated by the model.
615
- */
616
- refusal?: string | null;
617
- /**
618
- * The tool calls generated by the model, such as function calls.
619
- */
620
- tool_calls?: Array<ChatCompletionMessageToolCalls> | null;
621
- annotations?: Array<ChatCompletionResponseMessageAnnotation> | null;
622
- /**
623
- * The role of the author of this message.
624
- */
625
- role: Role;
626
- function_call?: null | FunctionCall;
627
- audio?: null | ChatCompletionResponseMessageAudio;
628
- /**
629
- * The contents of the reasoning message.
630
- */
631
- reasoning_content?: string | null;
632
- };
633
-
634
- export type ChatCompletionResponseMessageAnnotation = {
635
- url_citation: UrlCitation;
636
- type: 'url_citation';
637
- };
638
-
639
- export type ChatCompletionResponseMessageAudio = {
640
- /**
641
- * Unique identifier for this audio response.
642
- */
643
- id: string;
644
- /**
645
- * The Unix timestamp (in seconds) for when this audio response will no longer be accessible on the server for use in multi-turn conversations.
646
- */
647
- expires_at: number;
291
+ export type BodhiApiError = {
648
292
  /**
649
- * Base64 encoded audio bytes generated by the model, in the format specified in the request.
650
- */
651
- data: string;
652
- /**
653
- * Transcript of the audio generated by the model.
654
- */
655
- transcript: string;
656
- };
657
-
658
- /**
659
- * Options for streaming response. Only set this when you set `stream: true`.
660
- */
661
- export type ChatCompletionStreamOptions = {
662
- /**
663
- * If set, an additional chunk will be streamed before the `data: [DONE]`
664
- * message. The `usage` field on this chunk shows the token usage statistics
665
- * for the entire request, and the `choices` field will always be an empty
666
- * array.
667
- *
668
- * All other chunks will also include a `usage` field, but with a null
669
- * value. **NOTE:** If the stream is interrupted, you may not receive the
670
- * final usage chunk which contains the total token usage for the request.
671
- */
672
- include_usage?: boolean | null;
673
- /**
674
- * When true, stream obfuscation will be enabled. Stream obfuscation adds
675
- * random characters to an `obfuscation` field on streaming delta events to
676
- * normalize payload sizes as a mitigation to certain side-channel attacks.
677
- * These obfuscation fields are included by default, but add a small amount
678
- * of overhead to the data stream. You can set `include_obfuscation` to
679
- * false to optimize for bandwidth if you trust the network links between
680
- * your application and the OpenAI API.
681
- */
682
- include_obfuscation?: boolean | null;
683
- };
684
-
685
- /**
686
- * A chat completion delta generated by streamed model responses.
687
- */
688
- export type ChatCompletionStreamResponseDelta = {
689
- /**
690
- * The contents of the chunk message.
691
- */
692
- content?: string | null;
693
- function_call?: null | FunctionCallStream;
694
- tool_calls?: Array<ChatCompletionMessageToolCallChunk> | null;
695
- role?: null | Role;
696
- /**
697
- * The refusal message generated by the model.
698
- */
699
- refusal?: string | null;
700
- /**
701
- * The contents of the chunk reasoning message.
293
+ * Error details following OpenAI API error format
702
294
  */
703
- reasoning_content?: string | null;
295
+ error: BodhiErrorBody;
704
296
  };
705
297
 
706
- export type ChatCompletionTokenLogprob = {
298
+ export type BodhiErrorBody = {
707
299
  /**
708
- * The token.
709
- */
710
- token: string;
711
- /**
712
- * 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.
713
- */
714
- logprob: number;
715
- /**
716
- * 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.
717
- */
718
- bytes?: Array<number> | null;
719
- /**
720
- * 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.
300
+ * Human-readable error message describing what went wrong
721
301
  */
722
- top_logprobs: Array<TopLogprobs>;
723
- };
724
-
725
- export type ChatCompletionTool = {
726
- function: FunctionObject;
727
- };
728
-
729
- /**
730
- * Controls which (if any) tool is called by the model.
731
- * `none` means the model will not call any tool and instead generates a message.
732
- * `auto` means the model can pick between generating a message or calling one or more tools.
733
- * `required` means the model must call one or more tools.
734
- * Specifying a particular tool via `{"type": "function", "function": {"name": "my_function"}}` forces the model to call that tool.
735
- *
736
- * `none` is the default when no tools are present. `auto` is the default if tools are present.
737
- */
738
- export type ChatCompletionToolChoiceOption = (ChatCompletionAllowedToolsChoice & {
739
- type: 'allowed_tools';
740
- }) | (ChatCompletionNamedToolChoice & {
741
- type: 'function';
742
- }) | (ChatCompletionNamedToolChoiceCustom & {
743
- type: 'custom';
744
- }) | (ToolChoiceOptions & {
745
- type: 'mode';
746
- });
747
-
748
- export type ChatCompletionTools = (ChatCompletionTool & {
749
- type: 'function';
750
- }) | (CustomToolChatCompletions & {
751
- type: 'custom';
752
- });
753
-
754
- export type ChatRequest = {
755
- model: string;
756
- messages: Array<Message>;
757
- stream?: boolean | null;
758
- format?: string | null;
759
- keep_alive?: null | Duration;
760
- options?: null | Options;
761
- };
762
-
763
- /**
764
- * Breakdown of tokens used in a completion.
765
- */
766
- export type CompletionTokensDetails = {
767
- accepted_prediction_tokens?: number | null;
302
+ message: string;
768
303
  /**
769
- * Audio input tokens generated by the model.
304
+ * Error type categorizing the kind of error that occurred
770
305
  */
771
- audio_tokens?: number | null;
306
+ type: string;
772
307
  /**
773
- * Tokens generated by the model for reasoning.
308
+ * Specific error code for programmatic error handling
774
309
  */
775
- reasoning_tokens?: number | null;
310
+ code?: string | null;
776
311
  /**
777
- * When using Predicted Outputs, the number of tokens in the
778
- * prediction that did not appear in the completion. However, like
779
- * reasoning tokens, these tokens are still counted in the total
780
- * completion tokens for purposes of billing, output, and context
781
- * window limits.
312
+ * Additional error parameters as key-value pairs (for validation errors)
782
313
  */
783
- rejected_prediction_tokens?: number | null;
314
+ param?: {
315
+ [key: string]: string;
316
+ } | null;
784
317
  };
785
318
 
786
319
  /**
787
- * Usage statistics for the completion request.
320
+ * Change user role request
788
321
  */
789
- export type CompletionUsage = {
790
- /**
791
- * Number of tokens in the prompt.
792
- */
793
- prompt_tokens: number;
794
- /**
795
- * Number of tokens in the generated completion.
796
- */
797
- completion_tokens: number;
322
+ export type ChangeRoleRequest = {
798
323
  /**
799
- * Total number of tokens used in the request (prompt + completion).
324
+ * Role to assign to the user
800
325
  */
801
- total_tokens: number;
802
- prompt_tokens_details?: null | PromptTokensDetails;
803
- completion_tokens_details?: null | CompletionTokensDetails;
326
+ role: ResourceRole;
804
327
  };
805
328
 
806
329
  export type ContextLimits = {
@@ -817,344 +340,47 @@ export type CopyAliasRequest = {
817
340
  */
818
341
  export type CreateAccessRequest = {
819
342
  /**
820
- * App client ID from Keycloak
821
- */
822
- app_client_id: string;
823
- /**
824
- * Flow type: "redirect" or "popup"
825
- */
826
- flow_type: FlowType;
827
- /**
828
- * Redirect URL for result notification (required for redirect flow)
829
- */
830
- redirect_url?: string | null;
831
- /**
832
- * Role requested for the external app (scope_user_user or scope_user_power_user)
833
- */
834
- requested_role: UserScope;
835
- /**
836
- * Resources requested (tools, etc.)
837
- */
838
- requested: RequestedResources;
839
- };
840
-
841
- export type CreateAccessRequestResponse = {
842
- /**
843
- * Access request ID
844
- */
845
- id: string;
846
- /**
847
- * Status (always "draft")
848
- */
849
- status: AppAccessRequestStatus;
850
- /**
851
- * Review URL for user to approve/deny
852
- */
853
- review_url: string;
854
- };
855
-
856
- /**
857
- * Wrapper for creating auth configs with server_id in body instead of path
858
- */
859
- export type CreateAuthConfig = CreateMcpAuthConfigRequest & {
860
- mcp_server_id: string;
861
- };
862
-
863
- export type CreateChatCompletionRequest = {
864
- /**
865
- * A list of messages comprising the conversation so far. Depending on the
866
- * [model](https://platform.openai.com/docs/models) you use, different message types (modalities)
867
- * are supported, like [text](https://platform.openai.com/docs/guides/text-generation),
868
- * [images](https://platform.openai.com/docs/guides/vision), and
869
- * [audio](https://platform.openai.com/docs/guides/audio).
870
- */
871
- messages: Array<ChatCompletionRequestMessage>;
872
- /**
873
- * Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI
874
- * offers a wide range of models with different capabilities, performance
875
- * characteristics, and price points. Refer to the
876
- * [model guide](https://platform.openai.com/docs/models)
877
- * to browse and compare available models.
878
- */
879
- model: string;
880
- /**
881
- * Output types that you would like the model to generate. Most models are capable of generating
882
- * text, which is the default:
883
- *
884
- * `["text"]`
885
- * The `gpt-4o-audio-preview` model can also be used to
886
- * [generate audio](https://platform.openai.com/docs/guides/audio). To request that this model
887
- * generate both text and audio responses, you can use:
888
- *
889
- * `["text", "audio"]`
890
- */
891
- modalities?: Array<ResponseModalities> | null;
892
- verbosity?: null | Verbosity;
893
- reasoning_effort?: null | ReasoningEffort;
894
- /**
895
- * An upper bound for the number of tokens that can be generated for a completion, including
896
- * visible output tokens and [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
897
- */
898
- max_completion_tokens?: number | null;
899
- /**
900
- * Number between -2.0 and 2.0. Positive values penalize new tokens based on
901
- * their existing frequency in the text so far, decreasing the model's
902
- * likelihood to repeat the same line verbatim.
903
- */
904
- frequency_penalty?: number | null;
905
- /**
906
- * Number between -2.0 and 2.0. Positive values penalize new tokens based on
907
- * whether they appear in the text so far, increasing the model's likelihood
908
- * to talk about new topics.
909
- */
910
- presence_penalty?: number | null;
911
- web_search_options?: null | WebSearchOptions;
912
- /**
913
- * An integer between 0 and 20 specifying the number of most likely tokens to
914
- * return at each token position, each with an associated log probability.
915
- * `logprobs` must be set to `true` if this parameter is used.
916
- */
917
- top_logprobs?: number | null;
918
- response_format?: null | ResponseFormat;
919
- audio?: null | ChatCompletionAudio;
920
- /**
921
- * Whether or not to store the output of this chat completion request for
922
- * use in our [model distillation](https://platform.openai.com/docs/guides/distillation) or
923
- * [evals](https://platform.openai.com/docs/guides/evals) products.
924
- *
925
- * Supports text and image inputs. Note: image inputs over 8MB will be dropped.
926
- */
927
- store?: boolean | null;
928
- /**
929
- * If set to true, the model response data will be streamed to the client
930
- * 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).
931
- * See the [Streaming section below](https://platform.openai.com/docs/api-reference/chat/streaming)
932
- * for more information, along with the [streaming responses](https://platform.openai.com/docs/guides/streaming-responses)
933
- * guide for more information on how to handle the streaming events.
934
- */
935
- stream?: boolean | null;
936
- stop?: null | StopConfiguration;
937
- /**
938
- * Modify the likelihood of specified tokens appearing in the completion.
939
- *
940
- * Accepts a json object that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100.
941
- * Mathematically, the bias is added to the logits generated by the model prior to sampling.
942
- * The exact effect will vary per model, but values between -1 and 1 should decrease or increase likelihood of selection;
943
- * values like -100 or 100 should result in a ban or exclusive selection of the relevant token.
944
- */
945
- logit_bias?: {
946
- [key: string]: number;
947
- } | null;
948
- /**
949
- * Whether to return log probabilities of the output tokens or not. If true,
950
- * returns the log probabilities of each output token returned in the `content` of `message`.
951
- */
952
- logprobs?: boolean | null;
953
- /**
954
- * The maximum number of [tokens](https://platform.openai.com/tokenizer) that can be generated in
955
- * the chat completion. This value can be used to control [costs](https://openai.com/api/pricing/) for text generated via API.
956
- * This value is now deprecated in favor of `max_completion_tokens`, and is
957
- * not compatible with [o-series models](https://platform.openai.com/docs/guides/reasoning).
958
- * @deprecated
959
- */
960
- max_tokens?: number | null;
961
- /**
962
- * How many chat completion choices to generate for each input message. Note that you will be
963
- * charged based on the number of generated tokens across all of the choices. Keep `n` as `1` to
964
- * minimize costs.
965
- */
966
- n?: number | null;
967
- prediction?: null | PredictionContent;
968
- /**
969
- * This feature is in Beta.
970
- *
971
- * If specified, our system will make a best effort to sample deterministically, such that
972
- * repeated requests with the same `seed` and parameters should return the same result.
973
- *
974
- * Determinism is not guaranteed, and you should refer to the `system_fingerprint` response
975
- * parameter to monitor changes in the backend.
976
- * @deprecated
977
- */
978
- seed?: number | null;
979
- stream_options?: null | ChatCompletionStreamOptions;
980
- service_tier?: null | ServiceTier;
981
- /**
982
- * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random,
983
- * while lower values like 0.2 will make it more focused and deterministic.
984
- *
985
- * We generally recommend altering this or `top_p` but not both.
986
- */
987
- temperature?: number | null;
988
- /**
989
- * An alternative to sampling with temperature, called nucleus sampling,
990
- * where the model considers the results of the tokens with top_p probability mass.
991
- * So 0.1 means only the tokens comprising the top 10% probability mass are considered.
992
- *
993
- * We generally recommend altering this or `temperature` but not both.
994
- */
995
- top_p?: number | null;
996
- /**
997
- * A list of tools the model may call. You can provide either
998
- * [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools) or
999
- * [function tools](https://platform.openai.com/docs/guides/function-calling).
1000
- */
1001
- tools?: Array<ChatCompletionTools> | null;
1002
- tool_choice?: null | ChatCompletionToolChoiceOption;
1003
- /**
1004
- * Whether to enable [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
1005
- * during tool use.
1006
- */
1007
- parallel_tool_calls?: boolean | null;
1008
- /**
1009
- * This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use `prompt_cache_key`
1010
- * instead to maintain caching optimizations.
1011
- * A stable identifier for your end-users.
1012
- * Used to boost cache hit rates by better bucketing similar requests and to help OpenAI detect and
1013
- * prevent abuse. [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
1014
- * @deprecated
1015
- */
1016
- user?: string | null;
1017
- /**
1018
- * A stable identifier used to help detect users of your application that may be violating OpenAI's
1019
- * usage policies.
1020
- *
1021
- * The IDs should be a string that uniquely identifies each user. We recommend hashing their username
1022
- * or email address, in order to avoid sending us any identifying information. [Learn
1023
- * more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
1024
- */
1025
- safety_identifier?: string | null;
1026
- /**
1027
- * Used by OpenAI to cache responses for similar requests to optimize your cache hit rates. Replaces
1028
- * the `user` field. [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
1029
- */
1030
- prompt_cache_key?: string | null;
1031
- function_call?: null | ChatCompletionFunctionCall;
1032
- /**
1033
- * Deprecated in favor of `tools`.
1034
- *
1035
- * A list of functions the model may generate JSON inputs for.
1036
- * @deprecated
1037
- */
1038
- functions?: Array<ChatCompletionFunctions> | null;
1039
- metadata?: null | Metadata;
1040
- /**
1041
- * llama.cpp compatible extra params in request
1042
- */
1043
- chat_template_kwargs?: {} | null;
1044
- };
1045
-
1046
- /**
1047
- * Represents a chat completion response returned by model, based on the provided input.
1048
- */
1049
- export type CreateChatCompletionResponse = {
1050
- /**
1051
- * A unique identifier for the chat completion.
1052
- */
1053
- id: string;
1054
- /**
1055
- * A list of chat completion choices. Can be more than one if `n` is greater than 1.
1056
- */
1057
- choices: Array<ChatChoice>;
1058
- /**
1059
- * The Unix timestamp (in seconds) of when the chat completion was created.
1060
- */
1061
- created: number;
1062
- /**
1063
- * The model used for the chat completion.
1064
- */
1065
- model: string;
1066
- service_tier?: null | ServiceTier;
1067
- /**
1068
- * This fingerprint represents the backend configuration that the model runs with.
1069
- *
1070
- * Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
1071
- * @deprecated
1072
- */
1073
- system_fingerprint?: string | null;
1074
- /**
1075
- * The object type, which is always `chat.completion`.
1076
- */
1077
- object: string;
1078
- usage?: null | CompletionUsage;
1079
- };
1080
-
1081
- /**
1082
- * 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).
1083
- */
1084
- export type CreateChatCompletionStreamResponse = {
1085
- /**
1086
- * A unique identifier for the chat completion. Each chunk has the same ID.
1087
- */
1088
- id: string;
1089
- /**
1090
- * 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}`.
343
+ * App client ID from Keycloak
1091
344
  */
1092
- choices: Array<ChatChoiceStream>;
345
+ app_client_id: string;
1093
346
  /**
1094
- * The Unix timestamp (in seconds) of when the chat completion was created. Each chunk has the same timestamp.
347
+ * Flow type: "redirect" or "popup"
1095
348
  */
1096
- created: number;
349
+ flow_type: FlowType;
1097
350
  /**
1098
- * The model to generate the completion.
351
+ * Redirect URL for result notification (required for redirect flow)
1099
352
  */
1100
- model: string;
1101
- service_tier?: null | ServiceTier;
353
+ redirect_url?: string | null;
1102
354
  /**
1103
- * This fingerprint represents the backend configuration that the model runs with.
1104
- * Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
1105
- * @deprecated
355
+ * Role requested for the external app (scope_user_user or scope_user_power_user)
1106
356
  */
1107
- system_fingerprint?: string | null;
357
+ requested_role: UserScope;
1108
358
  /**
1109
- * The object type, which is always `chat.completion.chunk`.
359
+ * Resources requested (tools, etc.)
1110
360
  */
1111
- object: string;
1112
- usage?: null | CompletionUsage;
361
+ requested: RequestedResources;
1113
362
  };
1114
363
 
1115
- export type CreateEmbeddingRequest = {
1116
- /**
1117
- * ID of the model to use. You can use the [List models](https://platform.openai.com/docs/api-reference/models/list)
1118
- * API to see all of your available models, or see our [Model overview](https://platform.openai.com/docs/models)
1119
- * for descriptions of them.
1120
- */
1121
- model: string;
364
+ export type CreateAccessRequestResponse = {
1122
365
  /**
1123
- * Input text to embed, encoded as a string or array of tokens. To embed multiple inputs in a single
1124
- * request, pass an array of strings or array of token arrays. The input must not exceed the max
1125
- * input tokens for the model (8192 tokens for all embedding models), cannot be an empty string, and
1126
- * any array must be 2048 dimensions or less. [Example Python
1127
- * code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken) for counting tokens.
1128
- * In addition to the per-input token limit, all embedding models enforce a maximum of 300,000
1129
- * tokens summed across all inputs in a single request.
366
+ * Access request ID
1130
367
  */
1131
- input: EmbeddingInput;
1132
- encoding_format?: null | EncodingFormat;
368
+ id: string;
1133
369
  /**
1134
- * A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.
1135
- * [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
370
+ * Status (always "draft")
1136
371
  */
1137
- user?: string | null;
372
+ status: AppAccessRequestStatus;
1138
373
  /**
1139
- * The number of dimensions the resulting output embeddings should have. Only supported in `text-embedding-3` and later models.
374
+ * Review URL for user to approve/deny
1140
375
  */
1141
- dimensions?: number | null;
376
+ review_url: string;
1142
377
  };
1143
378
 
1144
- export type CreateEmbeddingResponse = {
1145
- object: string;
1146
- /**
1147
- * The name of the model used to generate the embedding.
1148
- */
1149
- model: string;
1150
- /**
1151
- * The list of embeddings generated by the model.
1152
- */
1153
- data: Array<Embedding>;
1154
- /**
1155
- * The usage information for the request.
1156
- */
1157
- usage: EmbeddingUsage;
379
+ /**
380
+ * Wrapper for creating auth configs with server_id in body instead of path
381
+ */
382
+ export type CreateAuthConfig = CreateMcpAuthConfigRequest & {
383
+ mcp_server_id: string;
1158
384
  };
1159
385
 
1160
386
  /**
@@ -1203,61 +429,6 @@ export type CreateTokenRequest = {
1203
429
  scope: TokenScope;
1204
430
  };
1205
431
 
1206
- export type CustomGrammarFormatParam = {
1207
- /**
1208
- * The grammar definition.
1209
- */
1210
- definition: string;
1211
- /**
1212
- * The syntax of the grammar definition. One of `lark` or `regex`.
1213
- */
1214
- syntax: GrammarSyntax;
1215
- };
1216
-
1217
- export type CustomName = {
1218
- /**
1219
- * The name of the custom tool to call.
1220
- */
1221
- name: string;
1222
- };
1223
-
1224
- export type CustomTool = {
1225
- /**
1226
- * The name of the custom tool to call.
1227
- */
1228
- name: string;
1229
- /**
1230
- * The input for the custom tool call generated by the model.
1231
- */
1232
- input: string;
1233
- };
1234
-
1235
- export type CustomToolChatCompletions = {
1236
- custom: CustomToolProperties;
1237
- };
1238
-
1239
- export type CustomToolProperties = {
1240
- /**
1241
- * The name of the custom tool, used to identify it in tool calls.
1242
- */
1243
- name: string;
1244
- /**
1245
- * Optional description of the custom tool, used to provide more context.
1246
- */
1247
- description?: string | null;
1248
- /**
1249
- * The input format for the custom tool. Default is unconstrained text.
1250
- */
1251
- format: CustomToolPropertiesFormat;
1252
- };
1253
-
1254
- export type CustomToolPropertiesFormat = {
1255
- type: 'text';
1256
- } | {
1257
- grammar: CustomGrammarFormatParam;
1258
- type: 'grammar';
1259
- };
1260
-
1261
432
  /**
1262
433
  * Dashboard user information from a validated dashboard session token
1263
434
  */
@@ -1285,8 +456,6 @@ export type DownloadRequest = {
1285
456
 
1286
457
  export type DownloadStatus = 'pending' | 'completed' | 'error';
1287
458
 
1288
- export type Duration = string;
1289
-
1290
459
  export type DynamicRegisterRequest = {
1291
460
  registration_endpoint: string;
1292
461
  redirect_uri: string;
@@ -1301,61 +470,6 @@ export type DynamicRegisterResponse = {
1301
470
  registration_access_token?: string | null;
1302
471
  };
1303
472
 
1304
- /**
1305
- * Represents an embedding vector returned by embedding endpoint.
1306
- */
1307
- export type Embedding = {
1308
- /**
1309
- * The index of the embedding in the list of embeddings.
1310
- */
1311
- index: number;
1312
- /**
1313
- * The object type, which is always "embedding".
1314
- */
1315
- object: string;
1316
- /**
1317
- * The embedding vector, which is a list of floats. The length of vector
1318
- * depends on the model as listed in the [embedding guide](https://platform.openai.com/docs/guides/embeddings).
1319
- */
1320
- embedding: Array<number>;
1321
- };
1322
-
1323
- export type EmbeddingInput = string | Array<string> | Array<number> | Array<Array<number>>;
1324
-
1325
- export type EmbeddingUsage = {
1326
- /**
1327
- * The number of tokens used by the prompt.
1328
- */
1329
- prompt_tokens: number;
1330
- /**
1331
- * The total number of tokens used by the request.
1332
- */
1333
- total_tokens: number;
1334
- };
1335
-
1336
- export type EncodingFormat = 'float' | 'base64';
1337
-
1338
- export type ErrorBody = {
1339
- /**
1340
- * Human-readable error message describing what went wrong
1341
- */
1342
- message: string;
1343
- /**
1344
- * Error type categorizing the kind of error that occurred
1345
- */
1346
- type: string;
1347
- /**
1348
- * Specific error code for programmatic error handling
1349
- */
1350
- code?: string | null;
1351
- /**
1352
- * Additional error parameters as key-value pairs (for validation errors)
1353
- */
1354
- param?: {
1355
- [key: string]: string;
1356
- } | null;
1357
- };
1358
-
1359
473
  /**
1360
474
  * Request to fetch available models from provider
1361
475
  */
@@ -1377,110 +491,8 @@ export type FetchModelsResponse = {
1377
491
  models: Array<string>;
1378
492
  };
1379
493
 
1380
- export type FileObject = {
1381
- /**
1382
- * The base64 encoded file data, used when passing the file to the model
1383
- * as a string.
1384
- */
1385
- file_data?: string | null;
1386
- /**
1387
- * The ID of an uploaded file to use as input.
1388
- */
1389
- file_id?: string | null;
1390
- /**
1391
- * The name of the file, used when passing the file to the model as a
1392
- * string.
1393
- */
1394
- filename?: string | null;
1395
- };
1396
-
1397
- export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
1398
-
1399
494
  export type FlowType = 'redirect' | 'popup';
1400
495
 
1401
- /**
1402
- * The name and arguments of a function that should be called, as generated by the model.
1403
- */
1404
- export type FunctionCall = {
1405
- /**
1406
- * The name of the function to call.
1407
- */
1408
- name: string;
1409
- /**
1410
- * 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.
1411
- */
1412
- arguments: string;
1413
- };
1414
-
1415
- export type FunctionCallStream = {
1416
- /**
1417
- * The name of the function to call.
1418
- */
1419
- name?: string | null;
1420
- /**
1421
- * The arguments to call the function with, as generated by the model in JSON format.
1422
- * Note that the model does not always generate valid JSON, and may hallucinate
1423
- * parameters not defined by your function schema. Validate the arguments in your
1424
- * code before calling your function.
1425
- */
1426
- arguments?: string | null;
1427
- };
1428
-
1429
- export type FunctionName = {
1430
- /**
1431
- * The name of the function to call.
1432
- */
1433
- name: string;
1434
- };
1435
-
1436
- export type FunctionObject = {
1437
- /**
1438
- * 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.
1439
- */
1440
- name: string;
1441
- /**
1442
- * A description of what the function does, used by the model to choose when and how to call the function.
1443
- */
1444
- description?: string | null;
1445
- /**
1446
- * 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.
1447
- *
1448
- * Omitting `parameters` defines a function with an empty parameter list.
1449
- */
1450
- parameters?: unknown;
1451
- /**
1452
- * 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).
1453
- */
1454
- strict?: boolean | null;
1455
- };
1456
-
1457
- export type FunctionType = 'function';
1458
-
1459
- export type GrammarSyntax = 'lark' | 'regex';
1460
-
1461
- export type ImageDetail = 'auto' | 'low' | 'high';
1462
-
1463
- export type ImageUrl = {
1464
- /**
1465
- * Either a URL of the image or the base64 encoded image data.
1466
- */
1467
- url: string;
1468
- detail?: null | ImageDetail;
1469
- };
1470
-
1471
- export type InputAudio = {
1472
- /**
1473
- * Base64 encoded audio data.
1474
- */
1475
- data: string;
1476
- /**
1477
- * The format of the encoded audio data. Currently supports "wav" and "mp3".
1478
- */
1479
- format: InputAudioFormat;
1480
- };
1481
-
1482
- export type InputAudioFormat = 'wav' | 'mp3';
1483
-
1484
496
  export type JsonVec = Array<string>;
1485
497
 
1486
498
  export type ListMcpServersResponse = {
@@ -1491,11 +503,6 @@ export type ListMcpsResponse = {
1491
503
  mcps: Array<Mcp>;
1492
504
  };
1493
505
 
1494
- export type ListModelResponse = {
1495
- object: string;
1496
- data: Array<Model>;
1497
- };
1498
-
1499
506
  /**
1500
507
  * List users query parameters. Intentionally omits sort fields (unlike PaginationSortParams)
1501
508
  * because user listing is fetched from the auth service which handles its own ordering.
@@ -1786,44 +793,6 @@ export type McpServerReviewInfo = {
1786
793
  instances: Array<Mcp>;
1787
794
  };
1788
795
 
1789
- export type Message = {
1790
- role: string;
1791
- content: string;
1792
- images?: Array<string> | null;
1793
- };
1794
-
1795
- /**
1796
- * Set of 16 key-value pairs that can be attached to an object.
1797
- * This can be useful for storing additional information about the
1798
- * object in a structured format, and querying for objects via API
1799
- * or the dashboard. Keys are strings with a maximum length of 64
1800
- * characters. Values are strings with a maximum length of 512
1801
- * characters.
1802
- */
1803
- export type Metadata = unknown;
1804
-
1805
- /**
1806
- * Describes an OpenAI model offering that can be used with the API.
1807
- */
1808
- export type Model = {
1809
- /**
1810
- * The model identifier, which can be referenced in the API endpoints.
1811
- */
1812
- id: string;
1813
- /**
1814
- * The object type, which is always "model".
1815
- */
1816
- object: string;
1817
- /**
1818
- * The Unix timestamp (in seconds) when the model was created.
1819
- */
1820
- created: number;
1821
- /**
1822
- * The organization that owns the model.
1823
- */
1824
- owned_by: string;
1825
- };
1826
-
1827
796
  export type ModelAlias = {
1828
797
  alias: string;
1829
798
  repo: string;
@@ -1857,15 +826,6 @@ export type ModelCapabilities = {
1857
826
  tools: ToolCapabilities;
1858
827
  };
1859
828
 
1860
- export type ModelDetails = {
1861
- parent_model?: string | null;
1862
- format: string;
1863
- family: string;
1864
- families?: Array<string> | null;
1865
- parameter_size: string;
1866
- quantization_level: string;
1867
- };
1868
-
1869
829
  /**
1870
830
  * Model metadata for API responses
1871
831
  */
@@ -1876,10 +836,6 @@ export type ModelMetadata = {
1876
836
  chat_template?: string | null;
1877
837
  };
1878
838
 
1879
- export type ModelsResponse = {
1880
- models: Array<OllamaModel>;
1881
- };
1882
-
1883
839
  /**
1884
840
  * Request for creating a new download request
1885
841
  */
@@ -1955,57 +911,6 @@ export type OAuthTokenResponse = {
1955
911
  updated_at: string;
1956
912
  };
1957
913
 
1958
- export type OllamaError = {
1959
- error: string;
1960
- };
1961
-
1962
- export type OllamaModel = {
1963
- model: string;
1964
- modified_at: number;
1965
- size: number;
1966
- digest: string;
1967
- details: ModelDetails;
1968
- };
1969
-
1970
- export type OpenAiApiError = {
1971
- /**
1972
- * Error details following OpenAI API error format
1973
- */
1974
- error: ErrorBody;
1975
- };
1976
-
1977
- export type Options = {
1978
- num_keep?: number | null;
1979
- seed?: number | null;
1980
- num_predict?: number | null;
1981
- top_k?: number | null;
1982
- top_p?: number | null;
1983
- tfs_z?: number | null;
1984
- typical_p?: number | null;
1985
- repeat_last_n?: number | null;
1986
- temperature?: number | null;
1987
- repeat_penalty?: number | null;
1988
- presence_penalty?: number | null;
1989
- frequency_penalty?: number | null;
1990
- mirostat?: number | null;
1991
- mirostat_tau?: number | null;
1992
- mirostat_eta?: number | null;
1993
- penalize_newline?: boolean | null;
1994
- stop?: Array<string> | null;
1995
- numa?: boolean | null;
1996
- num_ctx?: number | null;
1997
- num_batch?: number | null;
1998
- num_gpu?: number | null;
1999
- main_gpu?: number | null;
2000
- low_vram?: boolean | null;
2001
- f16_kv?: boolean | null;
2002
- logits_all?: boolean | null;
2003
- vocab_only?: boolean | null;
2004
- use_mmap?: boolean | null;
2005
- use_mlock?: boolean | null;
2006
- num_thread?: number | null;
2007
- };
2008
-
2009
914
  /**
2010
915
  * Paginated list of all model aliases (user, model, and API)
2011
916
  */
@@ -2107,38 +1012,6 @@ export type PingResponse = {
2107
1012
  message: string;
2108
1013
  };
2109
1014
 
2110
- /**
2111
- * The type of the predicted content you want to provide. This type is
2112
- * currently always `content`.
2113
- */
2114
- export type PredictionContent = {
2115
- /**
2116
- * The type of the predicted content you want to provide. This type is
2117
- * currently always `content`.
2118
- */
2119
- content: PredictionContentContent;
2120
- type: 'content';
2121
- };
2122
-
2123
- /**
2124
- * 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.
2125
- */
2126
- export type PredictionContentContent = string | Array<ChatCompletionRequestMessageContentPartText>;
2127
-
2128
- /**
2129
- * Breakdown of tokens used in a completion.
2130
- */
2131
- export type PromptTokensDetails = {
2132
- /**
2133
- * Audio input tokens present in the prompt.
2134
- */
2135
- audio_tokens?: number | null;
2136
- /**
2137
- * Cached tokens present in the prompt.
2138
- */
2139
- cached_tokens?: number | null;
2140
- };
2141
-
2142
1015
  /**
2143
1016
  * Response for queue status operations
2144
1017
  */
@@ -2149,8 +1022,6 @@ export type QueueStatusResponse = {
2149
1022
  status: string;
2150
1023
  };
2151
1024
 
2152
- export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
2153
-
2154
1025
  export type RedirectResponse = {
2155
1026
  /**
2156
1027
  * The URL to redirect to (OAuth authorization URL or application home page)
@@ -2202,71 +1073,24 @@ export type RefreshSource = 'all' | 'model';
2202
1073
  * OAuth 2.1 registration type: pre-registered client or dynamic client registration (DCR).
2203
1074
  */
2204
1075
  export type RegistrationType = 'pre_registered' | 'dynamic_registration';
2205
-
2206
- export type RequestedMcpServer = {
2207
- url: string;
2208
- };
2209
-
2210
- /**
2211
- * Versioned envelope for requested resources.
2212
- * The `version` tag is mandatory — clients must specify which version they are using.
2213
- */
2214
- export type RequestedResources = RequestedResourcesV1 & {
2215
- version: '1';
2216
- };
2217
-
2218
- export type RequestedResourcesV1 = {
2219
- mcp_servers?: Array<RequestedMcpServer>;
2220
- };
2221
-
2222
- export type ResourceRole = 'resource_anonymous' | 'resource_guest' | 'resource_user' | 'resource_power_user' | 'resource_manager' | 'resource_admin';
2223
-
2224
- export type ResponseFormat = {
2225
- type: 'text';
2226
- } | {
2227
- type: 'json_object';
2228
- } | {
2229
- json_schema: ResponseFormatJsonSchema;
2230
- type: 'json_schema';
2231
- };
2232
-
2233
- export type ResponseFormatJsonSchema = {
2234
- /**
2235
- * A description of what the response format is for, used by the model to determine how to respond in the format.
2236
- */
2237
- description?: string | null;
2238
- /**
2239
- * 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.
2240
- */
2241
- name: string;
2242
- /**
2243
- * The schema for the response format, described as a JSON Schema object.
2244
- * Learn how to build JSON schemas [here](https://json-schema.org/).
2245
- */
2246
- schema?: unknown;
2247
- /**
2248
- * Whether to enable strict schema adherence when generating the output.
2249
- * If set to true, the model will always follow the exact schema defined
2250
- * in the `schema` field. Only a subset of JSON Schema is supported when
2251
- * `strict` is `true`. To learn more, read the [Structured Outputs
2252
- * guide](https://platform.openai.com/docs/guides/structured-outputs).
2253
- */
2254
- strict?: boolean | null;
1076
+
1077
+ export type RequestedMcpServer = {
1078
+ url: string;
2255
1079
  };
2256
1080
 
2257
1081
  /**
2258
- * Output types that you would like the model to generate for this request.
2259
- *
2260
- * Most models are capable of generating text, which is the default: `["text"]`
2261
- *
2262
- * The `gpt-4o-audio-preview` model can also be used to [generate
2263
- * audio](https://platform.openai.com/docs/guides/audio). To request that this model generate both text and audio responses, you can use: `["text", "audio"]`
1082
+ * Versioned envelope for requested resources.
1083
+ * The `version` tag is mandatory — clients must specify which version they are using.
2264
1084
  */
2265
- export type ResponseModalities = 'text' | 'audio';
1085
+ export type RequestedResources = RequestedResourcesV1 & {
1086
+ version: '1';
1087
+ };
2266
1088
 
2267
- export type Role = 'system' | 'user' | 'assistant' | 'tool' | 'function';
1089
+ export type RequestedResourcesV1 = {
1090
+ mcp_servers?: Array<RequestedMcpServer>;
1091
+ };
2268
1092
 
2269
- export type ServiceTier = 'auto' | 'default' | 'flex' | 'scale' | 'priority';
1093
+ export type ResourceRole = 'resource_anonymous' | 'resource_guest' | 'resource_user' | 'resource_power_user' | 'resource_manager' | 'resource_admin';
2270
1094
 
2271
1095
  export type SettingInfo = {
2272
1096
  key: string;
@@ -2315,22 +1139,6 @@ export type SetupResponse = {
2315
1139
  status: AppStatus;
2316
1140
  };
2317
1141
 
2318
- export type ShowRequest = {
2319
- name: string;
2320
- };
2321
-
2322
- export type ShowResponse = {
2323
- details: ModelDetails;
2324
- license: string;
2325
- model_info: {};
2326
- modelfile: string;
2327
- modified_at: number;
2328
- parameters: string;
2329
- template: string;
2330
- };
2331
-
2332
- export type StopConfiguration = string | Array<string>;
2333
-
2334
1142
  export type TenantListItem = {
2335
1143
  client_id: string;
2336
1144
  name: string;
@@ -2381,6 +1189,10 @@ export type TestPromptRequest = {
2381
1189
  * Test prompt (max 30 characters for cost control)
2382
1190
  */
2383
1191
  prompt: string;
1192
+ /**
1193
+ * API format to use for the test request (defaults to OpenAI Chat Completions)
1194
+ */
1195
+ api_format?: ApiFormat;
2384
1196
  };
2385
1197
 
2386
1198
  /**
@@ -2426,25 +1238,6 @@ export type ToolCapabilities = {
2426
1238
  structured_output?: boolean | null;
2427
1239
  };
2428
1240
 
2429
- export type ToolChoiceAllowedMode = 'auto' | 'required';
2430
-
2431
- export type ToolChoiceOptions = 'none' | 'auto' | 'required';
2432
-
2433
- export type TopLogprobs = {
2434
- /**
2435
- * The token.
2436
- */
2437
- token: string;
2438
- /**
2439
- * The log probability of this token.
2440
- */
2441
- logprob: number;
2442
- /**
2443
- * 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.
2444
- */
2445
- bytes?: Array<number> | null;
2446
- };
2447
-
2448
1241
  /**
2449
1242
  * Request to update a setting value
2450
1243
  */
@@ -2466,25 +1259,6 @@ export type UpdateTokenRequest = {
2466
1259
  status: TokenStatus;
2467
1260
  };
2468
1261
 
2469
- export type UrlCitation = {
2470
- /**
2471
- * The index of the last character of the URL citation in the message.
2472
- */
2473
- end_index: number;
2474
- /**
2475
- * The index of the first character of the URL citation in the message.
2476
- */
2477
- start_index: number;
2478
- /**
2479
- * The title of the web resource.
2480
- */
2481
- title: string;
2482
- /**
2483
- * The URL of the web resource.
2484
- */
2485
- url: string;
2486
- };
2487
-
2488
1262
  /**
2489
1263
  * User access request output type for API responses
2490
1264
  */
@@ -2618,176 +1392,6 @@ export type UserResponse = {
2618
1392
 
2619
1393
  export type UserScope = 'scope_user_user' | 'scope_user_power_user';
2620
1394
 
2621
- /**
2622
- * 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`.
2623
- */
2624
- export type Verbosity = 'low' | 'medium' | 'high';
2625
-
2626
- /**
2627
- * The amount of context window space to use for the search.
2628
- */
2629
- export type WebSearchContextSize = 'low' | 'medium' | 'high';
2630
-
2631
- /**
2632
- * Approximate location parameters for the search.
2633
- */
2634
- export type WebSearchLocation = {
2635
- /**
2636
- * The two-letter [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1) of the user, e.g. `US`.
2637
- */
2638
- country?: string | null;
2639
- /**
2640
- * Free text input for the region of the user, e.g. `California`.
2641
- */
2642
- region?: string | null;
2643
- /**
2644
- * Free text input for the city of the user, e.g. `San Francisco`.
2645
- */
2646
- city?: string | null;
2647
- /**
2648
- * The [IANA timezone](https://timeapi.io/documentation/iana-timezones) of the user, e.g. `America/Los_Angeles`.
2649
- */
2650
- timezone?: string | null;
2651
- };
2652
-
2653
- /**
2654
- * Options for the web search tool.
2655
- */
2656
- export type WebSearchOptions = {
2657
- search_context_size?: null | WebSearchContextSize;
2658
- user_location?: null | WebSearchUserLocation;
2659
- };
2660
-
2661
- export type WebSearchUserLocation = {
2662
- type: WebSearchUserLocationType;
2663
- approximate: WebSearchLocation;
2664
- };
2665
-
2666
- export type WebSearchUserLocationType = 'approximate';
2667
-
2668
- export type ChatOllamaModelData = {
2669
- /**
2670
- * Chat request in Ollama format
2671
- */
2672
- body: ChatRequest;
2673
- path?: never;
2674
- query?: never;
2675
- url: '/api/chat';
2676
- };
2677
-
2678
- export type ChatOllamaModelErrors = {
2679
- /**
2680
- * Invalid request parameters
2681
- */
2682
- 400: OpenAiApiError;
2683
- /**
2684
- * Not authenticated
2685
- */
2686
- 401: OpenAiApiError;
2687
- /**
2688
- * Insufficient permissions
2689
- */
2690
- 403: OpenAiApiError;
2691
- /**
2692
- * Model not found
2693
- */
2694
- 404: OllamaError;
2695
- /**
2696
- * Internal server error
2697
- */
2698
- 500: OpenAiApiError;
2699
- };
2700
-
2701
- export type ChatOllamaModelError = ChatOllamaModelErrors[keyof ChatOllamaModelErrors];
2702
-
2703
- export type ChatOllamaModelResponses = {
2704
- /**
2705
- * Chat response
2706
- */
2707
- 200: unknown;
2708
- };
2709
-
2710
- export type ShowOllamaModelData = {
2711
- /**
2712
- * Model name to get details for
2713
- */
2714
- body: ShowRequest;
2715
- path?: never;
2716
- query?: never;
2717
- url: '/api/show';
2718
- };
2719
-
2720
- export type ShowOllamaModelErrors = {
2721
- /**
2722
- * Invalid request parameters
2723
- */
2724
- 400: OpenAiApiError;
2725
- /**
2726
- * Not authenticated
2727
- */
2728
- 401: OpenAiApiError;
2729
- /**
2730
- * Insufficient permissions
2731
- */
2732
- 403: OpenAiApiError;
2733
- /**
2734
- * Model not found
2735
- */
2736
- 404: OllamaError;
2737
- /**
2738
- * Internal server error
2739
- */
2740
- 500: OpenAiApiError;
2741
- };
2742
-
2743
- export type ShowOllamaModelError = ShowOllamaModelErrors[keyof ShowOllamaModelErrors];
2744
-
2745
- export type ShowOllamaModelResponses = {
2746
- /**
2747
- * Model details
2748
- */
2749
- 200: ShowResponse;
2750
- };
2751
-
2752
- export type ShowOllamaModelResponse = ShowOllamaModelResponses[keyof ShowOllamaModelResponses];
2753
-
2754
- export type ListOllamaModelsData = {
2755
- body?: never;
2756
- path?: never;
2757
- query?: never;
2758
- url: '/api/tags';
2759
- };
2760
-
2761
- export type ListOllamaModelsErrors = {
2762
- /**
2763
- * Invalid request parameters
2764
- */
2765
- 400: OpenAiApiError;
2766
- /**
2767
- * Not authenticated
2768
- */
2769
- 401: OpenAiApiError;
2770
- /**
2771
- * Insufficient permissions
2772
- */
2773
- 403: OpenAiApiError;
2774
- /**
2775
- * Internal server error
2776
- */
2777
- 500: OpenAiApiError;
2778
- };
2779
-
2780
- export type ListOllamaModelsError = ListOllamaModelsErrors[keyof ListOllamaModelsErrors];
2781
-
2782
- export type ListOllamaModelsResponses = {
2783
- /**
2784
- * List of available models
2785
- */
2786
- 200: ModelsResponse;
2787
- };
2788
-
2789
- export type ListOllamaModelsResponse = ListOllamaModelsResponses[keyof ListOllamaModelsResponses];
2790
-
2791
1395
  export type ListAllAccessRequestsData = {
2792
1396
  body?: never;
2793
1397
  path?: never;
@@ -2816,19 +1420,19 @@ export type ListAllAccessRequestsErrors = {
2816
1420
  /**
2817
1421
  * Invalid request parameters
2818
1422
  */
2819
- 400: OpenAiApiError;
1423
+ 400: BodhiApiError;
2820
1424
  /**
2821
1425
  * Not authenticated
2822
1426
  */
2823
- 401: OpenAiApiError;
1427
+ 401: BodhiApiError;
2824
1428
  /**
2825
1429
  * Insufficient permissions
2826
1430
  */
2827
- 403: OpenAiApiError;
1431
+ 403: BodhiApiError;
2828
1432
  /**
2829
1433
  * Internal server error
2830
1434
  */
2831
- 500: OpenAiApiError;
1435
+ 500: BodhiApiError;
2832
1436
  };
2833
1437
 
2834
1438
  export type ListAllAccessRequestsError = ListAllAccessRequestsErrors[keyof ListAllAccessRequestsErrors];
@@ -2870,19 +1474,19 @@ export type ListPendingAccessRequestsErrors = {
2870
1474
  /**
2871
1475
  * Invalid request parameters
2872
1476
  */
2873
- 400: OpenAiApiError;
1477
+ 400: BodhiApiError;
2874
1478
  /**
2875
1479
  * Not authenticated
2876
1480
  */
2877
- 401: OpenAiApiError;
1481
+ 401: BodhiApiError;
2878
1482
  /**
2879
1483
  * Insufficient permissions
2880
1484
  */
2881
- 403: OpenAiApiError;
1485
+ 403: BodhiApiError;
2882
1486
  /**
2883
1487
  * Internal server error
2884
1488
  */
2885
- 500: OpenAiApiError;
1489
+ 500: BodhiApiError;
2886
1490
  };
2887
1491
 
2888
1492
  export type ListPendingAccessRequestsError = ListPendingAccessRequestsErrors[keyof ListPendingAccessRequestsErrors];
@@ -2915,23 +1519,23 @@ export type ApproveAccessRequestErrors = {
2915
1519
  /**
2916
1520
  * Invalid request parameters
2917
1521
  */
2918
- 400: OpenAiApiError;
1522
+ 400: BodhiApiError;
2919
1523
  /**
2920
1524
  * Not authenticated
2921
1525
  */
2922
- 401: OpenAiApiError;
1526
+ 401: BodhiApiError;
2923
1527
  /**
2924
1528
  * Insufficient permissions
2925
1529
  */
2926
- 403: OpenAiApiError;
1530
+ 403: BodhiApiError;
2927
1531
  /**
2928
1532
  * Request not found
2929
1533
  */
2930
- 404: OpenAiApiError;
1534
+ 404: BodhiApiError;
2931
1535
  /**
2932
1536
  * Internal server error
2933
1537
  */
2934
- 500: OpenAiApiError;
1538
+ 500: BodhiApiError;
2935
1539
  };
2936
1540
 
2937
1541
  export type ApproveAccessRequestError = ApproveAccessRequestErrors[keyof ApproveAccessRequestErrors];
@@ -2962,27 +1566,27 @@ export type ApproveAppsAccessRequestErrors = {
2962
1566
  /**
2963
1567
  * Invalid request parameters
2964
1568
  */
2965
- 400: OpenAiApiError;
1569
+ 400: BodhiApiError;
2966
1570
  /**
2967
1571
  * Not authenticated
2968
1572
  */
2969
- 401: OpenAiApiError;
1573
+ 401: BodhiApiError;
2970
1574
  /**
2971
1575
  * Insufficient permissions
2972
1576
  */
2973
- 403: OpenAiApiError;
1577
+ 403: BodhiApiError;
2974
1578
  /**
2975
1579
  * Not found
2976
1580
  */
2977
- 404: OpenAiApiError;
1581
+ 404: BodhiApiError;
2978
1582
  /**
2979
1583
  * Already processed
2980
1584
  */
2981
- 409: OpenAiApiError;
1585
+ 409: BodhiApiError;
2982
1586
  /**
2983
1587
  * Internal server error
2984
1588
  */
2985
- 500: OpenAiApiError;
1589
+ 500: BodhiApiError;
2986
1590
  };
2987
1591
 
2988
1592
  export type ApproveAppsAccessRequestError = ApproveAppsAccessRequestErrors[keyof ApproveAppsAccessRequestErrors];
@@ -3012,27 +1616,27 @@ export type DenyAccessRequestErrors = {
3012
1616
  /**
3013
1617
  * Invalid request parameters
3014
1618
  */
3015
- 400: OpenAiApiError;
1619
+ 400: BodhiApiError;
3016
1620
  /**
3017
1621
  * Not authenticated
3018
1622
  */
3019
- 401: OpenAiApiError;
1623
+ 401: BodhiApiError;
3020
1624
  /**
3021
1625
  * Insufficient permissions
3022
1626
  */
3023
- 403: OpenAiApiError;
1627
+ 403: BodhiApiError;
3024
1628
  /**
3025
1629
  * Not found
3026
1630
  */
3027
- 404: OpenAiApiError;
1631
+ 404: BodhiApiError;
3028
1632
  /**
3029
1633
  * Already processed
3030
1634
  */
3031
- 409: OpenAiApiError;
1635
+ 409: BodhiApiError;
3032
1636
  /**
3033
1637
  * Internal server error
3034
1638
  */
3035
- 500: OpenAiApiError;
1639
+ 500: BodhiApiError;
3036
1640
  };
3037
1641
 
3038
1642
  export type DenyAccessRequestError = DenyAccessRequestErrors[keyof DenyAccessRequestErrors];
@@ -3062,23 +1666,23 @@ export type RejectAccessRequestErrors = {
3062
1666
  /**
3063
1667
  * Invalid request parameters
3064
1668
  */
3065
- 400: OpenAiApiError;
1669
+ 400: BodhiApiError;
3066
1670
  /**
3067
1671
  * Not authenticated
3068
1672
  */
3069
- 401: OpenAiApiError;
1673
+ 401: BodhiApiError;
3070
1674
  /**
3071
1675
  * Insufficient permissions
3072
1676
  */
3073
- 403: OpenAiApiError;
1677
+ 403: BodhiApiError;
3074
1678
  /**
3075
1679
  * Request not found
3076
1680
  */
3077
- 404: OpenAiApiError;
1681
+ 404: BodhiApiError;
3078
1682
  /**
3079
1683
  * Internal server error
3080
1684
  */
3081
- 500: OpenAiApiError;
1685
+ 500: BodhiApiError;
3082
1686
  };
3083
1687
 
3084
1688
  export type RejectAccessRequestError = RejectAccessRequestErrors[keyof RejectAccessRequestErrors];
@@ -3106,27 +1710,27 @@ export type GetAccessRequestReviewErrors = {
3106
1710
  /**
3107
1711
  * Invalid request parameters
3108
1712
  */
3109
- 400: OpenAiApiError;
1713
+ 400: BodhiApiError;
3110
1714
  /**
3111
1715
  * Not authenticated
3112
1716
  */
3113
- 401: OpenAiApiError;
1717
+ 401: BodhiApiError;
3114
1718
  /**
3115
1719
  * Insufficient permissions
3116
1720
  */
3117
- 403: OpenAiApiError;
1721
+ 403: BodhiApiError;
3118
1722
  /**
3119
1723
  * Not found
3120
1724
  */
3121
- 404: OpenAiApiError;
1725
+ 404: BodhiApiError;
3122
1726
  /**
3123
1727
  * Request expired
3124
1728
  */
3125
- 410: OpenAiApiError;
1729
+ 410: BodhiApiError;
3126
1730
  /**
3127
1731
  * Internal server error
3128
1732
  */
3129
- 500: OpenAiApiError;
1733
+ 500: BodhiApiError;
3130
1734
  };
3131
1735
 
3132
1736
  export type GetAccessRequestReviewError = GetAccessRequestReviewErrors[keyof GetAccessRequestReviewErrors];
@@ -3161,23 +1765,23 @@ export type GetAccessRequestStatusErrors = {
3161
1765
  /**
3162
1766
  * Invalid request parameters
3163
1767
  */
3164
- 400: OpenAiApiError;
1768
+ 400: BodhiApiError;
3165
1769
  /**
3166
1770
  * Not authenticated
3167
1771
  */
3168
- 401: OpenAiApiError;
1772
+ 401: BodhiApiError;
3169
1773
  /**
3170
1774
  * Insufficient permissions
3171
1775
  */
3172
- 403: OpenAiApiError;
1776
+ 403: BodhiApiError;
3173
1777
  /**
3174
1778
  * Not found or app_client_id mismatch
3175
1779
  */
3176
- 404: OpenAiApiError;
1780
+ 404: BodhiApiError;
3177
1781
  /**
3178
1782
  * Internal server error
3179
1783
  */
3180
- 500: OpenAiApiError;
1784
+ 500: BodhiApiError;
3181
1785
  };
3182
1786
 
3183
1787
  export type GetAccessRequestStatusError = GetAccessRequestStatusErrors[keyof GetAccessRequestStatusErrors];
@@ -3202,19 +1806,19 @@ export type AppsListMcpsErrors = {
3202
1806
  /**
3203
1807
  * Invalid request parameters
3204
1808
  */
3205
- 400: OpenAiApiError;
1809
+ 400: BodhiApiError;
3206
1810
  /**
3207
1811
  * Not authenticated
3208
1812
  */
3209
- 401: OpenAiApiError;
1813
+ 401: BodhiApiError;
3210
1814
  /**
3211
1815
  * Insufficient permissions
3212
1816
  */
3213
- 403: OpenAiApiError;
1817
+ 403: BodhiApiError;
3214
1818
  /**
3215
1819
  * Internal server error
3216
1820
  */
3217
- 500: OpenAiApiError;
1821
+ 500: BodhiApiError;
3218
1822
  };
3219
1823
 
3220
1824
  export type AppsListMcpsError = AppsListMcpsErrors[keyof AppsListMcpsErrors];
@@ -3244,15 +1848,15 @@ export type AppsGetMcpErrors = {
3244
1848
  /**
3245
1849
  * Invalid request parameters
3246
1850
  */
3247
- 400: OpenAiApiError;
1851
+ 400: BodhiApiError;
3248
1852
  /**
3249
1853
  * Not authenticated
3250
1854
  */
3251
- 401: OpenAiApiError;
1855
+ 401: BodhiApiError;
3252
1856
  /**
3253
1857
  * Insufficient permissions
3254
1858
  */
3255
- 403: OpenAiApiError;
1859
+ 403: BodhiApiError;
3256
1860
  /**
3257
1861
  * MCP not found
3258
1862
  */
@@ -3260,7 +1864,7 @@ export type AppsGetMcpErrors = {
3260
1864
  /**
3261
1865
  * Internal server error
3262
1866
  */
3263
- 500: OpenAiApiError;
1867
+ 500: BodhiApiError;
3264
1868
  };
3265
1869
 
3266
1870
  export type AppsGetMcpError = AppsGetMcpErrors[keyof AppsGetMcpErrors];
@@ -3290,19 +1894,19 @@ export type McpProxyErrors = {
3290
1894
  /**
3291
1895
  * Invalid request parameters
3292
1896
  */
3293
- 400: OpenAiApiError;
1897
+ 400: BodhiApiError;
3294
1898
  /**
3295
1899
  * Not authenticated
3296
1900
  */
3297
- 401: OpenAiApiError;
1901
+ 401: BodhiApiError;
3298
1902
  /**
3299
1903
  * Insufficient permissions
3300
1904
  */
3301
- 403: OpenAiApiError;
1905
+ 403: BodhiApiError;
3302
1906
  /**
3303
1907
  * Internal server error
3304
1908
  */
3305
- 500: OpenAiApiError;
1909
+ 500: BodhiApiError;
3306
1910
  };
3307
1911
 
3308
1912
  export type McpProxyError = McpProxyErrors[keyof McpProxyErrors];
@@ -3328,23 +1932,23 @@ export type CreateAccessRequestErrors = {
3328
1932
  /**
3329
1933
  * Invalid request parameters
3330
1934
  */
3331
- 400: OpenAiApiError;
1935
+ 400: BodhiApiError;
3332
1936
  /**
3333
1937
  * Not authenticated
3334
1938
  */
3335
- 401: OpenAiApiError;
1939
+ 401: BodhiApiError;
3336
1940
  /**
3337
1941
  * Insufficient permissions
3338
1942
  */
3339
- 403: OpenAiApiError;
1943
+ 403: BodhiApiError;
3340
1944
  /**
3341
1945
  * App client not found
3342
1946
  */
3343
- 404: OpenAiApiError;
1947
+ 404: BodhiApiError;
3344
1948
  /**
3345
1949
  * Internal server error
3346
1950
  */
3347
- 500: OpenAiApiError;
1951
+ 500: BodhiApiError;
3348
1952
  };
3349
1953
 
3350
1954
  export type CreateAccessRequestError = CreateAccessRequestErrors[keyof CreateAccessRequestErrors];
@@ -3372,23 +1976,23 @@ export type CompleteOAuthFlowErrors = {
3372
1976
  /**
3373
1977
  * Invalid request parameters
3374
1978
  */
3375
- 400: OpenAiApiError;
1979
+ 400: BodhiApiError;
3376
1980
  /**
3377
1981
  * Not authenticated
3378
1982
  */
3379
- 401: OpenAiApiError;
1983
+ 401: BodhiApiError;
3380
1984
  /**
3381
1985
  * Insufficient permissions
3382
1986
  */
3383
- 403: OpenAiApiError;
1987
+ 403: BodhiApiError;
3384
1988
  /**
3385
1989
  * OAuth error, invalid request parameters, or state mismatch
3386
1990
  */
3387
- 422: OpenAiApiError;
1991
+ 422: BodhiApiError;
3388
1992
  /**
3389
1993
  * Internal server error
3390
1994
  */
3391
- 500: OpenAiApiError;
1995
+ 500: BodhiApiError;
3392
1996
  };
3393
1997
 
3394
1998
  export type CompleteOAuthFlowError = CompleteOAuthFlowErrors[keyof CompleteOAuthFlowErrors];
@@ -3416,19 +2020,19 @@ export type CompleteDashboardOAuthFlowErrors = {
3416
2020
  /**
3417
2021
  * Invalid request parameters
3418
2022
  */
3419
- 400: OpenAiApiError;
2023
+ 400: BodhiApiError;
3420
2024
  /**
3421
2025
  * Not authenticated
3422
2026
  */
3423
- 401: OpenAiApiError;
2027
+ 401: BodhiApiError;
3424
2028
  /**
3425
2029
  * Insufficient permissions
3426
2030
  */
3427
- 403: OpenAiApiError;
2031
+ 403: BodhiApiError;
3428
2032
  /**
3429
2033
  * Internal server error
3430
2034
  */
3431
- 500: OpenAiApiError;
2035
+ 500: BodhiApiError;
3432
2036
  };
3433
2037
 
3434
2038
  export type CompleteDashboardOAuthFlowError = CompleteDashboardOAuthFlowErrors[keyof CompleteDashboardOAuthFlowErrors];
@@ -3453,19 +2057,19 @@ export type InitiateDashboardOAuthFlowErrors = {
3453
2057
  /**
3454
2058
  * Invalid request parameters
3455
2059
  */
3456
- 400: OpenAiApiError;
2060
+ 400: BodhiApiError;
3457
2061
  /**
3458
2062
  * Not authenticated
3459
2063
  */
3460
- 401: OpenAiApiError;
2064
+ 401: BodhiApiError;
3461
2065
  /**
3462
2066
  * Insufficient permissions
3463
2067
  */
3464
- 403: OpenAiApiError;
2068
+ 403: BodhiApiError;
3465
2069
  /**
3466
2070
  * Internal server error
3467
2071
  */
3468
- 500: OpenAiApiError;
2072
+ 500: BodhiApiError;
3469
2073
  };
3470
2074
 
3471
2075
  export type InitiateDashboardOAuthFlowError = InitiateDashboardOAuthFlowErrors[keyof InitiateDashboardOAuthFlowErrors];
@@ -3497,19 +2101,19 @@ export type InitiateOAuthFlowErrors = {
3497
2101
  /**
3498
2102
  * Invalid request parameters
3499
2103
  */
3500
- 400: OpenAiApiError;
2104
+ 400: BodhiApiError;
3501
2105
  /**
3502
2106
  * Not authenticated
3503
2107
  */
3504
- 401: OpenAiApiError;
2108
+ 401: BodhiApiError;
3505
2109
  /**
3506
2110
  * Insufficient permissions
3507
2111
  */
3508
- 403: OpenAiApiError;
2112
+ 403: BodhiApiError;
3509
2113
  /**
3510
2114
  * Internal server error
3511
2115
  */
3512
- 500: OpenAiApiError;
2116
+ 500: BodhiApiError;
3513
2117
  };
3514
2118
 
3515
2119
  export type InitiateOAuthFlowError = InitiateOAuthFlowErrors[keyof InitiateOAuthFlowErrors];
@@ -3538,11 +2142,11 @@ export type GetAppInfoErrors = {
3538
2142
  /**
3539
2143
  * Invalid request parameters
3540
2144
  */
3541
- 400: OpenAiApiError;
2145
+ 400: BodhiApiError;
3542
2146
  /**
3543
2147
  * Internal server error
3544
2148
  */
3545
- 500: OpenAiApiError;
2149
+ 500: BodhiApiError;
3546
2150
  };
3547
2151
 
3548
2152
  export type GetAppInfoError = GetAppInfoErrors[keyof GetAppInfoErrors];
@@ -3567,19 +2171,19 @@ export type LogoutUserErrors = {
3567
2171
  /**
3568
2172
  * Invalid request parameters
3569
2173
  */
3570
- 400: OpenAiApiError;
2174
+ 400: BodhiApiError;
3571
2175
  /**
3572
2176
  * Not authenticated
3573
2177
  */
3574
- 401: OpenAiApiError;
2178
+ 401: BodhiApiError;
3575
2179
  /**
3576
2180
  * Insufficient permissions
3577
2181
  */
3578
- 403: OpenAiApiError;
2182
+ 403: BodhiApiError;
3579
2183
  /**
3580
2184
  * Internal server error
3581
2185
  */
3582
- 500: OpenAiApiError;
2186
+ 500: BodhiApiError;
3583
2187
  };
3584
2188
 
3585
2189
  export type LogoutUserError = LogoutUserErrors[keyof LogoutUserErrors];
@@ -3604,19 +2208,19 @@ export type ListMcpsErrors = {
3604
2208
  /**
3605
2209
  * Invalid request parameters
3606
2210
  */
3607
- 400: OpenAiApiError;
2211
+ 400: BodhiApiError;
3608
2212
  /**
3609
2213
  * Not authenticated
3610
2214
  */
3611
- 401: OpenAiApiError;
2215
+ 401: BodhiApiError;
3612
2216
  /**
3613
2217
  * Insufficient permissions
3614
2218
  */
3615
- 403: OpenAiApiError;
2219
+ 403: BodhiApiError;
3616
2220
  /**
3617
2221
  * Internal server error
3618
2222
  */
3619
- 500: OpenAiApiError;
2223
+ 500: BodhiApiError;
3620
2224
  };
3621
2225
 
3622
2226
  export type ListMcpsError = ListMcpsErrors[keyof ListMcpsErrors];
@@ -3641,19 +2245,19 @@ export type CreateMcpErrors = {
3641
2245
  /**
3642
2246
  * Invalid request parameters
3643
2247
  */
3644
- 400: OpenAiApiError;
2248
+ 400: BodhiApiError;
3645
2249
  /**
3646
2250
  * Not authenticated
3647
2251
  */
3648
- 401: OpenAiApiError;
2252
+ 401: BodhiApiError;
3649
2253
  /**
3650
2254
  * Insufficient permissions
3651
2255
  */
3652
- 403: OpenAiApiError;
2256
+ 403: BodhiApiError;
3653
2257
  /**
3654
2258
  * Internal server error
3655
2259
  */
3656
- 500: OpenAiApiError;
2260
+ 500: BodhiApiError;
3657
2261
  };
3658
2262
 
3659
2263
  export type CreateMcpError = CreateMcpErrors[keyof CreateMcpErrors];
@@ -3680,19 +2284,19 @@ export type ListMcpAuthConfigsErrors = {
3680
2284
  /**
3681
2285
  * Invalid request parameters
3682
2286
  */
3683
- 400: OpenAiApiError;
2287
+ 400: BodhiApiError;
3684
2288
  /**
3685
2289
  * Not authenticated
3686
2290
  */
3687
- 401: OpenAiApiError;
2291
+ 401: BodhiApiError;
3688
2292
  /**
3689
2293
  * Insufficient permissions
3690
2294
  */
3691
- 403: OpenAiApiError;
2295
+ 403: BodhiApiError;
3692
2296
  /**
3693
2297
  * Internal server error
3694
2298
  */
3695
- 500: OpenAiApiError;
2299
+ 500: BodhiApiError;
3696
2300
  };
3697
2301
 
3698
2302
  export type ListMcpAuthConfigsError = ListMcpAuthConfigsErrors[keyof ListMcpAuthConfigsErrors];
@@ -3717,19 +2321,19 @@ export type CreateMcpAuthConfigErrors = {
3717
2321
  /**
3718
2322
  * Invalid request parameters
3719
2323
  */
3720
- 400: OpenAiApiError;
2324
+ 400: BodhiApiError;
3721
2325
  /**
3722
2326
  * Not authenticated
3723
2327
  */
3724
- 401: OpenAiApiError;
2328
+ 401: BodhiApiError;
3725
2329
  /**
3726
2330
  * Insufficient permissions
3727
2331
  */
3728
- 403: OpenAiApiError;
2332
+ 403: BodhiApiError;
3729
2333
  /**
3730
2334
  * Internal server error
3731
2335
  */
3732
- 500: OpenAiApiError;
2336
+ 500: BodhiApiError;
3733
2337
  };
3734
2338
 
3735
2339
  export type CreateMcpAuthConfigError = CreateMcpAuthConfigErrors[keyof CreateMcpAuthConfigErrors];
@@ -3759,15 +2363,15 @@ export type DeleteMcpAuthConfigErrors = {
3759
2363
  /**
3760
2364
  * Invalid request parameters
3761
2365
  */
3762
- 400: OpenAiApiError;
2366
+ 400: BodhiApiError;
3763
2367
  /**
3764
2368
  * Not authenticated
3765
2369
  */
3766
- 401: OpenAiApiError;
2370
+ 401: BodhiApiError;
3767
2371
  /**
3768
2372
  * Insufficient permissions
3769
2373
  */
3770
- 403: OpenAiApiError;
2374
+ 403: BodhiApiError;
3771
2375
  /**
3772
2376
  * Not found
3773
2377
  */
@@ -3775,7 +2379,7 @@ export type DeleteMcpAuthConfigErrors = {
3775
2379
  /**
3776
2380
  * Internal server error
3777
2381
  */
3778
- 500: OpenAiApiError;
2382
+ 500: BodhiApiError;
3779
2383
  };
3780
2384
 
3781
2385
  export type DeleteMcpAuthConfigError = DeleteMcpAuthConfigErrors[keyof DeleteMcpAuthConfigErrors];
@@ -3805,15 +2409,15 @@ export type GetMcpAuthConfigErrors = {
3805
2409
  /**
3806
2410
  * Invalid request parameters
3807
2411
  */
3808
- 400: OpenAiApiError;
2412
+ 400: BodhiApiError;
3809
2413
  /**
3810
2414
  * Not authenticated
3811
2415
  */
3812
- 401: OpenAiApiError;
2416
+ 401: BodhiApiError;
3813
2417
  /**
3814
2418
  * Insufficient permissions
3815
2419
  */
3816
- 403: OpenAiApiError;
2420
+ 403: BodhiApiError;
3817
2421
  /**
3818
2422
  * Not found
3819
2423
  */
@@ -3821,7 +2425,7 @@ export type GetMcpAuthConfigErrors = {
3821
2425
  /**
3822
2426
  * Internal server error
3823
2427
  */
3824
- 500: OpenAiApiError;
2428
+ 500: BodhiApiError;
3825
2429
  };
3826
2430
 
3827
2431
  export type GetMcpAuthConfigError = GetMcpAuthConfigErrors[keyof GetMcpAuthConfigErrors];
@@ -3851,15 +2455,15 @@ export type McpOAuthLoginErrors = {
3851
2455
  /**
3852
2456
  * Invalid request parameters
3853
2457
  */
3854
- 400: OpenAiApiError;
2458
+ 400: BodhiApiError;
3855
2459
  /**
3856
2460
  * Not authenticated
3857
2461
  */
3858
- 401: OpenAiApiError;
2462
+ 401: BodhiApiError;
3859
2463
  /**
3860
2464
  * Insufficient permissions
3861
2465
  */
3862
- 403: OpenAiApiError;
2466
+ 403: BodhiApiError;
3863
2467
  /**
3864
2468
  * Auth config not found
3865
2469
  */
@@ -3867,7 +2471,7 @@ export type McpOAuthLoginErrors = {
3867
2471
  /**
3868
2472
  * Internal server error
3869
2473
  */
3870
- 500: OpenAiApiError;
2474
+ 500: BodhiApiError;
3871
2475
  };
3872
2476
 
3873
2477
  export type McpOAuthLoginError = McpOAuthLoginErrors[keyof McpOAuthLoginErrors];
@@ -3897,15 +2501,15 @@ export type McpOAuthTokenExchangeErrors = {
3897
2501
  /**
3898
2502
  * Invalid request parameters
3899
2503
  */
3900
- 400: OpenAiApiError;
2504
+ 400: BodhiApiError;
3901
2505
  /**
3902
2506
  * Not authenticated
3903
2507
  */
3904
- 401: OpenAiApiError;
2508
+ 401: BodhiApiError;
3905
2509
  /**
3906
2510
  * Insufficient permissions
3907
2511
  */
3908
- 403: OpenAiApiError;
2512
+ 403: BodhiApiError;
3909
2513
  /**
3910
2514
  * Auth config not found
3911
2515
  */
@@ -3913,7 +2517,7 @@ export type McpOAuthTokenExchangeErrors = {
3913
2517
  /**
3914
2518
  * Internal server error
3915
2519
  */
3916
- 500: OpenAiApiError;
2520
+ 500: BodhiApiError;
3917
2521
  };
3918
2522
 
3919
2523
  export type McpOAuthTokenExchangeError = McpOAuthTokenExchangeErrors[keyof McpOAuthTokenExchangeErrors];
@@ -3943,15 +2547,15 @@ export type DeleteMcpOAuthTokenErrors = {
3943
2547
  /**
3944
2548
  * Invalid request parameters
3945
2549
  */
3946
- 400: OpenAiApiError;
2550
+ 400: BodhiApiError;
3947
2551
  /**
3948
2552
  * Not authenticated
3949
2553
  */
3950
- 401: OpenAiApiError;
2554
+ 401: BodhiApiError;
3951
2555
  /**
3952
2556
  * Insufficient permissions
3953
2557
  */
3954
- 403: OpenAiApiError;
2558
+ 403: BodhiApiError;
3955
2559
  /**
3956
2560
  * Not found
3957
2561
  */
@@ -3959,7 +2563,7 @@ export type DeleteMcpOAuthTokenErrors = {
3959
2563
  /**
3960
2564
  * Internal server error
3961
2565
  */
3962
- 500: OpenAiApiError;
2566
+ 500: BodhiApiError;
3963
2567
  };
3964
2568
 
3965
2569
  export type DeleteMcpOAuthTokenError = DeleteMcpOAuthTokenErrors[keyof DeleteMcpOAuthTokenErrors];
@@ -3989,15 +2593,15 @@ export type GetMcpOAuthTokenErrors = {
3989
2593
  /**
3990
2594
  * Invalid request parameters
3991
2595
  */
3992
- 400: OpenAiApiError;
2596
+ 400: BodhiApiError;
3993
2597
  /**
3994
2598
  * Not authenticated
3995
2599
  */
3996
- 401: OpenAiApiError;
2600
+ 401: BodhiApiError;
3997
2601
  /**
3998
2602
  * Insufficient permissions
3999
2603
  */
4000
- 403: OpenAiApiError;
2604
+ 403: BodhiApiError;
4001
2605
  /**
4002
2606
  * Not found
4003
2607
  */
@@ -4005,7 +2609,7 @@ export type GetMcpOAuthTokenErrors = {
4005
2609
  /**
4006
2610
  * Internal server error
4007
2611
  */
4008
- 500: OpenAiApiError;
2612
+ 500: BodhiApiError;
4009
2613
  };
4010
2614
 
4011
2615
  export type GetMcpOAuthTokenError = GetMcpOAuthTokenErrors[keyof GetMcpOAuthTokenErrors];
@@ -4030,19 +2634,19 @@ export type McpOAuthDiscoverAsErrors = {
4030
2634
  /**
4031
2635
  * Invalid request parameters
4032
2636
  */
4033
- 400: OpenAiApiError;
2637
+ 400: BodhiApiError;
4034
2638
  /**
4035
2639
  * Not authenticated
4036
2640
  */
4037
- 401: OpenAiApiError;
2641
+ 401: BodhiApiError;
4038
2642
  /**
4039
2643
  * Insufficient permissions
4040
2644
  */
4041
- 403: OpenAiApiError;
2645
+ 403: BodhiApiError;
4042
2646
  /**
4043
2647
  * Internal server error
4044
2648
  */
4045
- 500: OpenAiApiError;
2649
+ 500: BodhiApiError;
4046
2650
  };
4047
2651
 
4048
2652
  export type McpOAuthDiscoverAsError = McpOAuthDiscoverAsErrors[keyof McpOAuthDiscoverAsErrors];
@@ -4067,19 +2671,19 @@ export type McpOAuthDiscoverMcpErrors = {
4067
2671
  /**
4068
2672
  * Invalid request parameters
4069
2673
  */
4070
- 400: OpenAiApiError;
2674
+ 400: BodhiApiError;
4071
2675
  /**
4072
2676
  * Not authenticated
4073
2677
  */
4074
- 401: OpenAiApiError;
2678
+ 401: BodhiApiError;
4075
2679
  /**
4076
2680
  * Insufficient permissions
4077
2681
  */
4078
- 403: OpenAiApiError;
2682
+ 403: BodhiApiError;
4079
2683
  /**
4080
2684
  * Internal server error
4081
2685
  */
4082
- 500: OpenAiApiError;
2686
+ 500: BodhiApiError;
4083
2687
  };
4084
2688
 
4085
2689
  export type McpOAuthDiscoverMcpError = McpOAuthDiscoverMcpErrors[keyof McpOAuthDiscoverMcpErrors];
@@ -4104,19 +2708,19 @@ export type McpOAuthDynamicRegisterStandaloneErrors = {
4104
2708
  /**
4105
2709
  * Invalid request parameters
4106
2710
  */
4107
- 400: OpenAiApiError;
2711
+ 400: BodhiApiError;
4108
2712
  /**
4109
2713
  * Not authenticated
4110
2714
  */
4111
- 401: OpenAiApiError;
2715
+ 401: BodhiApiError;
4112
2716
  /**
4113
2717
  * Insufficient permissions
4114
2718
  */
4115
- 403: OpenAiApiError;
2719
+ 403: BodhiApiError;
4116
2720
  /**
4117
2721
  * Internal server error
4118
2722
  */
4119
- 500: OpenAiApiError;
2723
+ 500: BodhiApiError;
4120
2724
  };
4121
2725
 
4122
2726
  export type McpOAuthDynamicRegisterStandaloneError = McpOAuthDynamicRegisterStandaloneErrors[keyof McpOAuthDynamicRegisterStandaloneErrors];
@@ -4146,19 +2750,19 @@ export type ListMcpServersErrors = {
4146
2750
  /**
4147
2751
  * Invalid request parameters
4148
2752
  */
4149
- 400: OpenAiApiError;
2753
+ 400: BodhiApiError;
4150
2754
  /**
4151
2755
  * Not authenticated
4152
2756
  */
4153
- 401: OpenAiApiError;
2757
+ 401: BodhiApiError;
4154
2758
  /**
4155
2759
  * Insufficient permissions
4156
2760
  */
4157
- 403: OpenAiApiError;
2761
+ 403: BodhiApiError;
4158
2762
  /**
4159
2763
  * Internal server error
4160
2764
  */
4161
- 500: OpenAiApiError;
2765
+ 500: BodhiApiError;
4162
2766
  };
4163
2767
 
4164
2768
  export type ListMcpServersError = ListMcpServersErrors[keyof ListMcpServersErrors];
@@ -4183,15 +2787,15 @@ export type CreateMcpServerErrors = {
4183
2787
  /**
4184
2788
  * Invalid request parameters
4185
2789
  */
4186
- 400: OpenAiApiError;
2790
+ 400: BodhiApiError;
4187
2791
  /**
4188
2792
  * Not authenticated
4189
2793
  */
4190
- 401: OpenAiApiError;
2794
+ 401: BodhiApiError;
4191
2795
  /**
4192
2796
  * Insufficient permissions
4193
2797
  */
4194
- 403: OpenAiApiError;
2798
+ 403: BodhiApiError;
4195
2799
  /**
4196
2800
  * URL already exists
4197
2801
  */
@@ -4199,7 +2803,7 @@ export type CreateMcpServerErrors = {
4199
2803
  /**
4200
2804
  * Internal server error
4201
2805
  */
4202
- 500: OpenAiApiError;
2806
+ 500: BodhiApiError;
4203
2807
  };
4204
2808
 
4205
2809
  export type CreateMcpServerError = CreateMcpServerErrors[keyof CreateMcpServerErrors];
@@ -4229,15 +2833,15 @@ export type GetMcpServerErrors = {
4229
2833
  /**
4230
2834
  * Invalid request parameters
4231
2835
  */
4232
- 400: OpenAiApiError;
2836
+ 400: BodhiApiError;
4233
2837
  /**
4234
2838
  * Not authenticated
4235
2839
  */
4236
- 401: OpenAiApiError;
2840
+ 401: BodhiApiError;
4237
2841
  /**
4238
2842
  * Insufficient permissions
4239
2843
  */
4240
- 403: OpenAiApiError;
2844
+ 403: BodhiApiError;
4241
2845
  /**
4242
2846
  * Not found
4243
2847
  */
@@ -4245,7 +2849,7 @@ export type GetMcpServerErrors = {
4245
2849
  /**
4246
2850
  * Internal server error
4247
2851
  */
4248
- 500: OpenAiApiError;
2852
+ 500: BodhiApiError;
4249
2853
  };
4250
2854
 
4251
2855
  export type GetMcpServerError = GetMcpServerErrors[keyof GetMcpServerErrors];
@@ -4275,15 +2879,15 @@ export type UpdateMcpServerErrors = {
4275
2879
  /**
4276
2880
  * Invalid request parameters
4277
2881
  */
4278
- 400: OpenAiApiError;
2882
+ 400: BodhiApiError;
4279
2883
  /**
4280
2884
  * Not authenticated
4281
2885
  */
4282
- 401: OpenAiApiError;
2886
+ 401: BodhiApiError;
4283
2887
  /**
4284
2888
  * Insufficient permissions
4285
2889
  */
4286
- 403: OpenAiApiError;
2890
+ 403: BodhiApiError;
4287
2891
  /**
4288
2892
  * Not found
4289
2893
  */
@@ -4295,7 +2899,7 @@ export type UpdateMcpServerErrors = {
4295
2899
  /**
4296
2900
  * Internal server error
4297
2901
  */
4298
- 500: OpenAiApiError;
2902
+ 500: BodhiApiError;
4299
2903
  };
4300
2904
 
4301
2905
  export type UpdateMcpServerError = UpdateMcpServerErrors[keyof UpdateMcpServerErrors];
@@ -4325,15 +2929,15 @@ export type DeleteMcpErrors = {
4325
2929
  /**
4326
2930
  * Invalid request parameters
4327
2931
  */
4328
- 400: OpenAiApiError;
2932
+ 400: BodhiApiError;
4329
2933
  /**
4330
2934
  * Not authenticated
4331
2935
  */
4332
- 401: OpenAiApiError;
2936
+ 401: BodhiApiError;
4333
2937
  /**
4334
2938
  * Insufficient permissions
4335
2939
  */
4336
- 403: OpenAiApiError;
2940
+ 403: BodhiApiError;
4337
2941
  /**
4338
2942
  * MCP not found
4339
2943
  */
@@ -4341,7 +2945,7 @@ export type DeleteMcpErrors = {
4341
2945
  /**
4342
2946
  * Internal server error
4343
2947
  */
4344
- 500: OpenAiApiError;
2948
+ 500: BodhiApiError;
4345
2949
  };
4346
2950
 
4347
2951
  export type DeleteMcpError = DeleteMcpErrors[keyof DeleteMcpErrors];
@@ -4371,15 +2975,15 @@ export type GetMcpErrors = {
4371
2975
  /**
4372
2976
  * Invalid request parameters
4373
2977
  */
4374
- 400: OpenAiApiError;
2978
+ 400: BodhiApiError;
4375
2979
  /**
4376
2980
  * Not authenticated
4377
2981
  */
4378
- 401: OpenAiApiError;
2982
+ 401: BodhiApiError;
4379
2983
  /**
4380
2984
  * Insufficient permissions
4381
2985
  */
4382
- 403: OpenAiApiError;
2986
+ 403: BodhiApiError;
4383
2987
  /**
4384
2988
  * MCP not found
4385
2989
  */
@@ -4387,7 +2991,7 @@ export type GetMcpErrors = {
4387
2991
  /**
4388
2992
  * Internal server error
4389
2993
  */
4390
- 500: OpenAiApiError;
2994
+ 500: BodhiApiError;
4391
2995
  };
4392
2996
 
4393
2997
  export type GetMcpError = GetMcpErrors[keyof GetMcpErrors];
@@ -4417,15 +3021,15 @@ export type UpdateMcpErrors = {
4417
3021
  /**
4418
3022
  * Invalid request parameters
4419
3023
  */
4420
- 400: OpenAiApiError;
3024
+ 400: BodhiApiError;
4421
3025
  /**
4422
3026
  * Not authenticated
4423
3027
  */
4424
- 401: OpenAiApiError;
3028
+ 401: BodhiApiError;
4425
3029
  /**
4426
3030
  * Insufficient permissions
4427
3031
  */
4428
- 403: OpenAiApiError;
3032
+ 403: BodhiApiError;
4429
3033
  /**
4430
3034
  * MCP not found
4431
3035
  */
@@ -4433,7 +3037,7 @@ export type UpdateMcpErrors = {
4433
3037
  /**
4434
3038
  * Internal server error
4435
3039
  */
4436
- 500: OpenAiApiError;
3040
+ 500: BodhiApiError;
4437
3041
  };
4438
3042
 
4439
3043
  export type UpdateMcpError = UpdateMcpErrors[keyof UpdateMcpErrors];
@@ -4475,19 +3079,19 @@ export type ListAllModelsErrors = {
4475
3079
  /**
4476
3080
  * Invalid request parameters
4477
3081
  */
4478
- 400: OpenAiApiError;
3082
+ 400: BodhiApiError;
4479
3083
  /**
4480
3084
  * Not authenticated
4481
3085
  */
4482
- 401: OpenAiApiError;
3086
+ 401: BodhiApiError;
4483
3087
  /**
4484
3088
  * Insufficient permissions
4485
3089
  */
4486
- 403: OpenAiApiError;
3090
+ 403: BodhiApiError;
4487
3091
  /**
4488
3092
  * Internal server error
4489
3093
  */
4490
- 500: OpenAiApiError;
3094
+ 500: BodhiApiError;
4491
3095
  };
4492
3096
 
4493
3097
  export type ListAllModelsError = ListAllModelsErrors[keyof ListAllModelsErrors];
@@ -4512,19 +3116,19 @@ export type ModelsAliasCreateErrors = {
4512
3116
  /**
4513
3117
  * Invalid request parameters
4514
3118
  */
4515
- 400: OpenAiApiError;
3119
+ 400: BodhiApiError;
4516
3120
  /**
4517
3121
  * Not authenticated
4518
3122
  */
4519
- 401: OpenAiApiError;
3123
+ 401: BodhiApiError;
4520
3124
  /**
4521
3125
  * Insufficient permissions
4522
3126
  */
4523
- 403: OpenAiApiError;
3127
+ 403: BodhiApiError;
4524
3128
  /**
4525
3129
  * Internal server error
4526
3130
  */
4527
- 500: OpenAiApiError;
3131
+ 500: BodhiApiError;
4528
3132
  };
4529
3133
 
4530
3134
  export type ModelsAliasCreateError = ModelsAliasCreateErrors[keyof ModelsAliasCreateErrors];
@@ -4554,15 +3158,15 @@ export type ModelsAliasDestroyErrors = {
4554
3158
  /**
4555
3159
  * Invalid request parameters
4556
3160
  */
4557
- 400: OpenAiApiError;
3161
+ 400: BodhiApiError;
4558
3162
  /**
4559
3163
  * Not authenticated
4560
3164
  */
4561
- 401: OpenAiApiError;
3165
+ 401: BodhiApiError;
4562
3166
  /**
4563
3167
  * Insufficient permissions
4564
3168
  */
4565
- 403: OpenAiApiError;
3169
+ 403: BodhiApiError;
4566
3170
  /**
4567
3171
  * Alias not found
4568
3172
  */
@@ -4570,7 +3174,7 @@ export type ModelsAliasDestroyErrors = {
4570
3174
  /**
4571
3175
  * Internal server error
4572
3176
  */
4573
- 500: OpenAiApiError;
3177
+ 500: BodhiApiError;
4574
3178
  };
4575
3179
 
4576
3180
  export type ModelsAliasDestroyError = ModelsAliasDestroyErrors[keyof ModelsAliasDestroyErrors];
@@ -4598,19 +3202,19 @@ export type ModelsAliasUpdateErrors = {
4598
3202
  /**
4599
3203
  * Invalid request parameters
4600
3204
  */
4601
- 400: OpenAiApiError;
3205
+ 400: BodhiApiError;
4602
3206
  /**
4603
3207
  * Not authenticated
4604
3208
  */
4605
- 401: OpenAiApiError;
3209
+ 401: BodhiApiError;
4606
3210
  /**
4607
3211
  * Insufficient permissions
4608
3212
  */
4609
- 403: OpenAiApiError;
3213
+ 403: BodhiApiError;
4610
3214
  /**
4611
3215
  * Internal server error
4612
3216
  */
4613
- 500: OpenAiApiError;
3217
+ 500: BodhiApiError;
4614
3218
  };
4615
3219
 
4616
3220
  export type ModelsAliasUpdateError = ModelsAliasUpdateErrors[keyof ModelsAliasUpdateErrors];
@@ -4640,15 +3244,15 @@ export type ModelsAliasCopyErrors = {
4640
3244
  /**
4641
3245
  * Invalid request parameters
4642
3246
  */
4643
- 400: OpenAiApiError;
3247
+ 400: BodhiApiError;
4644
3248
  /**
4645
3249
  * Not authenticated
4646
3250
  */
4647
- 401: OpenAiApiError;
3251
+ 401: BodhiApiError;
4648
3252
  /**
4649
3253
  * Insufficient permissions
4650
3254
  */
4651
- 403: OpenAiApiError;
3255
+ 403: BodhiApiError;
4652
3256
  /**
4653
3257
  * Source alias not found
4654
3258
  */
@@ -4656,7 +3260,7 @@ export type ModelsAliasCopyErrors = {
4656
3260
  /**
4657
3261
  * Internal server error
4658
3262
  */
4659
- 500: OpenAiApiError;
3263
+ 500: BodhiApiError;
4660
3264
  };
4661
3265
 
4662
3266
  export type ModelsAliasCopyError = ModelsAliasCopyErrors[keyof ModelsAliasCopyErrors];
@@ -4681,23 +3285,23 @@ export type CreateApiModelErrors = {
4681
3285
  /**
4682
3286
  * Invalid request parameters
4683
3287
  */
4684
- 400: OpenAiApiError;
3288
+ 400: BodhiApiError;
4685
3289
  /**
4686
3290
  * Not authenticated
4687
3291
  */
4688
- 401: OpenAiApiError;
3292
+ 401: BodhiApiError;
4689
3293
  /**
4690
3294
  * Insufficient permissions
4691
3295
  */
4692
- 403: OpenAiApiError;
3296
+ 403: BodhiApiError;
4693
3297
  /**
4694
3298
  * Alias already exists
4695
3299
  */
4696
- 409: OpenAiApiError;
3300
+ 409: BodhiApiError;
4697
3301
  /**
4698
3302
  * Internal server error
4699
3303
  */
4700
- 500: OpenAiApiError;
3304
+ 500: BodhiApiError;
4701
3305
  };
4702
3306
 
4703
3307
  export type CreateApiModelError = CreateApiModelErrors[keyof CreateApiModelErrors];
@@ -4722,19 +3326,19 @@ export type FetchApiModelsErrors = {
4722
3326
  /**
4723
3327
  * Invalid request parameters
4724
3328
  */
4725
- 400: OpenAiApiError;
3329
+ 400: BodhiApiError;
4726
3330
  /**
4727
3331
  * Not authenticated
4728
3332
  */
4729
- 401: OpenAiApiError;
3333
+ 401: BodhiApiError;
4730
3334
  /**
4731
3335
  * Insufficient permissions
4732
3336
  */
4733
- 403: OpenAiApiError;
3337
+ 403: BodhiApiError;
4734
3338
  /**
4735
3339
  * Internal server error
4736
3340
  */
4737
- 500: OpenAiApiError;
3341
+ 500: BodhiApiError;
4738
3342
  };
4739
3343
 
4740
3344
  export type FetchApiModelsError = FetchApiModelsErrors[keyof FetchApiModelsErrors];
@@ -4759,19 +3363,19 @@ export type GetApiFormatsErrors = {
4759
3363
  /**
4760
3364
  * Invalid request parameters
4761
3365
  */
4762
- 400: OpenAiApiError;
3366
+ 400: BodhiApiError;
4763
3367
  /**
4764
3368
  * Not authenticated
4765
3369
  */
4766
- 401: OpenAiApiError;
3370
+ 401: BodhiApiError;
4767
3371
  /**
4768
3372
  * Insufficient permissions
4769
3373
  */
4770
- 403: OpenAiApiError;
3374
+ 403: BodhiApiError;
4771
3375
  /**
4772
3376
  * Internal server error
4773
3377
  */
4774
- 500: OpenAiApiError;
3378
+ 500: BodhiApiError;
4775
3379
  };
4776
3380
 
4777
3381
  export type GetApiFormatsError = GetApiFormatsErrors[keyof GetApiFormatsErrors];
@@ -4796,19 +3400,19 @@ export type TestApiModelErrors = {
4796
3400
  /**
4797
3401
  * Invalid request parameters
4798
3402
  */
4799
- 400: OpenAiApiError;
3403
+ 400: BodhiApiError;
4800
3404
  /**
4801
3405
  * Not authenticated
4802
3406
  */
4803
- 401: OpenAiApiError;
3407
+ 401: BodhiApiError;
4804
3408
  /**
4805
3409
  * Insufficient permissions
4806
3410
  */
4807
- 403: OpenAiApiError;
3411
+ 403: BodhiApiError;
4808
3412
  /**
4809
3413
  * Internal server error
4810
3414
  */
4811
- 500: OpenAiApiError;
3415
+ 500: BodhiApiError;
4812
3416
  };
4813
3417
 
4814
3418
  export type TestApiModelError = TestApiModelErrors[keyof TestApiModelErrors];
@@ -4838,23 +3442,23 @@ export type DeleteApiModelErrors = {
4838
3442
  /**
4839
3443
  * Invalid request parameters
4840
3444
  */
4841
- 400: OpenAiApiError;
3445
+ 400: BodhiApiError;
4842
3446
  /**
4843
3447
  * Not authenticated
4844
3448
  */
4845
- 401: OpenAiApiError;
3449
+ 401: BodhiApiError;
4846
3450
  /**
4847
3451
  * Insufficient permissions
4848
3452
  */
4849
- 403: OpenAiApiError;
3453
+ 403: BodhiApiError;
4850
3454
  /**
4851
3455
  * API model not found
4852
3456
  */
4853
- 404: OpenAiApiError;
3457
+ 404: BodhiApiError;
4854
3458
  /**
4855
3459
  * Internal server error
4856
3460
  */
4857
- 500: OpenAiApiError;
3461
+ 500: BodhiApiError;
4858
3462
  };
4859
3463
 
4860
3464
  export type DeleteApiModelError = DeleteApiModelErrors[keyof DeleteApiModelErrors];
@@ -4884,23 +3488,23 @@ export type GetApiModelErrors = {
4884
3488
  /**
4885
3489
  * Invalid request parameters
4886
3490
  */
4887
- 400: OpenAiApiError;
3491
+ 400: BodhiApiError;
4888
3492
  /**
4889
3493
  * Not authenticated
4890
3494
  */
4891
- 401: OpenAiApiError;
3495
+ 401: BodhiApiError;
4892
3496
  /**
4893
3497
  * Insufficient permissions
4894
3498
  */
4895
- 403: OpenAiApiError;
3499
+ 403: BodhiApiError;
4896
3500
  /**
4897
3501
  * API model with specified ID not found
4898
3502
  */
4899
- 404: OpenAiApiError;
3503
+ 404: BodhiApiError;
4900
3504
  /**
4901
3505
  * Internal server error
4902
3506
  */
4903
- 500: OpenAiApiError;
3507
+ 500: BodhiApiError;
4904
3508
  };
4905
3509
 
4906
3510
  export type GetApiModelError = GetApiModelErrors[keyof GetApiModelErrors];
@@ -4930,23 +3534,23 @@ export type UpdateApiModelErrors = {
4930
3534
  /**
4931
3535
  * Invalid request parameters
4932
3536
  */
4933
- 400: OpenAiApiError;
3537
+ 400: BodhiApiError;
4934
3538
  /**
4935
3539
  * Not authenticated
4936
3540
  */
4937
- 401: OpenAiApiError;
3541
+ 401: BodhiApiError;
4938
3542
  /**
4939
3543
  * Insufficient permissions
4940
3544
  */
4941
- 403: OpenAiApiError;
3545
+ 403: BodhiApiError;
4942
3546
  /**
4943
3547
  * API model not found
4944
3548
  */
4945
- 404: OpenAiApiError;
3549
+ 404: BodhiApiError;
4946
3550
  /**
4947
3551
  * Internal server error
4948
3552
  */
4949
- 500: OpenAiApiError;
3553
+ 500: BodhiApiError;
4950
3554
  };
4951
3555
 
4952
3556
  export type UpdateApiModelError = UpdateApiModelErrors[keyof UpdateApiModelErrors];
@@ -4976,15 +3580,15 @@ export type SyncModelsErrors = {
4976
3580
  /**
4977
3581
  * Invalid request parameters
4978
3582
  */
4979
- 400: OpenAiApiError;
3583
+ 400: BodhiApiError;
4980
3584
  /**
4981
3585
  * Not authenticated
4982
3586
  */
4983
- 401: OpenAiApiError;
3587
+ 401: BodhiApiError;
4984
3588
  /**
4985
3589
  * Insufficient permissions
4986
3590
  */
4987
- 403: OpenAiApiError;
3591
+ 403: BodhiApiError;
4988
3592
  /**
4989
3593
  * API model not found
4990
3594
  */
@@ -4992,7 +3596,7 @@ export type SyncModelsErrors = {
4992
3596
  /**
4993
3597
  * Internal server error
4994
3598
  */
4995
- 500: OpenAiApiError;
3599
+ 500: BodhiApiError;
4996
3600
  };
4997
3601
 
4998
3602
  export type SyncModelsError = SyncModelsErrors[keyof SyncModelsErrors];
@@ -5034,19 +3638,19 @@ export type ListModelFilesErrors = {
5034
3638
  /**
5035
3639
  * Invalid request parameters
5036
3640
  */
5037
- 400: OpenAiApiError;
3641
+ 400: BodhiApiError;
5038
3642
  /**
5039
3643
  * Not authenticated
5040
3644
  */
5041
- 401: OpenAiApiError;
3645
+ 401: BodhiApiError;
5042
3646
  /**
5043
3647
  * Insufficient permissions
5044
3648
  */
5045
- 403: OpenAiApiError;
3649
+ 403: BodhiApiError;
5046
3650
  /**
5047
3651
  * Internal server error
5048
3652
  */
5049
- 500: OpenAiApiError;
3653
+ 500: BodhiApiError;
5050
3654
  };
5051
3655
 
5052
3656
  export type ListModelFilesError = ListModelFilesErrors[keyof ListModelFilesErrors];
@@ -5088,19 +3692,19 @@ export type ListDownloadsErrors = {
5088
3692
  /**
5089
3693
  * Invalid request parameters
5090
3694
  */
5091
- 400: OpenAiApiError;
3695
+ 400: BodhiApiError;
5092
3696
  /**
5093
3697
  * Not authenticated
5094
3698
  */
5095
- 401: OpenAiApiError;
3699
+ 401: BodhiApiError;
5096
3700
  /**
5097
3701
  * Insufficient permissions
5098
3702
  */
5099
- 403: OpenAiApiError;
3703
+ 403: BodhiApiError;
5100
3704
  /**
5101
3705
  * Internal server error
5102
3706
  */
5103
- 500: OpenAiApiError;
3707
+ 500: BodhiApiError;
5104
3708
  };
5105
3709
 
5106
3710
  export type ListDownloadsError = ListDownloadsErrors[keyof ListDownloadsErrors];
@@ -5128,19 +3732,19 @@ export type PullModelFileErrors = {
5128
3732
  /**
5129
3733
  * Invalid request parameters
5130
3734
  */
5131
- 400: OpenAiApiError;
3735
+ 400: BodhiApiError;
5132
3736
  /**
5133
3737
  * Not authenticated
5134
3738
  */
5135
- 401: OpenAiApiError;
3739
+ 401: BodhiApiError;
5136
3740
  /**
5137
3741
  * Insufficient permissions
5138
3742
  */
5139
- 403: OpenAiApiError;
3743
+ 403: BodhiApiError;
5140
3744
  /**
5141
3745
  * Internal server error
5142
3746
  */
5143
- 500: OpenAiApiError;
3747
+ 500: BodhiApiError;
5144
3748
  };
5145
3749
 
5146
3750
  export type PullModelFileError = PullModelFileErrors[keyof PullModelFileErrors];
@@ -5174,23 +3778,23 @@ export type GetDownloadStatusErrors = {
5174
3778
  /**
5175
3779
  * Invalid request parameters
5176
3780
  */
5177
- 400: OpenAiApiError;
3781
+ 400: BodhiApiError;
5178
3782
  /**
5179
3783
  * Not authenticated
5180
3784
  */
5181
- 401: OpenAiApiError;
3785
+ 401: BodhiApiError;
5182
3786
  /**
5183
3787
  * Insufficient permissions
5184
3788
  */
5185
- 403: OpenAiApiError;
3789
+ 403: BodhiApiError;
5186
3790
  /**
5187
3791
  * Download request not found
5188
3792
  */
5189
- 404: OpenAiApiError;
3793
+ 404: BodhiApiError;
5190
3794
  /**
5191
3795
  * Internal server error
5192
3796
  */
5193
- 500: OpenAiApiError;
3797
+ 500: BodhiApiError;
5194
3798
  };
5195
3799
 
5196
3800
  export type GetDownloadStatusError = GetDownloadStatusErrors[keyof GetDownloadStatusErrors];
@@ -5218,15 +3822,15 @@ export type RefreshModelMetadataErrors = {
5218
3822
  /**
5219
3823
  * Invalid request parameters
5220
3824
  */
5221
- 400: OpenAiApiError;
3825
+ 400: BodhiApiError;
5222
3826
  /**
5223
3827
  * Not authenticated
5224
3828
  */
5225
- 401: OpenAiApiError;
3829
+ 401: BodhiApiError;
5226
3830
  /**
5227
3831
  * Insufficient permissions
5228
3832
  */
5229
- 403: OpenAiApiError;
3833
+ 403: BodhiApiError;
5230
3834
  /**
5231
3835
  * Model alias not found for specified repo/filename/snapshot
5232
3836
  */
@@ -5234,7 +3838,7 @@ export type RefreshModelMetadataErrors = {
5234
3838
  /**
5235
3839
  * Internal server error
5236
3840
  */
5237
- 500: OpenAiApiError;
3841
+ 500: BodhiApiError;
5238
3842
  };
5239
3843
 
5240
3844
  export type RefreshModelMetadataError = RefreshModelMetadataErrors[keyof RefreshModelMetadataErrors];
@@ -5268,23 +3872,23 @@ export type GetAliasErrors = {
5268
3872
  /**
5269
3873
  * Invalid request parameters
5270
3874
  */
5271
- 400: OpenAiApiError;
3875
+ 400: BodhiApiError;
5272
3876
  /**
5273
3877
  * Not authenticated
5274
3878
  */
5275
- 401: OpenAiApiError;
3879
+ 401: BodhiApiError;
5276
3880
  /**
5277
3881
  * Insufficient permissions
5278
3882
  */
5279
- 403: OpenAiApiError;
3883
+ 403: BodhiApiError;
5280
3884
  /**
5281
3885
  * Alias not found
5282
3886
  */
5283
- 404: OpenAiApiError;
3887
+ 404: BodhiApiError;
5284
3888
  /**
5285
3889
  * Internal server error
5286
3890
  */
5287
- 500: OpenAiApiError;
3891
+ 500: BodhiApiError;
5288
3892
  };
5289
3893
 
5290
3894
  export type GetAliasError = GetAliasErrors[keyof GetAliasErrors];
@@ -5309,19 +3913,19 @@ export type GetQueueStatusErrors = {
5309
3913
  /**
5310
3914
  * Invalid request parameters
5311
3915
  */
5312
- 400: OpenAiApiError;
3916
+ 400: BodhiApiError;
5313
3917
  /**
5314
3918
  * Not authenticated
5315
3919
  */
5316
- 401: OpenAiApiError;
3920
+ 401: BodhiApiError;
5317
3921
  /**
5318
3922
  * Insufficient permissions
5319
3923
  */
5320
- 403: OpenAiApiError;
3924
+ 403: BodhiApiError;
5321
3925
  /**
5322
3926
  * Internal server error
5323
3927
  */
5324
- 500: OpenAiApiError;
3928
+ 500: BodhiApiError;
5325
3929
  };
5326
3930
 
5327
3931
  export type GetQueueStatusError = GetQueueStatusErrors[keyof GetQueueStatusErrors];
@@ -5346,19 +3950,19 @@ export type ListSettingsErrors = {
5346
3950
  /**
5347
3951
  * Invalid request parameters
5348
3952
  */
5349
- 400: OpenAiApiError;
3953
+ 400: BodhiApiError;
5350
3954
  /**
5351
3955
  * Not authenticated
5352
3956
  */
5353
- 401: OpenAiApiError;
3957
+ 401: BodhiApiError;
5354
3958
  /**
5355
3959
  * Insufficient permissions
5356
3960
  */
5357
- 403: OpenAiApiError;
3961
+ 403: BodhiApiError;
5358
3962
  /**
5359
3963
  * Internal server error
5360
3964
  */
5361
- 500: OpenAiApiError;
3965
+ 500: BodhiApiError;
5362
3966
  };
5363
3967
 
5364
3968
  export type ListSettingsError = ListSettingsErrors[keyof ListSettingsErrors];
@@ -5388,23 +3992,23 @@ export type DeleteSettingErrors = {
5388
3992
  /**
5389
3993
  * Invalid request parameters
5390
3994
  */
5391
- 400: OpenAiApiError;
3995
+ 400: BodhiApiError;
5392
3996
  /**
5393
3997
  * Not authenticated
5394
3998
  */
5395
- 401: OpenAiApiError;
3999
+ 401: BodhiApiError;
5396
4000
  /**
5397
4001
  * Insufficient permissions
5398
4002
  */
5399
- 403: OpenAiApiError;
4003
+ 403: BodhiApiError;
5400
4004
  /**
5401
4005
  * Setting not found
5402
4006
  */
5403
- 404: OpenAiApiError;
4007
+ 404: BodhiApiError;
5404
4008
  /**
5405
4009
  * Internal server error
5406
4010
  */
5407
- 500: OpenAiApiError;
4011
+ 500: BodhiApiError;
5408
4012
  };
5409
4013
 
5410
4014
  export type DeleteSettingError = DeleteSettingErrors[keyof DeleteSettingErrors];
@@ -5442,23 +4046,23 @@ export type UpdateSettingErrors = {
5442
4046
  /**
5443
4047
  * Invalid request parameters
5444
4048
  */
5445
- 400: OpenAiApiError;
4049
+ 400: BodhiApiError;
5446
4050
  /**
5447
4051
  * Not authenticated
5448
4052
  */
5449
- 401: OpenAiApiError;
4053
+ 401: BodhiApiError;
5450
4054
  /**
5451
4055
  * Insufficient permissions
5452
4056
  */
5453
- 403: OpenAiApiError;
4057
+ 403: BodhiApiError;
5454
4058
  /**
5455
4059
  * Setting not found
5456
4060
  */
5457
- 404: OpenAiApiError;
4061
+ 404: BodhiApiError;
5458
4062
  /**
5459
4063
  * Internal server error
5460
4064
  */
5461
- 500: OpenAiApiError;
4065
+ 500: BodhiApiError;
5462
4066
  };
5463
4067
 
5464
4068
  export type UpdateSettingError = UpdateSettingErrors[keyof UpdateSettingErrors];
@@ -5486,11 +4090,11 @@ export type SetupAppErrors = {
5486
4090
  /**
5487
4091
  * Invalid request parameters
5488
4092
  */
5489
- 400: OpenAiApiError;
4093
+ 400: BodhiApiError;
5490
4094
  /**
5491
4095
  * Internal server error
5492
4096
  */
5493
- 500: OpenAiApiError;
4097
+ 500: BodhiApiError;
5494
4098
  };
5495
4099
 
5496
4100
  export type SetupAppError = SetupAppErrors[keyof SetupAppErrors];
@@ -5515,19 +4119,19 @@ export type TenantsListErrors = {
5515
4119
  /**
5516
4120
  * Invalid request parameters
5517
4121
  */
5518
- 400: OpenAiApiError;
4122
+ 400: BodhiApiError;
5519
4123
  /**
5520
4124
  * Not authenticated
5521
4125
  */
5522
- 401: OpenAiApiError;
4126
+ 401: BodhiApiError;
5523
4127
  /**
5524
4128
  * Insufficient permissions
5525
4129
  */
5526
- 403: OpenAiApiError;
4130
+ 403: BodhiApiError;
5527
4131
  /**
5528
4132
  * Internal server error
5529
4133
  */
5530
- 500: OpenAiApiError;
4134
+ 500: BodhiApiError;
5531
4135
  };
5532
4136
 
5533
4137
  export type TenantsListError = TenantsListErrors[keyof TenantsListErrors];
@@ -5555,19 +4159,19 @@ export type TenantsCreateErrors = {
5555
4159
  /**
5556
4160
  * Invalid request parameters
5557
4161
  */
5558
- 400: OpenAiApiError;
4162
+ 400: BodhiApiError;
5559
4163
  /**
5560
4164
  * Not authenticated
5561
4165
  */
5562
- 401: OpenAiApiError;
4166
+ 401: BodhiApiError;
5563
4167
  /**
5564
4168
  * Insufficient permissions
5565
4169
  */
5566
- 403: OpenAiApiError;
4170
+ 403: BodhiApiError;
5567
4171
  /**
5568
4172
  * Internal server error
5569
4173
  */
5570
- 500: OpenAiApiError;
4174
+ 500: BodhiApiError;
5571
4175
  };
5572
4176
 
5573
4177
  export type TenantsCreateError = TenantsCreateErrors[keyof TenantsCreateErrors];
@@ -5597,19 +4201,19 @@ export type TenantsActivateErrors = {
5597
4201
  /**
5598
4202
  * Invalid request parameters
5599
4203
  */
5600
- 400: OpenAiApiError;
4204
+ 400: BodhiApiError;
5601
4205
  /**
5602
4206
  * Not authenticated
5603
4207
  */
5604
- 401: OpenAiApiError;
4208
+ 401: BodhiApiError;
5605
4209
  /**
5606
4210
  * Insufficient permissions
5607
4211
  */
5608
- 403: OpenAiApiError;
4212
+ 403: BodhiApiError;
5609
4213
  /**
5610
4214
  * Internal server error
5611
4215
  */
5612
- 500: OpenAiApiError;
4216
+ 500: BodhiApiError;
5613
4217
  };
5614
4218
 
5615
4219
  export type TenantsActivateError = TenantsActivateErrors[keyof TenantsActivateErrors];
@@ -5649,19 +4253,19 @@ export type ListApiTokensErrors = {
5649
4253
  /**
5650
4254
  * Invalid request parameters
5651
4255
  */
5652
- 400: OpenAiApiError;
4256
+ 400: BodhiApiError;
5653
4257
  /**
5654
4258
  * Not authenticated
5655
4259
  */
5656
- 401: OpenAiApiError;
4260
+ 401: BodhiApiError;
5657
4261
  /**
5658
4262
  * Insufficient permissions
5659
4263
  */
5660
- 403: OpenAiApiError;
4264
+ 403: BodhiApiError;
5661
4265
  /**
5662
4266
  * Internal server error
5663
4267
  */
5664
- 500: OpenAiApiError;
4268
+ 500: BodhiApiError;
5665
4269
  };
5666
4270
 
5667
4271
  export type ListApiTokensError = ListApiTokensErrors[keyof ListApiTokensErrors];
@@ -5689,19 +4293,19 @@ export type CreateApiTokenErrors = {
5689
4293
  /**
5690
4294
  * Invalid request parameters
5691
4295
  */
5692
- 400: OpenAiApiError;
4296
+ 400: BodhiApiError;
5693
4297
  /**
5694
4298
  * Not authenticated
5695
4299
  */
5696
- 401: OpenAiApiError;
4300
+ 401: BodhiApiError;
5697
4301
  /**
5698
4302
  * Insufficient permissions
5699
4303
  */
5700
- 403: OpenAiApiError;
4304
+ 403: BodhiApiError;
5701
4305
  /**
5702
4306
  * Internal server error
5703
4307
  */
5704
- 500: OpenAiApiError;
4308
+ 500: BodhiApiError;
5705
4309
  };
5706
4310
 
5707
4311
  export type CreateApiTokenError = CreateApiTokenErrors[keyof CreateApiTokenErrors];
@@ -5734,23 +4338,23 @@ export type UpdateApiTokenErrors = {
5734
4338
  /**
5735
4339
  * Invalid request parameters
5736
4340
  */
5737
- 400: OpenAiApiError;
4341
+ 400: BodhiApiError;
5738
4342
  /**
5739
4343
  * Not authenticated
5740
4344
  */
5741
- 401: OpenAiApiError;
4345
+ 401: BodhiApiError;
5742
4346
  /**
5743
4347
  * Insufficient permissions
5744
4348
  */
5745
- 403: OpenAiApiError;
4349
+ 403: BodhiApiError;
5746
4350
  /**
5747
4351
  * Token not found
5748
4352
  */
5749
- 404: OpenAiApiError;
4353
+ 404: BodhiApiError;
5750
4354
  /**
5751
4355
  * Internal server error
5752
4356
  */
5753
- 500: OpenAiApiError;
4357
+ 500: BodhiApiError;
5754
4358
  };
5755
4359
 
5756
4360
  export type UpdateApiTokenError = UpdateApiTokenErrors[keyof UpdateApiTokenErrors];
@@ -5775,19 +4379,19 @@ export type GetCurrentUserErrors = {
5775
4379
  /**
5776
4380
  * Invalid request parameters
5777
4381
  */
5778
- 400: OpenAiApiError;
4382
+ 400: BodhiApiError;
5779
4383
  /**
5780
4384
  * Not authenticated
5781
4385
  */
5782
- 401: OpenAiApiError;
4386
+ 401: BodhiApiError;
5783
4387
  /**
5784
4388
  * Insufficient permissions
5785
4389
  */
5786
- 403: OpenAiApiError;
4390
+ 403: BodhiApiError;
5787
4391
  /**
5788
4392
  * Internal server error
5789
4393
  */
5790
- 500: OpenAiApiError;
4394
+ 500: BodhiApiError;
5791
4395
  };
5792
4396
 
5793
4397
  export type GetCurrentUserError = GetCurrentUserErrors[keyof GetCurrentUserErrors];
@@ -5812,27 +4416,27 @@ export type RequestUserAccessErrors = {
5812
4416
  /**
5813
4417
  * Invalid request parameters
5814
4418
  */
5815
- 400: OpenAiApiError;
4419
+ 400: BodhiApiError;
5816
4420
  /**
5817
4421
  * Not authenticated
5818
4422
  */
5819
- 401: OpenAiApiError;
4423
+ 401: BodhiApiError;
5820
4424
  /**
5821
4425
  * Insufficient permissions
5822
4426
  */
5823
- 403: OpenAiApiError;
4427
+ 403: BodhiApiError;
5824
4428
  /**
5825
4429
  * Pending request already exists
5826
4430
  */
5827
- 409: OpenAiApiError;
4431
+ 409: BodhiApiError;
5828
4432
  /**
5829
4433
  * User already has role
5830
4434
  */
5831
- 422: OpenAiApiError;
4435
+ 422: BodhiApiError;
5832
4436
  /**
5833
4437
  * Internal server error
5834
4438
  */
5835
- 500: OpenAiApiError;
4439
+ 500: BodhiApiError;
5836
4440
  };
5837
4441
 
5838
4442
  export type RequestUserAccessError = RequestUserAccessErrors[keyof RequestUserAccessErrors];
@@ -5855,23 +4459,23 @@ export type GetUserAccessStatusErrors = {
5855
4459
  /**
5856
4460
  * Invalid request parameters
5857
4461
  */
5858
- 400: OpenAiApiError;
4462
+ 400: BodhiApiError;
5859
4463
  /**
5860
4464
  * Not authenticated
5861
4465
  */
5862
- 401: OpenAiApiError;
4466
+ 401: BodhiApiError;
5863
4467
  /**
5864
4468
  * Insufficient permissions
5865
4469
  */
5866
- 403: OpenAiApiError;
4470
+ 403: BodhiApiError;
5867
4471
  /**
5868
4472
  * Request not found
5869
4473
  */
5870
- 404: OpenAiApiError;
4474
+ 404: BodhiApiError;
5871
4475
  /**
5872
4476
  * Internal server error
5873
4477
  */
5874
- 500: OpenAiApiError;
4478
+ 500: BodhiApiError;
5875
4479
  };
5876
4480
 
5877
4481
  export type GetUserAccessStatusError = GetUserAccessStatusErrors[keyof GetUserAccessStatusErrors];
@@ -5905,19 +4509,19 @@ export type ListUsersErrors = {
5905
4509
  /**
5906
4510
  * Invalid request parameters
5907
4511
  */
5908
- 400: OpenAiApiError;
4512
+ 400: BodhiApiError;
5909
4513
  /**
5910
4514
  * Not authenticated
5911
4515
  */
5912
- 401: OpenAiApiError;
4516
+ 401: BodhiApiError;
5913
4517
  /**
5914
4518
  * Insufficient permissions
5915
4519
  */
5916
- 403: OpenAiApiError;
4520
+ 403: BodhiApiError;
5917
4521
  /**
5918
4522
  * Internal server error
5919
4523
  */
5920
- 500: OpenAiApiError;
4524
+ 500: BodhiApiError;
5921
4525
  };
5922
4526
 
5923
4527
  export type ListUsersError = ListUsersErrors[keyof ListUsersErrors];
@@ -5947,23 +4551,23 @@ export type RemoveUserErrors = {
5947
4551
  /**
5948
4552
  * Invalid request parameters
5949
4553
  */
5950
- 400: OpenAiApiError;
4554
+ 400: BodhiApiError;
5951
4555
  /**
5952
4556
  * Not authenticated
5953
4557
  */
5954
- 401: OpenAiApiError;
4558
+ 401: BodhiApiError;
5955
4559
  /**
5956
4560
  * Insufficient permissions
5957
4561
  */
5958
- 403: OpenAiApiError;
4562
+ 403: BodhiApiError;
5959
4563
  /**
5960
4564
  * User not found
5961
4565
  */
5962
- 404: OpenAiApiError;
4566
+ 404: BodhiApiError;
5963
4567
  /**
5964
4568
  * Internal server error
5965
4569
  */
5966
- 500: OpenAiApiError;
4570
+ 500: BodhiApiError;
5967
4571
  };
5968
4572
 
5969
4573
  export type RemoveUserError = RemoveUserErrors[keyof RemoveUserErrors];
@@ -5991,23 +4595,23 @@ export type ChangeUserRoleErrors = {
5991
4595
  /**
5992
4596
  * Invalid request parameters
5993
4597
  */
5994
- 400: OpenAiApiError;
4598
+ 400: BodhiApiError;
5995
4599
  /**
5996
4600
  * Not authenticated
5997
4601
  */
5998
- 401: OpenAiApiError;
4602
+ 401: BodhiApiError;
5999
4603
  /**
6000
4604
  * Insufficient permissions
6001
4605
  */
6002
- 403: OpenAiApiError;
4606
+ 403: BodhiApiError;
6003
4607
  /**
6004
4608
  * User not found
6005
4609
  */
6006
- 404: OpenAiApiError;
4610
+ 404: BodhiApiError;
6007
4611
  /**
6008
4612
  * Internal server error
6009
4613
  */
6010
- 500: OpenAiApiError;
4614
+ 500: BodhiApiError;
6011
4615
  };
6012
4616
 
6013
4617
  export type ChangeUserRoleError = ChangeUserRoleErrors[keyof ChangeUserRoleErrors];
@@ -6030,11 +4634,11 @@ export type HealthCheckErrors = {
6030
4634
  /**
6031
4635
  * Invalid request parameters
6032
4636
  */
6033
- 400: OpenAiApiError;
4637
+ 400: BodhiApiError;
6034
4638
  /**
6035
4639
  * Internal server error
6036
4640
  */
6037
- 500: OpenAiApiError;
4641
+ 500: BodhiApiError;
6038
4642
  };
6039
4643
 
6040
4644
  export type HealthCheckError = HealthCheckErrors[keyof HealthCheckErrors];
@@ -6059,11 +4663,11 @@ export type PingServerErrors = {
6059
4663
  /**
6060
4664
  * Invalid request parameters
6061
4665
  */
6062
- 400: OpenAiApiError;
4666
+ 400: BodhiApiError;
6063
4667
  /**
6064
4668
  * Internal server error
6065
4669
  */
6066
- 500: OpenAiApiError;
4670
+ 500: BodhiApiError;
6067
4671
  };
6068
4672
 
6069
4673
  export type PingServerError = PingServerErrors[keyof PingServerErrors];
@@ -6077,167 +4681,6 @@ export type PingServerResponses = {
6077
4681
 
6078
4682
  export type PingServerResponse = PingServerResponses[keyof PingServerResponses];
6079
4683
 
6080
- export type CreateChatCompletionData = {
6081
- body: CreateChatCompletionRequest;
6082
- path?: never;
6083
- query?: never;
6084
- url: '/v1/chat/completions';
6085
- };
6086
-
6087
- export type CreateChatCompletionErrors = {
6088
- /**
6089
- * Invalid request parameters
6090
- */
6091
- 400: OpenAiApiError;
6092
- /**
6093
- * Not authenticated
6094
- */
6095
- 401: OpenAiApiError;
6096
- /**
6097
- * Insufficient permissions
6098
- */
6099
- 403: OpenAiApiError;
6100
- /**
6101
- * Internal server error
6102
- */
6103
- 500: OpenAiApiError;
6104
- };
6105
-
6106
- export type CreateChatCompletionError = CreateChatCompletionErrors[keyof CreateChatCompletionErrors];
6107
-
6108
- export type CreateChatCompletionResponses = {
6109
- /**
6110
- * Chat completion response
6111
- */
6112
- 200: CreateChatCompletionResponse;
6113
- /**
6114
- * Chat completion stream, the status is 200, using 201 to avoid OpenAPI format limitation.
6115
- */
6116
- 201: CreateChatCompletionStreamResponse;
6117
- };
6118
-
6119
- export type CreateChatCompletionResponse2 = CreateChatCompletionResponses[keyof CreateChatCompletionResponses];
6120
-
6121
- export type CreateEmbeddingData = {
6122
- body: CreateEmbeddingRequest;
6123
- path?: never;
6124
- query?: never;
6125
- url: '/v1/embeddings';
6126
- };
6127
-
6128
- export type CreateEmbeddingErrors = {
6129
- /**
6130
- * Invalid request parameters
6131
- */
6132
- 400: OpenAiApiError;
6133
- /**
6134
- * Not authenticated
6135
- */
6136
- 401: OpenAiApiError;
6137
- /**
6138
- * Insufficient permissions
6139
- */
6140
- 403: OpenAiApiError;
6141
- /**
6142
- * Internal server error
6143
- */
6144
- 500: OpenAiApiError;
6145
- };
6146
-
6147
- export type CreateEmbeddingError = CreateEmbeddingErrors[keyof CreateEmbeddingErrors];
6148
-
6149
- export type CreateEmbeddingResponses = {
6150
- /**
6151
- * Embedding response
6152
- */
6153
- 200: CreateEmbeddingResponse;
6154
- };
6155
-
6156
- export type CreateEmbeddingResponse2 = CreateEmbeddingResponses[keyof CreateEmbeddingResponses];
6157
-
6158
- export type ListModelsData = {
6159
- body?: never;
6160
- path?: never;
6161
- query?: never;
6162
- url: '/v1/models';
6163
- };
6164
-
6165
- export type ListModelsErrors = {
6166
- /**
6167
- * Invalid request parameters
6168
- */
6169
- 400: OpenAiApiError;
6170
- /**
6171
- * Not authenticated
6172
- */
6173
- 401: OpenAiApiError;
6174
- /**
6175
- * Insufficient permissions
6176
- */
6177
- 403: OpenAiApiError;
6178
- /**
6179
- * Internal server error
6180
- */
6181
- 500: OpenAiApiError;
6182
- };
6183
-
6184
- export type ListModelsError = ListModelsErrors[keyof ListModelsErrors];
6185
-
6186
- export type ListModelsResponses = {
6187
- /**
6188
- * List of available models
6189
- */
6190
- 200: ListModelResponse;
6191
- };
6192
-
6193
- export type ListModelsResponse = ListModelsResponses[keyof ListModelsResponses];
6194
-
6195
- export type GetModelData = {
6196
- body?: never;
6197
- path: {
6198
- /**
6199
- * Model identifier - can be user alias (e.g., 'llama2:chat'), model alias, or API provider alias
6200
- */
6201
- id: string;
6202
- };
6203
- query?: never;
6204
- url: '/v1/models/{id}';
6205
- };
6206
-
6207
- export type GetModelErrors = {
6208
- /**
6209
- * Invalid request parameters
6210
- */
6211
- 400: OpenAiApiError;
6212
- /**
6213
- * Not authenticated
6214
- */
6215
- 401: OpenAiApiError;
6216
- /**
6217
- * Insufficient permissions
6218
- */
6219
- 403: OpenAiApiError;
6220
- /**
6221
- * Model not found
6222
- */
6223
- 404: OpenAiApiError;
6224
- /**
6225
- * Internal server error
6226
- */
6227
- 500: OpenAiApiError;
6228
- };
6229
-
6230
- export type GetModelError = GetModelErrors[keyof GetModelErrors];
6231
-
6232
- export type GetModelResponses = {
6233
- /**
6234
- * Model details
6235
- */
6236
- 200: Model;
6237
- };
6238
-
6239
- export type GetModelResponse = GetModelResponses[keyof GetModelResponses];
6240
-
6241
4684
  export type ClientOptions = {
6242
4685
  baseUrl: 'http://localhost:1135' | (string & {});
6243
4686
  };