objectiveai 1.1.2 → 1.1.4

package/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScoreModel = exports.ScoreLlm = exports.Metadata = exports.Auth = exports.Models = exports.Score = exports.Chat = void 0;
+exports.MultichatModel = exports.ScoreModel = exports.MultichatLlm = exports.ScoreLlm = exports.Metadata = exports.Auth = exports.Models = exports.Conversation = exports.Multichat = exports.Score = exports.Chat = void 0;
 var Chat;
 (function (Chat) {
     let Completions;
@@ -537,6 +537,132 @@ var Score;
         Completions.create = create;
     })(Completions = Score.Completions || (Score.Completions = {}));
 })(Score || (exports.Score = Score = {}));
+var Multichat;
+(function (Multichat) {
+    let Completions;
+    (function (Completions) {
+        let Response;
+        (function (Response) {
+            let Streaming;
+            (function (Streaming) {
+                let ChatCompletionChunk;
+                (function (ChatCompletionChunk) {
+                    function merged(a, b) {
+                        const id = a.id;
+                        const [choices, choicesChanged] = Choice.mergedList(a.choices, b.choices);
+                        const created = a.created;
+                        const model = a.model;
+                        const object = a.object;
+                        const [usage, usageChanged] = merge(a.usage, b.usage, Chat.Completions.Response.Usage.merged);
+                        if (choicesChanged || usageChanged) {
+                            return [
+                                Object.assign({ id,
+                                    choices,
+                                    created,
+                                    model,
+                                    object }, (usage !== undefined ? { usage } : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    ChatCompletionChunk.merged = merged;
+                })(ChatCompletionChunk = Streaming.ChatCompletionChunk || (Streaming.ChatCompletionChunk = {}));
+                let Choice;
+                (function (Choice) {
+                    function merged(a, b) {
+                        const [delta, deltaChanged] = merge(a.delta, b.delta, Chat.Completions.Response.Streaming.Delta.merged);
+                        const [finish_reason, finish_reasonChanged] = merge(a.finish_reason, b.finish_reason);
+                        const index = a.index;
+                        const [logprobs, logprobsChanged] = merge(a.logprobs, b.logprobs, Chat.Completions.Response.Logprobs.merged);
+                        const [error, errorChanged] = merge(a.error, b.error);
+                        const [model, modelChanged] = merge(a.model, b.model);
+                        const [model_index, model_indexChanged] = merge(a.model_index, b.model_index);
+                        const [completion_metadata, completion_metadataChanged] = merge(a.completion_metadata, b.completion_metadata, Score.Completions.Response.CompletionMetadata.merged);
+                        if (deltaChanged ||
+                            finish_reasonChanged ||
+                            logprobsChanged ||
+                            errorChanged ||
+                            modelChanged ||
+                            model_indexChanged ||
+                            completion_metadataChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ delta,
+                                    finish_reason,
+                                    index }, (logprobs !== undefined ? { logprobs } : {})), (error !== undefined ? { error } : {})), (model !== undefined ? { model } : {})), (model_index !== undefined ? { model_index } : {})), (completion_metadata !== undefined
+                                    ? { completion_metadata }
+                                    : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    Choice.merged = merged;
+                    function mergedList(a, b) {
+                        let merged = undefined;
+                        for (const choice of b) {
+                            const existingIndex = a.findIndex(({ index }) => index === choice.index);
+                            if (existingIndex === -1) {
+                                if (merged === undefined) {
+                                    merged = [...a, choice];
+                                }
+                                else {
+                                    merged.push(choice);
+                                }
+                            }
+                            else {
+                                const [mergedChoice, choiceChanged] = Choice.merged(a[existingIndex], choice);
+                                if (choiceChanged) {
+                                    if (merged === undefined) {
+                                        merged = [...a];
+                                    }
+                                    merged[existingIndex] = mergedChoice;
+                                }
+                            }
+                        }
+                        return merged ? [merged, true] : [a, false];
+                    }
+                    Choice.mergedList = mergedList;
+                })(Choice = Streaming.Choice || (Streaming.Choice = {}));
+            })(Streaming = Response.Streaming || (Response.Streaming = {}));
+        })(Response = Completions.Response || (Completions.Response = {}));
+        async function list(openai, listOptions, options) {
+            const response = await openai.get("/multichat/completions", Object.assign({ query: listOptions }, options));
+            return response;
+        }
+        Completions.list = list;
+        async function publish(openai, id, options) {
+            await openai.post(`/multichat/completions/${id}/publish`, options);
+        }
+        Completions.publish = publish;
+        async function retrieve(openai, id, options) {
+            const response = await openai.get(`/multichat/completions/${id}`, options);
+            return response;
+        }
+        Completions.retrieve = retrieve;
+        async function create(openai, body, options) {
+            var _a;
+            const response = await openai.post("/multichat/completions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+            return response;
+        }
+        Completions.create = create;
+    })(Completions = Multichat.Completions || (Multichat.Completions = {}));
+})(Multichat || (exports.Multichat = Multichat = {}));
+var Conversation;
+(function (Conversation) {
+    let Completions;
+    (function (Completions) {
+        async function list(openai, listOptions, options) {
+            const response = await openai.get("/conversation/completions", Object.assign({ query: listOptions }, options));
+            return response;
+        }
+        Completions.list = list;
+    })(Completions = Conversation.Completions || (Conversation.Completions = {}));
+})(Conversation || (exports.Conversation = Conversation = {}));
 var Models;
 (function (Models) {
     async function list(openai, listOptions, options) {
@@ -636,6 +762,29 @@ var ScoreLlm;
     }
     ScoreLlm.retrieveValidate = retrieveValidate;
 })(ScoreLlm || (exports.ScoreLlm = ScoreLlm = {}));
+var MultichatLlm;
+(function (MultichatLlm) {
+    async function list(openai, listOptions, options) {
+        const response = await openai.get("/multichat/llms", Object.assign({ query: listOptions }, options));
+        return response;
+    }
+    MultichatLlm.list = list;
+    async function count(openai, options) {
+        const response = await openai.get("/multichat/llms/count", options);
+        return response;
+    }
+    MultichatLlm.count = count;
+    async function retrieve(openai, model, retrieveOptions, options) {
+        const response = await openai.get(`/multichat/llms/${model}`, Object.assign({ query: retrieveOptions }, options));
+        return response;
+    }
+    MultichatLlm.retrieve = retrieve;
+    async function retrieveValidate(openai, model, retrieveOptions, options) {
+        const response = await openai.post("/multichat/llms", Object.assign({ query: retrieveOptions, body: model }, options));
+        return response;
+    }
+    MultichatLlm.retrieveValidate = retrieveValidate;
+})(MultichatLlm || (exports.MultichatLlm = MultichatLlm = {}));
 var ScoreModel;
 (function (ScoreModel) {
     async function list(openai, listOptions, options) {
@@ -659,6 +808,29 @@ var ScoreModel;
     }
     ScoreModel.retrieveValidate = retrieveValidate;
 })(ScoreModel || (exports.ScoreModel = ScoreModel = {}));
+var MultichatModel;
+(function (MultichatModel) {
+    async function list(openai, listOptions, options) {
+        const response = await openai.get("/multichat/models", Object.assign({ query: listOptions }, options));
+        return response;
+    }
+    MultichatModel.list = list;
+    async function count(openai, options) {
+        const response = await openai.get("/multichat/models/count", options);
+        return response;
+    }
+    MultichatModel.count = count;
+    async function retrieve(openai, model, retrieveOptions, options) {
+        const response = await openai.get(`/multichat/models/${model}`, Object.assign({ query: retrieveOptions }, options));
+        return response;
+    }
+    MultichatModel.retrieve = retrieve;
+    async function retrieveValidate(openai, model, retrieveOptions, options) {
+        const response = await openai.post("/multichat/models", Object.assign({ query: retrieveOptions, body: model }, options));
+        return response;
+    }
+    MultichatModel.retrieveValidate = retrieveValidate;
+})(MultichatModel || (exports.MultichatModel = MultichatModel = {}));
 function merge(a, b, combine) {
     if (a !== null && a !== undefined && b !== null && b !== undefined) {
         return combine ? combine(a, b) : [a, false];

package/dist/index.d.ts

@@ -132,7 +132,7 @@ export declare namespace Chat {
                     }
                 }
             }
-            type Message = Message.Developer | Message.System | Message.User | Message.Assistant | Message.Tool | Message.ChatCompletion | Message.ScoreCompletion;
+            type Message = Message.Developer | Message.System | Message.User | Message.Assistant | Message.Tool | Message.ChatCompletion | Message.ScoreCompletion | Message.MultichatCompletion;
             namespace Message {
                 type SimpleContent = string | SimpleContentPart[];
                 interface SimpleContentPart {
@@ -243,6 +243,12 @@ export declare namespace Chat {
                     choice_index: number;
                     name?: string | null;
                 }
+                interface MultichatCompletion {
+                    role: "multichat_completion";
+                    id: string;
+                    choice_index: number;
+                    name?: string | null;
+                }
             }
             interface ProviderPreferences {
                 order?: string[] | null;
@@ -505,7 +511,7 @@ export declare namespace Score {
             }
             type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
             type Model = string | ScoreModelBase;
-            type Choice = string | Choice.ChatCompletion | Choice.ScoreCompletion;
+            type Choice = string | Chat.Completions.Response.Unary.Message | Choice.ChatCompletion | Choice.ScoreCompletion | Choice.MultichatCompletion;
             namespace Choice {
                 interface ChatCompletion {
                     type: "chat_completion";
@@ -517,6 +523,11 @@ export declare namespace Score {
                     id: string;
                     choice_index: number;
                 }
+                interface MultichatCompletion {
+                    type: "multichat_completion";
+                    id: string;
+                    choice_index: number;
+                }
             }
         }
         namespace Response {
@@ -618,12 +629,7 @@ export declare namespace Score {
                 function merged(a: CompletionMetadata, b: CompletionMetadata): [CompletionMetadata, boolean];
             }
         }
-        interface ListOptions extends Chat.Completions.ListOptions {
-            count?: number | null;
-            offset?: number | null;
-            chat_filter?: boolean | null;
-        }
-        function list(openai: OpenAI, listOptions?: ListOptions, options?: OpenAI.RequestOptions): Promise<{
+        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>;
@@ -639,6 +645,99 @@ export declare namespace Score {
         function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
     }
 }
+export declare namespace Multichat {
+    namespace Completions {
+        namespace Request {
+            interface ChatCompletionCreateParamsBase {
+                messages: Chat.Completions.Request.Message[];
+                model: Model;
+                seed?: number | null;
+                service_tier?: Chat.Completions.Request.ServiceTier | null;
+                stream_options?: Chat.Completions.Request.StreamOptions | null;
+                tools?: Chat.Completions.Request.Tool[] | null;
+                usage?: Chat.Completions.Request.Usage | null;
+                response_format?: Chat.Completions.Request.ResponseFormat | null;
+            }
+            interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
+                stream: true;
+            }
+            interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
+                stream?: false | null;
+            }
+            type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
+            type Model = string | MultichatModelBase;
+        }
+        namespace Response {
+            namespace Streaming {
+                interface ChatCompletionChunk {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: string;
+                    object: "chat.completion.chunk";
+                    usage?: Chat.Completions.Response.Usage;
+                }
+                namespace ChatCompletionChunk {
+                    function merged(a: ChatCompletionChunk, b: ChatCompletionChunk): [ChatCompletionChunk, boolean];
+                }
+                interface Choice {
+                    delta: Chat.Completions.Response.Streaming.Delta;
+                    finish_reason: Chat.Completions.Response.FinishReason | null;
+                    index: number;
+                    logprobs?: Chat.Completions.Response.Logprobs;
+                    error?: ObjectiveAIError;
+                    model?: string;
+                    model_index?: number | null;
+                    completion_metadata?: Score.Completions.Response.CompletionMetadata;
+                }
+                namespace Choice {
+                    function merged(a: Choice, b: Choice): [Choice, boolean];
+                    function mergedList(a: Choice[], b: Choice[]): [Choice[], boolean];
+                }
+            }
+            namespace Unary {
+                interface ChatCompletion {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: string;
+                    object: "chat.completion";
+                    usage?: Chat.Completions.Response.Usage;
+                }
+                interface Choice {
+                    message: Chat.Completions.Response.Unary.Message;
+                    finish_reason: Chat.Completions.Response.FinishReason;
+                    index: number;
+                    logprobs: Chat.Completions.Response.Logprobs | null;
+                    error: ObjectiveAIError | null;
+                    model: string | null;
+                    model_index: number | null;
+                    completion_metadata: Score.Completions.Response.CompletionMetadata | null;
+                }
+            }
+        }
+        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 Conversation {
+    namespace Completions {
+        interface ListItem extends Chat.Completions.ListItem {
+            type: "score" | "multichat";
+        }
+        function list(openai: OpenAI, listOptions?: Chat.Completions.ListOptions, options?: OpenAI.RequestOptions): Promise<{
+            data: ListItem[];
+        }>;
+    }
+}
 export declare namespace Models {
     interface Model {
         id: string;
@@ -767,6 +866,10 @@ export interface Metadata {
     chat_completion_tokens: number;
     chat_prompt_tokens: number;
     chat_total_cost: number;
+    multichat_requests: number;
+    multichat_completion_tokens: number;
+    multichat_prompt_tokens: number;
+    multichat_total_cost: number;
 }
 export declare namespace Metadata {
     function get(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<Metadata>;
@@ -798,6 +901,7 @@ export interface ScoreLlmBase {
 }
 export interface ScoreLlmWithoutIndices extends ScoreLlmBase {
     id: string;
+    multichat_id: string;
     training_table_id?: string;
 }
 export interface ScoreLlmWithoutIndicesWithMetadata extends ScoreLlmWithoutIndices {
@@ -809,6 +913,7 @@ export interface ScoreLlmWithoutIndicesWithMetadata extends ScoreLlmWithoutIndic
 }
 export interface ScoreLlm extends ScoreLlmWithoutIndices {
     index: number;
+    multichat_index: number;
     training_table_index?: number;
 }
 export declare namespace ScoreLlm {
@@ -837,12 +942,29 @@ export declare namespace ScoreLlm {
     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 type MultichatLlmBase = ScoreLlmBase;
+export type MultichatLlmWithoutIndices = ScoreLlmWithoutIndices;
+export type MultichatLlmWithoutIndicesWithMetadata = ScoreLlmWithoutIndicesWithMetadata;
+export type MultichatLlm = ScoreLlm;
+export declare namespace MultichatLlm {
+    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;
+    multichat_id: string;
     training_table_id?: string;
     llms: ScoreLlm[];
     weight: ScoreModel.Weight;
@@ -881,6 +1003,21 @@ export declare namespace ScoreModel {
     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 MultichatModelBase = ScoreModelBase;
+export type MultichatModel = ScoreModel;
+export type MultichatModelWithMetadata = ScoreModelWithMetadata;
+export declare namespace MultichatModel {
+    function list(openai: OpenAI, listOptions?: Models.ListOptions, options?: OpenAI.RequestOptions): Promise<{
+        data: string[];
+    }>;
+    function count(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<{
+        count: number;
+    }>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<MultichatModel>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<MultichatModelWithMetadata>;
+    function retrieveValidate(openai: OpenAI, model: MultichatModelBase, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<MultichatModel>;
+    function retrieveValidate(openai: OpenAI, model: MultichatModelBase, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<MultichatModelWithMetadata>;
+}
 export type JsonValue = null | boolean | number | string | JsonValue[] | {
     [key: string]: JsonValue;
 };

package/dist/index.js

@@ -534,6 +534,132 @@ export var Score;
         Completions.create = create;
     })(Completions = Score.Completions || (Score.Completions = {}));
 })(Score || (Score = {}));
+export var Multichat;
+(function (Multichat) {
+    let Completions;
+    (function (Completions) {
+        let Response;
+        (function (Response) {
+            let Streaming;
+            (function (Streaming) {
+                let ChatCompletionChunk;
+                (function (ChatCompletionChunk) {
+                    function merged(a, b) {
+                        const id = a.id;
+                        const [choices, choicesChanged] = Choice.mergedList(a.choices, b.choices);
+                        const created = a.created;
+                        const model = a.model;
+                        const object = a.object;
+                        const [usage, usageChanged] = merge(a.usage, b.usage, Chat.Completions.Response.Usage.merged);
+                        if (choicesChanged || usageChanged) {
+                            return [
+                                Object.assign({ id,
+                                    choices,
+                                    created,
+                                    model,
+                                    object }, (usage !== undefined ? { usage } : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    ChatCompletionChunk.merged = merged;
+                })(ChatCompletionChunk = Streaming.ChatCompletionChunk || (Streaming.ChatCompletionChunk = {}));
+                let Choice;
+                (function (Choice) {
+                    function merged(a, b) {
+                        const [delta, deltaChanged] = merge(a.delta, b.delta, Chat.Completions.Response.Streaming.Delta.merged);
+                        const [finish_reason, finish_reasonChanged] = merge(a.finish_reason, b.finish_reason);
+                        const index = a.index;
+                        const [logprobs, logprobsChanged] = merge(a.logprobs, b.logprobs, Chat.Completions.Response.Logprobs.merged);
+                        const [error, errorChanged] = merge(a.error, b.error);
+                        const [model, modelChanged] = merge(a.model, b.model);
+                        const [model_index, model_indexChanged] = merge(a.model_index, b.model_index);
+                        const [completion_metadata, completion_metadataChanged] = merge(a.completion_metadata, b.completion_metadata, Score.Completions.Response.CompletionMetadata.merged);
+                        if (deltaChanged ||
+                            finish_reasonChanged ||
+                            logprobsChanged ||
+                            errorChanged ||
+                            modelChanged ||
+                            model_indexChanged ||
+                            completion_metadataChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ delta,
+                                    finish_reason,
+                                    index }, (logprobs !== undefined ? { logprobs } : {})), (error !== undefined ? { error } : {})), (model !== undefined ? { model } : {})), (model_index !== undefined ? { model_index } : {})), (completion_metadata !== undefined
+                                    ? { completion_metadata }
+                                    : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    Choice.merged = merged;
+                    function mergedList(a, b) {
+                        let merged = undefined;
+                        for (const choice of b) {
+                            const existingIndex = a.findIndex(({ index }) => index === choice.index);
+                            if (existingIndex === -1) {
+                                if (merged === undefined) {
+                                    merged = [...a, choice];
+                                }
+                                else {
+                                    merged.push(choice);
+                                }
+                            }
+                            else {
+                                const [mergedChoice, choiceChanged] = Choice.merged(a[existingIndex], choice);
+                                if (choiceChanged) {
+                                    if (merged === undefined) {
+                                        merged = [...a];
+                                    }
+                                    merged[existingIndex] = mergedChoice;
+                                }
+                            }
+                        }
+                        return merged ? [merged, true] : [a, false];
+                    }
+                    Choice.mergedList = mergedList;
+                })(Choice = Streaming.Choice || (Streaming.Choice = {}));
+            })(Streaming = Response.Streaming || (Response.Streaming = {}));
+        })(Response = Completions.Response || (Completions.Response = {}));
+        async function list(openai, listOptions, options) {
+            const response = await openai.get("/multichat/completions", Object.assign({ query: listOptions }, options));
+            return response;
+        }
+        Completions.list = list;
+        async function publish(openai, id, options) {
+            await openai.post(`/multichat/completions/${id}/publish`, options);
+        }
+        Completions.publish = publish;
+        async function retrieve(openai, id, options) {
+            const response = await openai.get(`/multichat/completions/${id}`, options);
+            return response;
+        }
+        Completions.retrieve = retrieve;
+        async function create(openai, body, options) {
+            var _a;
+            const response = await openai.post("/multichat/completions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+            return response;
+        }
+        Completions.create = create;
+    })(Completions = Multichat.Completions || (Multichat.Completions = {}));
+})(Multichat || (Multichat = {}));
+export var Conversation;
+(function (Conversation) {
+    let Completions;
+    (function (Completions) {
+        async function list(openai, listOptions, options) {
+            const response = await openai.get("/conversation/completions", Object.assign({ query: listOptions }, options));
+            return response;
+        }
+        Completions.list = list;
+    })(Completions = Conversation.Completions || (Conversation.Completions = {}));
+})(Conversation || (Conversation = {}));
 export var Models;
 (function (Models) {
     async function list(openai, listOptions, options) {
@@ -633,6 +759,29 @@ export var ScoreLlm;
     }
     ScoreLlm.retrieveValidate = retrieveValidate;
 })(ScoreLlm || (ScoreLlm = {}));
+export var MultichatLlm;
+(function (MultichatLlm) {
+    async function list(openai, listOptions, options) {
+        const response = await openai.get("/multichat/llms", Object.assign({ query: listOptions }, options));
+        return response;
+    }
+    MultichatLlm.list = list;
+    async function count(openai, options) {
+        const response = await openai.get("/multichat/llms/count", options);
+        return response;
+    }
+    MultichatLlm.count = count;
+    async function retrieve(openai, model, retrieveOptions, options) {
+        const response = await openai.get(`/multichat/llms/${model}`, Object.assign({ query: retrieveOptions }, options));
+        return response;
+    }
+    MultichatLlm.retrieve = retrieve;
+    async function retrieveValidate(openai, model, retrieveOptions, options) {
+        const response = await openai.post("/multichat/llms", Object.assign({ query: retrieveOptions, body: model }, options));
+        return response;
+    }
+    MultichatLlm.retrieveValidate = retrieveValidate;
+})(MultichatLlm || (MultichatLlm = {}));
 export var ScoreModel;
 (function (ScoreModel) {
     async function list(openai, listOptions, options) {
@@ -656,6 +805,29 @@ export var ScoreModel;
     }
     ScoreModel.retrieveValidate = retrieveValidate;
 })(ScoreModel || (ScoreModel = {}));
+export var MultichatModel;
+(function (MultichatModel) {
+    async function list(openai, listOptions, options) {
+        const response = await openai.get("/multichat/models", Object.assign({ query: listOptions }, options));
+        return response;
+    }
+    MultichatModel.list = list;
+    async function count(openai, options) {
+        const response = await openai.get("/multichat/models/count", options);
+        return response;
+    }
+    MultichatModel.count = count;
+    async function retrieve(openai, model, retrieveOptions, options) {
+        const response = await openai.get(`/multichat/models/${model}`, Object.assign({ query: retrieveOptions }, options));
+        return response;
+    }
+    MultichatModel.retrieve = retrieve;
+    async function retrieveValidate(openai, model, retrieveOptions, options) {
+        const response = await openai.post("/multichat/models", Object.assign({ query: retrieveOptions, body: model }, options));
+        return response;
+    }
+    MultichatModel.retrieveValidate = retrieveValidate;
+})(MultichatModel || (MultichatModel = {}));
 function merge(a, b, combine) {
     if (a !== null && a !== undefined && b !== null && b !== undefined) {
         return combine ? combine(a, b) : [a, false];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objectiveai",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "SDK for the ObjectiveAI API.",
   "main": "dist/index.js",
   "repository": {