objectiveai 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryModel = exports.Metadata = exports.Auth = exports.Models = exports.QueryChat = exports.QueryTool = exports.Query = exports.Chat = void 0;
+var Chat;
+(function (Chat) {
+    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 [service_tier, service_tierChanged] = merge(a.service_tier, b.service_tier);
+                        const [system_fingerprint, system_fingerprintChanged] = merge(a.system_fingerprint, b.system_fingerprint);
+                        const [usage, usageChanged] = merge(a.usage, b.usage, Usage.merged);
+                        const [provider, providerChanged] = merge(a.provider, b.provider);
+                        if (choicesChanged ||
+                            service_tierChanged ||
+                            system_fingerprintChanged ||
+                            usageChanged ||
+                            providerChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign({ id,
+                                    choices,
+                                    created,
+                                    model,
+                                    object }, (service_tier !== undefined ? { service_tier } : {})), (system_fingerprint !== undefined
+                                    ? { system_fingerprint }
+                                    : {})), (usage !== undefined ? { usage } : {})), (provider !== undefined ? { provider } : {})),
+                                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, 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, Logprobs.merged);
+                        if (deltaChanged || finish_reasonChanged || logprobsChanged) {
+                            return [
+                                Object.assign({ delta,
+                                    finish_reason,
+                                    index }, (logprobs !== undefined ? { logprobs } : {})),
+                                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 = {}));
+                let Delta;
+                (function (Delta) {
+                    function merged(a, b) {
+                        const [content, contentChanged] = merge(a.content, b.content, mergedString);
+                        const [refusal, refusalChanged] = merge(a.refusal, b.refusal, mergedString);
+                        const [role, roleChanged] = merge(a.role, b.role);
+                        const [tool_calls, tool_callsChanged] = merge(a.tool_calls, b.tool_calls, ToolCall.mergedList);
+                        const [reasoning, reasoningChanged] = merge(a.reasoning, b.reasoning, mergedString);
+                        const [images, imagesChanged] = merge(a.images, b.images, Image.mergedList);
+                        if (contentChanged ||
+                            reasoningChanged ||
+                            refusalChanged ||
+                            roleChanged ||
+                            tool_callsChanged ||
+                            imagesChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (content !== undefined ? { content } : {})), (reasoning !== undefined ? { reasoning } : {})), (refusal !== undefined ? { refusal } : {})), (role !== undefined ? { role } : {})), (tool_calls !== undefined ? { tool_calls } : {})), (images !== undefined ? { images } : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    Delta.merged = merged;
+                })(Delta = Streaming.Delta || (Streaming.Delta = {}));
+                let ToolCall;
+                (function (ToolCall) {
+                    function merged(a, b) {
+                        return Function.merged(a, b);
+                    }
+                    ToolCall.merged = merged;
+                    function mergedList(a, b) {
+                        let merged = undefined;
+                        for (const toolCall of b) {
+                            const existingIndex = a.findIndex(({ index }) => index === toolCall.index);
+                            if (existingIndex === -1) {
+                                if (merged === undefined) {
+                                    merged = [...a, toolCall];
+                                }
+                                else {
+                                    merged.push(toolCall);
+                                }
+                            }
+                            else {
+                                const [mergedToolCall, toolCallChanged] = ToolCall.merged(a[existingIndex], toolCall);
+                                if (toolCallChanged) {
+                                    if (merged === undefined) {
+                                        merged = [...a];
+                                    }
+                                    merged[existingIndex] = mergedToolCall;
+                                }
+                            }
+                        }
+                        return merged ? [merged, true] : [a, false];
+                    }
+                    ToolCall.mergedList = mergedList;
+                    let Function;
+                    (function (Function) {
+                        function merged(a, b) {
+                            const index = a.index;
+                            const [id, idChanged] = merge(a.id, b.id);
+                            const [function_, functionChanged] = merge(a.function, b.function, Definition.merged);
+                            const [type, typeChanged] = merge(a.type, b.type);
+                            if (idChanged || functionChanged || typeChanged) {
+                                return [
+                                    Object.assign(Object.assign(Object.assign({ index }, (id !== undefined ? { id } : {})), (function_ !== undefined ? { function: function_ } : {})), (type !== undefined ? { type } : {})),
+                                    true,
+                                ];
+                            }
+                            else {
+                                return [a, false];
+                            }
+                        }
+                        Function.merged = merged;
+                        let Definition;
+                        (function (Definition) {
+                            function merged(a, b) {
+                                const [name, nameChanged] = merge(a.name, b.name);
+                                const [arguments_, argumentsChanged] = merge(a.arguments, b.arguments, mergedString);
+                                if (nameChanged || argumentsChanged) {
+                                    return [
+                                        Object.assign(Object.assign({}, (name !== undefined ? { name } : {})), (arguments_ !== undefined
+                                            ? { arguments: arguments_ }
+                                            : {})),
+                                        true,
+                                    ];
+                                }
+                                else {
+                                    return [a, false];
+                                }
+                            }
+                            Definition.merged = merged;
+                        })(Definition = Function.Definition || (Function.Definition = {}));
+                    })(Function = ToolCall.Function || (ToolCall.Function = {}));
+                })(ToolCall = Streaming.ToolCall || (Streaming.ToolCall = {}));
+            })(Streaming = Response.Streaming || (Response.Streaming = {}));
+            let Usage;
+            (function (Usage) {
+                function merged(a, b) {
+                    const [completion_tokens, completion_tokensChanged] = merge(a.completion_tokens, b.completion_tokens, mergedNumber);
+                    const [prompt_tokens, prompt_tokensChanged] = merge(a.prompt_tokens, b.prompt_tokens, mergedNumber);
+                    const [total_tokens, total_tokensChanged] = merge(a.total_tokens, b.total_tokens, mergedNumber);
+                    const [completion_tokens_details, completion_tokens_detailsChanged] = merge(a.completion_tokens_details, b.completion_tokens_details, CompletionTokensDetails.merged);
+                    const [prompt_tokens_details, prompt_tokens_detailsChanged] = merge(a.prompt_tokens_details, b.prompt_tokens_details, PromptTokensDetails.merged);
+                    const [cost, costChanged] = merge(a.cost, b.cost, mergedNumber);
+                    const [cost_details, cost_detailsChanged] = merge(a.cost_details, b.cost_details, CostDetails.merged);
+                    if (completion_tokensChanged ||
+                        prompt_tokensChanged ||
+                        total_tokensChanged ||
+                        completion_tokens_detailsChanged ||
+                        prompt_tokens_detailsChanged ||
+                        costChanged ||
+                        cost_detailsChanged) {
+                        return [
+                            Object.assign(Object.assign(Object.assign(Object.assign({ completion_tokens,
+                                prompt_tokens,
+                                total_tokens }, (completion_tokens_details !== undefined
+                                ? { completion_tokens_details }
+                                : {})), (prompt_tokens_details !== undefined
+                                ? { prompt_tokens_details }
+                                : {})), (cost !== undefined ? { cost } : {})), (cost_details !== undefined ? { cost_details } : {})),
+                            true,
+                        ];
+                    }
+                    else {
+                        return [a, false];
+                    }
+                }
+                Usage.merged = merged;
+                let CompletionTokensDetails;
+                (function (CompletionTokensDetails) {
+                    function merged(a, b) {
+                        const [accepted_prediction_tokens, accepted_prediction_tokensChanged,] = merge(a.accepted_prediction_tokens, b.accepted_prediction_tokens, mergedNumber);
+                        const [audio_tokens, audio_tokensChanged] = merge(a.audio_tokens, b.audio_tokens, mergedNumber);
+                        const [reasoning_tokens, reasoning_tokensChanged] = merge(a.reasoning_tokens, b.reasoning_tokens, mergedNumber);
+                        const [rejected_prediction_tokens, rejected_prediction_tokensChanged,] = merge(a.rejected_prediction_tokens, b.rejected_prediction_tokens, mergedNumber);
+                        if (accepted_prediction_tokensChanged ||
+                            audio_tokensChanged ||
+                            reasoning_tokensChanged ||
+                            rejected_prediction_tokensChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign({}, (accepted_prediction_tokens !== undefined
+                                    ? { accepted_prediction_tokens }
+                                    : {})), (audio_tokens !== undefined ? { audio_tokens } : {})), (reasoning_tokens !== undefined
+                                    ? { reasoning_tokens }
+                                    : {})), (rejected_prediction_tokens !== undefined
+                                    ? { rejected_prediction_tokens }
+                                    : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    CompletionTokensDetails.merged = merged;
+                })(CompletionTokensDetails = Usage.CompletionTokensDetails || (Usage.CompletionTokensDetails = {}));
+                let PromptTokensDetails;
+                (function (PromptTokensDetails) {
+                    function merged(a, b) {
+                        const [audio_tokens, audio_tokensChanged] = merge(a.audio_tokens, b.audio_tokens, mergedNumber);
+                        const [cached_tokens, cached_tokensChanged] = merge(a.cached_tokens, b.cached_tokens, mergedNumber);
+                        if (audio_tokensChanged || cached_tokensChanged) {
+                            return [
+                                Object.assign(Object.assign({}, (audio_tokens !== undefined ? { audio_tokens } : {})), (cached_tokens !== undefined ? { cached_tokens } : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    PromptTokensDetails.merged = merged;
+                })(PromptTokensDetails = Usage.PromptTokensDetails || (Usage.PromptTokensDetails = {}));
+                let CostDetails;
+                (function (CostDetails) {
+                    function merged(a, b) {
+                        const [upstream_inference_cost, upstream_inference_costChanged] = merge(a.upstream_inference_cost, b.upstream_inference_cost, mergedNumber);
+                        const [upstream_upstream_inference_cost, upstream_upstream_inference_costChanged,] = merge(a.upstream_upstream_inference_cost, b.upstream_upstream_inference_cost, mergedNumber);
+                        if (upstream_inference_costChanged ||
+                            upstream_upstream_inference_costChanged) {
+                            return [
+                                Object.assign(Object.assign({}, (upstream_inference_cost !== undefined
+                                    ? { upstream_inference_cost }
+                                    : {})), (upstream_upstream_inference_cost !== undefined
+                                    ? { upstream_upstream_inference_cost }
+                                    : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    CostDetails.merged = merged;
+                })(CostDetails = Usage.CostDetails || (Usage.CostDetails = {}));
+            })(Usage = Response.Usage || (Response.Usage = {}));
+            let Logprobs;
+            (function (Logprobs) {
+                function merged(a, b) {
+                    const [content, contentChanged] = merge(a.content, b.content, Logprob.mergedList);
+                    const [refusal, refusalChanged] = merge(a.refusal, b.refusal, Logprob.mergedList);
+                    if (contentChanged || refusalChanged) {
+                        return [{ content, refusal }, true];
+                    }
+                    else {
+                        return [a, false];
+                    }
+                }
+                Logprobs.merged = merged;
+                let Logprob;
+                (function (Logprob) {
+                    function mergedList(a, b) {
+                        if (b.length === 0) {
+                            return [a, false];
+                        }
+                        else if (a.length === 0) {
+                            return [b, true];
+                        }
+                        else {
+                            return [[...a, ...b], true];
+                        }
+                    }
+                    Logprob.mergedList = mergedList;
+                })(Logprob = Logprobs.Logprob || (Logprobs.Logprob = {}));
+            })(Logprobs = Response.Logprobs || (Response.Logprobs = {}));
+            let Image;
+            (function (Image) {
+                function mergedList(a, b) {
+                    if (b.length === 0) {
+                        return [a, false];
+                    }
+                    else if (a.length === 0) {
+                        return [b, true];
+                    }
+                    else {
+                        return [[...a, ...b], true];
+                    }
+                }
+                Image.mergedList = mergedList;
+            })(Image = Response.Image || (Response.Image = {}));
+        })(Response = Completions.Response || (Completions.Response = {}));
+        async function list(openai, listOptions, options) {
+            const response = await openai.chat.completions.list(Object.assign({ query: listOptions }, options));
+            return response;
+        }
+        Completions.list = list;
+        async function publish(openai, id, options) {
+            await openai.post(`/chat/completions/${id}/publish`, options);
+        }
+        Completions.publish = publish;
+        async function retrieve(openai, id, options) {
+            const response = await openai.chat.completions.retrieve(id, options);
+            return response;
+        }
+        Completions.retrieve = retrieve;
+        async function create(openai, body, options) {
+            var _a;
+            const response = await openai.post("/chat/completions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+            return response;
+        }
+        Completions.create = create;
+    })(Completions = Chat.Completions || (Chat.Completions = {}));
+})(Chat || (exports.Chat = Chat = {}));
+var Query;
+(function (Query) {
+    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 [service_tier, service_tierChanged] = merge(a.service_tier, b.service_tier);
+                        const [system_fingerprint, system_fingerprintChanged] = merge(a.system_fingerprint, b.system_fingerprint);
+                        const [usage, usageChanged] = merge(a.usage, b.usage, Chat.Completions.Response.Usage.merged);
+                        const [training_table_data, training_table_dataChanged] = merge(a.training_table_data, b.training_table_data);
+                        if (choicesChanged ||
+                            service_tierChanged ||
+                            system_fingerprintChanged ||
+                            usageChanged ||
+                            training_table_dataChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign({ id,
+                                    choices,
+                                    created,
+                                    model,
+                                    object }, (service_tier !== undefined ? { service_tier } : {})), (system_fingerprint !== undefined
+                                    ? { system_fingerprint }
+                                    : {})), (usage !== undefined ? { usage } : {})), (training_table_data !== undefined
+                                    ? { training_table_data }
+                                    : {})),
+                                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 [generate_id, generate_idChanged] = merge(a.generate_id, b.generate_id);
+                        const [confidence_id, confidence_idChanged] = merge(a.confidence_id, b.confidence_id);
+                        const [confidence_weight, confidence_weightChanged] = merge(a.confidence_weight, b.confidence_weight);
+                        const [confidence, confidenceChanged] = merge(a.confidence, b.confidence);
+                        const [embedding, embeddingChanged] = merge(a.embedding, b.embedding);
+                        const [error, errorChanged] = merge(a.error, b.error);
+                        const model = a.model;
+                        const model_index = a.model_index;
+                        const [completion_metadata, completion_metadataChanged] = CompletionMetadata.merged(a.completion_metadata, b.completion_metadata);
+                        if (deltaChanged ||
+                            finish_reasonChanged ||
+                            logprobsChanged ||
+                            generate_idChanged ||
+                            confidence_idChanged ||
+                            confidence_weightChanged ||
+                            confidenceChanged ||
+                            embeddingChanged ||
+                            errorChanged ||
+                            completion_metadataChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ delta,
+                                    finish_reason,
+                                    index }, (logprobs !== undefined ? { logprobs } : {})), (generate_id !== undefined ? { generate_id } : {})), (confidence_id !== undefined ? { confidence_id } : {})), (confidence_weight !== undefined
+                                    ? { confidence_weight }
+                                    : {})), (confidence !== undefined ? { confidence } : {})), (embedding !== undefined ? { embedding } : {})), (error !== undefined ? { error } : {})), { model,
+                                    model_index,
+                                    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 = {}));
+            let CompletionMetadata;
+            (function (CompletionMetadata) {
+                function merged(a, b) {
+                    const id = a.id;
+                    const created = a.created;
+                    const model = a.model;
+                    const [service_tier, service_tierChanged] = merge(a.service_tier, b.service_tier);
+                    const [system_fingerprint, system_fingerprintChanged] = merge(a.system_fingerprint, b.system_fingerprint);
+                    const [usage, usageChanged] = merge(a.usage, b.usage, Chat.Completions.Response.Usage.merged);
+                    if (service_tierChanged ||
+                        system_fingerprintChanged ||
+                        usageChanged) {
+                        return [
+                            Object.assign(Object.assign(Object.assign({ id,
+                                created,
+                                model }, (service_tier !== undefined ? { service_tier } : {})), (system_fingerprint !== undefined
+                                ? { system_fingerprint }
+                                : {})), (usage !== undefined ? { usage } : {})),
+                            true,
+                        ];
+                    }
+                    else {
+                        return [a, false];
+                    }
+                }
+                CompletionMetadata.merged = merged;
+            })(CompletionMetadata = Response.CompletionMetadata || (Response.CompletionMetadata = {}));
+        })(Response = Completions.Response || (Completions.Response = {}));
+        async function list(openai, listOptions, options) {
+            const response = await openai.get("/query/completions", Object.assign({ query: listOptions }, options));
+            return response;
+        }
+        Completions.list = list;
+        async function publish(openai, id, options) {
+            await openai.post(`/query/completions/${id}/publish`, options);
+        }
+        Completions.publish = publish;
+        async function retrieve(openai, id, options) {
+            const response = await openai.get(`/query/completions/${id}`, options);
+            return response;
+        }
+        Completions.retrieve = retrieve;
+        async function trainingTableMark(openai, id, correctConfidenceId, options) {
+            await openai.post(`/query/completions/${id}/training_table`, Object.assign({ body: { correct_confidence_id: correctConfidenceId } }, options));
+        }
+        Completions.trainingTableMark = trainingTableMark;
+        async function trainingTableUnmark(openai, id, options) {
+            await openai.delete(`/query/completions/${id}/training_table`, options);
+        }
+        Completions.trainingTableUnmark = trainingTableUnmark;
+        async function create(openai, body, options) {
+            var _a;
+            const response = await openai.post("/query/completions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+            return response;
+        }
+        Completions.create = create;
+    })(Completions = Query.Completions || (Query.Completions = {}));
+})(Query || (exports.Query = Query = {}));
+var QueryTool;
+(function (QueryTool) {
+    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 [service_tier, service_tierChanged] = merge(a.service_tier, b.service_tier);
+                        const [system_fingerprint, system_fingerprintChanged] = merge(a.system_fingerprint, b.system_fingerprint);
+                        const [usage, usageChanged] = merge(a.usage, b.usage, Chat.Completions.Response.Usage.merged);
+                        if (choicesChanged ||
+                            service_tierChanged ||
+                            system_fingerprintChanged ||
+                            usageChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign({ id,
+                                    choices,
+                                    created,
+                                    model,
+                                    object }, (service_tier !== undefined ? { service_tier } : {})), (system_fingerprint !== undefined
+                                    ? { system_fingerprint }
+                                    : {})), (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, 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);
+                        if (deltaChanged || finish_reasonChanged || logprobsChanged) {
+                            return [
+                                Object.assign({ delta,
+                                    finish_reason,
+                                    index }, (logprobs !== undefined ? { logprobs } : {})),
+                                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 = {}));
+                let Delta;
+                (function (Delta) {
+                    function merged(a, b) {
+                        const [content, contentChanged] = merge(a.content, b.content, mergedString);
+                        const [reasoning, reasoningChanged] = merge(a.reasoning, b.reasoning, Reasoning.merged);
+                        const [refusal, refusalChanged] = merge(a.refusal, b.refusal, mergedString);
+                        const [role, roleChanged] = merge(a.role, b.role);
+                        const [tool_calls, tool_callsChanged] = merge(a.tool_calls, b.tool_calls, Chat.Completions.Response.Streaming.ToolCall.mergedList);
+                        if (contentChanged ||
+                            reasoningChanged ||
+                            refusalChanged ||
+                            roleChanged ||
+                            tool_callsChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (content !== undefined ? { content } : {})), (reasoning !== undefined ? { reasoning } : {})), (refusal !== undefined ? { refusal } : {})), (role !== undefined ? { role } : {})), (tool_calls !== undefined ? { tool_calls } : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    Delta.merged = merged;
+                })(Delta = Streaming.Delta || (Streaming.Delta = {}));
+                let Reasoning;
+                (function (Reasoning) {
+                    function merged(a, b) {
+                        let merged = undefined;
+                        if (Array.isArray(a)) {
+                            if (Array.isArray(b)) {
+                                for (const item of b) {
+                                    if (merged === undefined) {
+                                        const existingIndex = a.findIndex(({ index, type }) => index === item.index && type === item.type);
+                                        if (existingIndex === -1) {
+                                            merged = [...a, item];
+                                        }
+                                        else if (item.type === "query") {
+                                            const [mergedItem, itemChanged] = ReasoningCompletion.QueryCompletion.merged(a[existingIndex], item);
+                                            if (itemChanged) {
+                                                merged = [...a];
+                                                merged[existingIndex] = mergedItem;
+                                            }
+                                        }
+                                        else if (item.type === "chat") {
+                                            const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(a[existingIndex], item);
+                                            if (itemChanged) {
+                                                merged = [...a];
+                                                merged[existingIndex] = mergedItem;
+                                            }
+                                        }
+                                    }
+                                    else if (Array.isArray(merged) /* always true */) {
+                                        const existingIndex = merged.findIndex(({ index, type }) => index === item.index && type === item.type);
+                                        if (existingIndex === -1) {
+                                            merged.push(item);
+                                        }
+                                        else if (item.type === "query") {
+                                            const [mergedItem, itemChanged] = ReasoningCompletion.QueryCompletion.merged(merged[existingIndex], item);
+                                            if (itemChanged) {
+                                                merged[existingIndex] = mergedItem;
+                                            }
+                                        }
+                                        else if (item.type === "chat") {
+                                            const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(merged[existingIndex], item);
+                                            if (itemChanged) {
+                                                merged[existingIndex] = mergedItem;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                const existingIndex = a.findIndex(({ index, type }) => index === b.index && type === b.type);
+                                if (existingIndex === -1) {
+                                    merged = [...a, b];
+                                }
+                                else if (b.type === "query") {
+                                    const [mergedItem, itemChanged] = ReasoningCompletion.QueryCompletion.merged(a[existingIndex], b);
+                                    if (itemChanged) {
+                                        merged = [...a];
+                                        merged[existingIndex] = mergedItem;
+                                    }
+                                }
+                                else if (b.type === "chat") {
+                                    const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(a[existingIndex], b);
+                                    if (itemChanged) {
+                                        merged = [...a];
+                                        merged[existingIndex] = mergedItem;
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            if (Array.isArray(b)) {
+                                merged = [a];
+                                for (const item of b) {
+                                    const existingIndex = merged.findIndex(({ index, type }) => index === item.index && type === item.type);
+                                    if (existingIndex === -1) {
+                                        merged.push(item);
+                                    }
+                                    else if (item.type === "query") {
+                                        const [mergedItem, itemChanged] = ReasoningCompletion.QueryCompletion.merged(merged[existingIndex], item);
+                                        if (itemChanged) {
+                                            merged[existingIndex] = mergedItem;
+                                        }
+                                    }
+                                    else if (item.type === "chat") {
+                                        const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(merged[existingIndex], item);
+                                        if (itemChanged) {
+                                            merged[existingIndex] = mergedItem;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                if (a.index === b.index && a.type === b.type) {
+                                    if (b.type === "query") {
+                                        const [mergedItem, itemChanged] = ReasoningCompletion.QueryCompletion.merged(a, b);
+                                        if (itemChanged) {
+                                            merged = mergedItem;
+                                        }
+                                    }
+                                    else if (b.type === "chat") {
+                                        const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(a, b);
+                                        if (itemChanged) {
+                                            merged = mergedItem;
+                                        }
+                                    }
+                                }
+                                else {
+                                    merged = [a, b];
+                                }
+                            }
+                        }
+                        return merged ? [merged, true] : [a, false];
+                    }
+                    Reasoning.merged = merged;
+                })(Reasoning = Streaming.Reasoning || (Streaming.Reasoning = {}));
+                let ReasoningCompletion;
+                (function (ReasoningCompletion) {
+                    let QueryCompletion;
+                    (function (QueryCompletion) {
+                        function merged(a, b) {
+                            const [merged, changed] = Query.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
+                            return changed
+                                ? [Object.assign({ type: a.type, index: a.index }, merged), true]
+                                : [a, false];
+                        }
+                        QueryCompletion.merged = merged;
+                    })(QueryCompletion = ReasoningCompletion.QueryCompletion || (ReasoningCompletion.QueryCompletion = {}));
+                    let ChatCompletion;
+                    (function (ChatCompletion) {
+                        function merged(a, b) {
+                            const [merged, changed] = Chat.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
+                            return changed
+                                ? [Object.assign({ type: a.type, index: a.index }, merged), true]
+                                : [a, false];
+                        }
+                        ChatCompletion.merged = merged;
+                    })(ChatCompletion = ReasoningCompletion.ChatCompletion || (ReasoningCompletion.ChatCompletion = {}));
+                })(ReasoningCompletion = Streaming.ReasoningCompletion || (Streaming.ReasoningCompletion = {}));
+            })(Streaming = Response.Streaming || (Response.Streaming = {}));
+        })(Response = Completions.Response || (Completions.Response = {}));
+        async function list(openai, listOptions, options) {
+            const response = await openai.get("/query_tool/completions", Object.assign({ query: listOptions }, options));
+            return response;
+        }
+        Completions.list = list;
+        async function publish(openai, id, options) {
+            await openai.post(`/query_tool/completions/${id}/publish`, options);
+        }
+        Completions.publish = publish;
+        async function retrieve(openai, id, options) {
+            const response = await openai.get(`/query_tool/completions/${id}`, options);
+            return response;
+        }
+        Completions.retrieve = retrieve;
+        async function create(openai, body, options) {
+            var _a;
+            const response = await openai.post("/query_tool/completions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+            return response;
+        }
+        Completions.create = create;
+    })(Completions = QueryTool.Completions || (QueryTool.Completions = {}));
+})(QueryTool || (exports.QueryTool = QueryTool = {}));
+var QueryChat;
+(function (QueryChat) {
+    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 [service_tier, service_tierChanged] = merge(a.service_tier, b.service_tier);
+                        const [system_fingerprint, system_fingerprintChanged] = merge(a.system_fingerprint, b.system_fingerprint);
+                        const [usage, usageChanged] = merge(a.usage, b.usage, Chat.Completions.Response.Usage.merged);
+                        if (choicesChanged ||
+                            service_tierChanged ||
+                            system_fingerprintChanged ||
+                            usageChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign({ id,
+                                    choices,
+                                    created,
+                                    model,
+                                    object }, (service_tier !== undefined ? { service_tier } : {})), (system_fingerprint !== undefined
+                                    ? { system_fingerprint }
+                                    : {})), (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, 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);
+                        if (deltaChanged || finish_reasonChanged || logprobsChanged) {
+                            return [
+                                Object.assign({ delta,
+                                    finish_reason,
+                                    index }, (logprobs !== undefined ? { logprobs } : {})),
+                                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 = {}));
+                let Delta;
+                (function (Delta) {
+                    function merged(a, b) {
+                        const [content, contentChanged] = merge(a.content, b.content, mergedString);
+                        const [refusal, refusalChanged] = merge(a.refusal, b.refusal, mergedString);
+                        const [role, roleChanged] = merge(a.role, b.role);
+                        const [tool_calls, tool_callsChanged] = merge(a.tool_calls, b.tool_calls, Chat.Completions.Response.Streaming.ToolCall.mergedList);
+                        const [images, imagesChanged] = merge(a.images, b.images, Chat.Completions.Response.Image.mergedList);
+                        const [reasoning, reasoningChanged] = merge(a.reasoning, b.reasoning, Reasoning.merged);
+                        if (contentChanged ||
+                            reasoningChanged ||
+                            refusalChanged ||
+                            roleChanged ||
+                            tool_callsChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (content !== undefined ? { content } : {})), (refusal !== undefined ? { refusal } : {})), (role !== undefined ? { role } : {})), (tool_calls !== undefined ? { tool_calls } : {})), (images !== undefined ? { images } : {})), (reasoning !== undefined ? { reasoning } : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    Delta.merged = merged;
+                })(Delta = Streaming.Delta || (Streaming.Delta = {}));
+                let Reasoning;
+                (function (Reasoning) {
+                    function merged(a, b) {
+                        let merged = undefined;
+                        if (Array.isArray(a)) {
+                            if (Array.isArray(b)) {
+                                for (const item of b) {
+                                    if (merged === undefined) {
+                                        const existingIndex = a.findIndex(({ index, type }) => index === item.index && type === item.type);
+                                        if (existingIndex === -1) {
+                                            merged = [...a, item];
+                                        }
+                                        else if (item.type === "query_tool") {
+                                            const [mergedItem, itemChanged] = ReasoningCompletion.QueryToolCompletion.merged(a[existingIndex], item);
+                                            if (itemChanged) {
+                                                merged = [...a];
+                                                merged[existingIndex] = mergedItem;
+                                            }
+                                        }
+                                        else if (item.type === "chat") {
+                                            const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(a[existingIndex], item);
+                                            if (itemChanged) {
+                                                merged = [...a];
+                                                merged[existingIndex] = mergedItem;
+                                            }
+                                        }
+                                    }
+                                    else if (Array.isArray(merged) /* always true */) {
+                                        const existingIndex = merged.findIndex(({ index, type }) => index === item.index && type === item.type);
+                                        if (existingIndex === -1) {
+                                            merged.push(item);
+                                        }
+                                        else if (item.type === "query_tool") {
+                                            const [mergedItem, itemChanged] = ReasoningCompletion.QueryToolCompletion.merged(merged[existingIndex], item);
+                                            if (itemChanged) {
+                                                merged[existingIndex] = mergedItem;
+                                            }
+                                        }
+                                        else if (item.type === "chat") {
+                                            const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(merged[existingIndex], item);
+                                            if (itemChanged) {
+                                                merged[existingIndex] = mergedItem;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                const existingIndex = a.findIndex(({ index, type }) => index === b.index && type === b.type);
+                                if (existingIndex === -1) {
+                                    merged = [...a, b];
+                                }
+                                else if (b.type === "query_tool") {
+                                    const [mergedItem, itemChanged] = ReasoningCompletion.QueryToolCompletion.merged(a[existingIndex], b);
+                                    if (itemChanged) {
+                                        merged = [...a];
+                                        merged[existingIndex] = mergedItem;
+                                    }
+                                }
+                                else if (b.type === "chat") {
+                                    const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(a[existingIndex], b);
+                                    if (itemChanged) {
+                                        merged = [...a];
+                                        merged[existingIndex] = mergedItem;
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            if (Array.isArray(b)) {
+                                merged = [a];
+                                for (const item of b) {
+                                    const existingIndex = merged.findIndex(({ index, type }) => index === item.index && type === item.type);
+                                    if (existingIndex === -1) {
+                                        merged.push(item);
+                                    }
+                                    else if (item.type === "query_tool") {
+                                        const [mergedItem, itemChanged] = ReasoningCompletion.QueryToolCompletion.merged(merged[existingIndex], item);
+                                        if (itemChanged) {
+                                            merged[existingIndex] = mergedItem;
+                                        }
+                                    }
+                                    else if (item.type === "chat") {
+                                        const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(merged[existingIndex], item);
+                                        if (itemChanged) {
+                                            merged[existingIndex] = mergedItem;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                if (a.index === b.index && a.type === b.type) {
+                                    if (b.type === "query_tool") {
+                                        const [mergedItem, itemChanged] = ReasoningCompletion.QueryToolCompletion.merged(a, b);
+                                        if (itemChanged) {
+                                            merged = mergedItem;
+                                        }
+                                    }
+                                    else if (b.type === "chat") {
+                                        const [mergedItem, itemChanged] = ReasoningCompletion.ChatCompletion.merged(a, b);
+                                        if (itemChanged) {
+                                            merged = mergedItem;
+                                        }
+                                    }
+                                }
+                                else {
+                                    merged = [a, b];
+                                }
+                            }
+                        }
+                        return merged ? [merged, true] : [a, false];
+                    }
+                    Reasoning.merged = merged;
+                })(Reasoning = Streaming.Reasoning || (Streaming.Reasoning = {}));
+                let ReasoningCompletion;
+                (function (ReasoningCompletion) {
+                    let QueryToolCompletion;
+                    (function (QueryToolCompletion) {
+                        function merged(a, b) {
+                            const [merged, changed] = QueryTool.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
+                            const [error, errorChanged] = merge(a.error, b.error);
+                            return changed || errorChanged
+                                ? [
+                                    Object.assign(Object.assign({ index: a.index, type: a.type, tool_call_id: a.tool_call_id }, merged), { error }),
+                                    true,
+                                ]
+                                : [a, false];
+                        }
+                        QueryToolCompletion.merged = merged;
+                    })(QueryToolCompletion = ReasoningCompletion.QueryToolCompletion || (ReasoningCompletion.QueryToolCompletion = {}));
+                    let ChatCompletion;
+                    (function (ChatCompletion) {
+                        function merged(a, b) {
+                            const [merged, changed] = Chat.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
+                            const [error, errorChanged] = merge(a.error, b.error);
+                            return changed || errorChanged
+                                ? [Object.assign(Object.assign({ index: a.index, type: a.type }, merged), { error }), true]
+                                : [a, false];
+                        }
+                        ChatCompletion.merged = merged;
+                    })(ChatCompletion = ReasoningCompletion.ChatCompletion || (ReasoningCompletion.ChatCompletion = {}));
+                })(ReasoningCompletion = Streaming.ReasoningCompletion || (Streaming.ReasoningCompletion = {}));
+            })(Streaming = Response.Streaming || (Response.Streaming = {}));
+        })(Response = Completions.Response || (Completions.Response = {}));
+        async function list(openai, listOptions, options) {
+            const response = await openai.get("/query_chat/completions", Object.assign({ query: listOptions }, options));
+            return response;
+        }
+        Completions.list = list;
+        async function publish(openai, id, options) {
+            await openai.post(`/query_chat/completions/${id}/publish`, options);
+        }
+        Completions.publish = publish;
+        async function retrieve(openai, id, options) {
+            const response = await openai.get(`/query_chat/completions/${id}`, options);
+            return response;
+        }
+        Completions.retrieve = retrieve;
+        async function create(openai, body, options) {
+            var _a;
+            const response = await openai.post("/query_chat/completions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+            return response;
+        }
+        Completions.create = create;
+    })(Completions = QueryChat.Completions || (QueryChat.Completions = {}));
+})(QueryChat || (exports.QueryChat = QueryChat = {}));
+var Models;
+(function (Models) {
+    async function list(openai, listOptions, options) {
+        const response = await openai.models.list(Object.assign({ query: listOptions }, options));
+        return response;
+    }
+    Models.list = list;
+    async function retrieve(openai, model, retrieveOptions, options) {
+        const response = await openai.models.retrieve(model, Object.assign({ query: retrieveOptions }, options));
+        return response;
+    }
+    Models.retrieve = retrieve;
+})(Models || (exports.Models = Models = {}));
+var Auth;
+(function (Auth) {
+    let ApiKey;
+    (function (ApiKey) {
+        async function list(openai, options) {
+            const response = await openai.get("/auth/keys", options);
+            return response;
+        }
+        ApiKey.list = list;
+        async function create(openai, name, expires, description, options) {
+            const response = await openai.post("/auth/keys", Object.assign({ body: {
+                    name,
+                    expires,
+                    description,
+                } }, options));
+            return response;
+        }
+        ApiKey.create = create;
+        async function remove(openai, key, options) {
+            const response = await openai.delete("/auth/keys", Object.assign({ body: {
+                    api_key: key,
+                } }, options));
+            return response;
+        }
+        ApiKey.remove = remove;
+    })(ApiKey = Auth.ApiKey || (Auth.ApiKey = {}));
+    let OpenRouterApiKey;
+    (function (OpenRouterApiKey) {
+        async function retrieve(openai, options) {
+            const response = await openai.get("/auth/keys/openrouter", options);
+            return response;
+        }
+        OpenRouterApiKey.retrieve = retrieve;
+        async function create(openai, apiKey, options) {
+            const response = await openai.post("/auth/keys/openrouter", Object.assign({ body: {
+                    api_key: apiKey,
+                } }, options));
+            return response;
+        }
+        OpenRouterApiKey.create = create;
+        async function remove(openai, options) {
+            const response = await openai.delete("/auth/keys/openrouter", options);
+            return response;
+        }
+        OpenRouterApiKey.remove = remove;
+    })(OpenRouterApiKey = Auth.OpenRouterApiKey || (Auth.OpenRouterApiKey = {}));
+    let Credits;
+    (function (Credits) {
+        async function retrieve(openai, options) {
+            const response = await openai.get("/auth/credits", options);
+            return response;
+        }
+        Credits.retrieve = retrieve;
+    })(Credits = Auth.Credits || (Auth.Credits = {}));
+})(Auth || (exports.Auth = Auth = {}));
+var Metadata;
+(function (Metadata) {
+    async function get(openai, options) {
+        const response = await openai.get("/metadata", options);
+        return response;
+    }
+    Metadata.get = get;
+})(Metadata || (exports.Metadata = Metadata = {}));
+var QueryModel;
+(function (QueryModel) {
+    let QueryLlm;
+    (function (QueryLlm) {
+        async function retrieve(openai, model, retrieveOptions, options) {
+            const response = await openai.get(`/query_llms/${model}`, Object.assign({ query: retrieveOptions }, options));
+            return response;
+        }
+        QueryLlm.retrieve = retrieve;
+        async function retrieveValidate(openai, model, retrieveOptions, options) {
+            const response = await openai.post("/query_llms", Object.assign({ query: retrieveOptions, body: model }, options));
+            return response;
+        }
+        QueryLlm.retrieveValidate = retrieveValidate;
+    })(QueryLlm = QueryModel.QueryLlm || (QueryModel.QueryLlm = {}));
+    async function list(openai, listOptions, options) {
+        const response = await openai.get("/query_models", Object.assign({ query: listOptions }, options));
+        return response;
+    }
+    QueryModel.list = list;
+    async function count(openai, options) {
+        const response = await openai.get("/query_models/count", options);
+        return response;
+    }
+    QueryModel.count = count;
+    async function retrieve(openai, model, retrieveOptions, options) {
+        const response = await openai.get(`/query_models/${model}`, Object.assign({ query: retrieveOptions }, options));
+        return response;
+    }
+    QueryModel.retrieve = retrieve;
+    async function retrieveValidate(openai, model, retrieveOptions, options) {
+        const response = await openai.post("/query_models", Object.assign({ query: retrieveOptions, body: model }, options));
+        return response;
+    }
+    QueryModel.retrieveValidate = retrieveValidate;
+})(QueryModel || (exports.QueryModel = QueryModel = {}));
+function merge(a, b, combine) {
+    if (a !== null && a !== undefined && b !== null && b !== undefined) {
+        return combine ? combine(a, b) : [a, false];
+    }
+    else if (a !== null && a !== undefined) {
+        return [a, false];
+    }
+    else if (b !== null && b !== undefined) {
+        return [b, true];
+    }
+    else if (a === null || b === null) {
+        return [null, false];
+    }
+    else {
+        return [undefined, false];
+    }
+}
+function mergedString(a, b) {
+    return b === "" ? [a, false] : [a + b, true];
+}
+function mergedNumber(a, b) {
+    return b === 0 ? [a, false] : [a + b, true];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objectiveai",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "SDK for the Objective AI API, intended for use in conjunction with the OpenAI SDK.",
   "main": "dist/index.js",
   "repository": {
@@ -8,7 +8,9 @@
     "url": "https://github.com/ObjectiveAI/objective_ai_js.git"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rimraf dist && npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc --project tsconfig.cjs.json && shx mv dist/index.js dist/index.cjs",
+    "build:esm": "tsc --project tsconfig.esm.json",
     "test": "echo \"Error: no test specified\" && exit 1",
     "start": "node dist/index.js",
     "prepare": "npm run build"
@@ -18,19 +20,29 @@
     "email": "support@objective-ai.io",
     "url": "https://objective-ai.io"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "license": "MIT",
   "devDependencies": {
     "openai": "^4.98.0",
+    "rimraf": "^6.0.1",
+    "shx": "^0.4.0",
     "typescript": "^5.8.3"
   },
   "keywords": [
-    "api",
-    "client",
     "llm",
     "ai",
-    "mcp",
-    "objective",
+    "api",
+    "client",
+    "sdk",
+    "prompt",
+    "prompt engineering",
+    "machine learning",
+    "ml",
+    "objectiveai",
     "objective ai",
+    "objective",
     "confidence",
     "confidence id",
     "confidence score"
@@ -38,6 +50,7 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     }
   },