objectiveai 1.1.12 → 1.2.1

package/dist/index.js

@@ -1,117 +1,1434 @@
+import z from "zod";
+// Expressions
+export const ExpressionSchema = z
+    .object({
+    $jmespath: z.string().describe("A JMESPath expression."),
+})
+    .describe("An expression which evaluates to a value.")
+    .meta({ title: "Expression" });
+export const JsonValueSchema = z
+    .lazy(() => z.union([
+    z.null(),
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(JsonValueSchema.meta({
+        title: "JsonValue",
+        recursive: true,
+    })),
+    z.record(z.string(), JsonValueSchema.meta({
+        title: "JsonValue",
+        recursive: true,
+    })),
+]))
+    .describe("A JSON value.")
+    .meta({ title: "JsonValue" });
+export const JsonValueExpressionSchema = z
+    .lazy(() => z.union([
+    z.null(),
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(JsonValueExpressionSchema.meta({
+        title: "JsonValueExpression",
+        recursive: true,
+    })),
+    z.record(z.string(), JsonValueExpressionSchema.meta({
+        title: "JsonValueExpression",
+        recursive: true,
+    })),
+    ExpressionSchema.describe("An expression which evaluates to a JSON value."),
+]))
+    .describe(JsonValueSchema.description)
+    .meta({ title: "JsonValueExpression" });
+// Errors
+export const ObjectiveAIErrorSchema = z
+    .object({
+    code: z.uint32().describe("The status code of the error."),
+    message: z.any().describe("The message or details of the error."),
+})
+    .describe("An error returned by the ObjectiveAI API.")
+    .meta({ title: "ObjectiveAIError" });
+// Messages
+export var Message;
+(function (Message) {
+    let SimpleContent;
+    (function (SimpleContent) {
+        SimpleContent.TextSchema = z
+            .string()
+            .describe("Plain text content.")
+            .meta({ title: "SimpleContentText" });
+        SimpleContent.PartSchema = z
+            .object({
+            type: z.literal("text"),
+            text: z.string().describe("The text content."),
+        })
+            .describe("A simple content part.")
+            .meta({ title: "SimpleContentPart" });
+        SimpleContent.PartExpressionSchema = z
+            .union([
+            SimpleContent.PartSchema,
+            ExpressionSchema.describe("An expression which evaluates to a simple content part."),
+        ])
+            .describe(SimpleContent.PartSchema.description)
+            .meta({ title: "SimpleContentPartExpression" });
+        SimpleContent.PartsSchema = z
+            .array(SimpleContent.PartSchema)
+            .describe("An array of simple content parts.")
+            .meta({ title: "SimpleContentParts" });
+        SimpleContent.PartsExpressionSchema = z
+            .array(SimpleContent.PartExpressionSchema)
+            .describe(SimpleContent.PartsSchema.description)
+            .meta({ title: "SimpleContentPartExpressions" });
+    })(SimpleContent = Message.SimpleContent || (Message.SimpleContent = {}));
+    Message.SimpleContentSchema = z
+        .union([SimpleContent.TextSchema, SimpleContent.PartsSchema])
+        .describe("Simple content.")
+        .meta({ title: "SimpleContent" });
+    Message.SimpleContentExpressionSchema = z
+        .union([
+        SimpleContent.TextSchema,
+        SimpleContent.PartsExpressionSchema,
+        ExpressionSchema.describe("An expression which evaluates to simple content."),
+    ])
+        .describe(Message.SimpleContentSchema.description)
+        .meta({ title: "SimpleContentExpression" });
+    let RichContent;
+    (function (RichContent) {
+        RichContent.TextSchema = z
+            .string()
+            .describe("Plain text content.")
+            .meta({ title: "RichContentText" });
+        let Part;
+        (function (Part) {
+            let Text;
+            (function (Text) {
+                Text.TextSchema = z.string().describe("The text content.");
+            })(Text = Part.Text || (Part.Text = {}));
+            Part.TextSchema = z
+                .object({
+                type: z.literal("text"),
+                text: Text.TextSchema,
+            })
+                .describe("A text rich content part.")
+                .meta({ title: "TextRichContentPart" });
+            let ImageUrl;
+            (function (ImageUrl) {
+                ImageUrl.DetailSchema = z
+                    .enum(["auto", "low", "high"])
+                    .describe("Specifies the detail level of the image.");
+                ImageUrl.UrlSchema = z
+                    .string()
+                    .describe("Either a URL of the image or the base64 encoded image data.");
+                ImageUrl.DefinitionSchema = z
+                    .object({
+                    url: ImageUrl.UrlSchema,
+                    detail: ImageUrl.DetailSchema.optional().nullable(),
+                })
+                    .describe("The URL of the image and its optional detail level.");
+            })(ImageUrl = Part.ImageUrl || (Part.ImageUrl = {}));
+            Part.ImageUrlSchema = z
+                .object({
+                type: z.literal("image_url"),
+                image_url: ImageUrl.DefinitionSchema,
+            })
+                .describe("An image rich content part.")
+                .meta({ title: "ImageRichContentPart" });
+            let InputAudio;
+            (function (InputAudio) {
+                InputAudio.FormatSchema = z
+                    .enum(["wav", "mp3"])
+                    .describe("The format of the encoded audio data.");
+                InputAudio.DataSchema = z
+                    .string()
+                    .describe("Base64 encoded audio data.");
+                InputAudio.DefinitionSchema = z
+                    .object({
+                    data: InputAudio.DataSchema,
+                    format: InputAudio.FormatSchema,
+                })
+                    .describe("The audio data and its format.");
+            })(InputAudio = Part.InputAudio || (Part.InputAudio = {}));
+            Part.InputAudioSchema = z
+                .object({
+                type: z.literal("input_audio"),
+                input_audio: InputAudio.DefinitionSchema,
+            })
+                .describe("An audio rich content part.")
+                .meta({ title: "AudioRichContentPart" });
+            let VideoUrl;
+            (function (VideoUrl) {
+                VideoUrl.UrlSchema = z.string().describe("URL of the video.");
+                VideoUrl.DefinitionSchema = z.object({
+                    url: VideoUrl.UrlSchema,
+                });
+            })(VideoUrl = Part.VideoUrl || (Part.VideoUrl = {}));
+            Part.VideoUrlSchema = z
+                .object({
+                type: z.enum(["video_url", "input_video"]),
+                video_url: VideoUrl.DefinitionSchema,
+            })
+                .describe("A video rich content part.")
+                .meta({ title: "VideoRichContentPart" });
+            let File;
+            (function (File) {
+                File.FileDataSchema = z
+                    .string()
+                    .describe("The base64 encoded file data, used when passing the file to the model as a string.");
+                File.FileIdSchema = z
+                    .string()
+                    .describe("The ID of an uploaded file to use as input.");
+                File.FilenameSchema = z
+                    .string()
+                    .describe("The name of the file, used when passing the file to the model as a string.");
+                File.FileUrlSchema = z
+                    .string()
+                    .describe("The URL of the file, used when passing the file to the model as a URL.");
+                File.DefinitionSchema = z
+                    .object({
+                    file_data: File.FileDataSchema.optional().nullable(),
+                    file_id: File.FileIdSchema.optional().nullable(),
+                    filename: File.FilenameSchema.optional().nullable(),
+                    file_url: File.FileUrlSchema.optional().nullable(),
+                })
+                    .describe("The file to be used as input, either as base64 data, an uploaded file ID, or a URL.");
+            })(File = Part.File || (Part.File = {}));
+            Part.FileSchema = z
+                .object({
+                type: z.literal("file"),
+                file: File.DefinitionSchema,
+            })
+                .describe("A file rich content part.")
+                .meta({ title: "FileRichContentPart" });
+        })(Part = RichContent.Part || (RichContent.Part = {}));
+        RichContent.PartSchema = z
+            .discriminatedUnion("type", [
+            Part.TextSchema,
+            Part.ImageUrlSchema,
+            Part.InputAudioSchema,
+            Part.VideoUrlSchema,
+            Part.FileSchema,
+        ])
+            .describe("A rich content part.")
+            .meta({ title: "RichContentPart" });
+        RichContent.PartExpressionSchema = z
+            .union([
+            RichContent.PartSchema,
+            ExpressionSchema.describe("An expression which evaluates to a rich content part."),
+        ])
+            .describe(RichContent.PartSchema.description)
+            .meta({ title: "RichContentPartExpression" });
+        RichContent.PartsSchema = z
+            .array(RichContent.PartSchema)
+            .describe("An array of rich content parts.")
+            .meta({ title: "RichContentParts" });
+        RichContent.PartsExpressionSchema = z
+            .array(RichContent.PartExpressionSchema)
+            .describe(RichContent.PartsSchema.description)
+            .meta({ title: "RichContentPartExpressions" });
+    })(RichContent = Message.RichContent || (Message.RichContent = {}));
+    Message.RichContentSchema = z
+        .union([RichContent.TextSchema, RichContent.PartsSchema])
+        .describe("Rich content.")
+        .meta({ title: "RichContent" });
+    Message.RichContentExpressionSchema = z
+        .union([
+        RichContent.TextSchema,
+        RichContent.PartsExpressionSchema,
+        ExpressionSchema.describe("An expression which evaluates to rich content."),
+    ])
+        .describe(Message.RichContentSchema.description)
+        .meta({ title: "RichContentExpression" });
+    Message.NameSchema = z
+        .string()
+        .describe("An optional name for the participant. Provides the model information to differentiate between participants of the same role.")
+        .meta({ title: "MessageName" });
+    Message.NameExpressionSchema = z
+        .union([
+        Message.NameSchema,
+        ExpressionSchema.describe("An expression which evaluates to a string."),
+    ])
+        .describe(Message.NameSchema.description)
+        .meta({ title: "MessageNameExpression" });
+    Message.DeveloperSchema = z
+        .object({
+        role: z.literal("developer"),
+        content: Message.SimpleContentSchema,
+        name: Message.NameSchema.optional().nullable(),
+    })
+        .describe("Developer-provided instructions that the model should follow, regardless of messages sent by the user.")
+        .meta({ title: "DeveloperMessage" });
+    Message.DeveloperExpressionSchema = z
+        .object({
+        role: z.literal("developer"),
+        content: Message.SimpleContentExpressionSchema,
+        name: Message.NameExpressionSchema.optional().nullable(),
+    })
+        .describe(Message.DeveloperSchema.description)
+        .meta({ title: "DeveloperMessageExpression" });
+    Message.SystemSchema = z
+        .object({
+        role: z.literal("system"),
+        content: Message.SimpleContentSchema,
+        name: Message.NameSchema.optional().nullable(),
+    })
+        .describe("Developer-provided instructions that the model should follow, regardless of messages sent by the user.")
+        .meta({ title: "SystemMessage" });
+    Message.SystemExpressionSchema = z
+        .object({
+        role: z.literal("system"),
+        content: Message.SimpleContentExpressionSchema,
+        name: Message.NameExpressionSchema.optional().nullable(),
+    })
+        .describe(Message.SystemSchema.description)
+        .meta({ title: "SystemMessageExpression" });
+    Message.UserSchema = z
+        .object({
+        role: z.literal("user"),
+        content: Message.RichContentSchema,
+        name: Message.NameSchema.optional().nullable(),
+    })
+        .describe("Messages sent by an end user, containing prompts or additional context information.")
+        .meta({ title: "UserMessage" });
+    Message.UserExpressionSchema = z
+        .object({
+        role: z.literal("user"),
+        content: Message.RichContentExpressionSchema,
+        name: Message.NameExpressionSchema.optional().nullable(),
+    })
+        .describe(Message.UserSchema.description)
+        .meta({ title: "UserMessageExpression" });
+    let Tool;
+    (function (Tool) {
+        Tool.ToolCallIdSchema = z
+            .string()
+            .describe("The ID of the tool call that this message is responding to.")
+            .meta({ title: "ToolMessageToolCallId" });
+        Tool.ToolCallIdExpressionSchema = z
+            .union([
+            Tool.ToolCallIdSchema,
+            ExpressionSchema.describe("An expression which evaluates to a string."),
+        ])
+            .describe(Tool.ToolCallIdSchema.description)
+            .meta({ title: "ToolMessageToolCallIdExpression" });
+    })(Tool = Message.Tool || (Message.Tool = {}));
+    Message.ToolSchema = z
+        .object({
+        role: z.literal("tool"),
+        content: Message.RichContentSchema,
+        tool_call_id: Tool.ToolCallIdSchema,
+    })
+        .describe("Messages sent by tools in response to tool calls made by the assistant.")
+        .meta({ title: "ToolMessage" });
+    Message.ToolExpressionSchema = z
+        .object({
+        role: z.literal("tool"),
+        content: Message.RichContentExpressionSchema,
+        tool_call_id: Tool.ToolCallIdExpressionSchema,
+    })
+        .describe(Message.ToolSchema.description)
+        .meta({ title: "ToolMessageExpression" });
+    let Assistant;
+    (function (Assistant) {
+        Assistant.RefusalSchema = z
+            .string()
+            .describe("The refusal message by the assistant.")
+            .meta({ title: "AssistantMessageRefusal" });
+        Assistant.RefusalExpressionSchema = z
+            .union([
+            Assistant.RefusalSchema,
+            ExpressionSchema.describe("An expression which evaluates to a string."),
+        ])
+            .describe(Assistant.RefusalSchema.description)
+            .meta({ title: "AssistantMessageRefusalExpression" });
+        Assistant.ReasoningSchema = z
+            .string()
+            .describe("The reasoning provided by the assistant.")
+            .meta({ title: "AssistantMessageReasoning" });
+        Assistant.ReasoningExpressionSchema = z
+            .union([
+            Assistant.ReasoningSchema,
+            ExpressionSchema.describe("An expression which evaluates to a string."),
+        ])
+            .describe(Assistant.ReasoningSchema.description)
+            .meta({ title: "AssistantMessageReasoningExpression" });
+        let ToolCall;
+        (function (ToolCall) {
+            ToolCall.IdSchema = z
+                .string()
+                .describe("The unique identifier for the tool call.")
+                .meta({ title: "AssistantMessageToolCallId" });
+            ToolCall.IdExpressionSchema = z
+                .union([
+                ToolCall.IdSchema,
+                ExpressionSchema.describe("An expression which evaluates to a string."),
+            ])
+                .describe(ToolCall.IdSchema.description)
+                .meta({ title: "AssistantMessageToolCallIdExpression" });
+            let Function;
+            (function (Function) {
+                Function.NameSchema = z
+                    .string()
+                    .describe("The name of the function called.")
+                    .meta({ title: "AssistantMessageToolCallFunctionName" });
+                Function.NameExpressionSchema = z
+                    .union([
+                    Function.NameSchema,
+                    ExpressionSchema.describe("An expression which evaluates to a string."),
+                ])
+                    .describe(Function.NameSchema.description)
+                    .meta({ title: "AssistantMessageToolCallFunctionNameExpression" });
+                Function.ArgumentsSchema = z
+                    .string()
+                    .describe("The arguments passed to the function.")
+                    .meta({ title: "AssistantMessageToolCallFunctionArguments" });
+                Function.ArgumentsExpressionSchema = z
+                    .union([
+                    Function.ArgumentsSchema,
+                    ExpressionSchema.describe("An expression which evaluates to a string."),
+                ])
+                    .describe(Function.ArgumentsSchema.description)
+                    .meta({
+                    title: "AssistantMessageToolCallFunctionArgumentsExpression",
+                });
+                Function.DefinitionSchema = z
+                    .object({
+                    name: Function.NameSchema,
+                    arguments: Function.ArgumentsSchema,
+                })
+                    .describe("The name and arguments of the function called.")
+                    .meta({ title: "AssistantMessageToolCallFunctionDefinition" });
+                Function.DefinitionExpressionSchema = z
+                    .object({
+                    name: Function.NameExpressionSchema,
+                    arguments: Function.ArgumentsExpressionSchema,
+                })
+                    .describe(Function.DefinitionSchema.description)
+                    .meta({
+                    title: "AssistantMessageToolCallFunctionDefinitionExpression",
+                });
+            })(Function = ToolCall.Function || (ToolCall.Function = {}));
+            ToolCall.FunctionSchema = z
+                .object({
+                type: z.literal("function"),
+                id: ToolCall.IdSchema,
+                function: Function.DefinitionSchema,
+            })
+                .describe("A function tool call made by the assistant.")
+                .meta({ title: "AssistantMessageToolCallFunction" });
+            ToolCall.FunctionExpressionSchema = z
+                .object({
+                type: z.literal("function"),
+                id: ToolCall.IdExpressionSchema,
+                function: Function.DefinitionExpressionSchema,
+            })
+                .describe(ToolCall.FunctionSchema.description)
+                .meta({ title: "AssistantMessageToolCallFunctionExpression" });
+        })(ToolCall = Assistant.ToolCall || (Assistant.ToolCall = {}));
+        Assistant.ToolCallSchema = z
+            .union([ToolCall.FunctionSchema])
+            .describe("A tool call made by the assistant.")
+            .meta({ title: "AssistantMessageToolCall" });
+        Assistant.ToolCallExpressionSchema = z
+            .union([
+            ToolCall.FunctionExpressionSchema,
+            ExpressionSchema.describe("An expression which evaluates to a tool call."),
+        ])
+            .describe(Assistant.ToolCallSchema.description)
+            .meta({ title: "AssistantMessageToolCallExpression" });
+        Assistant.ToolCallsSchema = z
+            .array(Assistant.ToolCallSchema)
+            .describe("Tool calls made by the assistant.")
+            .meta({ title: "AssistantMessageToolCalls" });
+        Assistant.ToolCallsExpressionSchema = z
+            .union([
+            z
+                .array(Assistant.ToolCallExpressionSchema)
+                .describe(Assistant.ToolCallsSchema.description),
+            ExpressionSchema.describe("An expression which evaluates to an array of tool calls."),
+        ])
+            .describe(Assistant.ToolCallsSchema.description)
+            .meta({ title: "AssistantMessageToolCallsExpression" });
+    })(Assistant = Message.Assistant || (Message.Assistant = {}));
+    Message.AssistantSchema = z
+        .object({
+        role: z.literal("assistant"),
+        content: Message.RichContentSchema.optional().nullable(),
+        name: Message.NameSchema.optional().nullable(),
+        refusal: Assistant.RefusalSchema.optional().nullable(),
+        tool_calls: Assistant.ToolCallsSchema.optional().nullable(),
+        reasoning: Assistant.ReasoningSchema.optional().nullable(),
+    })
+        .describe("Messages sent by the model in response to user messages.")
+        .meta({ title: "AssistantMessage" });
+    Message.AssistantExpressionSchema = z
+        .object({
+        role: z.literal("assistant"),
+        content: Message.RichContentExpressionSchema.optional().nullable(),
+        name: Message.NameExpressionSchema.optional().nullable(),
+        refusal: Assistant.RefusalExpressionSchema.optional().nullable(),
+        tool_calls: Assistant.ToolCallsExpressionSchema.optional().nullable(),
+        reasoning: Assistant.ReasoningExpressionSchema.optional().nullable(),
+    })
+        .describe(Message.AssistantSchema.description)
+        .meta({ title: "AssistantMessageExpression" });
+})(Message || (Message = {}));
+export const MessageSchema = z
+    .discriminatedUnion("role", [
+    Message.DeveloperSchema,
+    Message.SystemSchema,
+    Message.UserSchema,
+    Message.ToolSchema,
+    Message.AssistantSchema,
+])
+    .describe("A message exchanged in a chat conversation.")
+    .meta({ title: "Message" });
+export const MessageExpressionSchema = z
+    .union([
+    z
+        .discriminatedUnion("role", [
+        Message.DeveloperExpressionSchema,
+        Message.SystemExpressionSchema,
+        Message.UserExpressionSchema,
+        Message.ToolExpressionSchema,
+        Message.AssistantExpressionSchema,
+    ])
+        .describe(MessageSchema.description),
+    ExpressionSchema.describe("An expression which evaluates to a message."),
+])
+    .describe(MessageSchema.description)
+    .meta({ title: "MessageExpression" });
+export const MessagesSchema = z
+    .array(MessageSchema)
+    .describe("A list of messages exchanged in a chat conversation.")
+    .meta({ title: "Messages" });
+export const MessagesExpressionSchema = z
+    .union([
+    z
+        .array(MessageExpressionSchema)
+        .describe(MessagesSchema.description)
+        .meta({ title: "MessageExpressions" }),
+    ExpressionSchema.describe("An expression which evaluates to an array of messages."),
+])
+    .describe(MessagesSchema.description)
+    .meta({ title: "MessagesExpression" });
+// Tools
+export var Tool;
+(function (Tool) {
+    let Function;
+    (function (Function) {
+        Function.NameSchema = z
+            .string()
+            .describe("The name of the function.")
+            .meta({ title: "FunctionToolName" });
+        Function.NameExpressionSchema = z
+            .union([
+            Function.NameSchema,
+            ExpressionSchema.describe("An expression which evaluates to a string."),
+        ])
+            .describe(Function.NameSchema.description)
+            .meta({ title: "FunctionToolNameExpression" });
+        Function.DescriptionSchema = z
+            .string()
+            .describe("The description of the function.")
+            .meta({ title: "FunctionToolDescription" });
+        Function.DescriptionExpressionSchema = z
+            .union([
+            Function.DescriptionSchema,
+            ExpressionSchema.describe("An expression which evaluates to a string."),
+        ])
+            .describe(Function.DescriptionSchema.description)
+            .meta({ title: "FunctionToolDescriptionExpression" });
+        Function.ParametersSchema = z
+            .record(z.string(), JsonValueSchema)
+            .describe("The JSON schema defining the parameters of the function.")
+            .meta({ title: "FunctionToolParameters" });
+        Function.ParametersExpressionSchema = z
+            .union([
+            z.record(z.string(), JsonValueExpressionSchema),
+            ExpressionSchema.describe("An expression which evaluates to a JSON schema object."),
+        ])
+            .describe(Function.ParametersSchema.description)
+            .meta({ title: "FunctionToolParametersExpression" });
+        Function.StrictSchema = z
+            .boolean()
+            .describe("Whether to enforce strict adherence to the parameter schema.")
+            .meta({ title: "FunctionToolStrict" });
+        Function.StrictExpressionSchema = z
+            .union([
+            Function.StrictSchema,
+            ExpressionSchema.describe("An expression which evaluates to a boolean."),
+        ])
+            .describe(Function.StrictSchema.description)
+            .meta({ title: "FunctionToolStrictExpression" });
+        Function.DefinitionSchema = z
+            .object({
+            name: Function.NameSchema,
+            description: Function.DescriptionSchema.optional().nullable(),
+            parameters: Function.ParametersSchema.optional().nullable(),
+            strict: Function.StrictSchema.optional().nullable(),
+        })
+            .describe("The definition of a function tool.")
+            .meta({ title: "FunctionToolDefinition" });
+        Function.DefinitionExpressionSchema = z
+            .object({
+            name: Function.NameExpressionSchema,
+            description: Function.DescriptionExpressionSchema.optional().nullable(),
+            parameters: Function.ParametersExpressionSchema.optional().nullable(),
+            strict: Function.StrictExpressionSchema.optional().nullable(),
+        })
+            .describe(Function.DefinitionSchema.description)
+            .meta({ title: "FunctionToolDefinitionExpression" });
+    })(Function = Tool.Function || (Tool.Function = {}));
+    Tool.FunctionSchema = z
+        .object({
+        type: z.literal("function"),
+        function: Function.DefinitionSchema,
+    })
+        .describe("A function tool that the assistant can call.")
+        .meta({ title: "FunctionTool" });
+    Tool.FunctionExpressionSchema = z
+        .object({
+        type: z.literal("function"),
+        function: Function.DefinitionExpressionSchema,
+    })
+        .describe(Tool.FunctionSchema.description)
+        .meta({ title: "FunctionToolExpression" });
+})(Tool || (Tool = {}));
+export const ToolSchema = z
+    .union([Tool.FunctionSchema])
+    .describe("A tool that the assistant can call.")
+    .meta({ title: "Tool" });
+export const ToolExpressionSchema = z
+    .union([
+    Tool.FunctionExpressionSchema,
+    ExpressionSchema.describe("An expression which evaluates to a tool."),
+])
+    .describe(ToolSchema.description)
+    .meta({ title: "ToolExpression" });
+export const ToolsSchema = z
+    .array(ToolSchema)
+    .describe("A list of tools that the assistant can call.")
+    .meta({ title: "Tools" });
+export const ToolsExpressionSchema = z
+    .union([
+    z
+        .array(ToolExpressionSchema)
+        .describe(ToolsSchema.description)
+        .meta({ title: "ToolExpressions" }),
+    ExpressionSchema.describe("An expression which evaluates to an array of tools."),
+])
+    .describe(ToolsSchema.description)
+    .meta({ title: "ToolsExpression" });
+// Vector Responses
+export const VectorResponseSchema = Message.RichContentSchema.describe("A possible assistant response. The LLMs in the Ensemble may vote for this option.").meta({ title: "VectorResponse" });
+export const VectorResponseExpressionSchema = z
+    .union([
+    VectorResponseSchema,
+    ExpressionSchema.describe("An expression which evaluates to a possible assistant response."),
+])
+    .describe(VectorResponseSchema.description)
+    .meta({ title: "VectorResponseExpression" });
+export const VectorResponsesSchema = z
+    .array(VectorResponseSchema)
+    .describe("A list of possible assistant responses which the LLMs in the Ensemble will vote on. The output scores will be of the same length, each corresponding to one response. The winner is the response with the highest score.")
+    .meta({ title: "VectorResponses" });
+export const VectorResponsesExpressionSchema = z
+    .union([
+    z
+        .array(VectorResponseExpressionSchema)
+        .describe(VectorResponsesSchema.description)
+        .meta({ title: "VectorResponseExpressions" }),
+    ExpressionSchema.describe("An expression which evaluates to an array of possible assistant responses."),
+])
+    .describe(VectorResponsesSchema.description)
+    .meta({ title: "VectorResponsesExpression" });
+// Ensemble LLM
+export var EnsembleLlm;
+(function (EnsembleLlm) {
+    EnsembleLlm.OutputModeSchema = z
+        .enum(["instruction", "json_schema", "tool_call"])
+        .describe('For Vector Completions only, specifies the LLM\'s voting output mode. For "instruction", the assistant is instructed to output a key. For "json_schema", the assistant is constrained to output a valid key using a JSON schema. For "tool_call", the assistant is instructed to output a tool call to select the key.');
+    EnsembleLlm.StopSchema = z
+        .union([
+        z
+            .string()
+            .describe("Generation will stop when this string is generated.")
+            .meta({ title: "StopString" }),
+        z
+            .array(z.string().meta({ title: "StopString" }))
+            .describe("Generation will stop when any of these strings are generated.")
+            .meta({ title: "StopStrings" }),
+    ])
+        .describe("The assistant will stop when any of the provided strings are generated.")
+        .meta({ title: "Stop" });
+    let Provider;
+    (function (Provider) {
+        Provider.QuantizationSchema = z
+            .enum([
+            "int4",
+            "int8",
+            "fp4",
+            "fp6",
+            "fp8",
+            "fp16",
+            "bf16",
+            "fp32",
+            "unknown",
+        ])
+            .describe("An LLM quantization.")
+            .meta({ title: "ProviderQuantization" });
+    })(Provider = EnsembleLlm.Provider || (EnsembleLlm.Provider = {}));
+    EnsembleLlm.ProviderSchema = z
+        .object({
+        allow_fallbacks: z
+            .boolean()
+            .optional()
+            .nullable()
+            .describe("Whether to allow fallback providers if the preferred provider is unavailable."),
+        require_parameters: z
+            .boolean()
+            .optional()
+            .nullable()
+            .describe("Whether to require that the provider supports all specified parameters."),
+        order: z
+            .array(z.string().meta({ title: "ProviderName" }))
+            .optional()
+            .nullable()
+            .describe("An ordered list of provider names to use when selecting a provider for this model."),
+        only: z
+            .array(z.string().meta({ title: "ProviderName" }))
+            .optional()
+            .nullable()
+            .describe("A list of provider names to restrict selection to when selecting a provider for this model."),
+        ignore: z
+            .array(z.string().meta({ title: "ProviderName" }))
+            .optional()
+            .nullable()
+            .describe("A list of provider names to ignore when selecting a provider for this model."),
+        quantizations: z
+            .array(Provider.QuantizationSchema)
+            .optional()
+            .nullable()
+            .describe("Specifies the quantizations to allow when selecting providers for this model."),
+    })
+        .describe("Options for selecting the upstream provider of this model.");
+    let Reasoning;
+    (function (Reasoning) {
+        Reasoning.EffortSchema = z
+            .enum(["none", "minimal", "low", "medium", "high", "xhigh"])
+            .describe("Constrains effort on reasoning for supported reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.")
+            .meta({ title: "ReasoningEffort" });
+        Reasoning.SummaryVerbositySchema = z
+            .enum(["auto", "concise", "detailed"])
+            .describe("Controls the verbosity of the reasoning summary for supported reasoning models.")
+            .meta({ title: "ReasoningSummaryVerbosity" });
+    })(Reasoning = EnsembleLlm.Reasoning || (EnsembleLlm.Reasoning = {}));
+    EnsembleLlm.ReasoningSchema = z
+        .object({
+        enabled: z
+            .boolean()
+            .optional()
+            .nullable()
+            .describe("Enables or disables reasoning for supported models."),
+        max_tokens: z
+            .int()
+            .min(0)
+            .max(2147483647)
+            .optional()
+            .nullable()
+            .describe("The maximum number of tokens to use for reasoning in a response."),
+        effort: Reasoning.EffortSchema.optional().nullable(),
+        summary_verbosity: Reasoning.SummaryVerbositySchema.optional().nullable(),
+    })
+        .optional()
+        .nullable()
+        .describe("Options for controlling reasoning behavior of the model.");
+    EnsembleLlm.VerbositySchema = z
+        .enum(["low", "medium", "high"])
+        .describe("Controls the verbosity and length of the model response. Lower values produce more concise responses, while higher values produce more detailed and comprehensive responses.");
+    EnsembleLlm.ListItemSchema = z.object({
+        id: z.string().describe("The unique identifier for the Ensemble LLM."),
+    });
+    async function list(openai, options) {
+        const response = await openai.get("/ensemble_llms", options);
+        return response;
+    }
+    EnsembleLlm.list = list;
+    EnsembleLlm.RetrieveItemSchema = z.lazy(() => EnsembleLlmSchema.extend({
+        created: z
+            .uint32()
+            .describe("The Unix timestamp (in seconds) when the Ensemble LLM was created."),
+    }));
+    async function retrieve(openai, id, options) {
+        const response = await openai.get(`/ensemble_llms/${id}`, options);
+        return response;
+    }
+    EnsembleLlm.retrieve = retrieve;
+    EnsembleLlm.HistoricalUsageSchema = z.object({
+        requests: z
+            .uint32()
+            .describe("The total number of requests made to this Ensemble LLM."),
+        completion_tokens: z
+            .uint32()
+            .describe("The total number of completion tokens generated by this Ensemble LLM."),
+        prompt_tokens: z
+            .uint32()
+            .describe("The total number of prompt tokens sent to this Ensemble LLM."),
+        total_cost: z
+            .number()
+            .describe("The total cost incurred by using this Ensemble LLM."),
+    });
+    async function retrieveUsage(openai, id, options) {
+        const response = await openai.get(`/ensemble_llms/${id}/usage`, options);
+        return response;
+    }
+    EnsembleLlm.retrieveUsage = retrieveUsage;
+})(EnsembleLlm || (EnsembleLlm = {}));
+export const EnsembleLlmBaseSchema = z
+    .object({
+    model: z.string().describe("The full ID of the LLM to use."),
+    output_mode: EnsembleLlm.OutputModeSchema,
+    synthetic_reasoning: z
+        .boolean()
+        .optional()
+        .nullable()
+        .describe("For Vector Completions only, whether to use synthetic reasoning prior to voting. Works for any LLM, even those that do not have native reasoning capabilities."),
+    top_logprobs: z
+        .int()
+        .min(0)
+        .max(20)
+        .optional()
+        .nullable()
+        .describe("For Vector Completions only, whether to use logprobs to make the vote probabilistic. This means that the LLM can vote for multiple keys based on their logprobabilities. Allows LLMs to express native uncertainty when voting."),
+    prefix_messages: MessagesSchema.optional()
+        .nullable()
+        .describe(`${MessagesSchema.description} These will be prepended to every prompt sent to this LLM. Useful for setting context or influencing behavior.`),
+    suffix_messages: MessagesSchema.optional()
+        .nullable()
+        .describe(`${MessagesSchema.description} These will be appended to every prompt sent to this LLM. Useful for setting context or influencing behavior.`),
+    frequency_penalty: z
+        .number()
+        .min(-2.0)
+        .max(2.0)
+        .optional()
+        .nullable()
+        .describe("This setting aims to control the repetition of tokens based on how often they appear in the input. It tries to use less frequently those tokens that appear more in the input, proportional to how frequently they occur. Token penalty scales with the number of occurrences. Negative values will encourage token reuse."),
+    logit_bias: z
+        .record(z.string(), z.int().min(-100).max(100))
+        .optional()
+        .nullable()
+        .describe("Accepts a JSON object that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100. Mathematically, the bias is added to the logits generated by the model prior to sampling. The exact effect will vary per model, but values between -1 and 1 should decrease or increase likelihood of selection; values like -100 or 100 should result in a ban or exclusive selection of the relevant token."),
+    max_completion_tokens: z
+        .int()
+        .min(0)
+        .max(2147483647)
+        .optional()
+        .nullable()
+        .describe("An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens."),
+    presence_penalty: z
+        .number()
+        .min(-2.0)
+        .max(2.0)
+        .optional()
+        .nullable()
+        .describe("This setting aims to control the presence of tokens in the output. It tries to encourage the model to use tokens that are less present in the input, proportional to their presence in the input. Token presence scales with the number of occurrences. Negative values will encourage more diverse token usage."),
+    stop: EnsembleLlm.StopSchema.optional().nullable(),
+    temperature: z
+        .number()
+        .min(0.0)
+        .max(2.0)
+        .optional()
+        .nullable()
+        .describe("This setting influences the variety in the model’s responses. Lower values lead to more predictable and typical responses, while higher values encourage more diverse and less common responses. At 0, the model always gives the same response for a given input."),
+    top_p: z
+        .number()
+        .min(0.0)
+        .max(1.0)
+        .optional()
+        .nullable()
+        .describe("This setting limits the model’s choices to a percentage of likely tokens: only the top tokens whose probabilities add up to P. A lower value makes the model’s responses more predictable, while the default setting allows for a full range of token choices. Think of it like a dynamic Top-K."),
+    max_tokens: z
+        .int()
+        .min(0)
+        .max(2147483647)
+        .optional()
+        .nullable()
+        .describe("This sets the upper limit for the number of tokens the model can generate in response. It won’t produce more than this limit. The maximum value is the context length minus the prompt length."),
+    min_p: z
+        .number()
+        .min(0.0)
+        .max(1.0)
+        .optional()
+        .nullable()
+        .describe("Represents the minimum probability for a token to be considered, relative to the probability of the most likely token. (The value changes depending on the confidence level of the most probable token.) If your Min-P is set to 0.1, that means it will only allow for tokens that are at least 1/10th as probable as the best possible option."),
+    provider: EnsembleLlm.ProviderSchema.optional().nullable(),
+    reasoning: EnsembleLlm.ReasoningSchema.optional().nullable(),
+    repetition_penalty: z
+        .number()
+        .min(0.0)
+        .max(2.0)
+        .optional()
+        .nullable()
+        .describe("Helps to reduce the repetition of tokens from the input. A higher value makes the model less likely to repeat tokens, but too high a value can make the output less coherent (often with run-on sentences that lack small words). Token penalty scales based on original token’s probability."),
+    top_a: z
+        .number()
+        .min(0.0)
+        .max(1.0)
+        .optional()
+        .nullable()
+        .describe("Consider only the top tokens with “sufficiently high” probabilities based on the probability of the most likely token. Think of it like a dynamic Top-P. A lower Top-A value focuses the choices based on the highest probability token but with a narrower scope. A higher Top-A value does not necessarily affect the creativity of the output, but rather refines the filtering process based on the maximum probability."),
+    top_k: z
+        .int()
+        .min(0)
+        .max(2147483647)
+        .optional()
+        .nullable()
+        .describe("This limits the model’s choice of tokens at each step, making it choose from a smaller set. A value of 1 means the model will always pick the most likely next token, leading to predictable results. By default this setting is disabled, making the model to consider all choices."),
+    verbosity: EnsembleLlm.VerbositySchema.optional().nullable(),
+})
+    .describe("An LLM to be used within an Ensemble or standalone with Chat Completions.");
+export const EnsembleLlmBaseWithFallbacksAndCountSchema = EnsembleLlmBaseSchema.extend({
+    count: z
+        .uint32()
+        .min(1)
+        .optional()
+        .nullable()
+        .describe("A count greater than one effectively means that there are multiple instances of this LLM in an ensemble."),
+    fallbacks: z
+        .array(EnsembleLlmBaseSchema)
+        .optional()
+        .nullable()
+        .describe("A list of fallback LLMs to use if the primary LLM fails."),
+}).describe("An LLM to be used within an Ensemble, including optional fallbacks and count.");
+export const EnsembleLlmSchema = EnsembleLlmBaseSchema.extend({
+    id: z.string().describe("The unique identifier for the Ensemble LLM."),
+}).describe("An LLM to be used within an Ensemble or standalone with Chat Completions, including its unique identifier.");
+export const EnsembleLlmWithFallbacksAndCountSchema = EnsembleLlmSchema.extend({
+    count: EnsembleLlmBaseWithFallbacksAndCountSchema.shape.count,
+    fallbacks: z
+        .array(EnsembleLlmSchema)
+        .optional()
+        .nullable()
+        .describe(EnsembleLlmBaseWithFallbacksAndCountSchema.shape.fallbacks.description),
+}).describe("An LLM to be used within an Ensemble, including its unique identifier, optional fallbacks, and count.");
+// Ensemble
+export const EnsembleBaseSchema = z
+    .object({
+    llms: z
+        .array(EnsembleLlmBaseWithFallbacksAndCountSchema)
+        .describe("The list of LLMs that make up the ensemble."),
+})
+    .describe("An ensemble of LLMs.");
+export const EnsembleSchema = z
+    .object({
+    id: z.string().describe("The unique identifier for the Ensemble."),
+    llms: z
+        .array(EnsembleLlmWithFallbacksAndCountSchema)
+        .describe(EnsembleBaseSchema.shape.llms.description),
+})
+    .describe("An ensemble of LLMs with a unique identifier.");
+export var Ensemble;
+(function (Ensemble) {
+    Ensemble.ListItemSchema = z.object({
+        id: z.string().describe("The unique identifier for the Ensemble."),
+    });
+    async function list(openai, options) {
+        const response = await openai.get("/ensembles", options);
+        return response;
+    }
+    Ensemble.list = list;
+    Ensemble.RetrieveItemSchema = EnsembleSchema.extend({
+        created: z
+            .uint32()
+            .describe("The Unix timestamp (in seconds) when the Ensemble was created."),
+    });
+    async function retrieve(openai, id, options) {
+        const response = await openai.get(`/ensembles/${id}`, options);
+        return response;
+    }
+    Ensemble.retrieve = retrieve;
+    Ensemble.HistoricalUsageSchema = z.object({
+        requests: z
+            .uint32()
+            .describe("The total number of requests made to this Ensemble."),
+        completion_tokens: z
+            .uint32()
+            .describe("The total number of completion tokens generated by this Ensemble."),
+        prompt_tokens: z
+            .uint32()
+            .describe("The total number of prompt tokens sent to this Ensemble."),
+        total_cost: z
+            .number()
+            .describe("The total cost incurred by using this Ensemble."),
+    });
+    async function retrieveUsage(openai, id, options) {
+        const response = await openai.get(`/ensembles/${id}/usage`, options);
+        return response;
+    }
+    Ensemble.retrieveUsage = retrieveUsage;
+})(Ensemble || (Ensemble = {}));
+// Chat Completions
 export var Chat;
 (function (Chat) {
     let Completions;
     (function (Completions) {
+        let Request;
+        (function (Request) {
+            let Provider;
+            (function (Provider) {
+                Provider.DataCollectionSchema = z
+                    .enum(["allow", "deny"])
+                    .describe("Specifies whether to allow providers which collect data.");
+                Provider.SortSchema = z
+                    .enum(["price", "throughput", "latency"])
+                    .describe("Specifies the sorting strategy for provider selection.");
+                Provider.MaxPriceSchema = z.object({
+                    prompt: z
+                        .number()
+                        .optional()
+                        .nullable()
+                        .describe("Maximum price for prompt tokens."),
+                    completion: z
+                        .number()
+                        .optional()
+                        .nullable()
+                        .describe("Maximum price for completion tokens."),
+                    image: z
+                        .number()
+                        .optional()
+                        .nullable()
+                        .describe("Maximum price for image generation."),
+                    audio: z
+                        .number()
+                        .optional()
+                        .nullable()
+                        .describe("Maximum price for audio generation."),
+                    request: z
+                        .number()
+                        .optional()
+                        .nullable()
+                        .describe("Maximum price per request."),
+                });
+            })(Provider = Request.Provider || (Request.Provider = {}));
+            Request.ProviderSchema = z
+                .object({
+                data_collection: Provider.DataCollectionSchema.optional().nullable(),
+                zdr: z
+                    .boolean()
+                    .optional()
+                    .nullable()
+                    .describe("Whether to enforce Zero Data Retention (ZDR) policies when selecting providers."),
+                sort: Provider.SortSchema.optional().nullable(),
+                max_price: Provider.MaxPriceSchema.optional().nullable(),
+                preferred_min_throughput: z
+                    .number()
+                    .optional()
+                    .nullable()
+                    .describe("Preferred minimum throughput for the provider."),
+                preferred_max_latency: z
+                    .number()
+                    .optional()
+                    .nullable()
+                    .describe("Preferred maximum latency for the provider."),
+                min_throughput: z
+                    .number()
+                    .optional()
+                    .nullable()
+                    .describe("Minimum throughput for the provider."),
+                max_latency: z
+                    .number()
+                    .optional()
+                    .nullable()
+                    .describe("Maximum latency for the provider."),
+            })
+                .describe("Options for selecting the upstream provider of this completion.");
+            Request.ModelSchema = z
+                .union([z.string(), EnsembleLlmBaseSchema])
+                .describe("The Ensemble LLM to use for this completion. May be a unique ID or an inline definition.");
+            let ResponseFormat;
+            (function (ResponseFormat) {
+                ResponseFormat.TextSchema = z
+                    .object({
+                    type: z.literal("text"),
+                })
+                    .describe("The response will be arbitrary text.")
+                    .meta({ title: "ResponseFormatText" });
+                ResponseFormat.JsonObjectSchema = z
+                    .object({
+                    type: z.literal("json_object"),
+                })
+                    .describe("The response will be a JSON object.")
+                    .meta({ title: "ResponseFormatJsonObject" });
+                let JsonSchema;
+                (function (JsonSchema) {
+                    JsonSchema.JsonSchemaSchema = z
+                        .object({
+                        name: z.string().describe("The name of the JSON schema."),
+                        description: z
+                            .string()
+                            .optional()
+                            .nullable()
+                            .describe("The description of the JSON schema."),
+                        schema: z
+                            .any()
+                            .optional()
+                            .describe("The JSON schema definition."),
+                        strict: z
+                            .boolean()
+                            .optional()
+                            .nullable()
+                            .describe("Whether to enforce strict adherence to the JSON schema."),
+                    })
+                        .describe("A JSON schema definition for constraining model output.")
+                        .meta({ title: "ResponseFormatJsonSchemaJsonSchema" });
+                })(JsonSchema = ResponseFormat.JsonSchema || (ResponseFormat.JsonSchema = {}));
+                ResponseFormat.JsonSchemaSchema = z
+                    .object({
+                    type: z.literal("json_schema"),
+                    json_schema: JsonSchema.JsonSchemaSchema,
+                })
+                    .describe("The response will conform to the provided JSON schema.")
+                    .meta({ title: "ResponseFormatJsonSchema" });
+                ResponseFormat.GrammarSchema = z
+                    .object({
+                    type: z.literal("grammar"),
+                    grammar: z
+                        .string()
+                        .describe("The grammar definition to constrain the response."),
+                })
+                    .describe("The response will conform to the provided grammar definition.")
+                    .meta({ title: "ResponseFormatGrammar" });
+                ResponseFormat.PythonSchema = z
+                    .object({
+                    type: z.literal("python"),
+                })
+                    .describe("The response will be Python code.")
+                    .meta({ title: "ResponseFormatPython" });
+            })(ResponseFormat = Request.ResponseFormat || (Request.ResponseFormat = {}));
+            Request.ResponseFormatSchema = z
+                .union([
+                ResponseFormat.TextSchema,
+                ResponseFormat.JsonObjectSchema,
+                ResponseFormat.JsonSchemaSchema,
+                ResponseFormat.GrammarSchema,
+                ResponseFormat.PythonSchema,
+            ])
+                .describe("The desired format of the model's response.")
+                .meta({ title: "ResponseFormat" });
+            let ToolChoice;
+            (function (ToolChoice) {
+                let Function;
+                (function (Function) {
+                    Function.FunctionSchema = z
+                        .object({
+                        name: z
+                            .string()
+                            .describe("The name of the function the assistant will call."),
+                    })
+                        .meta({ title: "ToolChoiceFunctionFunction" });
+                })(Function = ToolChoice.Function || (ToolChoice.Function = {}));
+                ToolChoice.FunctionSchema = z
+                    .object({
+                    type: z.literal("function"),
+                    function: Function.FunctionSchema,
+                })
+                    .describe("Specify a function for the assistant to call.")
+                    .meta({ title: "ToolChoiceFunction" });
+            })(ToolChoice = Request.ToolChoice || (Request.ToolChoice = {}));
+            Request.ToolChoiceSchema = z
+                .union([
+                z.literal("none"),
+                z.literal("auto"),
+                z.literal("required"),
+                ToolChoice.FunctionSchema,
+            ])
+                .describe("Specifies tool call behavior for the assistant.")
+                .meta({ title: "ToolChoice" });
+            let Prediction;
+            (function (Prediction) {
+                let Content;
+                (function (Content) {
+                    Content.PartSchema = z
+                        .object({
+                        type: z.literal("text"),
+                        text: z.string(),
+                    })
+                        .describe("A part of the predicted content.")
+                        .meta({ title: "PredictionContentPart" });
+                })(Content = Prediction.Content || (Prediction.Content = {}));
+                Prediction.ContentSchema = z.union([
+                    z.string().meta({ title: "PredictionContentText" }),
+                    z.array(Content.PartSchema).meta({ title: "PredictionContentParts" }),
+                ]);
+            })(Prediction = Request.Prediction || (Request.Prediction = {}));
+            Request.PredictionSchema = z
+                .object({
+                type: z.literal("content"),
+                content: Prediction.ContentSchema,
+            })
+                .describe("Configuration for a Predicted Output, which can greatly improve response times when large parts of the model response are known ahead of time. This is most common when you are regenerating a file with only minor changes to most of the content.");
+            Request.SeedSchema = z
+                .bigint()
+                .describe("If specified, upstream systems will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result.");
+            Request.BackoffMaxElapsedTimeSchema = z
+                .uint32()
+                .describe("The maximum total time in milliseconds to spend on retries when a transient error occurs.");
+            Request.FirstChunkTimeoutSchema = z
+                .uint32()
+                .describe("The maximum time in milliseconds to wait for the first chunk of a streaming response.");
+            Request.OtherChunkTimeoutSchema = z
+                .uint32()
+                .describe("The maximum time in milliseconds to wait between subsequent chunks of a streaming response.");
+            Request.ChatCompletionCreateParamsBaseSchema = z
+                .object({
+                messages: MessagesSchema,
+                provider: Request.ProviderSchema.optional().nullable(),
+                model: Request.ModelSchema,
+                models: z
+                    .array(Request.ModelSchema)
+                    .optional()
+                    .nullable()
+                    .describe("Fallback Ensemble LLMs to use if the primary Ensemble LLM fails."),
+                top_logprobs: z
+                    .int()
+                    .min(0)
+                    .max(20)
+                    .optional()
+                    .nullable()
+                    .describe("An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability."),
+                response_format: Request.ResponseFormatSchema.optional().nullable(),
+                seed: Request.SeedSchema.optional().nullable(),
+                tool_choice: Request.ToolChoiceSchema.optional().nullable(),
+                tools: ToolsSchema,
+                parallel_tool_calls: z
+                    .boolean()
+                    .optional()
+                    .nullable()
+                    .describe("Whether to allow the model to make multiple tool calls in parallel."),
+                prediction: Request.PredictionSchema.optional().nullable(),
+                backoff_max_elapsed_time: Request.BackoffMaxElapsedTimeSchema.optional().nullable(),
+                first_chunk_timeout: Request.FirstChunkTimeoutSchema.optional().nullable(),
+                other_chunk_timeout: Request.OtherChunkTimeoutSchema.optional().nullable(),
+            })
+                .describe("Base parameters for creating a chat completion.");
+            Request.StreamTrueSchema = z
+                .literal(true)
+                .describe("Whether to stream the response as a series of chunks.");
+            Request.ChatCompletionCreateParamsStreamingSchema = Request.ChatCompletionCreateParamsBaseSchema.extend({
+                stream: Request.StreamTrueSchema,
+            })
+                .describe("Parameters for creating a streaming chat completion.")
+                .meta({ title: "ChatCompletionCreateParamsStreaming" });
+            Request.StreamFalseSchema = z
+                .literal(false)
+                .describe("Whether to stream the response as a series of chunks.");
+            Request.ChatCompletionCreateParamsNonStreamingSchema = Request.ChatCompletionCreateParamsBaseSchema.extend({
+                stream: Request.StreamFalseSchema.optional().nullable(),
+            })
+                .describe("Parameters for creating a unary chat completion.")
+                .meta({ title: "ChatCompletionCreateParamsNonStreaming" });
+            Request.ChatCompletionCreateParamsSchema = z
+                .union([
+                Request.ChatCompletionCreateParamsStreamingSchema,
+                Request.ChatCompletionCreateParamsNonStreamingSchema,
+            ])
+                .describe("Parameters for creating a chat completion.")
+                .meta({ title: "ChatCompletionCreateParams" });
+        })(Request = Completions.Request || (Completions.Request = {}));
         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];
-                        }
+            Response.FinishReasonSchema = z
+                .enum(["stop", "length", "tool_calls", "content_filter", "error"])
+                .describe("The reason why the assistant ceased to generate further tokens.");
+            let Usage;
+            (function (Usage) {
+                Usage.CompletionTokensDetailsSchema = z
+                    .object({
+                    accepted_prediction_tokens: z
+                        .uint32()
+                        .optional()
+                        .describe("The number of accepted prediction tokens in the completion."),
+                    audio_tokens: z
+                        .uint32()
+                        .optional()
+                        .describe("The number of generated audio tokens in the completion."),
+                    reasoning_tokens: z
+                        .uint32()
+                        .optional()
+                        .describe("The number of generated reasoning tokens in the completion."),
+                    rejected_prediction_tokens: z
+                        .uint32()
+                        .optional()
+                        .describe("The number of rejected prediction tokens in the completion."),
+                })
+                    .describe("Detailed breakdown of generated completion tokens.");
+                Usage.PromptTokensDetailsSchema = z
+                    .object({
+                    audio_tokens: z
+                        .uint32()
+                        .optional()
+                        .describe("The number of audio tokens in the prompt."),
+                    cached_tokens: z
+                        .uint32()
+                        .optional()
+                        .describe("The number of cached tokens in the prompt."),
+                    cache_write_tokens: z
+                        .uint32()
+                        .optional()
+                        .describe("The number of prompt tokens written to cache."),
+                    video_tokens: z
+                        .uint32()
+                        .optional()
+                        .describe("The number of video tokens in the prompt."),
+                })
+                    .describe("Detailed breakdown of prompt tokens.");
+                Usage.CostDetailsSchema = z
+                    .object({
+                    upstream_inference_cost: z
+                        .number()
+                        .optional()
+                        .describe("The cost incurred upstream."),
+                    upstream_upstream_inference_cost: z
+                        .number()
+                        .optional()
+                        .describe("The cost incurred by upstream's upstream."),
+                })
+                    .describe("Detailed breakdown of upstream costs incurred.");
+            })(Usage = Response.Usage || (Response.Usage = {}));
+            Response.UsageSchema = z
+                .object({
+                completion_tokens: z
+                    .uint32()
+                    .describe("The number of tokens generated in the completion."),
+                prompt_tokens: z
+                    .uint32()
+                    .describe("The number of tokens in the prompt."),
+                total_tokens: z
+                    .uint32()
+                    .describe("The total number of tokens used in the prompt or generated in the completion."),
+                completion_tokens_details: Usage.CompletionTokensDetailsSchema.optional(),
+                prompt_tokens_details: Usage.PromptTokensDetailsSchema.optional(),
+                cost: z
+                    .number()
+                    .describe("The cost in credits incurred for this completion."),
+                cost_details: Usage.CostDetailsSchema.optional(),
+                total_cost: z
+                    .number()
+                    .describe("The total cost in credits incurred including upstream costs."),
+                cost_multiplier: z
+                    .number()
+                    .describe("The cost multiplier applied to upstream costs for computing ObjectiveAI costs."),
+                is_byok: z
+                    .boolean()
+                    .describe("Whether the completion used a BYOK (Bring Your Own Key) API Key."),
+            })
+                .describe("Token and cost usage statistics for the completion.");
+            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];
                     }
-                    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];
-                        }
+                    else {
+                        return [a, false];
                     }
-                    Choice.merged = merged;
+                }
+                Logprobs.merged = merged;
+                let Logprob;
+                (function (Logprob) {
                     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;
-                                }
-                            }
+                        if (b.length === 0) {
+                            return [a, false];
                         }
-                        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 if (a.length === 0) {
+                            return [b, true];
                         }
                         else {
-                            return [a, false];
+                            return [[...a, ...b], true];
                         }
                     }
-                    Delta.merged = merged;
-                })(Delta = Streaming.Delta || (Streaming.Delta = {}));
+                    Logprob.mergedList = mergedList;
+                    Logprob.TopLogprobSchema = z
+                        .object({
+                        token: z.string().describe("The token string."),
+                        bytes: z
+                            .array(z.uint32())
+                            .optional()
+                            .nullable()
+                            .describe("The byte representation of the token."),
+                        logprob: z
+                            .number()
+                            .optional()
+                            .nullable()
+                            .describe("The log probability of the token."),
+                    })
+                        .describe("The log probability of a token in the list of top tokens.");
+                })(Logprob = Logprobs.Logprob || (Logprobs.Logprob = {}));
+                Logprobs.LogprobSchema = z
+                    .object({
+                    token: z
+                        .string()
+                        .describe("The token string which was selected by the sampler."),
+                    bytes: z
+                        .array(z.uint32())
+                        .optional()
+                        .nullable()
+                        .describe("The byte representation of the token which was selected by the sampler."),
+                    logprob: z
+                        .number()
+                        .describe("The log probability of the token which was selected by the sampler."),
+                    top_logprobs: z
+                        .array(Logprob.TopLogprobSchema)
+                        .describe("The log probabilities of the top tokens for this position."),
+                })
+                    .describe("The token which was selected by the sampler for this position as well as the logprobabilities of the top options.");
+            })(Logprobs = Response.Logprobs || (Response.Logprobs = {}));
+            Response.LogprobsSchema = z
+                .object({
+                content: z
+                    .array(Logprobs.LogprobSchema)
+                    .optional()
+                    .nullable()
+                    .describe("The log probabilities of the tokens in the content."),
+                refusal: z
+                    .array(Logprobs.LogprobSchema)
+                    .optional()
+                    .nullable()
+                    .describe("The log probabilities of the tokens in the refusal."),
+            })
+                .describe("The log probabilities of the tokens generated by the model.");
+            Response.RoleSchema = z
+                .enum(["assistant"])
+                .describe("The role of the message author.");
+            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.ImageUrlSchema = z.object({
+                    type: z.literal("image_url"),
+                    image_url: z.object({
+                        url: z.string().describe("The Base64 URL of the generated image."),
+                    }),
+                });
+            })(Image = Response.Image || (Response.Image = {}));
+            Response.ImageSchema = z
+                .union([Image.ImageUrlSchema])
+                .describe("An image generated by the model.");
+            let Streaming;
+            (function (Streaming) {
                 let ToolCall;
                 (function (ToolCall) {
                     function merged(a, b) {
@@ -147,9 +1464,9 @@ export var Chat;
                     (function (Function) {
                         function merged(a, b) {
                             const index = a.index;
+                            const [type, typeChanged] = merge(a.type, b.type);
                             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 } : {})),
@@ -180,61 +1497,73 @@ export var Chat;
                             }
                             Definition.merged = merged;
                         })(Definition = Function.Definition || (Function.Definition = {}));
+                        Function.DefinitionSchema = z.object({
+                            name: z.string().optional().describe("The name of the function."),
+                            arguments: z
+                                .string()
+                                .optional()
+                                .describe("The arguments passed to the function."),
+                        });
                     })(Function = ToolCall.Function || (ToolCall.Function = {}));
+                    ToolCall.FunctionSchema = z
+                        .object({
+                        index: z
+                            .uint32()
+                            .describe("The index of the tool call in the sequence of tool calls."),
+                        type: z.literal("function").optional(),
+                        id: z
+                            .string()
+                            .optional()
+                            .describe("The unique identifier of the function tool."),
+                        function: Function.DefinitionSchema.optional(),
+                    })
+                        .describe("A function tool call made by the assistant.");
                 })(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) {
+                Streaming.ToolCallSchema = z
+                    .union([ToolCall.FunctionSchema])
+                    .describe("A tool call made by the assistant.");
+                Streaming.DeltaSchema = z
+                    .object({
+                    content: z
+                        .string()
+                        .optional()
+                        .describe("The content added in this delta."),
+                    refusal: z
+                        .string()
+                        .optional()
+                        .describe("The refusal message added in this delta."),
+                    role: Response.RoleSchema.optional(),
+                    tool_calls: z
+                        .array(Streaming.ToolCallSchema)
+                        .optional()
+                        .describe("Tool calls made in this delta."),
+                    reasoning: z
+                        .string()
+                        .optional()
+                        .describe("The reasoning added in this delta."),
+                    images: z
+                        .array(Response.ImageSchema)
+                        .optional()
+                        .describe("Images added in this delta."),
+                })
+                    .describe("A delta in a streaming chat completion response.");
+                let Delta;
+                (function (Delta) {
                     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) {
+                        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({}, (accepted_prediction_tokens !== undefined
-                                    ? { accepted_prediction_tokens }
-                                    : {})), (audio_tokens !== undefined ? { audio_tokens } : {})), (reasoning_tokens !== undefined
-                                    ? { reasoning_tokens }
-                                    : {})), (rejected_prediction_tokens !== undefined
-                                    ? { rejected_prediction_tokens }
-                                    : {})),
+                                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,
                             ];
                         }
@@ -242,16 +1571,30 @@ export var Chat;
                             return [a, false];
                         }
                     }
-                    CompletionTokensDetails.merged = merged;
-                })(CompletionTokensDetails = Usage.CompletionTokensDetails || (Usage.CompletionTokensDetails = {}));
-                let PromptTokensDetails;
-                (function (PromptTokensDetails) {
+                    Delta.merged = merged;
+                })(Delta = Streaming.Delta || (Streaming.Delta = {}));
+                Streaming.ChoiceSchema = z
+                    .object({
+                    delta: Streaming.DeltaSchema,
+                    finish_reason: Response.FinishReasonSchema.optional(),
+                    index: z
+                        .uint32()
+                        .describe("The index of the choice in the list of choices."),
+                    logprobs: Response.LogprobsSchema.optional(),
+                })
+                    .describe("A choice in a streaming chat completion response.");
+                let Choice;
+                (function (Choice) {
                     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) {
+                        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(Object.assign({}, (audio_tokens !== undefined ? { audio_tokens } : {})), (cached_tokens !== undefined ? { cached_tokens } : {})),
+                                Object.assign({ delta,
+                                    finish_reason,
+                                    index }, (logprobs !== undefined ? { logprobs } : {})),
                                 true,
                             ];
                         }
@@ -259,21 +1602,92 @@ export var Chat;
                             return [a, false];
                         }
                     }
-                    PromptTokensDetails.merged = merged;
-                })(PromptTokensDetails = Usage.PromptTokensDetails || (Usage.PromptTokensDetails = {}));
-                let CostDetails;
-                (function (CostDetails) {
+                    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.ChatCompletionChunkSchema = z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the chat completion."),
+                    upstream_id: z
+                        .string()
+                        .describe("The unique identifier of the upstream chat completion."),
+                    choices: z
+                        .array(Streaming.ChoiceSchema)
+                        .describe("The list of choices in this chunk."),
+                    created: z
+                        .uint32()
+                        .describe("The Unix timestamp (in seconds) when the chat completion was created."),
+                    model: z
+                        .string()
+                        .describe("The unique identifier of the Ensemble LLM used for this chat completion."),
+                    upstream_model: z
+                        .string()
+                        .describe("The upstream model used for this chat completion."),
+                    object: z.literal("chat.completion.chunk"),
+                    service_tier: z.string().optional(),
+                    system_fingerprint: z.string().optional(),
+                    usage: Response.UsageSchema.optional(),
+                    provider: z
+                        .string()
+                        .optional()
+                        .describe("The provider used for this chat completion."),
+                })
+                    .describe("A chunk in a streaming chat completion response.");
+                let ChatCompletionChunk;
+                (function (ChatCompletionChunk) {
                     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) {
+                        const id = a.id;
+                        const upstream_id = a.upstream_id;
+                        const [choices, choicesChanged] = Choice.mergedList(a.choices, b.choices);
+                        const created = a.created;
+                        const model = a.model;
+                        const upstream_model = a.upstream_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);
+                        const [provider, providerChanged] = merge(a.provider, b.provider);
+                        if (choicesChanged ||
+                            service_tierChanged ||
+                            system_fingerprintChanged ||
+                            usageChanged ||
+                            providerChanged) {
                             return [
-                                Object.assign(Object.assign({}, (upstream_inference_cost !== undefined
-                                    ? { upstream_inference_cost }
-                                    : {})), (upstream_upstream_inference_cost !== undefined
-                                    ? { upstream_upstream_inference_cost }
-                                    : {})),
+                                Object.assign(Object.assign(Object.assign(Object.assign({ id,
+                                    upstream_id,
+                                    choices,
+                                    created,
+                                    model,
+                                    upstream_model,
+                                    object }, (service_tier !== undefined ? { service_tier } : {})), (system_fingerprint !== undefined
+                                    ? { system_fingerprint }
+                                    : {})), (usage !== undefined ? { usage } : {})), (provider !== undefined ? { provider } : {})),
                                 true,
                             ];
                         }
@@ -281,68 +1695,106 @@ export var Chat;
                             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 = {}));
+                    ChatCompletionChunk.merged = merged;
+                })(ChatCompletionChunk = Streaming.ChatCompletionChunk || (Streaming.ChatCompletionChunk = {}));
+            })(Streaming = Response.Streaming || (Response.Streaming = {}));
+            let Unary;
+            (function (Unary) {
+                let ToolCall;
+                (function (ToolCall) {
+                    let Function;
+                    (function (Function) {
+                        Function.DefinitionSchema = z.object({
+                            name: z
+                                .string()
+                                .describe(Streaming.ToolCall.Function.DefinitionSchema.shape.name
+                                .description),
+                            arguments: z
+                                .string()
+                                .describe(Streaming.ToolCall.Function.DefinitionSchema.shape.arguments
+                                .description),
+                        });
+                    })(Function = ToolCall.Function || (ToolCall.Function = {}));
+                    ToolCall.FunctionSchema = z
+                        .object({
+                        type: z.literal("function"),
+                        id: z
+                            .string()
+                            .describe(Streaming.ToolCall.FunctionSchema.shape.id.description),
+                        function: Function.DefinitionSchema,
+                    })
+                        .describe(Streaming.ToolCall.FunctionSchema.description);
+                })(ToolCall = Unary.ToolCall || (Unary.ToolCall = {}));
+                Unary.ToolCallSchema = z
+                    .union([ToolCall.FunctionSchema])
+                    .describe(Streaming.ToolCallSchema.description);
+                Unary.MessageSchema = z
+                    .object({
+                    content: z
+                        .string()
+                        .nullable()
+                        .describe("The content of the message."),
+                    refusal: z
+                        .string()
+                        .nullable()
+                        .describe("The refusal message, if any."),
+                    role: Response.RoleSchema,
+                    tool_calls: z
+                        .array(Unary.ToolCallSchema)
+                        .nullable()
+                        .describe("The tool calls made by the assistant, if any."),
+                    reasoning: z
+                        .string()
+                        .optional()
+                        .describe("The reasoning provided by the assistant, if any."),
+                    images: z
+                        .array(Response.ImageSchema)
+                        .optional()
+                        .describe("The images generated by the assistant, if any."),
+                })
+                    .describe("A message generated by the assistant.");
+                Unary.ChoiceSchema = z
+                    .object({
+                    message: Unary.MessageSchema,
+                    finish_reason: Response.FinishReasonSchema,
+                    index: z
+                        .uint32()
+                        .describe(Streaming.ChoiceSchema.shape.index.description),
+                    logprobs: Response.LogprobsSchema.nullable(),
+                })
+                    .describe("A choice in a unary chat completion response.");
+                Unary.ChatCompletionSchema = z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the chat completion."),
+                    upstream_id: z
+                        .string()
+                        .describe("The unique identifier of the upstream chat completion."),
+                    choices: z
+                        .array(Unary.ChoiceSchema)
+                        .describe("The list of choices in this chat completion."),
+                    created: z
+                        .uint32()
+                        .describe("The Unix timestamp (in seconds) when the chat completion was created."),
+                    model: z
+                        .string()
+                        .describe("The unique identifier of the Ensemble LLM used for this chat completion."),
+                    upstream_model: z
+                        .string()
+                        .describe("The upstream model used for this chat completion."),
+                    object: z.literal("chat.completion"),
+                    service_tier: z.string().optional(),
+                    system_fingerprint: z.string().optional(),
+                    usage: Response.UsageSchema,
+                    provider: z
+                        .string()
+                        .optional()
+                        .describe("The provider used for this chat completion."),
+                })
+                    .describe("A unary chat completion response.");
+            })(Unary = Response.Unary || (Response.Unary = {}));
         })(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));
@@ -351,68 +1803,169 @@ export var Chat;
         Completions.create = create;
     })(Completions = Chat.Completions || (Chat.Completions = {}));
 })(Chat || (Chat = {}));
-export var Score;
-(function (Score) {
+// Vector Completions
+export var Vector;
+(function (Vector) {
     let Completions;
     (function (Completions) {
+        let Request;
+        (function (Request) {
+            Request.EnsembleSchema = z
+                .union([z.string(), EnsembleBaseSchema])
+                .describe("The Ensemble to use for this completion. May be a unique ID or an inline definition.");
+            Request.ProfileSchema = z
+                .array(z.number())
+                .describe('The profile to use for the completion. Must be of the same length as the Ensemble\'s "LLMs" field, ignoring count.');
+            Request.VectorCompletionCreateParamsBaseSchema = z
+                .object({
+                retry: z
+                    .string()
+                    .optional()
+                    .nullable()
+                    .describe("The unique ID of a previous incomplete or failed completion."),
+                messages: MessagesSchema,
+                provider: Chat.Completions.Request.ProviderSchema.optional().nullable(),
+                ensemble: Request.EnsembleSchema,
+                profile: Request.ProfileSchema,
+                seed: Chat.Completions.Request.SeedSchema.optional().nullable(),
+                tools: ToolsSchema.optional()
+                    .nullable()
+                    .describe(`${ToolsSchema.description} These are readonly and will only be useful for explaining prior tool calls or otherwise influencing behavior.`),
+                responses: VectorResponsesSchema,
+                backoff_max_elapsed_time: Chat.Completions.Request.BackoffMaxElapsedTimeSchema.optional().nullable(),
+                first_chunk_timeout: Chat.Completions.Request.FirstChunkTimeoutSchema.optional().nullable(),
+                other_chunk_timeout: Chat.Completions.Request.OtherChunkTimeoutSchema.optional().nullable(),
+            })
+                .describe("Base parameters for creating a vector completion.");
+            Request.VectorCompletionCreateParamsStreamingSchema = Request.VectorCompletionCreateParamsBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamTrueSchema,
+            })
+                .describe("Parameters for creating a streaming vector completion.")
+                .meta({ title: "VectorCompletionCreateParamsStreaming" });
+            Request.VectorCompletionCreateParamsNonStreamingSchema = Request.VectorCompletionCreateParamsBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
+            })
+                .describe("Parameters for creating a unary vector completion.")
+                .meta({ title: "VectorCompletionCreateParamsNonStreaming" });
+            Request.VectorCompletionCreateParamsSchema = z
+                .union([
+                Request.VectorCompletionCreateParamsStreamingSchema,
+                Request.VectorCompletionCreateParamsNonStreamingSchema,
+            ])
+                .describe("Parameters for creating a vector completion.")
+                .meta({ title: "VectorCompletionCreateParams" });
+        })(Request = Completions.Request || (Completions.Request = {}));
         let Response;
         (function (Response) {
+            let Vote;
+            (function (Vote) {
+                function mergedList(a, b) {
+                    let merged = undefined;
+                    for (const vote of b) {
+                        const existingIndex = a.findIndex(({ flat_ensemble_index }) => flat_ensemble_index === vote.flat_ensemble_index);
+                        if (existingIndex === -1) {
+                            if (merged === undefined) {
+                                merged = [...a, vote];
+                            }
+                            else {
+                                merged.push(vote);
+                            }
+                        }
+                    }
+                    return merged ? [merged, true] : [a, false];
+                }
+                Vote.mergedList = mergedList;
+            })(Vote = Response.Vote || (Response.Vote = {}));
+            Response.VoteSchema = z
+                .object({
+                model: z
+                    .string()
+                    .describe("The unique identifier of the Ensemble LLM which generated this vote."),
+                ensemble_index: z
+                    .uint32()
+                    .describe("The index of the Ensemble LLM in the Ensemble."),
+                flat_ensemble_index: z
+                    .uint32()
+                    .describe("The flat index of the Ensemble LLM in the expanded Ensemble, accounting for counts."),
+                vote: z
+                    .array(z.number())
+                    .describe("The vote generated by this Ensemble LLM. It is of the same length of the number of responses provided in the request. If the Ensemble LLM used logprobs, may be a probability distribution; otherwise, one of the responses will have a value of 1 and the rest 0."),
+                weight: z.number().describe("The weight assigned to this vote."),
+                retry: z
+                    .boolean()
+                    .optional()
+                    .describe("Whether this vote came from a previous Vector Completion which was retried."),
+            })
+                .describe("A vote from an Ensemble LLM within a Vector Completion.");
+            Response.VotesSchema = z
+                .array(Response.VoteSchema)
+                .describe("The list of votes for responses in the request from the Ensemble LLMs within the provided Ensemble.");
+            let Scores;
+            (function (Scores) {
+                function merged(a, b) {
+                    if (a.length === b.length) {
+                        for (let i = 0; i < a.length; i++) {
+                            if (a[i] !== b[i]) {
+                                return [b, true];
+                            }
+                        }
+                        return [a, false];
+                    }
+                    else {
+                        return [b, true];
+                    }
+                }
+                Scores.merged = merged;
+            })(Scores = Response.Scores || (Response.Scores = {}));
+            Response.ScoresSchema = z
+                .array(z.number())
+                .describe("The scores for each response in the request, aggregated from the votes of the Ensemble LLMs.");
+            let Weights;
+            (function (Weights) {
+                function merged(a, b) {
+                    return Scores.merged(a, b);
+                }
+                Weights.merged = merged;
+            })(Weights = Response.Weights || (Response.Weights = {}));
+            Response.WeightsSchema = z
+                .array(z.number())
+                .describe("The weights assigned to each response in the request, aggregated from the votes of the Ensemble LLMs.");
+            Response.EnsembleSchema = z
+                .string()
+                .describe("The unique identifier of the Ensemble used for this vector completion.");
+            Response.UsageSchema = z
+                .object({
+                completion_tokens: z
+                    .uint32()
+                    .describe("The number of tokens generated in the completion."),
+                prompt_tokens: z
+                    .uint32()
+                    .describe("The number of tokens in the prompt."),
+                total_tokens: z
+                    .uint32()
+                    .describe("The total number of tokens used in the prompt or generated in the completion."),
+                completion_tokens_details: Chat.Completions.Response.Usage.CompletionTokensDetailsSchema.optional(),
+                prompt_tokens_details: Chat.Completions.Response.Usage.PromptTokensDetailsSchema.optional(),
+                cost: z
+                    .number()
+                    .describe("The cost in credits incurred for this completion."),
+                cost_details: Chat.Completions.Response.Usage.CostDetailsSchema.optional(),
+                total_cost: z
+                    .number()
+                    .describe("The total cost in credits incurred including upstream costs."),
+            })
+                .describe("Token and cost usage statistics for the completion.");
             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);
-                        const [weight_data, weight_dataChanged] = merge(a.weight_data, b.weight_data);
-                        if (choicesChanged || usageChanged || weight_dataChanged) {
-                            return [
-                                Object.assign(Object.assign({ id,
-                                    choices,
-                                    created,
-                                    model,
-                                    object }, (usage !== undefined ? { usage } : {})), (weight_data !== undefined ? { weight_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, 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 [weight, weightChanged] = merge(a.weight, b.weight);
-                        const [confidence, confidenceChanged] = merge(a.confidence, b.confidence);
+                        const [base, baseChanged] = Chat.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
                         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, CompletionMetadata.merged);
-                        if (deltaChanged ||
-                            finish_reasonChanged ||
-                            logprobsChanged ||
-                            weightChanged ||
-                            confidenceChanged ||
-                            errorChanged ||
-                            modelChanged ||
-                            model_indexChanged ||
-                            completion_metadataChanged) {
+                        if (baseChanged || errorChanged) {
                             return [
-                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ delta,
-                                    finish_reason,
-                                    index }, (logprobs !== undefined ? { logprobs } : {})), (weight !== undefined ? { weight } : {})), (confidence !== undefined ? { confidence } : {})), (error !== undefined ? { error } : {})), (model !== undefined ? { model } : {})), (model_index !== undefined ? { model_index } : {})), (completion_metadata !== undefined
-                                    ? { completion_metadata }
-                                    : {})),
+                                Object.assign(Object.assign({ index }, base), (error !== undefined ? { error } : {})),
                                 true,
                             ];
                         }
@@ -420,52 +1973,65 @@ export var Score;
                             return [a, false];
                         }
                     }
-                    Choice.merged = merged;
+                    ChatCompletionChunk.merged = merged;
                     function mergedList(a, b) {
                         let merged = undefined;
-                        for (const choice of b) {
-                            const existingIndex = a.findIndex(({ index }) => index === choice.index);
+                        for (const chunk of b) {
+                            const existingIndex = a.findIndex(({ index }) => index === chunk.index);
                             if (existingIndex === -1) {
                                 if (merged === undefined) {
-                                    merged = [...a, choice];
+                                    merged = [...a, chunk];
                                 }
                                 else {
-                                    merged.push(choice);
+                                    merged.push(chunk);
                                 }
                             }
                             else {
-                                const [mergedChoice, choiceChanged] = Choice.merged(a[existingIndex], choice);
-                                if (choiceChanged) {
+                                const [mergedChunk, chunkChanged] = ChatCompletionChunk.merged(a[existingIndex], chunk);
+                                if (chunkChanged) {
                                     if (merged === undefined) {
                                         merged = [...a];
                                     }
-                                    merged[existingIndex] = mergedChoice;
+                                    merged[existingIndex] = mergedChunk;
                                 }
                             }
                         }
                         return merged ? [merged, true] : [a, false];
                     }
-                    Choice.mergedList = mergedList;
-                })(Choice = Streaming.Choice || (Streaming.Choice = {}));
-                let Delta;
-                (function (Delta) {
+                    ChatCompletionChunk.mergedList = mergedList;
+                })(ChatCompletionChunk = Streaming.ChatCompletionChunk || (Streaming.ChatCompletionChunk = {}));
+                Streaming.ChatCompletionChunkSchema = Chat.Completions.Response.Streaming.ChatCompletionChunkSchema.extend({
+                    index: z
+                        .uint32()
+                        .describe("The index of the completion amongst all chat completions."),
+                    error: ObjectiveAIErrorSchema.optional().describe("An error encountered during the generation of this chat completion."),
+                }).describe("A chat completion chunk generated in the pursuit of a vector completion.");
+                let VectorCompletionChunk;
+                (function (VectorCompletionChunk) {
                     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 [reasoning, reasoningChanged] = merge(a.reasoning, b.reasoning, mergedString);
-                        const [images, imagesChanged] = merge(a.images, b.images, Chat.Completions.Response.Image.mergedList);
-                        const [vote, voteChanged] = merge(a.vote, b.vote);
-                        if (contentChanged ||
-                            reasoningChanged ||
-                            refusalChanged ||
-                            roleChanged ||
-                            tool_callsChanged ||
-                            imagesChanged ||
-                            voteChanged) {
+                        const id = a.id;
+                        const [completions, completionsChanged] = ChatCompletionChunk.mergedList(a.completions, b.completions);
+                        const [votes, votesChanged] = Vote.mergedList(a.votes, b.votes);
+                        const [scores, scoresChanged] = Scores.merged(a.scores, b.scores);
+                        const [weights, weightsChanged] = Weights.merged(a.weights, b.weights);
+                        const created = a.created;
+                        const ensemble = a.ensemble;
+                        const object = a.object;
+                        const [usage, usageChanged] = merge(a.usage, b.usage);
+                        if (completionsChanged ||
+                            votesChanged ||
+                            scoresChanged ||
+                            weightsChanged ||
+                            usageChanged) {
                             return [
-                                Object.assign(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 } : {})), (vote !== undefined ? { vote } : {})),
+                                Object.assign({ id,
+                                    completions,
+                                    votes,
+                                    scores,
+                                    weights,
+                                    created,
+                                    ensemble,
+                                    object }, (usage !== undefined ? { usage } : {})),
                                 true,
                             ];
                         }
@@ -473,91 +2039,846 @@ export var Score;
                             return [a, false];
                         }
                     }
-                    Delta.merged = merged;
-                })(Delta = Streaming.Delta || (Streaming.Delta = {}));
+                    VectorCompletionChunk.merged = merged;
+                })(VectorCompletionChunk = Streaming.VectorCompletionChunk || (Streaming.VectorCompletionChunk = {}));
+                Streaming.VectorCompletionChunkSchema = z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the vector completion."),
+                    completions: z
+                        .array(Streaming.ChatCompletionChunkSchema)
+                        .describe("The list of chat completion chunks created for this vector completion."),
+                    votes: Response.VotesSchema,
+                    scores: Response.ScoresSchema,
+                    weights: Response.WeightsSchema,
+                    created: z
+                        .uint32()
+                        .describe("The Unix timestamp (in seconds) when the vector completion was created."),
+                    ensemble: Response.EnsembleSchema,
+                    object: z.literal("vector.completion.chunk"),
+                    usage: Response.UsageSchema.optional(),
+                })
+                    .describe("A chunk in a streaming vector completion response.");
             })(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 = {}));
+            let Unary;
+            (function (Unary) {
+                Unary.ChatCompletionSchema = Chat.Completions.Response.Unary.ChatCompletionSchema.extend({
+                    index: z
+                        .uint32()
+                        .describe("The index of the completion amongst all chat completions."),
+                    error: ObjectiveAIErrorSchema.optional().describe("An error encountered during the generation of this chat completion."),
+                }).describe("A chat completion generated in the pursuit of a vector completion.");
+                Unary.VectorCompletionSchema = z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the vector completion."),
+                    completions: z
+                        .array(Unary.ChatCompletionSchema)
+                        .describe("The list of chat completions created for this vector completion."),
+                    votes: Response.VotesSchema,
+                    scores: Response.ScoresSchema,
+                    weights: Response.WeightsSchema,
+                    created: z
+                        .uint32()
+                        .describe("The Unix timestamp (in seconds) when the vector completion was created."),
+                    ensemble: Response.EnsembleSchema,
+                    object: z.literal("vector.completion"),
+                    usage: Response.UsageSchema,
+                })
+                    .describe("A unary vector completion response.");
+            })(Unary = Response.Unary || (Response.Unary = {}));
         })(Response = Completions.Response || (Completions.Response = {}));
-        async function list(openai, listOptions, options) {
-            const response = await openai.get("/score/completions", Object.assign({ query: listOptions }, options));
-            return response;
-        }
-        Completions.list = list;
-        async function publish(openai, id, options) {
-            await openai.post(`/score/completions/${id}/publish`, options);
-        }
-        Completions.publish = publish;
-        async function retrieve(openai, id, options) {
-            const response = await openai.get(`/score/completions/${id}`, options);
-            return response;
-        }
-        Completions.retrieve = retrieve;
-        async function trainingTableAdd(openai, id, correctVote, options) {
-            await openai.post(`/score/completions/${id}/training_table`, Object.assign({ body: { correct_vote: correctVote } }, options));
-        }
-        Completions.trainingTableAdd = trainingTableAdd;
-        async function trainingTableDelete(openai, id, options) {
-            await openai.delete(`/score/completions/${id}/training_table`, options);
-        }
-        Completions.trainingTableDelete = trainingTableDelete;
         async function create(openai, body, options) {
             var _a;
-            const response = await openai.post("/score/completions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+            const response = await openai.post("/vector/completions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
             return response;
         }
         Completions.create = create;
-    })(Completions = Score.Completions || (Score.Completions = {}));
-})(Score || (Score = {}));
-export var Multichat;
-(function (Multichat) {
-    let Completions;
-    (function (Completions) {
+    })(Completions = Vector.Completions || (Vector.Completions = {}));
+})(Vector || (Vector = {}));
+// Function
+export var Function;
+(function (Function_1) {
+    Function_1.VectorCompletionProfileSchema = z
+        .object({
+        ensemble: Vector.Completions.Request.EnsembleSchema,
+        profile: Vector.Completions.Request.ProfileSchema,
+    })
+        .describe("A vector completion profile containing an Ensemble and array of weights.");
+    Function_1.FunctionProfileVersionRequiredSchema = z
+        .union([
+        z.object({
+            function_author: z
+                .string()
+                .describe("The author of the function the profile was published to."),
+            function_id: z
+                .string()
+                .describe("The unique identifier of the function the profile was published to."),
+            author: z.string().describe("The author of the profile."),
+            id: z.string().describe("The unique identifier of the profile."),
+            version: z.uint32().describe("The version of the profile."),
+        }),
+        z.lazy(() => z.array(Function_1.ProfileVersionRequiredSchema).meta({
+            title: "ProfileVersionRequiredArray",
+            recursive: true,
+        })),
+    ])
+        .describe("A function profile where remote profiles must specify a version.");
+    Function_1.FunctionProfileVersionOptionalSchema = z
+        .union([
+        z.object({
+            function_author: z
+                .string()
+                .describe("The author of the function the profile was published to."),
+            function_id: z
+                .string()
+                .describe("The unique identifier of the function the profile was published to."),
+            author: z.string().describe("The author of the profile."),
+            id: z.string().describe("The unique identifier of the profile."),
+            version: z
+                .uint32()
+                .optional()
+                .nullable()
+                .describe("The version of the profile."),
+        }),
+        z
+            .lazy(() => z.array(Function_1.ProfileVersionOptionalSchema))
+            .meta({
+            title: "ProfileVersionOptionalArray",
+            recursive: true,
+        }),
+    ])
+        .describe("A function profile where remote profiles may omit a version.");
+    Function_1.ProfileVersionRequiredSchema = z
+        .union([
+        Function_1.FunctionProfileVersionRequiredSchema,
+        Function_1.VectorCompletionProfileSchema,
+    ])
+        .describe("A profile where remote function profiles must specify a version.");
+    Function_1.ProfileVersionOptionalSchema = z
+        .union([
+        Function_1.FunctionProfileVersionOptionalSchema,
+        Function_1.VectorCompletionProfileSchema,
+    ])
+        .describe("A profile where remote function profiles may omit a version.");
+    Function_1.InputSchemaSchema = z.lazy(() => z
+        .union([
+        InputSchema.ObjectSchema,
+        InputSchema.ArraySchema,
+        InputSchema.StringSchema,
+        InputSchema.NumberSchema,
+        InputSchema.IntegerSchema,
+        InputSchema.BooleanSchema,
+        InputSchema.ImageSchema,
+        InputSchema.AudioSchema,
+        InputSchema.VideoSchema,
+        InputSchema.FileSchema,
+    ])
+        .describe("An input schema defining the structure of function inputs."));
+    let InputSchema;
+    (function (InputSchema) {
+        InputSchema.ObjectSchema = z
+            .object({
+            type: z.literal("object"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the object input."),
+            properties: z
+                .record(z.string(), Function_1.InputSchemaSchema.meta({
+                title: "InputSchema",
+                recursive: true,
+            }))
+                .describe("The properties of the object input."),
+            required: z
+                .array(z.string())
+                .optional()
+                .nullable()
+                .describe("The required properties of the object input."),
+        })
+            .describe("An object input schema.");
+        InputSchema.ArraySchema = z
+            .object({
+            type: z.literal("array"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the array input."),
+            minItems: z
+                .uint32()
+                .optional()
+                .nullable()
+                .describe("The minimum number of items in the array input."),
+            maxItems: z
+                .uint32()
+                .optional()
+                .nullable()
+                .describe("The maximum number of items in the array input."),
+            items: Function_1.InputSchemaSchema.describe("The schema of the items in the array input.").meta({
+                title: "InputSchema",
+                recursive: true,
+            }),
+        })
+            .describe("An array input schema.");
+        InputSchema.StringSchema = z
+            .object({
+            type: z.literal("string"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the string input."),
+            enum: z
+                .array(z.string())
+                .optional()
+                .nullable()
+                .describe("The enumeration of allowed string values."),
+        })
+            .describe("A string input schema.");
+        InputSchema.NumberSchema = z
+            .object({
+            type: z.literal("number"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the number input."),
+            minimum: z
+                .number()
+                .optional()
+                .nullable()
+                .describe("The minimum allowed value for the number input."),
+            maximum: z
+                .number()
+                .optional()
+                .nullable()
+                .describe("The maximum allowed value for the number input."),
+        })
+            .describe("A number input schema.");
+        InputSchema.IntegerSchema = z
+            .object({
+            type: z.literal("integer"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the integer input."),
+            minimum: z
+                .uint32()
+                .optional()
+                .nullable()
+                .describe("The minimum allowed value for the integer input."),
+            maximum: z
+                .uint32()
+                .optional()
+                .nullable()
+                .describe("The maximum allowed value for the integer input."),
+        })
+            .describe("An integer input schema.");
+        InputSchema.BooleanSchema = z
+            .object({
+            type: z.literal("boolean"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the boolean input."),
+        })
+            .describe("A boolean input schema.");
+        InputSchema.ImageSchema = z
+            .object({
+            type: z.literal("image"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the image input."),
+        })
+            .describe("An image input schema.");
+        InputSchema.AudioSchema = z
+            .object({
+            type: z.literal("audio"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the audio input."),
+        })
+            .describe("An audio input schema.");
+        InputSchema.VideoSchema = z
+            .object({
+            type: z.literal("video"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the video input."),
+        })
+            .describe("A video input schema.");
+        InputSchema.FileSchema = z
+            .object({
+            type: z.literal("file"),
+            description: z
+                .string()
+                .optional()
+                .nullable()
+                .describe("The description of the file input."),
+        })
+            .describe("A file input schema.");
+    })(InputSchema = Function_1.InputSchema || (Function_1.InputSchema = {}));
+    Function_1.InputSchema_ = z
+        .lazy(() => z.union([
+        Message.RichContent.PartSchema,
+        z.record(z.string(), Function_1.InputSchema_.meta({
+            title: "Input",
+            recursive: true,
+        })),
+        z.array(Function_1.InputSchema_.meta({
+            title: "Input",
+            recursive: true,
+        })),
+        z.string(),
+        z.number(),
+        z.boolean(),
+    ]))
+        .describe("The input provided to the function.");
+    Function_1.InputExpressionSchema = z.lazy(() => z
+        .union([
+        Message.RichContent.PartSchema,
+        z.record(z.string(), Function_1.InputExpressionSchema.meta({
+            title: "InputExpression",
+            recursive: true,
+        })),
+        z.array(Function_1.InputExpressionSchema.meta({
+            title: "InputExpression",
+            recursive: true,
+        })),
+        z.string(),
+        z.number(),
+        z.boolean(),
+        ExpressionSchema.describe("An expression which evaluates to an input."),
+    ])
+        .describe(Function_1.InputSchema_.description));
+    Function_1.InputMapsExpressionSchema = z
+        .union([
+        ExpressionSchema.describe("An expression which evaluates to a 2D array of Inputs."),
+        z
+            .array(ExpressionSchema.describe("An expression which evaluates to a 1D array of Inputs."))
+            .describe("A list of expressions which each evaluate to a 1D array of Inputs."),
+    ])
+        .describe("An expression or list of expressions which evaluate to a 2D array of Inputs. Each sub-array will be fed into Tasks which specify an index of this input map.");
+    let TaskExpression;
+    (function (TaskExpression) {
+        TaskExpression.SkipSchema = ExpressionSchema.describe("An expression which evaluates to a boolean indicating whether to skip this task.");
+        TaskExpression.MapSchema = z
+            .uint32()
+            .describe("If present, indicates that this task should be ran once for each entry in the specified input map (input map is a 2D array indexed by this value).");
+        TaskExpression.ScalarFunctionSchema = z
+            .object({
+            type: z.literal("scalar.function"),
+            author: z
+                .string()
+                .describe("The author of the remote published scalar function."),
+            id: z
+                .string()
+                .describe("The unique identifier of the remote published scalar function."),
+            version: z
+                .uint32()
+                .describe("The version of the remote published scalar function."),
+            skip: TaskExpression.SkipSchema.optional().nullable(),
+            map: TaskExpression.MapSchema.optional().nullable(),
+            input: Function_1.InputExpressionSchema,
+        })
+            .describe("A remote published scalar function task.");
+        TaskExpression.VectorFunctionSchema = z
+            .object({
+            type: z.literal("vector.function"),
+            author: z
+                .string()
+                .describe("The author of the remote published vector function."),
+            id: z
+                .string()
+                .describe("The unique identifier of the remote published vector function."),
+            version: z
+                .uint32()
+                .describe("The version of the remote published vector function."),
+            skip: TaskExpression.SkipSchema.optional().nullable(),
+            map: TaskExpression.MapSchema.optional().nullable(),
+            input: Function_1.InputExpressionSchema,
+        })
+            .describe("A remote published vector function task.");
+        TaskExpression.VectorCompletionSchema = z
+            .object({
+            type: z.literal("vector.completion"),
+            skip: TaskExpression.SkipSchema.optional().nullable(),
+            map: TaskExpression.MapSchema.optional().nullable(),
+            messages: MessagesExpressionSchema,
+            tools: ToolsExpressionSchema.optional()
+                .nullable()
+                .describe(`${ToolsExpressionSchema.description} These are readonly and will only be useful for explaining prior tool calls or otherwise influencing behavior.`),
+            responses: VectorResponsesExpressionSchema,
+        })
+            .describe("A vector completion task.");
+    })(TaskExpression = Function_1.TaskExpression || (Function_1.TaskExpression = {}));
+    Function_1.TaskExpressionSchema = z
+        .discriminatedUnion("type", [
+        TaskExpression.ScalarFunctionSchema,
+        TaskExpression.VectorFunctionSchema,
+        TaskExpression.VectorCompletionSchema,
+    ])
+        .describe("A task to be executed as part of the function. Will first be compiled using the parent function's input. May be skipped or mapped.");
+    Function_1.TaskExpressionsSchema = z
+        .array(Function_1.TaskExpressionSchema)
+        .describe("The list of tasks to be executed as part of the function.");
+    Function_1.ScalarSchema = z
+        .object({
+        type: z.literal("scalar.function"),
+        author: z.string().describe("The author of the scalar function."),
+        id: z.string().describe("The unique identifier of the scalar function."),
+        version: z.uint32().describe("The version of the scalar function."),
+        description: z
+            .string()
+            .describe("The description of the scalar function."),
+        changelog: z
+            .string()
+            .optional()
+            .nullable()
+            .describe("When present, describes changes from the previous version or versions."),
+        input_schema: Function_1.InputSchemaSchema,
+        input_maps: Function_1.InputMapsExpressionSchema.optional().nullable(),
+        tasks: Function_1.TaskExpressionsSchema,
+        output: ExpressionSchema.describe("An expression which evaluates to a single number. This is the output of the scalar function. Will be provided with the outputs of all tasks."),
+    })
+        .describe("A scalar function.")
+        .meta({ title: "ScalarFunction" });
+    Function_1.VectorSchema = z
+        .object({
+        type: z.literal("vector.function"),
+        author: z.string().describe("The author of the vector function."),
+        id: z.string().describe("The unique identifier of the vector function."),
+        version: z.uint32().describe("The version of the vector function."),
+        description: z
+            .string()
+            .describe("The description of the vector function."),
+        changelog: z
+            .string()
+            .optional()
+            .nullable()
+            .describe("When present, describes changes from the previous version or versions."),
+        input_schema: Function_1.InputSchemaSchema,
+        input_maps: Function_1.InputMapsExpressionSchema.optional().nullable(),
+        tasks: Function_1.TaskExpressionsSchema,
+        output: ExpressionSchema.describe("An expressions which evaluates to an array of numbers. This is the output of the vector function. Will be provided with the outputs of all tasks."),
+        output_length: z
+            .union([
+            z.uint32().describe("The fixed length of the output vector."),
+            ExpressionSchema.describe("An expression which evaluates to the length of the output vector. Will only be provided with the function input. The output length must be determinable from the input alone."),
+        ])
+            .describe("The length of the output vector."),
+    })
+        .describe("A vector function.")
+        .meta({ title: "VectorFunction" });
+    let Executions;
+    (function (Executions) {
+        let Request;
+        (function (Request) {
+            Request.FunctionExecutionParamsBaseSchema = z
+                .object({
+                retry_token: z
+                    .string()
+                    .optional()
+                    .nullable()
+                    .describe("The retry token provided by a previous incomplete or failed function execution."),
+                input: Function_1.InputSchema_,
+                provider: Chat.Completions.Request.ProviderSchema.optional().nullable(),
+                seed: Chat.Completions.Request.SeedSchema.optional().nullable(),
+                backoff_max_elapsed_time: Chat.Completions.Request.BackoffMaxElapsedTimeSchema.optional().nullable(),
+                first_chunk_timeout: Chat.Completions.Request.FirstChunkTimeoutSchema.optional().nullable(),
+                other_chunk_timeout: Chat.Completions.Request.OtherChunkTimeoutSchema.optional().nullable(),
+            })
+                .describe("Base parameters for executing a function.");
+            // Execute Inline Function
+            Request.FunctionExecutionParamsExecuteInlineBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
+                function: z.lazy(() => FunctionSchema),
+                profile: Function_1.FunctionProfileVersionOptionalSchema,
+            }).describe("Base parameters for executing an inline function.");
+            Request.FunctionExecutionParamsExecuteInlineStreamingSchema = Request.FunctionExecutionParamsExecuteInlineBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamTrueSchema,
+            })
+                .describe("Parameters for executing an inline function and streaming the response.")
+                .meta({ title: "FunctionExecutionParamsExecuteInlineStreaming" });
+            Request.FunctionExecutionParamsExecuteInlineNonStreamingSchema = Request.FunctionExecutionParamsExecuteInlineBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
+            })
+                .describe("Parameters for executing an inline function with a unary response.")
+                .meta({ title: "FunctionExecutionParamsExecuteInlineNonStreaming" });
+            Request.FunctionExecutionParamsExecuteInlineSchema = z
+                .union([
+                Request.FunctionExecutionParamsExecuteInlineStreamingSchema,
+                Request.FunctionExecutionParamsExecuteInlineNonStreamingSchema,
+            ])
+                .describe("Parameters for executing an inline function.")
+                .meta({ title: "FunctionExecutionParamsExecuteInline" });
+            // Execute Published Function
+            Request.FunctionExecutionParamsExecuteBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
+                profile: Function_1.FunctionProfileVersionOptionalSchema.optional().nullable(),
+            }).describe("Base parameters for executing a remote published function.");
+            Request.FunctionExecutionParamsExecuteStreamingSchema = Request.FunctionExecutionParamsExecuteBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamTrueSchema,
+            })
+                .describe("Parameters for executing a remote published function and streaming the response.")
+                .meta({ title: "FunctionExecutionParamsExecuteStreaming" });
+            Request.FunctionExecutionParamsExecuteNonStreamingSchema = Request.FunctionExecutionParamsExecuteBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
+            })
+                .describe("Parameters for executing a remote published function with a unary response.")
+                .meta({ title: "FunctionExecutionParamsExecuteNonStreaming" });
+            Request.FunctionExecutionParamsExecuteSchema = z
+                .union([
+                Request.FunctionExecutionParamsExecuteStreamingSchema,
+                Request.FunctionExecutionParamsExecuteNonStreamingSchema,
+            ])
+                .describe("Parameters for executing a remote published function.")
+                .meta({ title: "FunctionExecutionParamsExecute" });
+            // Publish Scalar Function
+            Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
+                function: Function_1.ScalarSchema,
+                publish_function: z
+                    .object({
+                    description: z
+                        .string()
+                        .describe("The description of the published scalar function."),
+                    changelog: z
+                        .string()
+                        .optional()
+                        .nullable()
+                        .describe("When present, describes changes from the previous version or versions."),
+                    input_schema: Function_1.InputSchemaSchema,
+                })
+                    .describe("Details about the scalar function to be published."),
+                profile: Function_1.FunctionProfileVersionRequiredSchema,
+                publish_profile: z
+                    .object({
+                    id: z
+                        .literal("default")
+                        .describe('The identifier of the profile to publish. Must be "default" when publishing a function.'),
+                    version: z
+                        .uint32()
+                        .describe("The version of the profile to publish. Must match the function's version."),
+                    description: z
+                        .string()
+                        .describe("The description of the published profile."),
+                    changelog: z
+                        .string()
+                        .optional()
+                        .nullable()
+                        .describe("When present, describes changes from the previous version or versions."),
+                })
+                    .describe("Details about the profile to be published."),
+            }).describe("Base parameters for executing and publishing an inline scalar function.");
+            Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema = Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamTrueSchema,
+            })
+                .describe("Parameters for executing and publishing an inline scalar function and streaming the response.")
+                .meta({
+                title: "FunctionExecutionParamsPublishScalarFunctionStreaming",
+            });
+            Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema = Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
+            })
+                .describe("Parameters for executing and publishing an inline scalar function with a unary response.")
+                .meta({
+                title: "FunctionExecutionParamsPublishScalarFunctionNonStreaming",
+            });
+            Request.FunctionExecutionParamsPublishScalarFunctionSchema = z
+                .union([
+                Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema,
+                Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema,
+            ])
+                .describe("Parameters for executing and publishing an inline scalar function.")
+                .meta({ title: "FunctionExecutionParamsPublishScalarFunction" });
+            // Publish Vector Function
+            Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
+                function: Function_1.VectorSchema,
+                publish_function: z
+                    .object({
+                    description: z
+                        .string()
+                        .describe("The description of the published vector function."),
+                    changelog: z
+                        .string()
+                        .optional()
+                        .nullable()
+                        .describe("When present, describes changes from the previous version or versions."),
+                    input_schema: Function_1.InputSchemaSchema,
+                    output_length: z
+                        .union([
+                        z.uint32().describe("The fixed length of the output vector."),
+                        ExpressionSchema.describe("An expression which evaluates to the length of the output vector. Will only be provided with the function input. The output length must be determinable from the input alone."),
+                    ])
+                        .describe("The length of the output vector."),
+                })
+                    .describe("Details about the vector function to be published."),
+                profile: Function_1.FunctionProfileVersionRequiredSchema,
+                publish_profile: z
+                    .object({
+                    id: z
+                        .literal("default")
+                        .describe('The identifier of the profile to publish. Must be "default" when publishing a function.'),
+                    version: z
+                        .uint32()
+                        .describe("The version of the profile to publish. Must match the function's version."),
+                    description: z
+                        .string()
+                        .describe("The description of the published profile."),
+                    changelog: z
+                        .string()
+                        .optional()
+                        .nullable()
+                        .describe("When present, describes changes from the previous version or versions."),
+                })
+                    .describe("Details about the profile to be published."),
+            }).describe("Base parameters for executing and publishing an inline vector function.");
+            Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema = Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamTrueSchema,
+            })
+                .describe("Parameters for executing and publishing an inline vector function and streaming the response.")
+                .meta({
+                title: "FunctionExecutionParamsPublishVectorFunctionStreaming",
+            });
+            Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema = Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
+            })
+                .describe("Parameters for executing and publishing an inline vector function with a unary response.")
+                .meta({
+                title: "FunctionExecutionParamsPublishVectorFunctionNonStreaming",
+            });
+            Request.FunctionExecutionParamsPublishVectorFunctionSchema = z
+                .union([
+                Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema,
+                Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema,
+            ])
+                .describe("Parameters for executing and publishing an inline vector function.")
+                .meta({ title: "FunctionExecutionParamsPublishVectorFunction" });
+            // Publish Function
+            Request.FunctionExecutionParamsPublishFunctionStreamingSchema = z
+                .union([
+                Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema,
+                Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema,
+            ])
+                .describe("Parameters for executing and publishing an inline function and streaming the response.")
+                .meta({ title: "FunctionExecutionParamsPublishFunctionStreaming" });
+            Request.FunctionExecutionParamsPublishFunctionNonStreamingSchema = z
+                .union([
+                Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema,
+                Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema,
+            ])
+                .describe("Parameters for executing and publishing an inline function with a unary response.")
+                .meta({ title: "FunctionExecutionParamsPublishFunctionNonStreaming" });
+            Request.FunctionExecutionParamsPublishFunctionSchema = z
+                .union([
+                Request.FunctionExecutionParamsPublishScalarFunctionSchema,
+                Request.FunctionExecutionParamsPublishVectorFunctionSchema,
+            ])
+                .describe("Parameters for executing and publishing an inline function.")
+                .meta({ title: "FunctionExecutionParamsPublishFunction" });
+            // Publish Profile
+            Request.FunctionExecutionParamsPublishProfileBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
+                profile: z
+                    .array(Function_1.ProfileVersionRequiredSchema)
+                    .describe("The profile to publish."),
+                publish_profile: z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the profile to publish."),
+                    version: z
+                        .uint32()
+                        .describe("The version of the profile to publish."),
+                    description: z
+                        .string()
+                        .describe("The description of the published profile."),
+                    changelog: z
+                        .string()
+                        .optional()
+                        .nullable()
+                        .describe("When present, describes changes from the previous version or versions."),
+                })
+                    .describe("Details about the profile to be published."),
+            }).describe("Base parameters for executing a remote published function and publishing a profile.");
+            Request.FunctionExecutionParamsPublishProfileStreamingSchema = Request.FunctionExecutionParamsPublishProfileBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamTrueSchema,
+            })
+                .describe("Parameters for executing a remote published function, publishing a profile, and streaming the response.")
+                .meta({ title: "FunctionExecutionParamsPublishProfileStreaming" });
+            Request.FunctionExecutionParamsPublishProfileNonStreamingSchema = Request.FunctionExecutionParamsPublishProfileBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
+            })
+                .describe("Parameters for executing a remote published function and publishing a profile with a unary response.")
+                .meta({ title: "FunctionExecutionParamsPublishProfileNonStreaming" });
+            Request.FunctionExecutionParamsPublishProfileSchema = z
+                .union([
+                Request.FunctionExecutionParamsPublishProfileStreamingSchema,
+                Request.FunctionExecutionParamsPublishProfileNonStreamingSchema,
+            ])
+                .describe("Parameters for executing a remote published function and publishing a profile.")
+                .meta({ title: "FunctionExecutionParamsPublishProfile" });
+        })(Request = Executions.Request || (Executions.Request = {}));
         let Response;
         (function (Response) {
+            let Task;
+            (function (Task) {
+                Task.IndexSchema = z
+                    .uint32()
+                    .describe("The index of the task in the sequence of tasks.");
+                Task.TaskIndexSchema = z
+                    .uint32()
+                    .describe("The index of the task amongst all mapped and non-skipped compiled tasks. Used internally.");
+                Task.TaskPathSchema = z
+                    .array(z.uint32())
+                    .describe("The path of this task which may be used to navigate which nested task this is amongst the root functions tasks and sub-tasks.");
+            })(Task = Response.Task || (Response.Task = {}));
             let Streaming;
             (function (Streaming) {
-                let ChatCompletionChunk;
-                (function (ChatCompletionChunk) {
+                let TaskChunk;
+                (function (TaskChunk) {
+                    function merged(a, b) {
+                        if ("scores" in a) {
+                            return VectorCompletion.merged(a, b);
+                        }
+                        else {
+                            return Function.merged(a, b);
+                        }
+                    }
+                    TaskChunk.merged = merged;
+                    function mergedList(a, b) {
+                        let merged = undefined;
+                        for (const chunk of b) {
+                            const existingIndex = a.findIndex(({ index }) => index === chunk.index);
+                            if (existingIndex === -1) {
+                                if (merged === undefined) {
+                                    merged = [...a, chunk];
+                                }
+                                else {
+                                    merged.push(chunk);
+                                }
+                            }
+                            else {
+                                const [mergedChunk, chunkChanged] = TaskChunk.merged(a[existingIndex], chunk);
+                                if (chunkChanged) {
+                                    if (merged === undefined) {
+                                        merged = [...a];
+                                    }
+                                    merged[existingIndex] = mergedChunk;
+                                }
+                            }
+                        }
+                        return merged ? [merged, true] : [a, false];
+                    }
+                    TaskChunk.mergedList = mergedList;
+                    let Function;
+                    (function (Function) {
+                        function merged(a, b) {
+                            const index = a.index;
+                            const task_index = a.task_index;
+                            const task_path = a.task_path;
+                            const [base, baseChanged] = FunctionExecutionChunk.merged(a, b);
+                            if (baseChanged) {
+                                return [
+                                    Object.assign({ index,
+                                        task_index,
+                                        task_path }, base),
+                                    true,
+                                ];
+                            }
+                            else {
+                                return [a, false];
+                            }
+                        }
+                        Function.merged = merged;
+                    })(Function = TaskChunk.Function || (TaskChunk.Function = {}));
+                    TaskChunk.FunctionSchema = z
+                        .lazy(() => Streaming.FunctionExecutionChunkSchema.extend({
+                        index: Task.IndexSchema,
+                        task_index: Task.TaskIndexSchema,
+                        task_path: Task.TaskPathSchema,
+                        tasks: z
+                            .array(Streaming.TaskChunkSchema)
+                            .meta({
+                            title: "TaskChunkArray",
+                            recursive: true,
+                        })
+                            .describe("The tasks executed as part of the function execution."),
+                    }))
+                        .describe("A chunk of a function execution task.");
+                    let VectorCompletion;
+                    (function (VectorCompletion) {
+                        function merged(a, b) {
+                            const index = a.index;
+                            const task_index = a.task_index;
+                            const task_path = a.task_path;
+                            const [base, baseChanged] = Vector.Completions.Response.Streaming.VectorCompletionChunk.merged(a, b);
+                            const [error, errorChanged] = merge(a.error, b.error);
+                            if (baseChanged || errorChanged) {
+                                return [
+                                    Object.assign(Object.assign({ index,
+                                        task_index,
+                                        task_path }, base), (error !== undefined ? { error } : {})),
+                                    true,
+                                ];
+                            }
+                            else {
+                                return [a, false];
+                            }
+                        }
+                        VectorCompletion.merged = merged;
+                    })(VectorCompletion = TaskChunk.VectorCompletion || (TaskChunk.VectorCompletion = {}));
+                    TaskChunk.VectorCompletionSchema = Vector.Completions.Response.Streaming.VectorCompletionChunkSchema.extend({
+                        index: Task.IndexSchema,
+                        task_index: Task.TaskIndexSchema,
+                        task_path: Task.TaskPathSchema,
+                        error: ObjectiveAIErrorSchema.optional().describe("When present, indicates that an error occurred during the vector completion task."),
+                    }).describe("A chunk of a vector completion task.");
+                })(TaskChunk = Streaming.TaskChunk || (Streaming.TaskChunk = {}));
+                Streaming.TaskChunkSchema = z
+                    .union([TaskChunk.FunctionSchema, TaskChunk.VectorCompletionSchema])
+                    .describe("A chunk of a task execution.");
+                let FunctionExecutionChunk;
+                (function (FunctionExecutionChunk) {
                     function merged(a, b) {
                         const id = a.id;
-                        const [choices, choicesChanged] = Choice.mergedList(a.choices, b.choices);
+                        const [tasks, tasksChanged] = TaskChunk.mergedList(a.tasks, b.tasks);
+                        const [tasks_errors, tasks_errorsChanged] = merge(a.tasks_errors, b.tasks_errors);
+                        const [output, outputChanged] = merge(a.output, b.output);
+                        const [error, errorChanged] = merge(a.error, b.error);
+                        const [retry_token, retry_tokenChanged] = merge(a.retry_token, b.retry_token);
+                        const [function_published, function_publishedChanged] = merge(a.function_published, b.function_published);
+                        const [profile_published, profile_publishedChanged] = merge(a.profile_published, b.profile_published);
                         const created = a.created;
-                        const model = a.model;
+                        const function_ = a.function;
+                        const profile = a.profile;
                         const object = a.object;
-                        const [usage, usageChanged] = merge(a.usage, b.usage, Chat.Completions.Response.Usage.merged);
-                        if (choicesChanged || usageChanged) {
+                        const [usage, usageChanged] = merge(a.usage, b.usage);
+                        if (tasksChanged ||
+                            tasks_errorsChanged ||
+                            outputChanged ||
+                            errorChanged ||
+                            retry_tokenChanged ||
+                            function_publishedChanged ||
+                            profile_publishedChanged ||
+                            usageChanged) {
                             return [
-                                Object.assign({ id,
-                                    choices,
-                                    created,
-                                    model,
-                                    object }, (usage !== undefined ? { usage } : {})),
+                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ id,
+                                    tasks }, (tasks_errors !== undefined ? { tasks_errors } : {})), (output !== undefined ? { output } : {})), (error !== undefined ? { error } : {})), (retry_token !== undefined ? { retry_token } : {})), (function_published !== undefined
+                                    ? { function_published }
+                                    : {})), (profile_published !== undefined
+                                    ? { profile_published }
+                                    : {})), { created, function: function_, profile,
+                                    object }), (usage !== undefined ? { usage } : {})),
                                 true,
                             ];
                         }
@@ -565,32 +2886,271 @@ export var Multichat;
                             return [a, false];
                         }
                     }
-                    ChatCompletionChunk.merged = merged;
-                })(ChatCompletionChunk = Streaming.ChatCompletionChunk || (Streaming.ChatCompletionChunk = {}));
-                let Choice;
-                (function (Choice) {
+                    FunctionExecutionChunk.merged = merged;
+                })(FunctionExecutionChunk = Streaming.FunctionExecutionChunk || (Streaming.FunctionExecutionChunk = {}));
+                Streaming.FunctionExecutionChunkSchema = z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the function execution."),
+                    tasks: z
+                        .array(Streaming.TaskChunkSchema)
+                        .describe("The tasks executed as part of the function execution."),
+                    tasks_errors: z
+                        .boolean()
+                        .optional()
+                        .describe("When true, indicates that one or more tasks encountered errors during execution."),
+                    output: z
+                        .union([
+                        z
+                            .number()
+                            .describe("The scalar output of the function execution."),
+                        z
+                            .array(z.number())
+                            .describe("The vector output of the function execution."),
+                        JsonValueSchema.describe("The erroneous output of the function execution."),
+                    ])
+                        .optional()
+                        .describe("The output of the function execution."),
+                    error: ObjectiveAIErrorSchema.optional().describe("When present, indicates that an error occurred during the function execution."),
+                    retry_token: z
+                        .string()
+                        .optional()
+                        .describe("A token which may be used to retry the function execution."),
+                    function_published: z
+                        .boolean()
+                        .optional()
+                        .describe("When true, indicates that a function was published as part of this execution."),
+                    profile_published: z
+                        .boolean()
+                        .optional()
+                        .describe("When true, indicates that a profile was published as part of this execution."),
+                    created: z
+                        .uint32()
+                        .describe("The UNIX timestamp (in seconds) when the function execution chunk was created."),
+                    function: z
+                        .string()
+                        .nullable()
+                        .describe("The unique identifier of the function being executed."),
+                    profile: z
+                        .string()
+                        .nullable()
+                        .describe("The unique identifier of the profile being used."),
+                    object: z
+                        .enum([
+                        "scalar.function.execution.chunk",
+                        "vector.function.execution.chunk",
+                    ])
+                        .describe("The object type."),
+                    usage: Vector.Completions.Response.UsageSchema.optional(),
+                })
+                    .describe("A chunk of a function execution.");
+            })(Streaming = Response.Streaming || (Response.Streaming = {}));
+            let Unary;
+            (function (Unary) {
+                let Task;
+                (function (Task) {
+                    Task.FunctionSchema = z
+                        .lazy(() => Unary.FunctionExecutionSchema.extend({
+                        index: Response.Task.IndexSchema,
+                        task_index: Response.Task.TaskIndexSchema,
+                        task_path: Response.Task.TaskPathSchema,
+                        tasks: z
+                            .array(Unary.TaskSchema)
+                            .meta({
+                            title: "TaskArray",
+                            recursive: true,
+                        })
+                            .describe("The tasks executed as part of the function execution."),
+                    }))
+                        .describe("A function execution task.");
+                    Task.VectorCompletionSchema = Vector.Completions.Response.Unary.VectorCompletionSchema.extend({
+                        index: Response.Task.IndexSchema,
+                        task_index: Response.Task.TaskIndexSchema,
+                        task_path: Response.Task.TaskPathSchema,
+                        error: ObjectiveAIErrorSchema.nullable().describe("When non-null, indicates that an error occurred during the vector completion task."),
+                    }).describe("A vector completion task.");
+                })(Task = Unary.Task || (Unary.Task = {}));
+                Unary.TaskSchema = z
+                    .union([Task.FunctionSchema, Task.VectorCompletionSchema])
+                    .describe("A task execution.");
+                Unary.FunctionExecutionSchema = z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the function execution."),
+                    tasks: z
+                        .array(Unary.TaskSchema)
+                        .describe("The tasks executed as part of the function execution."),
+                    tasks_errors: z
+                        .boolean()
+                        .describe("When true, indicates that one or more tasks encountered errors during execution."),
+                    output: z
+                        .union([
+                        z
+                            .number()
+                            .describe("The scalar output of the function execution."),
+                        z
+                            .array(z.number())
+                            .describe("The vector output of the function execution."),
+                        JsonValueSchema.describe("The erroneous output of the function execution."),
+                    ])
+                        .describe("The output of the function execution."),
+                    error: ObjectiveAIErrorSchema.nullable().describe("When non-null, indicates that an error occurred during the function execution."),
+                    retry_token: z
+                        .string()
+                        .nullable()
+                        .describe("A token which may be used to retry the function execution."),
+                    function_published: z
+                        .boolean()
+                        .optional()
+                        .describe("When true, indicates that a function was published as part of this execution."),
+                    profile_published: z
+                        .boolean()
+                        .optional()
+                        .describe("When true, indicates that a profile was published as part of this execution."),
+                    created: z
+                        .uint32()
+                        .describe("The UNIX timestamp (in seconds) when the function execution chunk was created."),
+                    function: z
+                        .string()
+                        .nullable()
+                        .describe("The unique identifier of the function being executed."),
+                    profile: z
+                        .string()
+                        .nullable()
+                        .describe("The unique identifier of the profile being used."),
+                    object: z
+                        .enum(["scalar.function.execution", "vector.function.execution"])
+                        .describe("The object type."),
+                    usage: Vector.Completions.Response.UsageSchema,
+                })
+                    .describe("A function execution.");
+            })(Unary = Response.Unary || (Response.Unary = {}));
+        })(Response = Executions.Response || (Executions.Response = {}));
+    })(Executions = Function_1.Executions || (Function_1.Executions = {}));
+    let ComputeProfile;
+    (function (ComputeProfile) {
+        let Request;
+        (function (Request) {
+            let DatasetItem;
+            (function (DatasetItem) {
+                let Target;
+                (function (Target) {
+                    Target.ScalarSchema = z
+                        .object({
+                        type: z.literal("scalar"),
+                        value: z.number(),
+                    })
+                        .describe("A scalar target output. The desired output is this exact scalar.");
+                    Target.VectorSchema = z
+                        .object({
+                        type: z.literal("vector"),
+                        value: z.array(z.number()),
+                    })
+                        .describe("A vector target output. The desired output is this exact vector.");
+                    Target.VectorWinnerSchema = z
+                        .object({
+                        type: z.literal("vector_winner"),
+                        value: z.uint32(),
+                    })
+                        .describe("A vector winner target output. The desired output is a vector where the highest value is at the specified index.");
+                })(Target = DatasetItem.Target || (DatasetItem.Target = {}));
+                DatasetItem.TargetSchema = z
+                    .discriminatedUnion("type", [
+                    Target.ScalarSchema,
+                    Target.VectorSchema,
+                    Target.VectorWinnerSchema,
+                ])
+                    .describe("The target output for a given function input.");
+            })(DatasetItem = Request.DatasetItem || (Request.DatasetItem = {}));
+            Request.DatasetItemSchema = z
+                .object({
+                input: Function_1.InputSchema_,
+                target: DatasetItem.TargetSchema,
+            })
+                .describe("A Function input and its corresponding target output.");
+            Request.FunctionComputeProfileParamsBaseSchema = z
+                .object({
+                retry_token: z
+                    .string()
+                    .optional()
+                    .nullable()
+                    .describe("The retry token provided by a previous incomplete or failed profile computation."),
+                max_retries: z
+                    .uint32()
+                    .optional()
+                    .nullable()
+                    .describe("The maximum number of retries to attempt when a function execution fails during profile computation."),
+                n: z
+                    .uint32()
+                    .describe("The number of function executions to perform per dataset item. Generally speaking, higher N values increase the quality of the computed profile."),
+                dataset: z
+                    .array(Request.DatasetItemSchema)
+                    .describe("The dataset of input and target output pairs to use for computing the profile."),
+                ensemble: Vector.Completions.Request.EnsembleSchema,
+                provider: Chat.Completions.Request.ProviderSchema.optional().nullable(),
+                seed: Chat.Completions.Request.SeedSchema.optional().nullable(),
+                backoff_max_elapsed_time: Chat.Completions.Request.BackoffMaxElapsedTimeSchema.optional().nullable(),
+                first_chunk_timeout: Chat.Completions.Request.FirstChunkTimeoutSchema.optional().nullable(),
+                other_chunk_timeout: Chat.Completions.Request.OtherChunkTimeoutSchema.optional().nullable(),
+            })
+                .describe("Base parameters for computing a function profile.");
+            Request.FunctionComputeProfileParamsStreamingSchema = Request.FunctionComputeProfileParamsBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamTrueSchema,
+            })
+                .describe("Parameters for computing a function profile and streaming the response.")
+                .meta({ title: "FunctionComputeProfileParamsStreaming" });
+            Request.FunctionComputeProfileParamsNonStreamingSchema = Request.FunctionComputeProfileParamsBaseSchema.extend({
+                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
+            })
+                .describe("Parameters for computing a function profile with a unary response.")
+                .meta({ title: "FunctionComputeProfileParamsNonStreaming" });
+            Request.FunctionComputeProfileParamsSchema = z
+                .union([
+                Request.FunctionComputeProfileParamsStreamingSchema,
+                Request.FunctionComputeProfileParamsNonStreamingSchema,
+            ])
+                .describe("Parameters for computing a function profile.")
+                .meta({ title: "FunctionComputeProfileParams" });
+        })(Request = ComputeProfile.Request || (ComputeProfile.Request = {}));
+        let Response;
+        (function (Response) {
+            Response.FittingStatsSchema = z
+                .object({
+                loss: z
+                    .number()
+                    .describe("The final sum loss achieved during weights fitting."),
+                executions: z
+                    .uint32()
+                    .describe("The total number of function executions used during weights fitting."),
+                starts: z
+                    .uint32()
+                    .describe("The number of fitting starts attempted. Each start begins with a randomized weight vector."),
+                rounds: z
+                    .uint32()
+                    .describe("The number of fitting rounds performed across all starts."),
+                errors: z
+                    .uint32()
+                    .describe("The number of errors which occured while computing outputs during fitting."),
+            })
+                .describe("Statistics about the fitting process used to compute the weights for the profile.");
+            let Streaming;
+            (function (Streaming) {
+                let FunctionExecutionChunk;
+                (function (FunctionExecutionChunk) {
                     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) {
+                        const dataset = a.dataset;
+                        const n = a.n;
+                        const retry = a.retry;
+                        const [base, baseChanged] = Executions.Response.Streaming.FunctionExecutionChunk.merged(a, b);
+                        if (baseChanged) {
                             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 }
-                                    : {})),
+                                Object.assign({ index,
+                                    dataset,
+                                    n,
+                                    retry }, base),
                                 true,
                             ];
                         }
@@ -598,205 +3158,343 @@ export var Multichat;
                             return [a, false];
                         }
                     }
-                    Choice.merged = merged;
+                    FunctionExecutionChunk.merged = merged;
                     function mergedList(a, b) {
                         let merged = undefined;
-                        for (const choice of b) {
-                            const existingIndex = a.findIndex(({ index }) => index === choice.index);
+                        for (const chunk of b) {
+                            const existingIndex = a.findIndex(({ index }) => index === chunk.index);
                             if (existingIndex === -1) {
                                 if (merged === undefined) {
-                                    merged = [...a, choice];
+                                    merged = [...a, chunk];
                                 }
                                 else {
-                                    merged.push(choice);
+                                    merged.push(chunk);
                                 }
                             }
                             else {
-                                const [mergedChoice, choiceChanged] = Choice.merged(a[existingIndex], choice);
-                                if (choiceChanged) {
+                                const [mergedChunk, chunkChanged] = FunctionExecutionChunk.merged(a[existingIndex], chunk);
+                                if (chunkChanged) {
                                     if (merged === undefined) {
                                         merged = [...a];
                                     }
-                                    merged[existingIndex] = mergedChoice;
+                                    merged[existingIndex] = mergedChunk;
                                 }
                             }
                         }
                         return merged ? [merged, true] : [a, false];
                     }
-                    Choice.mergedList = mergedList;
-                })(Choice = Streaming.Choice || (Streaming.Choice = {}));
+                    FunctionExecutionChunk.mergedList = mergedList;
+                })(FunctionExecutionChunk = Streaming.FunctionExecutionChunk || (Streaming.FunctionExecutionChunk = {}));
+                Streaming.FunctionExecutionChunkSchema = Executions.Response.Streaming.FunctionExecutionChunkSchema.extend({
+                    index: z
+                        .uint32()
+                        .describe("The index of the function execution chunk in the list of executions."),
+                    dataset: z
+                        .uint32()
+                        .describe("The index of the dataset item this function execution chunk corresponds to."),
+                    n: z
+                        .uint32()
+                        .describe("The N index for this function execution chunk. There will be N function executions, and N comes from the request parameters."),
+                    retry: z
+                        .uint32()
+                        .describe("The retry index for this function execution chunk. There may be multiple retries for a given dataset item and N index."),
+                }).describe("A chunk of a function execution ran during profile computation.");
+                let FunctionComputeProfileChunk;
+                (function (FunctionComputeProfileChunk) {
+                    function merged(a, b) {
+                        const id = a.id;
+                        const [executions, executionsChanged] = FunctionExecutionChunk.mergedList(a.executions, b.executions);
+                        const [executions_errors, executions_errorsChanged] = merge(a.executions_errors, b.executions_errors);
+                        const [profile, profileChanged] = merge(a.profile, b.profile);
+                        const [fitting_stats, fitting_statsChanged] = merge(a.fitting_stats, b.fitting_stats);
+                        const created = a.created;
+                        const function_ = a.function;
+                        const object = a.object;
+                        const [usage, usageChanged] = merge(a.usage, b.usage);
+                        if (executionsChanged ||
+                            executions_errorsChanged ||
+                            profileChanged ||
+                            fitting_statsChanged ||
+                            usageChanged) {
+                            return [
+                                Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ id,
+                                    executions }, (executions_errors !== undefined
+                                    ? { executions_errors }
+                                    : {})), (profile !== undefined ? { profile } : {})), (fitting_stats !== undefined ? { fitting_stats } : {})), { created, function: function_, object }), (usage !== undefined ? { usage } : {})),
+                                true,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    FunctionComputeProfileChunk.merged = merged;
+                })(FunctionComputeProfileChunk = Streaming.FunctionComputeProfileChunk || (Streaming.FunctionComputeProfileChunk = {}));
+                Streaming.FunctionComputeProfileChunkSchema = z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the function profile computation chunk."),
+                    executions: z
+                        .array(Streaming.FunctionExecutionChunkSchema)
+                        .describe("The function executions performed as part of computing the profile."),
+                    executions_errors: z
+                        .boolean()
+                        .optional()
+                        .describe("When true, indicates that one or more function executions encountered errors during profile computation."),
+                    profile: z
+                        .array(Function_1.ProfileVersionRequiredSchema)
+                        .optional()
+                        .describe("The computed function profile."),
+                    fitting_stats: Response.FittingStatsSchema.optional(),
+                    created: z
+                        .uint32()
+                        .describe("The UNIX timestamp (in seconds) when the function profile computation was created."),
+                    function: z
+                        .string()
+                        .describe("The unique identifier of the function for which the profile is being computed."),
+                    object: z.literal("function.compute.profile.chunk"),
+                    usage: Vector.Completions.Response.UsageSchema.optional(),
+                })
+                    .describe("A chunk of a function profile computation.");
             })(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);
+            let Unary;
+            (function (Unary) {
+                Unary.FunctionExecutionSchema = Executions.Response.Unary.FunctionExecutionSchema.extend({
+                    index: z
+                        .uint32()
+                        .describe("The index of the function execution in the list of executions."),
+                    dataset: z
+                        .uint32()
+                        .describe("The index of the dataset item this function execution corresponds to."),
+                    n: z
+                        .uint32()
+                        .describe("The N index for this function execution. There will be N function executions, and N comes from the request parameters."),
+                    retry: z
+                        .uint32()
+                        .describe("The retry index for this function execution. There may be multiple retries for a given dataset item and N index."),
+                }).describe("A function execution ran during profile computation.");
+                Unary.FunctionComputeProfileSchema = z
+                    .object({
+                    id: z
+                        .string()
+                        .describe("The unique identifier of the function profile computation."),
+                    executions: z
+                        .array(Unary.FunctionExecutionSchema)
+                        .describe("The function executions performed as part of computing the profile."),
+                    executions_errors: z
+                        .boolean()
+                        .describe("When true, indicates that one or more function executions encountered errors during profile computation."),
+                    profile: z
+                        .array(Function_1.ProfileVersionRequiredSchema)
+                        .describe("The computed function profile."),
+                    fitting_stats: Response.FittingStatsSchema,
+                    created: z
+                        .uint32()
+                        .describe("The UNIX timestamp (in seconds) when the function profile computation was created."),
+                    function: z
+                        .string()
+                        .describe("The unique identifier of the function for which the profile is being computed."),
+                    object: z.literal("function.compute.profile"),
+                    usage: Vector.Completions.Response.UsageSchema,
+                })
+                    .describe("A function profile computation.");
+            })(Unary = Response.Unary || (Response.Unary = {}));
+        })(Response = ComputeProfile.Response || (ComputeProfile.Response = {}));
+    })(ComputeProfile = Function_1.ComputeProfile || (Function_1.ComputeProfile = {}));
+    let Profile;
+    (function (Profile) {
+        Profile.ListItemSchema = z.object({
+            function_author: z
+                .string()
+                .describe("The author of the function the profile was published to."),
+            function_id: z
+                .string()
+                .describe("The unique identifier of the function the profile was published to."),
+            author: z.string().describe("The author of the profile."),
+            id: z.string().describe("The unique identifier of the profile."),
+            version: z.uint32().describe("The version of the profile."),
+        });
+        async function list(openai, options) {
+            const response = await openai.get("/functions/profiles", 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));
+        Profile.list = list;
+        Profile.RetrieveItemSchema = z.object({
+            created: z
+                .uint32()
+                .describe("The UNIX timestamp (in seconds) when the profile was created."),
+            shape: z
+                .string()
+                .describe("The shape of the profile. Unless Task Skip expressions work out favorably, profiles only work for functions with the same shape."),
+            function_author: z
+                .string()
+                .describe("The author of the function the profile was published to."),
+            function_id: z
+                .string()
+                .describe("The unique identifier of the function the profile was published to."),
+            author: z.string().describe("The author of the profile."),
+            id: z.string().describe("The unique identifier of the profile."),
+            version: z.uint32().describe("The version of the profile."),
+            profile: z
+                .array(Function.ProfileVersionRequiredSchema)
+                .describe("The function profile."),
+        });
+        async function retrieve(openai, function_author, function_id, author, id, version, options) {
+            const response = await openai.get(version !== null && version !== undefined
+                ? `/functions/${function_author}/${function_id}/profiles/${author}/${id}/${version}`
+                : `/functions/${function_author}/${function_id}/profiles/${author}/${id}`, 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));
+        Profile.retrieve = retrieve;
+        Profile.HistoricalUsageSchema = z.object({
+            requests: z
+                .uint32()
+                .describe("The total number of requests made to Functions while using this Profile."),
+            completion_tokens: z
+                .uint32()
+                .describe("The total number of completion tokens generated by Functions while using this Profile."),
+            prompt_tokens: z
+                .uint32()
+                .describe("The total number of prompt tokens sent to Functions while using this Profile."),
+            total_cost: z
+                .number()
+                .describe("The total cost incurred by using this Profile."),
+        });
+        async function retrieveUsage(openai, function_author, function_id, author, id, version, options) {
+            const response = await openai.get(version !== null && version !== undefined
+                ? `/functions/${function_author}/${function_id}/profiles/${author}/${id}/${version}/usage`
+                : `/functions/${function_author}/${function_id}/profiles/${author}/${id}/usage`, options);
             return response;
         }
-        Completions.list = list;
-    })(Completions = Conversation.Completions || (Conversation.Completions = {}));
-})(Conversation || (Conversation = {}));
-export var Functions;
-(function (Functions) {
-    let Response;
-    (function (Response) {
-        let Streaming;
-        (function (Streaming) {
-            let CompletionChunk;
-            (function (CompletionChunk) {
-                let ScoreCompletionChunk;
-                (function (ScoreCompletionChunk) {
-                    function merged(a, b) {
-                        const [base, baseChanged] = Score.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
-                        return baseChanged
-                            ? [Object.assign(Object.assign({ type: a.type }, base), { index: a.index }), true]
-                            : [a, false];
-                    }
-                    ScoreCompletionChunk.merged = merged;
-                })(ScoreCompletionChunk = CompletionChunk.ScoreCompletionChunk || (CompletionChunk.ScoreCompletionChunk = {}));
-                let MultichatCompletionChunk;
-                (function (MultichatCompletionChunk) {
-                    function merged(a, b) {
-                        const [base, baseChanged] = Multichat.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
-                        return baseChanged
-                            ? [Object.assign(Object.assign({ type: a.type }, base), { index: a.index }), true]
-                            : [a, false];
-                    }
-                    MultichatCompletionChunk.merged = merged;
-                })(MultichatCompletionChunk = CompletionChunk.MultichatCompletionChunk || (CompletionChunk.MultichatCompletionChunk = {}));
-                function mergedList(a, b) {
-                    let merged = undefined;
-                    for (const chunk of b) {
-                        const existingIndex = a.findIndex((c) => c.index === chunk.index && c.type === chunk.type);
-                        if (existingIndex === -1) {
-                            if (merged === undefined) {
-                                merged = [...a, chunk];
-                            }
-                            else {
-                                merged.push(chunk);
-                            }
-                        }
-                        else if (chunk.type === "score") {
-                            const [mergedChunk, chunkChanged] = ScoreCompletionChunk.merged(a[existingIndex], chunk);
-                            if (chunkChanged) {
-                                if (merged === undefined) {
-                                    merged = [...a];
-                                }
-                                merged[existingIndex] = mergedChunk;
-                            }
-                        }
-                        else if (chunk.type === "multichat") {
-                            const [mergedChunk, chunkChanged] = MultichatCompletionChunk.merged(a[existingIndex], chunk);
-                            if (chunkChanged) {
-                                if (merged === undefined) {
-                                    merged = [...a];
-                                }
-                                merged[existingIndex] = mergedChunk;
-                            }
-                        }
-                    }
-                    return merged ? [merged, true] : [a, false];
-                }
-                CompletionChunk.mergedList = mergedList;
-            })(CompletionChunk = Streaming.CompletionChunk || (Streaming.CompletionChunk = {}));
-            function merged(a, b) {
-                const [completions, completionsChanged] = CompletionChunk.mergedList(a.completions, b.completions);
-                const [output, outputChanged] = merge(a.output, b.output);
-                const [retry_token, retry_tokenChanged] = merge(a.retry_token, b.retry_token);
-                const [error, errorChanged] = merge(a.error, b.error);
-                const [function_published, function_publishedChanged] = merge(a.function_published, b.function_published);
-                if (completionsChanged ||
-                    outputChanged ||
-                    retry_tokenChanged ||
-                    errorChanged ||
-                    function_publishedChanged) {
-                    return [
-                        Object.assign(Object.assign(Object.assign(Object.assign({ completions }, (output !== undefined ? { output } : {})), (retry_token !== undefined ? { retry_token } : {})), (error !== undefined ? { error } : {})), (function_published !== undefined
-                            ? { function_published }
-                            : {})),
-                        true,
-                    ];
-                }
-                else {
-                    return [a, false];
-                }
-            }
-            Streaming.merged = merged;
-        })(Streaming = Response.Streaming || (Response.Streaming = {}));
-    })(Response = Functions.Response || (Functions.Response = {}));
-    async function list(openai, listOptions, options) {
-        const response = await openai.get("/functions", Object.assign({ query: listOptions }, options));
+        Profile.retrieveUsage = retrieveUsage;
+    })(Profile = Function_1.Profile || (Function_1.Profile = {}));
+    async function executeInline(openai, body, options) {
+        var _a;
+        const response = await openai.post("/functions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
-    Functions.list = list;
-    async function count(openai, options) {
-        const response = await openai.get("/functions/count", options);
+    Function_1.executeInline = executeInline;
+    async function execute(openai, author, id, version, body, options) {
+        var _a;
+        const response = await openai.post(version !== null && version !== undefined
+            ? `/functions/${author}/${id}/${version}`
+            : `/functions/${author}/${id}`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
-    Functions.count = count;
-    async function retrieve(openai, author, id, version, retrieveOptions, options) {
-        const url = version !== null && version !== undefined
-            ? `/functions/${author}/${id}/${version}`
-            : `/functions/${author}/${id}`;
-        const response = await openai.get(url, Object.assign({ query: retrieveOptions }, options));
+    Function_1.execute = execute;
+    async function publishFunction(openai, author, id, version, body, options) {
+        var _a;
+        const response = await openai.post(`/functions/${author}/${id}/${version}/publish`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
-    Functions.retrieve = retrieve;
-    async function executeById(openai, author, id, version, body, options) {
+    Function_1.publishFunction = publishFunction;
+    async function publishProfile(openai, function_author, function_id, body, options) {
         var _a;
-        const url = version !== null && version !== undefined
-            ? `/functions/${author}/${id}/${version}`
-            : `/functions/${author}/${id}`;
-        const response = await openai.post(url, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        const response = await openai.post(`/functions/${function_author}/${function_id}/profiles/publish`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
-    Functions.executeById = executeById;
-    async function executeByDefinition(openai, body, options) {
+    Function_1.publishProfile = publishProfile;
+    async function computeProfile(openai, author, id, version, body, options) {
         var _a;
-        const response = await openai.post("/functions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        const response = await openai.post(version !== null && version !== undefined
+            ? `/functions/${author}/${id}/${version}/profiles/compute`
+            : `/functions/${author}/${id}/profiles/compute`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        return response;
+    }
+    Function_1.computeProfile = computeProfile;
+    Function_1.ListItemSchema = z.object({
+        author: z.string().describe("The author of the function."),
+        id: z.string().describe("The unique identifier of the function."),
+        version: z.uint32().describe("The version of the function."),
+    });
+    async function list(openai, options) {
+        const response = await openai.get("/functions", options);
         return response;
     }
-    Functions.executeByDefinition = executeByDefinition;
-})(Functions || (Functions = {}));
-export var Models;
-(function (Models) {
-    async function list(openai, listOptions, options) {
-        const response = await openai.models.list(Object.assign({ query: listOptions }, options));
+    Function_1.list = list;
+    Function_1.ScalarRetrieveItemSchema = Function_1.ScalarSchema.extend({
+        created: z
+            .uint32()
+            .describe("The UNIX timestamp (in seconds) when the function was created."),
+        shape: z
+            .string()
+            .describe("The shape of the function. Unless Task Skip expressions work out favorably, functions only work with profiles that have the same shape."),
+    })
+        .describe("A retrieved scalar function.")
+        .meta({ title: "RetrievedScalarFunction" });
+    Function_1.VectorRetrieveItemSchema = Function_1.VectorSchema.extend({
+        created: z
+            .uint32()
+            .describe("The UNIX timestamp (in seconds) when the function was created."),
+        shape: z
+            .string()
+            .describe("The shape of the function. Unless Task Skip expressions work out favorably, functions only work with profiles that have the same shape."),
+    })
+        .describe("A retrieved vector function.")
+        .meta({ title: "RetrievedVectorFunction" });
+    Function_1.RetrieveItemSchema = z.discriminatedUnion("type", [
+        Function_1.ScalarRetrieveItemSchema,
+        Function_1.VectorRetrieveItemSchema,
+    ]);
+    async function retrieve(openai, author, id, version, options) {
+        const response = await openai.get(version !== null && version !== undefined
+            ? `/functions/${author}/${id}/${version}`
+            : `/functions/${author}/${id}`, 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));
+    Function_1.retrieve = retrieve;
+    Function_1.HistoricalUsageSchema = z.object({
+        requests: z
+            .uint32()
+            .describe("The total number of requests made to this Function."),
+        completion_tokens: z
+            .uint32()
+            .describe("The total number of completion tokens generated by this Function."),
+        prompt_tokens: z
+            .uint32()
+            .describe("The total number of prompt tokens sent to this Function."),
+        total_cost: z
+            .number()
+            .describe("The total cost incurred by using this Function."),
+    });
+    async function retrieveUsage(openai, author, id, version, options) {
+        const response = await openai.get(version !== null && version !== undefined
+            ? `/functions/${author}/${id}/${version}/usage`
+            : `/functions/${author}/${id}/usage`, options);
         return response;
     }
-    Models.retrieve = retrieve;
-})(Models || (Models = {}));
+    Function_1.retrieveUsage = retrieveUsage;
+})(Function || (Function = {}));
+export const FunctionSchema = z
+    .discriminatedUnion("type", [Function.ScalarSchema, Function.VectorSchema])
+    .describe("A function.");
 export var Auth;
 (function (Auth) {
+    Auth.ApiKeySchema = z.object({
+        api_key: z.string().describe("The API key."),
+        created: z
+            .string()
+            .describe("The RFC 3339 timestamp when the API key was created."),
+        expires: z
+            .string()
+            .nullable()
+            .describe("The RFC 3339 timestamp when the API key expires, or null if it does not expire."),
+        disabled: z
+            .string()
+            .nullable()
+            .describe("The RFC 3339 timestamp when the API key was disabled, or null if it is not disabled."),
+        name: z.string().describe("The name of the API key."),
+        description: z
+            .string()
+            .nullable()
+            .describe("The description of the API key, or null if no description was provided."),
+    });
+    Auth.ApiKeyWithCostSchema = Auth.ApiKeySchema.extend({
+        cost: z
+            .number()
+            .describe("The total cost incurred while using this API key."),
+    });
     let ApiKey;
     (function (ApiKey) {
         async function list(openai, options) {
@@ -821,6 +3519,9 @@ export var Auth;
         }
         ApiKey.remove = remove;
     })(ApiKey = Auth.ApiKey || (Auth.ApiKey = {}));
+    Auth.OpenRouterApiKeySchema = z.object({
+        api_key: z.string().describe("The OpenRouter API key."),
+    });
     let OpenRouterApiKey;
     (function (OpenRouterApiKey) {
         async function retrieve(openai, options) {
@@ -841,6 +3542,15 @@ export var Auth;
         }
         OpenRouterApiKey.remove = remove;
     })(OpenRouterApiKey = Auth.OpenRouterApiKey || (Auth.OpenRouterApiKey = {}));
+    Auth.CreditsSchema = z.object({
+        credits: z.number().describe("The current number of credits available."),
+        total_credits_purchased: z
+            .number()
+            .describe("The total number of credits ever purchased."),
+        total_credits_used: z
+            .number()
+            .describe("The total number of credits ever used."),
+    });
     let Credits;
     (function (Credits) {
         async function retrieve(openai, options) {
@@ -863,106 +3573,6 @@ export var Auth;
         Username.set = set;
     })(Username = Auth.Username || (Auth.Username = {}));
 })(Auth || (Auth = {}));
-export var Metadata;
-(function (Metadata) {
-    async function get(openai, options) {
-        const response = await openai.get("/metadata", options);
-        return response;
-    }
-    Metadata.get = get;
-})(Metadata || (Metadata = {}));
-export var ScoreLlm;
-(function (ScoreLlm) {
-    async function list(openai, listOptions, options) {
-        const response = await openai.get("/score/llms", Object.assign({ query: listOptions }, options));
-        return response;
-    }
-    ScoreLlm.list = list;
-    async function count(openai, options) {
-        const response = await openai.get("/score/llms/count", options);
-        return response;
-    }
-    ScoreLlm.count = count;
-    async function retrieve(openai, model, retrieveOptions, options) {
-        const response = await openai.get(`/score/llms/${model}`, Object.assign({ query: retrieveOptions }, options));
-        return response;
-    }
-    ScoreLlm.retrieve = retrieve;
-    async function retrieveValidate(openai, model, retrieveOptions, options) {
-        const response = await openai.post("/score/llms", Object.assign({ query: retrieveOptions, body: model }, options));
-        return response;
-    }
-    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) {
-        const response = await openai.get("/score/models", Object.assign({ query: listOptions }, options));
-        return response;
-    }
-    ScoreModel.list = list;
-    async function count(openai, options) {
-        const response = await openai.get("/score/models/count", options);
-        return response;
-    }
-    ScoreModel.count = count;
-    async function retrieve(openai, model, retrieveOptions, options) {
-        const response = await openai.get(`/score/models/${model}`, Object.assign({ query: retrieveOptions }, options));
-        return response;
-    }
-    ScoreModel.retrieve = retrieve;
-    async function retrieveValidate(openai, model, retrieveOptions, options) {
-        const response = await openai.post("/score/models", Object.assign({ query: retrieveOptions, body: model }, options));
-        return response;
-    }
-    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];
@@ -983,6 +3593,6 @@ function merge(a, b, combine) {
 function mergedString(a, b) {
     return b === "" ? [a, false] : [a + b, true];
 }
-function mergedNumber(a, b) {
-    return b === 0 ? [a, false] : [a + b, true];
-}
+// function mergedNumber(a: number, b: number): [number, boolean] {
+//   return b === 0 ? [a, false] : [a + b, true];
+// }