objectiveai 1.0.3 → 1.1.0

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 {
@@ -503,24 +503,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: string[];
             }
             interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
                 stream: true;
@@ -529,7 +523,7 @@ export declare namespace Query {
                 stream?: false | null;
             }
             type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
-            type Model = string | QueryModelBase;
+            type Model = string | ScoreModelBase;
         }
         namespace Response {
             namespace Streaming {
@@ -539,33 +533,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 +569,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 +623,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 +631,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 +760,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 interface ScoreLlm extends ScoreLlmWithoutIndices {
+    index: number;
+    training_table_index?: number;
 }
-export declare namespace QueryModel {
+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 +877,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;