objectiveai 1.0.3 → 1.1.1

package/dist/index.d.ts

@@ -61,7 +61,7 @@ export declare namespace Chat {
                     }
                 }
             }
-            type ReasoningEffort = "low" | "medium" | "high";
+            type ReasoningEffort = "minimal" | "low" | "medium" | "high";
             type ResponseFormat = ResponseFormat.Text | ResponseFormat.JsonObject | ResponseFormat.JsonSchema;
             namespace ResponseFormat {
                 interface Text {
@@ -132,108 +132,85 @@ export declare namespace Chat {
                     }
                 }
             }
-            type Message = Message.Developer | Message.System | Message.User | Message.Assistant | Message.Tool;
+            type Message = Message.Developer | Message.System | Message.User | Message.Assistant | Message.Tool | Message.ChatCompletion | Message.ScoreCompletion;
             namespace Message {
-                interface Developer {
-                    role: "developer";
-                    content: Developer.Content;
-                    name?: string;
+                type SimpleContent = string | SimpleContentPart[];
+                interface SimpleContentPart {
+                    text: string;
+                    type: "text";
                 }
-                namespace Developer {
-                    type Content = string | Content.Part[];
-                    namespace Content {
-                        interface Part {
-                            text: string;
-                            type: "text";
+                type RichContent = string | RichContentPart[];
+                type RichContentPart = RichContentPart.Text | RichContentPart.ImageUrl | RichContentPart.InputAudio | RichContentPart.InputVideo | RichContentPart.File;
+                namespace RichContentPart {
+                    interface Text {
+                        text: string;
+                        type: "text";
+                    }
+                    interface ImageUrl {
+                        image_url: ImageUrl.Definition;
+                        type: "image_url";
+                    }
+                    namespace ImageUrl {
+                        interface Definition {
+                            url: string;
+                            detail?: ImageUrl.Detail | null;
                         }
+                        type Detail = "auto" | "low" | "high";
+                    }
+                    interface InputAudio {
+                        input_audio: InputAudio.Definition;
+                        type: "input_audio";
                     }
+                    namespace InputAudio {
+                        interface Definition {
+                            data: string;
+                            format: Format;
+                        }
+                        type Format = "wav" | "mp3";
+                    }
+                    interface InputVideo {
+                        video_url: InputVideo.Definition;
+                    }
+                    namespace InputVideo {
+                        interface Definition {
+                            url: string;
+                        }
+                    }
+                    interface File {
+                        file: File.Definition;
+                        type: "file";
+                    }
+                    namespace File {
+                        interface Definition {
+                            file_data?: string | null;
+                            file_id?: string | null;
+                            filename?: string | null;
+                        }
+                    }
+                }
+                interface Developer {
+                    role: "developer";
+                    content: SimpleContent;
+                    name?: string;
                 }
                 interface System {
                     role: "system";
-                    content: System.Content;
+                    content: SimpleContent;
                     name?: string;
                 }
-                namespace System {
-                    type Content = string | Content.Part[];
-                    namespace Content {
-                        interface Part {
-                            text: string;
-                            type: "text";
-                        }
-                    }
-                }
                 interface User {
                     role: "user";
-                    content: User.Content;
+                    content: RichContent;
                     name?: string;
                 }
-                namespace User {
-                    type Content = string | Content.Part[];
-                    namespace Content {
-                        type Part = Part.Text | Part.ImageUrl | Part.InputAudio | Part.File;
-                        namespace Part {
-                            interface Text {
-                                text: string;
-                                type: "text";
-                            }
-                            interface ImageUrl {
-                                image_url: ImageUrl.Definition;
-                                type: "image_url";
-                            }
-                            namespace ImageUrl {
-                                interface Definition {
-                                    url: string;
-                                    detail?: ImageUrl.Detail | null;
-                                }
-                                type Detail = "auto" | "low" | "high";
-                            }
-                            interface InputAudio {
-                                input_audio: InputAudio.Definition;
-                                type: "input_audio";
-                            }
-                            namespace InputAudio {
-                                interface Definition {
-                                    data: string;
-                                    format: Format;
-                                }
-                                type Format = "wav" | "mp3";
-                            }
-                            interface File {
-                                file: File.Definition;
-                                type: "file";
-                            }
-                            namespace File {
-                                interface Definition {
-                                    file_data?: string | null;
-                                    file_id?: string | null;
-                                    filename?: string | null;
-                                }
-                            }
-                        }
-                    }
-                }
                 interface Assistant {
                     role: "assistant";
-                    content?: Assistant.Content | null;
+                    content?: RichContent | null;
                     name?: string | null;
                     refusal?: string | null;
                     tool_calls?: Assistant.ToolCall[] | null;
                 }
                 namespace Assistant {
-                    type Content = string | Content.Part[];
-                    namespace Content {
-                        type Part = Part.Text | Part.Refusal;
-                        namespace Part {
-                            interface Text {
-                                text: string;
-                                type: "text";
-                            }
-                            interface Refusal {
-                                refusal: string;
-                                type: "refusal";
-                            }
-                        }
-                    }
                     type ToolCall = ToolCall.Function;
                     namespace ToolCall {
                         interface Function {
@@ -251,17 +228,20 @@ export declare namespace Chat {
                 }
                 interface Tool {
                     role: "tool";
-                    content?: Tool.Content | null;
+                    content?: RichContent | null;
                     tool_call_id: string;
                 }
-                namespace Tool {
-                    type Content = string | Content.Part[];
-                    namespace Content {
-                        interface Part {
-                            text: string;
-                            type: "text";
-                        }
-                    }
+                interface ChatCompletion {
+                    role: "chat_completion";
+                    id: string;
+                    choice_index: number;
+                    name?: string | null;
+                }
+                interface ScoreCompletion {
+                    role: "score_completion";
+                    id: string;
+                    choice_index: number;
+                    name?: string | null;
                 }
             }
             interface ProviderPreferences {
@@ -503,24 +483,18 @@ export declare namespace Chat {
         function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
     }
 }
-export declare namespace Query {
+export declare namespace Score {
     namespace Completions {
         namespace Request {
             interface ChatCompletionCreateParamsBase {
                 messages: Chat.Completions.Request.Message[];
                 model: Model;
-                logprobs?: boolean | null;
-                n?: number | null;
-                prediction?: Chat.Completions.Request.Prediction | null;
-                response_format?: Chat.Completions.Request.ResponseFormat | null;
                 seed?: number | null;
                 service_tier?: Chat.Completions.Request.ServiceTier | null;
                 stream_options?: Chat.Completions.Request.StreamOptions | null;
                 tools?: Chat.Completions.Request.Tool[] | null;
-                top_logprobs?: number | null;
                 usage?: Chat.Completions.Request.Usage | null;
-                embeddings?: string | null;
-                select_deterministic?: boolean | null;
+                choices: Choice[];
             }
             interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
                 stream: true;
@@ -529,7 +503,20 @@ export declare namespace Query {
                 stream?: false | null;
             }
             type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
-            type Model = string | QueryModelBase;
+            type Model = string | ScoreModelBase;
+            type Choice = string | Choice.ChatCompletion | Choice.ScoreCompletion;
+            namespace Choice {
+                interface ChatCompletion {
+                    type: "chat_completion";
+                    id: string;
+                    choice_index: number;
+                }
+                interface ScoreCompletion {
+                    type: "score_completion";
+                    id: string;
+                    choice_index: number;
+                }
+            }
         }
         namespace Response {
             namespace Streaming {
@@ -539,33 +526,34 @@ export declare namespace Query {
                     created: number;
                     model: string;
                     object: "chat.completion.chunk";
-                    service_tier?: Chat.Completions.Response.ServiceTier;
-                    system_fingerprint?: string;
                     usage?: Chat.Completions.Response.Usage;
-                    training_table_data?: TrainingTableData;
+                    weight_data?: WeightData;
                 }
                 namespace ChatCompletionChunk {
                     function merged(a: ChatCompletionChunk, b: ChatCompletionChunk): [ChatCompletionChunk, boolean];
                 }
                 interface Choice {
-                    delta: Chat.Completions.Response.Streaming.Delta;
+                    delta: Delta;
                     finish_reason: Chat.Completions.Response.FinishReason | null;
                     index: number;
                     logprobs?: Chat.Completions.Response.Logprobs;
-                    generate_id?: string;
-                    confidence_id?: ConfidenceId;
-                    confidence_weight?: number;
+                    weight?: number;
                     confidence?: number;
-                    embedding?: EmbeddingsResponse | ObjectiveAIError;
                     error?: ObjectiveAIError;
-                    model: string;
-                    model_index: number | null;
-                    completion_metadata: CompletionMetadata;
+                    model?: string;
+                    model_index?: number | null;
+                    completion_metadata?: CompletionMetadata;
                 }
                 namespace Choice {
                     function merged(a: Choice, b: Choice): [Choice, boolean];
                     function mergedList(a: Choice[], b: Choice[]): [Choice[], boolean];
                 }
+                interface Delta extends Chat.Completions.Response.Streaming.Delta {
+                    vote?: number[];
+                }
+                namespace Delta {
+                    function merged(a: Delta, b: Delta): [Delta, boolean];
+                }
             }
             namespace Unary {
                 interface ChatCompletion {
@@ -574,30 +562,34 @@ export declare namespace Query {
                     created: number;
                     model: string;
                     object: "chat.completion";
-                    service_tier?: Chat.Completions.Response.ServiceTier;
-                    system_fingerprint?: string;
                     usage?: Chat.Completions.Response.Usage;
-                    training_table_data?: TrainingTableData;
+                    weight_data?: WeightData | null;
                 }
                 interface Choice {
-                    message: Chat.Completions.Response.Unary.Message;
+                    message: Message;
                     finish_reason: Chat.Completions.Response.FinishReason;
                     index: number;
                     logprobs: Chat.Completions.Response.Logprobs | null;
-                    generate_id: string | null;
-                    confidence_id: ConfidenceId | null;
-                    confidence_weight: number | null;
+                    weight: number | null;
                     confidence: number | null;
-                    embedding?: EmbeddingsResponse | ObjectiveAIError;
-                    error?: ObjectiveAIError;
-                    model: string;
+                    error: ObjectiveAIError | null;
+                    model: string | null;
                     model_index: number | null;
-                    completion_metadata: CompletionMetadata;
+                    completion_metadata: CompletionMetadata | null;
+                }
+                interface Message extends Chat.Completions.Response.Unary.Message {
+                    vote: number[] | null;
                 }
             }
-            interface TrainingTableData {
-                response_format_hash: string;
-                embeddings_response: EmbeddingsResponse;
+            type WeightData = WeightData.Static | WeightData.TrainingTable;
+            namespace WeightData {
+                interface Static {
+                    type: "static";
+                }
+                interface TrainingTable {
+                    type: "training_table";
+                    embeddings_response: EmbeddingsResponse;
+                }
             }
             interface EmbeddingsResponse {
                 data: EmbeddingsResponse.Embedding[];
@@ -624,357 +616,6 @@ export declare namespace Query {
             namespace CompletionMetadata {
                 function merged(a: CompletionMetadata, b: CompletionMetadata): [CompletionMetadata, boolean];
             }
-            type ConfidenceId = string | Record<string, number>;
-        }
-        function list(openai: OpenAI, listOptions?: Chat.Completions.ListOptions, options?: OpenAI.RequestOptions): Promise<{
-            data: Chat.Completions.ListItem[];
-        }>;
-        function publish(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
-        function retrieve(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<{
-            request: Request.ChatCompletionCreateParams;
-            response: Response.Unary.ChatCompletion;
-            correct_confidence_id?: string;
-        }>;
-        function trainingTableMark(openai: OpenAI, id: string, correctConfidenceId: string, options?: OpenAI.RequestOptions): Promise<void>;
-        function trainingTableUnmark(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
-        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ChatCompletionChunk | ObjectiveAIError>>;
-        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
-    }
-}
-export declare namespace QueryTool {
-    namespace Completions {
-        namespace Request {
-            interface ChatCompletionCreateParamsBase {
-                messages: Chat.Completions.Request.Message[];
-                model: Query.Completions.Request.Model;
-                logprobs?: boolean | null;
-                n?: number | null;
-                prediction?: Chat.Completions.Request.Prediction | null;
-                response_format: ResponseFormat;
-                seed?: number | null;
-                service_tier?: Chat.Completions.Request.ServiceTier | null;
-                stream_options?: Chat.Completions.Request.StreamOptions | null;
-                tools?: Chat.Completions.Request.Tool[] | null;
-                top_logprobs?: number | null;
-                usage?: Chat.Completions.Request.Usage | null;
-                embeddings?: string | null;
-            }
-            interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
-                stream: true;
-            }
-            interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
-                stream?: false | null;
-            }
-            type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
-            type ResponseFormat = ResponseFormat.Simple | ResponseFormat.NumberQuery | ResponseFormat.MultipleChoiceQuery | ResponseFormat.MultipleChoiceOptionsQuery | ResponseFormat.WeightedAverageChoiceQuery;
-            namespace ResponseFormat {
-                type Simple = {
-                    tool: "simple_query";
-                    top?: number | null;
-                    select_deterministic?: boolean | null;
-                } | ({
-                    tool: "simple_query";
-                    top?: number | null;
-                    select_deterministic?: boolean | null;
-                } & Chat.Completions.Request.ResponseFormat);
-                interface NumberQuery {
-                    tool: "number_query";
-                }
-                interface MultipleChoiceQuery {
-                    tool: "multiple_choice_query";
-                    choices: string[];
-                }
-                interface MultipleChoiceOptionsQuery {
-                    tool: "multiple_choice_options_query";
-                    min_items: number;
-                    max_items: number;
-                }
-                type WeightedAverageChoiceQuery = {
-                    tool: "weighted_average_choice_query";
-                    embeddings_model: string;
-                    select_deterministic?: boolean | null;
-                } | ({
-                    tool: "weighted_average_choice_query";
-                    embeddings_model: string;
-                    select_deterministic?: boolean | null;
-                } & Chat.Completions.Request.ResponseFormat);
-            }
-        }
-        namespace Response {
-            namespace Streaming {
-                interface ChatCompletionChunk {
-                    id: string;
-                    choices: Choice[];
-                    created: number;
-                    model: Model;
-                    object: "chat.completion.chunk";
-                    service_tier?: Chat.Completions.Response.ServiceTier;
-                    system_fingerprint?: string;
-                    usage?: Chat.Completions.Response.Usage;
-                }
-                namespace ChatCompletionChunk {
-                    function merged(a: ChatCompletionChunk, b: ChatCompletionChunk): [ChatCompletionChunk, boolean];
-                }
-                interface Choice {
-                    delta: Delta;
-                    finish_reason: Chat.Completions.Response.FinishReason | null;
-                    index: number;
-                    logprobs?: Chat.Completions.Response.Logprobs;
-                }
-                namespace Choice {
-                    function merged(a: Choice, b: Choice): [Choice, boolean];
-                    function mergedList(a: Choice[], b: Choice[]): [Choice[], boolean];
-                }
-                interface Delta {
-                    content?: string;
-                    refusal?: string;
-                    role?: Chat.Completions.Response.Role;
-                    tool_calls?: Chat.Completions.Response.Streaming.ToolCall[];
-                    reasoning?: Reasoning;
-                }
-                namespace Delta {
-                    function merged(a: Delta, b: Delta): [Delta, boolean];
-                }
-                type Reasoning = ReasoningCompletion | ReasoningCompletion[];
-                namespace Reasoning {
-                    function merged(a: Reasoning, b: Reasoning): [Reasoning, boolean];
-                }
-                type ReasoningCompletion = ReasoningCompletion.QueryCompletion | ReasoningCompletion.ChatCompletion;
-                namespace ReasoningCompletion {
-                    type QueryCompletion = {
-                        index: number;
-                        type: "query";
-                        error?: ObjectiveAIError;
-                    } & Query.Completions.Response.Streaming.ChatCompletionChunk;
-                    namespace QueryCompletion {
-                        function merged(a: QueryCompletion, b: QueryCompletion): [QueryCompletion, boolean];
-                    }
-                    type ChatCompletion = {
-                        index: number;
-                        type: "chat";
-                        error?: ObjectiveAIError;
-                    } & Chat.Completions.Response.Streaming.ChatCompletionChunk;
-                    namespace ChatCompletion {
-                        function merged(a: ChatCompletion, b: ChatCompletion): [ChatCompletion, boolean];
-                    }
-                }
-            }
-            namespace Unary {
-                interface ChatCompletion {
-                    id: string;
-                    choices: Choice[];
-                    created: number;
-                    model: Model;
-                    object: "chat.completion";
-                    service_tier?: Chat.Completions.Response.ServiceTier;
-                    system_fingerprint?: string;
-                    usage?: Chat.Completions.Response.Usage;
-                }
-                interface Choice {
-                    message: Message;
-                    finish_reason: Chat.Completions.Response.FinishReason;
-                    index: number;
-                    logprobs: Chat.Completions.Response.Logprobs | null;
-                }
-                interface Message {
-                    content: string | null;
-                    refusal: string | null;
-                    role: Chat.Completions.Response.Role;
-                    annotations?: Chat.Completions.Response.Unary.Annotation[];
-                    audio?: Chat.Completions.Response.Unary.Audio;
-                    tool_calls?: Chat.Completions.Response.Unary.ToolCall[];
-                    reasoning?: Reasoning;
-                }
-                type Reasoning = ReasoningCompletion | ReasoningCompletion[];
-                type ReasoningCompletion = ReasoningCompletion.QueryCompletion | ReasoningCompletion.ChatCompletion;
-                namespace ReasoningCompletion {
-                    type QueryCompletion = {
-                        index: number;
-                        type: "query";
-                        error?: ObjectiveAIError;
-                    } & Query.Completions.Response.Unary.ChatCompletion;
-                    type ChatCompletion = {
-                        index: number;
-                        type: "chat";
-                        error?: ObjectiveAIError;
-                    } & Chat.Completions.Response.Unary.ChatCompletion;
-                }
-            }
-            type Model = "simple_query" | "number_query" | "multiple_choice_query" | "multiple_choice_options_query" | "weighted_average_choice_query";
-        }
-        function list(openai: OpenAI, listOptions?: Chat.Completions.ListOptions, options?: OpenAI.RequestOptions): Promise<{
-            data: Chat.Completions.ListItem[];
-        }>;
-        function publish(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
-        function retrieve(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<{
-            request: Request.ChatCompletionCreateParams;
-            response: Response.Unary.ChatCompletion;
-        }>;
-        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ChatCompletionChunk | ObjectiveAIError>>;
-        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
-    }
-}
-export declare namespace QueryChat {
-    namespace Completions {
-        namespace Request {
-            interface ChatCompletionCreateParamsBase {
-                messages: Chat.Completions.Request.Message[];
-                model: string;
-                frequency_penalty?: number | null;
-                logit_bias?: Record<string, number> | null;
-                logprobs?: boolean | null;
-                max_completion_tokens?: number | null;
-                modalities?: string[] | null;
-                parallel_tool_calls?: boolean | null;
-                prediction?: Chat.Completions.Request.Prediction | null;
-                presence_penalty?: number | null;
-                reasoning_effort?: Chat.Completions.Request.ReasoningEffort | null;
-                response_format?: Chat.Completions.Request.ResponseFormat | null;
-                seed?: number | null;
-                service_tier?: Chat.Completions.Request.ServiceTier | null;
-                stop?: Chat.Completions.Request.Stop | null;
-                stream_options?: Chat.Completions.Request.StreamOptions | null;
-                temperature?: number | null;
-                top_logprobs?: number | null;
-                top_p?: number | null;
-                max_tokens?: number | null;
-                min_p?: number | null;
-                provider?: Chat.Completions.Request.ProviderPreferences | null;
-                reasoning?: Chat.Completions.Request.Reasoning | null;
-                repetition_penalty?: number | null;
-                top_a?: number | null;
-                top_k?: number | null;
-                usage?: Chat.Completions.Request.Usage | null;
-                verbosity?: Chat.Completions.Request.Verbosity | null;
-                models?: string[] | null;
-                training_table_name?: string | null;
-                simple_query: QueryToolParams;
-                multiple_choice_query: QueryToolParams;
-                multiple_choice_options_query: QueryToolParams;
-            }
-            interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
-                stream: true;
-            }
-            interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
-                stream?: false | null;
-            }
-            type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
-            interface QueryToolParams {
-                model: Query.Completions.Request.Model;
-                logprobs?: boolean | null;
-                n?: number | null;
-                prediction?: Chat.Completions.Request.Prediction | null;
-                seed?: number | null;
-                service_tier?: Chat.Completions.Request.ServiceTier | null;
-                tools?: Chat.Completions.Request.Tool[] | null;
-                top_logprobs?: number | null;
-                embeddings?: string | null;
-            }
-        }
-        namespace Response {
-            namespace Streaming {
-                interface ChatCompletionChunk {
-                    id: string;
-                    choices: Choice[];
-                    created: number;
-                    model: string;
-                    object: "chat.completion.chunk";
-                    service_tier?: Chat.Completions.Response.ServiceTier;
-                    system_fingerprint?: string;
-                    usage?: Chat.Completions.Response.Usage;
-                }
-                namespace ChatCompletionChunk {
-                    function merged(a: ChatCompletionChunk, b: ChatCompletionChunk): [ChatCompletionChunk, boolean];
-                }
-                interface Choice {
-                    delta: Delta;
-                    finish_reason: Chat.Completions.Response.FinishReason | null;
-                    index: number;
-                    logprobs?: Chat.Completions.Response.Logprobs;
-                }
-                namespace Choice {
-                    function merged(a: Choice, b: Choice): [Choice, boolean];
-                    function mergedList(a: Choice[], b: Choice[]): [Choice[], boolean];
-                }
-                interface Delta {
-                    content?: string;
-                    refusal?: string;
-                    role?: Chat.Completions.Response.Role;
-                    tool_calls?: Chat.Completions.Response.Streaming.ToolCall[];
-                    images?: Chat.Completions.Response.Image[];
-                    reasoning?: Reasoning;
-                }
-                namespace Delta {
-                    function merged(a: Delta, b: Delta): [Delta, boolean];
-                }
-                type Reasoning = ReasoningCompletion | ReasoningCompletion[];
-                namespace Reasoning {
-                    function merged(a: Reasoning, b: Reasoning): [Reasoning, boolean];
-                }
-                type ReasoningCompletion = ReasoningCompletion.QueryToolCompletion | ReasoningCompletion.ChatCompletion;
-                namespace ReasoningCompletion {
-                    type QueryToolCompletion = {
-                        index: number;
-                        type: "query_tool";
-                        tool_call_id: string;
-                        error?: ObjectiveAIError;
-                    } & QueryTool.Completions.Response.Streaming.ChatCompletionChunk;
-                    namespace QueryToolCompletion {
-                        function merged(a: QueryToolCompletion, b: QueryToolCompletion): [QueryToolCompletion, boolean];
-                    }
-                    type ChatCompletion = {
-                        index: number;
-                        type: "chat";
-                        error?: ObjectiveAIError;
-                    } & Chat.Completions.Response.Streaming.ChatCompletionChunk;
-                    namespace ChatCompletion {
-                        function merged(a: ChatCompletion, b: ChatCompletion): [ChatCompletion, boolean];
-                    }
-                }
-            }
-            namespace Unary {
-                interface ChatCompletion {
-                    id: string;
-                    choices: Choice[];
-                    created: number;
-                    model: string;
-                    object: "chat.completion";
-                    service_tier?: Chat.Completions.Response.ServiceTier;
-                    system_fingerprint?: string;
-                    usage?: Chat.Completions.Response.Usage;
-                }
-                interface Choice {
-                    message: Message;
-                    finish_reason: Chat.Completions.Response.FinishReason;
-                    index: number;
-                    logprobs: Chat.Completions.Response.Logprobs | null;
-                }
-                interface Message {
-                    content: string | null;
-                    refusal: string | null;
-                    role: Chat.Completions.Response.Role;
-                    annotations?: Chat.Completions.Response.Unary.Annotation[];
-                    audio?: Chat.Completions.Response.Unary.Audio;
-                    tool_calls?: Chat.Completions.Response.Unary.ToolCall[];
-                    images?: Chat.Completions.Response.Image[];
-                    reasoning?: Reasoning;
-                }
-                type Reasoning = ReasoningCompletion | ReasoningCompletion[];
-                type ReasoningCompletion = ReasoningCompletion.QueryToolCompletion | ReasoningCompletion.ChatCompletion;
-                namespace ReasoningCompletion {
-                    type QueryToolCompletion = {
-                        index: number;
-                        type: "query_tool";
-                        tool_call_id: string;
-                        error?: ObjectiveAIError;
-                    } & QueryTool.Completions.Response.Unary.ChatCompletion;
-                    type ChatCompletion = {
-                        index: number;
-                        type: "chat";
-                        error?: ObjectiveAIError;
-                    } & Chat.Completions.Response.Unary.ChatCompletion;
-                }
-            }
         }
         function list(openai: OpenAI, listOptions?: Chat.Completions.ListOptions, options?: OpenAI.RequestOptions): Promise<{
             data: Chat.Completions.ListItem[];
@@ -983,7 +624,11 @@ export declare namespace QueryChat {
         function retrieve(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<{
             request: Request.ChatCompletionCreateParams;
             response: Response.Unary.ChatCompletion;
+            correct_vote: number[] | null;
+            correct_vote_modified: string | null;
         }>;
+        function trainingTableAdd(openai: OpenAI, id: string, correctVote: number[], options?: OpenAI.RequestOptions): Promise<void>;
+        function trainingTableDelete(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
         function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ChatCompletionChunk | ObjectiveAIError>>;
         function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
     }
@@ -1108,116 +753,116 @@ export declare namespace Auth {
     }
 }
 export interface Metadata {
-    query_requests: number;
-    query_completion_tokens: number;
-    query_prompt_tokens: number;
-    query_cost: number;
+    score_requests: number;
+    score_completion_tokens: number;
+    score_prompt_tokens: number;
+    score_total_cost: number;
     chat_requests: number;
     chat_completion_tokens: number;
     chat_prompt_tokens: number;
-    chat_cost: number;
-    embedding_completion_tokens: number;
-    embedding_prompt_tokens: number;
-    embedding_cost: number;
+    chat_total_cost: number;
 }
 export declare namespace Metadata {
     function get(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<Metadata>;
 }
-export interface QueryModelBase {
-    models: QueryModel.QueryLlmBase[];
-    weight: QueryModel.Weight;
+export interface ScoreLlmBase {
+    model: string;
+    weight: ScoreLlm.Weight;
+    output_mode: ScoreLlm.OutputMode;
+    synthetic_reasoning?: boolean | null;
+    top_logprobs?: number | null;
+    prefix_messages?: Chat.Completions.Request.Message[] | null;
+    suffix_messages?: Chat.Completions.Request.Message[] | null;
+    frequency_penalty?: number | null;
+    logit_bias?: Record<string, number> | null;
+    max_completion_tokens?: number | null;
+    presence_penalty?: number | null;
+    stop?: Chat.Completions.Request.Stop | null;
+    temperature?: number | null;
+    top_p?: number | null;
+    max_tokens?: number | null;
+    min_p?: number | null;
+    provider?: Chat.Completions.Request.ProviderPreferences | null;
+    reasoning?: Chat.Completions.Request.Reasoning | null;
+    repetition_penalty?: number | null;
+    top_a?: number | null;
+    top_k?: number | null;
+    verbosity?: Chat.Completions.Request.Verbosity | null;
+    models?: string[] | null;
 }
-export interface QueryModel {
-    name: string;
-    training_table_name?: string;
-    models: QueryModel.QueryLlm[];
-    weight: QueryModel.Weight;
+export interface ScoreLlmWithoutIndices extends ScoreLlmBase {
+    id: string;
+    training_table_id?: string;
 }
-export interface QueryModelWithMetadata extends QueryModel {
-    user_id: string;
+export interface ScoreLlmWithoutIndicesWithMetadata extends ScoreLlmWithoutIndices {
     created: string;
     requests: number;
-    chat_completion_tokens: number;
-    chat_prompt_tokens: number;
-    chat_cost: number;
-    embedding_completion_tokens: number;
-    embedding_prompt_tokens: number;
-    embedding_cost: number;
+    completion_tokens: number;
+    prompt_tokens: number;
+    total_cost: number;
 }
-export declare namespace QueryModel {
+export interface ScoreLlm extends ScoreLlmWithoutIndices {
+    index: number;
+    training_table_index?: number;
+}
+export declare namespace ScoreLlm {
     type Weight = Weight.Static | Weight.TrainingTable;
     namespace Weight {
         interface Static {
             type: "static";
+            weight: number;
         }
         interface TrainingTable {
             type: "training_table";
-            embeddings_model: string;
-            top: number;
+            base_weight: number;
+            min_weight: number;
+            max_weight: number;
         }
     }
-    interface QueryLlmBase {
-        id: string;
-        mode: QueryLlm.Mode;
-        select_top_logprobs?: number | null;
-        tool_response_format?: boolean | null;
-        frequency_penalty?: number | null;
-        logit_bias?: Record<string, number> | null;
-        max_completion_tokens?: number | null;
-        presence_penalty?: number | null;
-        reasoning_effort?: Chat.Completions.Request.ReasoningEffort | null;
-        stop?: Chat.Completions.Request.Stop | null;
-        temperature?: number | null;
-        top_p?: number | null;
-        max_tokens?: number | null;
-        min_p?: number | null;
-        provider?: Chat.Completions.Request.ProviderPreferences | null;
-        reasoning?: Chat.Completions.Request.Reasoning | null;
-        repetition_penalty?: number | null;
-        top_a?: number | null;
-        top_k?: number | null;
-        verbosity?: Chat.Completions.Request.Verbosity | null;
-        models?: string[] | null;
-        weight: QueryLlm.Weight;
-    }
-    interface QueryLlmWithoutIndices extends QueryLlmBase {
-        name: string;
-        training_table_name?: string;
-    }
-    interface QueryLlm extends QueryLlmWithoutIndices {
-        index: number;
-        training_table_index?: number;
-    }
-    interface QueryLlmWithoutIndicesWithMetadata extends QueryLlmWithoutIndices {
-        user_id: string;
-        created: string;
-        requests: number;
-        chat_completion_tokens: number;
-        chat_prompt_tokens: number;
-        chat_cost: number;
-        embedding_completion_tokens: number;
-        embedding_prompt_tokens: number;
-        embedding_cost: number;
-    }
-    namespace QueryLlm {
-        type Mode = "generate" | "select_thinking" | "select_non_thinking" | "select_thinking_logprobs" | "select_non_thinking_logprobs";
-        type Weight = Weight.Static | Weight.TrainingTable;
-        namespace Weight {
-            interface Static {
-                type: "static";
-                weight: number;
-            }
-            interface TrainingTable {
-                type: "training_table";
-                base_weight: number;
-                min_weight: number;
-                max_weight: number;
-            }
+    type OutputMode = "instruction" | "json_schema" | "tool_call";
+    function list(openai: OpenAI, listOptions?: Models.ListOptions, options?: OpenAI.RequestOptions): Promise<{
+        data: string[];
+    }>;
+    function count(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<{
+        data: number;
+    }>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<ScoreLlmWithoutIndices>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<ScoreLlmWithoutIndicesWithMetadata>;
+    function retrieveValidate(openai: OpenAI, model: ScoreLlmBase, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<ScoreLlmWithoutIndices>;
+    function retrieveValidate(openai: OpenAI, model: ScoreLlmBase, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<ScoreLlmWithoutIndicesWithMetadata>;
+}
+export interface ScoreModelBase {
+    llms: ScoreLlmBase[];
+    weight: ScoreModel.Weight;
+}
+export interface ScoreModel {
+    id: string;
+    training_table_id?: string;
+    llms: ScoreLlm[];
+    weight: ScoreModel.Weight;
+}
+export interface ScoreModelWithMetadata extends ScoreModel {
+    created: string;
+    requests: number;
+    completion_tokens: number;
+    prompt_tokens: number;
+    total_cost: number;
+}
+export declare namespace ScoreModel {
+    type Weight = Weight.Static | Weight.TrainingTable;
+    namespace Weight {
+        interface Static {
+            type: "static";
+        }
+        interface TrainingTable {
+            type: "training_table";
+            embeddings: {
+                model: string;
+                max_tokens: number;
+                provider?: Chat.Completions.Request.ProviderPreferences | null;
+            };
+            top: number;
         }
-        function retrieve(openai: OpenAI, model: string, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<QueryLlmWithoutIndices>;
-        function retrieve(openai: OpenAI, model: string, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<QueryLlmWithoutIndicesWithMetadata>;
-        function retrieveValidate(openai: OpenAI, model: QueryLlmBase, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<QueryLlmWithoutIndices>;
-        function retrieveValidate(openai: OpenAI, model: QueryLlmBase, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<QueryLlmWithoutIndicesWithMetadata>;
     }
     function list(openai: OpenAI, listOptions?: Models.ListOptions, options?: OpenAI.RequestOptions): Promise<{
         data: string[];
@@ -1225,10 +870,10 @@ export declare namespace QueryModel {
     function count(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<{
         count: number;
     }>;
-    function retrieve(openai: OpenAI, model: string, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<QueryModel>;
-    function retrieve(openai: OpenAI, model: string, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<QueryModelWithMetadata>;
-    function retrieveValidate(openai: OpenAI, model: QueryModelBase, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<QueryModel>;
-    function retrieveValidate(openai: OpenAI, model: QueryModelBase, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<QueryModelWithMetadata>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<ScoreModel>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<ScoreModelWithMetadata>;
+    function retrieveValidate(openai: OpenAI, model: ScoreModelBase, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<ScoreModel>;
+    function retrieveValidate(openai: OpenAI, model: ScoreModelBase, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<ScoreModelWithMetadata>;
 }
 export type JsonValue = null | boolean | number | string | JsonValue[] | {
     [key: string]: JsonValue;