objectiveai 1.2.0 → 1.2.1

package/dist/index.js

@@ -4,145 +4,114 @@ export const ExpressionSchema = z
     .object({
     $jmespath: z.string().describe("A JMESPath expression."),
 })
-    .describe("An expression which evaluates to a value.");
+    .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),
-    z.record(z.string(), JsonValueSchema),
+    z.array(JsonValueSchema.meta({
+        title: "JsonValue",
+        recursive: true,
+    })),
+    z.record(z.string(), JsonValueSchema.meta({
+        title: "JsonValue",
+        recursive: true,
+    })),
 ]))
-    .describe("A JSON value.");
+    .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),
-    z.record(z.string(), JsonValueExpressionSchema),
+    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);
+    .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.");
+    .describe("An error returned by the ObjectiveAI API.")
+    .meta({ title: "ObjectiveAIError" });
 // Messages
-export const MessageSchema = z
-    .discriminatedUnion("role", [
-    Message.DeveloperSchema,
-    Message.SystemSchema,
-    Message.UserSchema,
-    Message.ToolSchema,
-    Message.AssistantSchema,
-])
-    .describe("A message exchanged in a chat conversation.");
-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);
 export var Message;
 (function (Message) {
-    Message.SimpleContentPartSchema = z
-        .object({
-        type: z.literal("text"),
-        text: z.string().describe("The text content."),
-    })
-        .describe("A simple text content part.");
-    Message.SimpleContentSchema = z
-        .union([SimpleContent.TextSchema, SimpleContent.PartsSchema])
-        .describe("Simple content.");
-    Message.SimpleContentExpressionSchema = z
-        .union([
-        SimpleContent.TextSchema,
-        SimpleContent.PartsExpressionSchema,
-        ExpressionSchema.describe("An expression which evaluates to simple content."),
-    ])
-        .describe(Message.SimpleContentSchema.description);
     let SimpleContent;
     (function (SimpleContent) {
-        SimpleContent.TextSchema = z.string().describe("Plain text content.");
+        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.");
+            .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);
+            .describe(SimpleContent.PartSchema.description)
+            .meta({ title: "SimpleContentPartExpression" });
         SimpleContent.PartsSchema = z
             .array(SimpleContent.PartSchema)
-            .describe("An array of simple content parts.");
+            .describe("An array of simple content parts.")
+            .meta({ title: "SimpleContentParts" });
         SimpleContent.PartsExpressionSchema = z
             .array(SimpleContent.PartExpressionSchema)
-            .describe(SimpleContent.PartsSchema.description);
+            .describe(SimpleContent.PartsSchema.description)
+            .meta({ title: "SimpleContentPartExpressions" });
     })(SimpleContent = Message.SimpleContent || (Message.SimpleContent = {}));
-    Message.RichContentSchema = z
-        .union([RichContent.TextSchema, RichContent.PartsSchema])
-        .describe("Rich content.");
-    Message.RichContentExpressionSchema = z
+    Message.SimpleContentSchema = z
+        .union([SimpleContent.TextSchema, SimpleContent.PartsSchema])
+        .describe("Simple content.")
+        .meta({ title: "SimpleContent" });
+    Message.SimpleContentExpressionSchema = z
         .union([
-        RichContent.TextSchema,
-        RichContent.PartsExpressionSchema,
-        ExpressionSchema.describe("An expression which evaluates to rich content."),
+        SimpleContent.TextSchema,
+        SimpleContent.PartsExpressionSchema,
+        ExpressionSchema.describe("An expression which evaluates to simple content."),
     ])
-        .describe(Message.RichContentSchema.description);
+        .describe(Message.SimpleContentSchema.description)
+        .meta({ title: "SimpleContentExpression" });
     let RichContent;
     (function (RichContent) {
-        RichContent.TextSchema = z.string().describe("Plain text content.");
-        RichContent.PartSchema = z
-            .discriminatedUnion("type", [
-            Part.TextSchema,
-            Part.ImageUrlSchema,
-            Part.InputAudioSchema,
-            Part.VideoUrlSchema,
-            Part.FileSchema,
-        ])
-            .describe("A rich content part.");
-        RichContent.PartExpressionSchema = z
-            .union([
-            RichContent.PartSchema,
-            ExpressionSchema.describe("An expression which evaluates to a rich content part."),
-        ])
-            .describe(RichContent.PartSchema.description);
+        RichContent.TextSchema = z
+            .string()
+            .describe("Plain text content.")
+            .meta({ title: "RichContentText" });
         let Part;
         (function (Part) {
-            Part.TextSchema = z
-                .object({
-                type: z.literal("text"),
-                text: Text.TextSchema,
-            })
-                .describe("A text rich content part.");
             let Text;
             (function (Text) {
                 Text.TextSchema = z.string().describe("The text content.");
             })(Text = Part.Text || (Part.Text = {}));
-            Part.ImageUrlSchema = z
+            Part.TextSchema = z
                 .object({
-                type: z.literal("image_url"),
-                image_url: ImageUrl.DefinitionSchema,
+                type: z.literal("text"),
+                text: Text.TextSchema,
             })
-                .describe("An image rich content part.");
+                .describe("A text rich content part.")
+                .meta({ title: "TextRichContentPart" });
             let ImageUrl;
             (function (ImageUrl) {
                 ImageUrl.DetailSchema = z
@@ -158,12 +127,13 @@ export var Message;
                 })
                     .describe("The URL of the image and its optional detail level.");
             })(ImageUrl = Part.ImageUrl || (Part.ImageUrl = {}));
-            Part.InputAudioSchema = z
+            Part.ImageUrlSchema = z
                 .object({
-                type: z.literal("input_audio"),
-                input_audio: InputAudio.DefinitionSchema,
+                type: z.literal("image_url"),
+                image_url: ImageUrl.DefinitionSchema,
             })
-                .describe("An audio rich content part.");
+                .describe("An image rich content part.")
+                .meta({ title: "ImageRichContentPart" });
             let InputAudio;
             (function (InputAudio) {
                 InputAudio.FormatSchema = z
@@ -179,12 +149,13 @@ export var Message;
                 })
                     .describe("The audio data and its format.");
             })(InputAudio = Part.InputAudio || (Part.InputAudio = {}));
-            Part.VideoUrlSchema = z
+            Part.InputAudioSchema = z
                 .object({
-                type: z.enum(["video_url", "input_video"]),
-                video_url: VideoUrl.DefinitionSchema,
+                type: z.literal("input_audio"),
+                input_audio: InputAudio.DefinitionSchema,
             })
-                .describe("A video rich content part.");
+                .describe("An audio rich content part.")
+                .meta({ title: "AudioRichContentPart" });
             let VideoUrl;
             (function (VideoUrl) {
                 VideoUrl.UrlSchema = z.string().describe("URL of the video.");
@@ -192,12 +163,13 @@ export var Message;
                     url: VideoUrl.UrlSchema,
                 });
             })(VideoUrl = Part.VideoUrl || (Part.VideoUrl = {}));
-            Part.FileSchema = z
+            Part.VideoUrlSchema = z
                 .object({
-                type: z.literal("file"),
-                file: File.DefinitionSchema,
+                type: z.enum(["video_url", "input_video"]),
+                video_url: VideoUrl.DefinitionSchema,
             })
-                .describe("A file rich content part.");
+                .describe("A video rich content part.")
+                .meta({ title: "VideoRichContentPart" });
             let File;
             (function (File) {
                 File.FileDataSchema = z
@@ -221,202 +193,253 @@ export var Message;
                 })
                     .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.");
+            .describe("An array of rich content parts.")
+            .meta({ title: "RichContentParts" });
         RichContent.PartsExpressionSchema = z
             .array(RichContent.PartExpressionSchema)
-            .describe(RichContent.PartsSchema.description);
+            .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.");
+        .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);
+        .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.");
+        .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);
+        .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.");
+        .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);
+        .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.");
+        .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);
-    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.");
-    Message.ToolExpressionSchema = z
-        .object({
-        role: z.literal("tool"),
-        content: Message.RichContentExpressionSchema,
-        tool_call_id: Tool.ToolCallIdExpressionSchema,
-    })
-        .describe(Message.ToolSchema.description);
+        .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.");
+            .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);
+            .describe(Tool.ToolCallIdSchema.description)
+            .meta({ title: "ToolMessageToolCallIdExpression" });
     })(Tool = Message.Tool || (Message.Tool = {}));
-    Message.AssistantSchema = z
+    Message.ToolSchema = 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(),
+        role: z.literal("tool"),
+        content: Message.RichContentSchema,
+        tool_call_id: Tool.ToolCallIdSchema,
     })
-        .describe("Messages sent by the model in response to user messages.");
-    Message.AssistantExpressionSchema = z
+        .describe("Messages sent by tools in response to tool calls made by the assistant.")
+        .meta({ title: "ToolMessage" });
+    Message.ToolExpressionSchema = 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(),
+        role: z.literal("tool"),
+        content: Message.RichContentExpressionSchema,
+        tool_call_id: Tool.ToolCallIdExpressionSchema,
     })
-        .describe(Message.AssistantSchema.description);
+        .describe(Message.ToolSchema.description)
+        .meta({ title: "ToolMessageExpression" });
     let Assistant;
     (function (Assistant) {
         Assistant.RefusalSchema = z
             .string()
-            .describe("The refusal message by the assistant.");
+            .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);
+            .describe(Assistant.RefusalSchema.description)
+            .meta({ title: "AssistantMessageRefusalExpression" });
         Assistant.ReasoningSchema = z
             .string()
-            .describe("The reasoning provided by the assistant.");
+            .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);
-        Assistant.ToolCallSchema = z
-            .union([ToolCall.FunctionSchema])
-            .describe("A tool call made by the assistant.");
-        Assistant.ToolCallExpressionSchema = z
-            .union([
-            ToolCall.FunctionExpressionSchema,
-            ExpressionSchema.describe("An expression which evaluates to a tool call."),
-        ])
-            .describe(Assistant.ToolCallSchema.description);
+            .describe(Assistant.ReasoningSchema.description)
+            .meta({ title: "AssistantMessageReasoningExpression" });
         let ToolCall;
         (function (ToolCall) {
             ToolCall.IdSchema = z
                 .string()
-                .describe("The unique identifier for the tool call.");
+                .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);
-            ToolCall.FunctionSchema = z
-                .object({
-                type: z.literal("function"),
-                id: ToolCall.IdSchema,
-                function: Function.DefinitionSchema,
-            })
-                .describe("A function tool call made by the assistant.");
-            ToolCall.FunctionExpressionSchema = z
-                .object({
-                type: z.literal("function"),
-                id: ToolCall.IdExpressionSchema,
-                function: Function.DefinitionExpressionSchema,
-            })
-                .describe(ToolCall.FunctionSchema.description);
+                .describe(ToolCall.IdSchema.description)
+                .meta({ title: "AssistantMessageToolCallIdExpression" });
             let Function;
             (function (Function) {
                 Function.NameSchema = z
                     .string()
-                    .describe("The name of the function called.");
+                    .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);
+                    .describe(Function.NameSchema.description)
+                    .meta({ title: "AssistantMessageToolCallFunctionNameExpression" });
                 Function.ArgumentsSchema = z
                     .string()
-                    .describe("The arguments passed to the function.");
+                    .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);
+                    .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.");
+                    .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);
+                    .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.");
+            .describe("Tool calls made by the assistant.")
+            .meta({ title: "AssistantMessageToolCalls" });
         Assistant.ToolCallsExpressionSchema = z
             .union([
             z
@@ -424,78 +447,120 @@ export var Message;
                 .describe(Assistant.ToolCallsSchema.description),
             ExpressionSchema.describe("An expression which evaluates to an array of tool calls."),
         ])
-            .describe(Assistant.ToolCallsSchema.description);
+            .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.");
+    .describe("A list of messages exchanged in a chat conversation.")
+    .meta({ title: "Messages" });
 export const MessagesExpressionSchema = z
     .union([
-    z.array(MessageExpressionSchema).describe(MessagesSchema.description),
+    z
+        .array(MessageExpressionSchema)
+        .describe(MessagesSchema.description)
+        .meta({ title: "MessageExpressions" }),
     ExpressionSchema.describe("An expression which evaluates to an array of messages."),
 ])
-    .describe(MessagesSchema.description);
+    .describe(MessagesSchema.description)
+    .meta({ title: "MessagesExpression" });
 // Tools
-export const ToolSchema = z
-    .union([Tool.FunctionSchema])
-    .describe("A tool that the assistant can call.");
-export const ToolExpressionSchema = z
-    .union([
-    Tool.FunctionExpressionSchema,
-    ExpressionSchema.describe("An expression which evaluates to a tool."),
-])
-    .describe(ToolSchema.description);
 export var Tool;
 (function (Tool) {
-    Tool.FunctionSchema = z
-        .object({
-        type: z.literal("function"),
-        function: Function.DefinitionSchema,
-    })
-        .describe("A function tool that the assistant can call.");
-    Tool.FunctionExpressionSchema = z
-        .object({
-        type: z.literal("function"),
-        function: Function.DefinitionExpressionSchema,
-    })
-        .describe(Tool.FunctionSchema.description);
     let Function;
     (function (Function) {
-        Function.NameSchema = z.string().describe("The name of the 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);
+            .describe(Function.NameSchema.description)
+            .meta({ title: "FunctionToolNameExpression" });
         Function.DescriptionSchema = z
             .string()
-            .describe("The description of the function.");
+            .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);
+            .describe(Function.DescriptionSchema.description)
+            .meta({ title: "FunctionToolDescriptionExpression" });
         Function.ParametersSchema = z
             .record(z.string(), JsonValueSchema)
-            .describe("The JSON schema defining the parameters of the function.");
+            .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);
+            .describe(Function.ParametersSchema.description)
+            .meta({ title: "FunctionToolParametersExpression" });
         Function.StrictSchema = z
             .boolean()
-            .describe("Whether to enforce strict adherence to the parameter schema.");
+            .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);
+            .describe(Function.StrictSchema.description)
+            .meta({ title: "FunctionToolStrictExpression" });
         Function.DefinitionSchema = z
             .object({
             name: Function.NameSchema,
@@ -503,7 +568,8 @@ export var Tool;
             parameters: Function.ParametersSchema.optional().nullable(),
             strict: Function.StrictSchema.optional().nullable(),
         })
-            .describe("The definition of a function tool.");
+            .describe("The definition of a function tool.")
+            .meta({ title: "FunctionToolDefinition" });
         Function.DefinitionExpressionSchema = z
             .object({
             name: Function.NameExpressionSchema,
@@ -511,38 +577,214 @@ export var Tool;
             parameters: Function.ParametersExpressionSchema.optional().nullable(),
             strict: Function.StrictExpressionSchema.optional().nullable(),
         })
-            .describe(Function.DefinitionSchema.description);
+            .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.");
+    .describe("A list of tools that the assistant can call.")
+    .meta({ title: "Tools" });
 export const ToolsExpressionSchema = z
     .union([
-    z.array(ToolExpressionSchema).describe(ToolsSchema.description),
+    z
+        .array(ToolExpressionSchema)
+        .describe(ToolsSchema.description)
+        .meta({ title: "ToolExpressions" }),
     ExpressionSchema.describe("An expression which evaluates to an array of tools."),
 ])
-    .describe(ToolsSchema.description);
+    .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.");
+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);
+    .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.");
+    .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),
+        .describe(VectorResponsesSchema.description)
+        .meta({ title: "VectorResponseExpressions" }),
     ExpressionSchema.describe("An expression which evaluates to an array of possible assistant responses."),
 ])
-    .describe(VectorResponsesSchema.description);
+    .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."),
@@ -656,155 +898,20 @@ export const EnsembleLlmBaseWithFallbacksAndCountSchema = EnsembleLlmBaseSchema.
     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.");
-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."),
-        z
-            .array(z.string())
-            .describe("Generation will stop when any of these strings are generated."),
-    ])
-        .describe("The assistant will stop when any of the provided strings are generated.");
-    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())
-            .optional()
-            .nullable()
-            .describe("An ordered list of provider names to use when selecting a provider for this model."),
-        only: z
-            .array(z.string())
-            .optional()
-            .nullable()
-            .describe("A list of provider names to restrict selection to when selecting a provider for this model."),
-        ignore: z
-            .array(z.string())
-            .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 Provider;
-    (function (Provider) {
-        Provider.QuantizationSchema = z
-            .enum([
-            "int4",
-            "int8",
-            "fp4",
-            "fp6",
-            "fp8",
-            "fp16",
-            "bf16",
-            "fp32",
-            "unknown",
-        ])
-            .describe("An LLM quantization.");
-    })(Provider = EnsembleLlm.Provider || (EnsembleLlm.Provider = {}));
-    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(),
-    })
+        .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("Options for controlling reasoning behavior of the 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.");
-        Reasoning.SummaryVerbositySchema = z
-            .enum(["auto", "concise", "detailed"])
-            .describe("Controls the verbosity of the reasoning summary for supported reasoning models.");
-    })(Reasoning = EnsembleLlm.Reasoning || (EnsembleLlm.Reasoning = {}));
-    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 = 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 = {}));
+        .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({
@@ -868,38 +975,6 @@ export var Chat;
     (function (Completions) {
         let Request;
         (function (Request) {
-            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.");
             let Provider;
             (function (Provider) {
                 Provider.DataCollectionSchema = z
@@ -936,36 +1011,55 @@ export var Chat;
                         .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.");
-            Request.ResponseFormatSchema = z
-                .union([
-                ResponseFormat.TextSchema,
-                ResponseFormat.JsonObjectSchema,
-                ResponseFormat.JsonSchemaSchema,
-                ResponseFormat.GrammarSchema,
-                ResponseFormat.PythonSchema,
-            ])
-                .describe("The desired format of the model's response.");
             let ResponseFormat;
             (function (ResponseFormat) {
                 ResponseFormat.TextSchema = z
                     .object({
                     type: z.literal("text"),
                 })
-                    .describe("The response will be arbitrary 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.");
-                ResponseFormat.JsonSchemaSchema = z
-                    .object({
-                    type: z.literal("json_schema"),
-                    json_schema: JsonSchema.JsonSchemaSchema,
-                })
-                    .describe("The response will conform to the provided JSON schema.");
+                    .describe("The response will be a JSON object.")
+                    .meta({ title: "ResponseFormatJsonObject" });
                 let JsonSchema;
                 (function (JsonSchema) {
                     JsonSchema.JsonSchemaSchema = z
@@ -986,8 +1080,16 @@ export var Chat;
                             .nullable()
                             .describe("Whether to enforce strict adherence to the JSON schema."),
                     })
-                        .describe("A JSON schema definition for constraining model output.");
+                        .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"),
@@ -995,50 +1097,56 @@ export var Chat;
                         .string()
                         .describe("The grammar definition to constrain the response."),
                 })
-                    .describe("The response will conform to the provided grammar definition.");
+                    .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.");
+                    .describe("The response will be Python code.")
+                    .meta({ title: "ResponseFormatPython" });
             })(ResponseFormat = Request.ResponseFormat || (Request.ResponseFormat = {}));
-            Request.ToolChoiceSchema = z
+            Request.ResponseFormatSchema = z
                 .union([
-                z.literal("none"),
-                z.literal("auto"),
-                z.literal("required"),
-                ToolChoice.FunctionSchema,
+                ResponseFormat.TextSchema,
+                ResponseFormat.JsonObjectSchema,
+                ResponseFormat.JsonSchemaSchema,
+                ResponseFormat.GrammarSchema,
+                ResponseFormat.PythonSchema,
             ])
-                .describe("Specifies tool call behavior for the assistant.");
+                .describe("The desired format of the model's response.")
+                .meta({ title: "ResponseFormat" });
             let ToolChoice;
             (function (ToolChoice) {
-                ToolChoice.FunctionSchema = z
-                    .object({
-                    type: z.literal("function"),
-                    function: Function.FunctionSchema,
-                })
-                    .describe("Specify a function for the assistant to call.");
                 let Function;
                 (function (Function) {
-                    Function.FunctionSchema = z.object({
+                    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.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.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) {
-                Prediction.ContentSchema = z.union([
-                    z.string(),
-                    z.array(Content.PartSchema),
-                ]);
                 let Content;
                 (function (Content) {
                     Content.PartSchema = z
@@ -1046,9 +1154,20 @@ export var Chat;
                         type: z.literal("text"),
                         text: z.string(),
                     })
-                        .describe("A part of the predicted content.");
+                        .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.");
@@ -1098,53 +1217,30 @@ export var Chat;
                 .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.");
+            })
+                .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.");
+            })
+                .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.");
+                .describe("Parameters for creating a chat completion.")
+                .meta({ title: "ChatCompletionCreateParams" });
         })(Request = Completions.Request || (Completions.Request = {}));
         let Response;
         (function (Response) {
             Response.FinishReasonSchema = z
                 .enum(["stop", "length", "tool_calls", "content_filter", "error"])
                 .describe("The reason why the assistant ceased to generate further tokens.");
-            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 Usage;
             (function (Usage) {
                 Usage.CompletionTokensDetailsSchema = z
@@ -1200,20 +1296,34 @@ export var Chat;
                 })
                     .describe("Detailed breakdown of upstream costs incurred.");
             })(Usage = Response.Usage || (Response.Usage = {}));
-            Response.LogprobsSchema = z
+            Response.UsageSchema = 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."),
+                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("The log probabilities of the tokens generated by the model.");
+                .describe("Token and cost usage statistics for the completion.");
             let Logprobs;
             (function (Logprobs) {
                 function merged(a, b) {
@@ -1227,24 +1337,6 @@ export var Chat;
                     }
                 }
                 Logprobs.merged = merged;
-                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.");
                 let Logprob;
                 (function (Logprob) {
                     function mergedList(a, b) {
@@ -1275,13 +1367,42 @@ export var Chat;
                     })
                         .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.");
-            Response.ImageSchema = z
-                .union([Image.ImageUrlSchema])
-                .describe("An image generated by the model.");
             let Image;
             (function (Image) {
                 function mergedList(a, b) {
@@ -1303,11 +1424,11 @@ export var Chat;
                     }),
                 });
             })(Image = Response.Image || (Response.Image = {}));
+            Response.ImageSchema = z
+                .union([Image.ImageUrlSchema])
+                .describe("An image generated by the model.");
             let Streaming;
             (function (Streaming) {
-                Streaming.ToolCallSchema = z
-                    .union([ToolCall.FunctionSchema])
-                    .describe("A tool call made by the assistant.");
                 let ToolCall;
                 (function (ToolCall) {
                     function merged(a, b) {
@@ -1339,19 +1460,6 @@ export var Chat;
                         return merged ? [merged, true] : [a, false];
                     }
                     ToolCall.mergedList = mergedList;
-                    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.");
                     let Function;
                     (function (Function) {
                         function merged(a, b) {
@@ -1370,13 +1478,6 @@ export var Chat;
                             }
                         }
                         Function.merged = merged;
-                        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."),
-                        });
                         let Definition;
                         (function (Definition) {
                             function merged(a, b) {
@@ -1396,8 +1497,31 @@ 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.ToolCallSchema = z
+                    .union([ToolCall.FunctionSchema])
+                    .describe("A tool call made by the assistant.");
                 Streaming.DeltaSchema = z
                     .object({
                     content: z
@@ -1576,20 +1700,8 @@ export var Chat;
             })(Streaming = Response.Streaming || (Response.Streaming = {}));
             let Unary;
             (function (Unary) {
-                Unary.ToolCallSchema = z
-                    .union([ToolCall.FunctionSchema])
-                    .describe(Streaming.ToolCallSchema.description);
                 let ToolCall;
                 (function (ToolCall) {
-                    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);
                     let Function;
                     (function (Function) {
                         Function.DefinitionSchema = z.object({
@@ -1603,7 +1715,19 @@ export var Chat;
                                 .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
@@ -1715,19 +1839,43 @@ export var Vector;
                 .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.");
+            })
+                .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.");
+            })
+                .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.");
+                .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
@@ -1749,25 +1897,42 @@ export var Vector;
                     .describe("Whether this vote came from a previous Vector Completion which was retried."),
             })
                 .describe("A vote from an Ensemble LLM within a Vector Completion.");
-            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);
+            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];
                     }
-                    return merged ? [merged, true] : [a, false];
                 }
-                Vote.mergedList = mergedList;
-            })(Vote = Response.Vote || (Response.Vote = {}));
+                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
@@ -1790,26 +1955,8 @@ export var Vector;
                     .describe("The total cost in credits incurred including upstream costs."),
             })
                 .describe("Token and cost usage statistics for the 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.");
-            Response.ScoresSchema = z
-                .array(z.number())
-                .describe("The scores for each response in the request, aggregated from the votes of the Ensemble LLMs.");
-            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.");
             let Streaming;
             (function (Streaming) {
-                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 ChatCompletionChunk;
                 (function (ChatCompletionChunk) {
                     function merged(a, b) {
@@ -1853,25 +2000,12 @@ export var Vector;
                     }
                     ChatCompletionChunk.mergedList = mergedList;
                 })(ChatCompletionChunk = Streaming.ChatCompletionChunk || (Streaming.ChatCompletionChunk = {}));
-                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
+                Streaming.ChatCompletionChunkSchema = Chat.Completions.Response.Streaming.ChatCompletionChunkSchema.extend({
+                    index: 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.");
+                        .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) {
@@ -1907,30 +2041,25 @@ export var Vector;
                     }
                     VectorCompletionChunk.merged = merged;
                 })(VectorCompletionChunk = Streaming.VectorCompletionChunk || (Streaming.VectorCompletionChunk = {}));
-                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 = Streaming.Scores || (Streaming.Scores = {}));
-                let Weights;
-                (function (Weights) {
-                    function merged(a, b) {
-                        return Scores.merged(a, b);
-                    }
-                    Weights.merged = merged;
-                })(Weights = Streaming.Weights || (Streaming.Weights = {}));
+                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 Unary;
             (function (Unary) {
@@ -1969,10 +2098,7 @@ export var Vector;
         Completions.create = create;
     })(Completions = Vector.Completions || (Vector.Completions = {}));
 })(Vector || (Vector = {}));
-// Function
-export const FunctionSchema = z
-    .discriminatedUnion("type", [Function.ScalarSchema, Function.VectorSchema])
-    .describe("A function.");
+// Function
 export var Function;
 (function (Function_1) {
     Function_1.VectorCompletionProfileSchema = z
@@ -1994,7 +2120,10 @@ export var Function;
             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)),
+        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
@@ -2014,7 +2143,12 @@ export var Function;
                 .nullable()
                 .describe("The version of the profile."),
         }),
-        z.lazy(() => z.array(Function_1.ProfileVersionOptionalSchema)),
+        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
@@ -2054,7 +2188,10 @@ export var Function;
                 .nullable()
                 .describe("The description of the object input."),
             properties: z
-                .record(z.string(), Function_1.InputSchemaSchema)
+                .record(z.string(), Function_1.InputSchemaSchema.meta({
+                title: "InputSchema",
+                recursive: true,
+            }))
                 .describe("The properties of the object input."),
             required: z
                 .array(z.string())
@@ -2081,7 +2218,10 @@ export var Function;
                 .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."),
+            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
@@ -2193,8 +2333,14 @@ export var Function;
     Function_1.InputSchema_ = z
         .lazy(() => z.union([
         Message.RichContent.PartSchema,
-        z.record(z.string(), Function_1.InputSchema_),
-        z.array(Function_1.InputSchema_),
+        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(),
@@ -2203,8 +2349,14 @@ export var Function;
     Function_1.InputExpressionSchema = z.lazy(() => z
         .union([
         Message.RichContent.PartSchema,
-        z.record(z.string(), Function_1.InputExpressionSchema),
-        z.array(Function_1.InputExpressionSchema),
+        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(),
@@ -2219,13 +2371,6 @@ export var Function;
             .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.");
-    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.");
     let TaskExpression;
     (function (TaskExpression) {
         TaskExpression.SkipSchema = ExpressionSchema.describe("An expression which evaluates to a boolean indicating whether to skip this task.");
@@ -2279,6 +2424,13 @@ export var Function;
         })
             .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.");
@@ -2301,7 +2453,8 @@ export var Function;
         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.");
+        .describe("A scalar function.")
+        .meta({ title: "ScalarFunction" });
     Function_1.VectorSchema = z
         .object({
         type: z.literal("vector.function"),
@@ -2327,7 +2480,8 @@ export var Function;
         ])
             .describe("The length of the output vector."),
     })
-        .describe("A vector function.");
+        .describe("A vector function.")
+        .meta({ title: "VectorFunction" });
     let Executions;
     (function (Executions) {
         let Request;
@@ -2349,37 +2503,47 @@ export var Function;
                 .describe("Base parameters for executing a function.");
             // Execute Inline Function
             Request.FunctionExecutionParamsExecuteInlineBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                function: FunctionSchema,
+                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.");
+            })
+                .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.");
+            })
+                .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.");
+                .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.");
+            })
+                .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.");
+            })
+                .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.");
+                .describe("Parameters for executing a remote published function.")
+                .meta({ title: "FunctionExecutionParamsExecute" });
             // Publish Scalar Function
             Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
                 function: Function_1.ScalarSchema,
@@ -2418,16 +2582,25 @@ export var Function;
             }).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.");
+            })
+                .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.");
+            })
+                .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.");
+                .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,
@@ -2472,35 +2645,47 @@ export var Function;
             }).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.");
+            })
+                .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.");
+            })
+                .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.");
+                .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.");
+                .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.");
+                .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.");
+                .describe("Parameters for executing and publishing an inline function.")
+                .meta({ title: "FunctionExecutionParamsPublishFunction" });
             // Publish Profile
             Request.FunctionExecutionParamsPublishProfileBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
                 profile: z
@@ -2527,16 +2712,21 @@ export var Function;
             }).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.");
+            })
+                .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.");
+            })
+                .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.");
+                .describe("Parameters for executing a remote published function and publishing a profile.")
+                .meta({ title: "FunctionExecutionParamsPublishProfile" });
         })(Request = Executions.Request || (Executions.Request = {}));
         let Response;
         (function (Response) {
@@ -2554,9 +2744,6 @@ export var Function;
             })(Task = Response.Task || (Response.Task = {}));
             let Streaming;
             (function (Streaming) {
-                Streaming.TaskChunkSchema = z
-                    .union([TaskChunk.FunctionSchema, TaskChunk.VectorCompletionSchema])
-                    .describe("A chunk of a task execution.");
                 let TaskChunk;
                 (function (TaskChunk) {
                     function merged(a, b) {
@@ -2593,13 +2780,6 @@ export var Function;
                         return merged ? [merged, true] : [a, false];
                     }
                     TaskChunk.mergedList = mergedList;
-                    TaskChunk.FunctionSchema = z
-                        .lazy(() => Streaming.FunctionExecutionChunkSchema.extend({
-                        index: Task.IndexSchema,
-                        task_index: Task.TaskIndexSchema,
-                        task_path: Task.TaskPathSchema,
-                    }))
-                        .describe("A chunk of a function execution task.");
                     let Function;
                     (function (Function) {
                         function merged(a, b) {
@@ -2621,12 +2801,20 @@ export var Function;
                         }
                         Function.merged = merged;
                     })(Function = TaskChunk.Function || (TaskChunk.Function = {}));
-                    TaskChunk.VectorCompletionSchema = Vector.Completions.Response.Streaming.VectorCompletionChunkSchema.extend({
+                    TaskChunk.FunctionSchema = z
+                        .lazy(() => Streaming.FunctionExecutionChunkSchema.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.");
+                        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) {
@@ -2649,7 +2837,57 @@ export var Function;
                         }
                         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 [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 function_ = a.function;
+                        const profile = a.profile;
+                        const object = a.object;
+                        const [usage, usageChanged] = merge(a.usage, b.usage);
+                        if (tasksChanged ||
+                            tasks_errorsChanged ||
+                            outputChanged ||
+                            errorChanged ||
+                            retry_tokenChanged ||
+                            function_publishedChanged ||
+                            profile_publishedChanged ||
+                            usageChanged) {
+                            return [
+                                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,
+                            ];
+                        }
+                        else {
+                            return [a, false];
+                        }
+                    }
+                    FunctionExecutionChunk.merged = merged;
+                })(FunctionExecutionChunk = Streaming.FunctionExecutionChunk || (Streaming.FunctionExecutionChunk = {}));
                 Streaming.FunctionExecutionChunkSchema = z
                     .object({
                     id: z
@@ -2707,53 +2945,9 @@ export var Function;
                     usage: Vector.Completions.Response.UsageSchema.optional(),
                 })
                     .describe("A chunk of a function execution.");
-                let FunctionExecutionChunk;
-                (function (FunctionExecutionChunk) {
-                    function merged(a, b) {
-                        const id = a.id;
-                        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 function_ = a.function;
-                        const profile = a.profile;
-                        const object = a.object;
-                        const [usage, usageChanged] = merge(a.usage, b.usage);
-                        if (tasksChanged ||
-                            tasks_errorsChanged ||
-                            outputChanged ||
-                            errorChanged ||
-                            retry_tokenChanged ||
-                            function_publishedChanged ||
-                            profile_publishedChanged ||
-                            usageChanged) {
-                            return [
-                                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,
-                            ];
-                        }
-                        else {
-                            return [a, false];
-                        }
-                    }
-                    FunctionExecutionChunk.merged = merged;
-                })(FunctionExecutionChunk = Streaming.FunctionExecutionChunk || (Streaming.FunctionExecutionChunk = {}));
             })(Streaming = Response.Streaming || (Response.Streaming = {}));
             let Unary;
             (function (Unary) {
-                Unary.TaskSchema = z
-                    .union([Task.FunctionSchema, Task.VectorCompletionSchema])
-                    .describe("A task execution.");
                 let Task;
                 (function (Task) {
                     Task.FunctionSchema = z
@@ -2761,8 +2955,15 @@ export var Function;
                         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 chunk of a function execution task.");
+                        .describe("A function execution task.");
                     Task.VectorCompletionSchema = Vector.Completions.Response.Unary.VectorCompletionSchema.extend({
                         index: Response.Task.IndexSchema,
                         task_index: Response.Task.TaskIndexSchema,
@@ -2770,6 +2971,9 @@ export var Function;
                         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
@@ -2829,21 +3033,8 @@ export var Function;
     (function (ComputeProfile) {
         let Request;
         (function (Request) {
-            Request.DatasetItemSchema = z
-                .object({
-                input: Function_1.InputSchema_,
-                target: DatasetItem.TargetSchema,
-            })
-                .describe("A Function input and its corresponding target output.");
             let DatasetItem;
             (function (DatasetItem) {
-                DatasetItem.TargetSchema = z
-                    .union([
-                    Target.ScalarSchema,
-                    Target.VectorSchema,
-                    Target.VectorWinnerSchema,
-                ])
-                    .describe("The target output for a given function input.");
                 let Target;
                 (function (Target) {
                     Target.ScalarSchema = z
@@ -2865,7 +3056,20 @@ export var Function;
                     })
                         .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
@@ -2894,16 +3098,21 @@ export var Function;
                 .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.");
+            })
+                .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.");
+            })
+                .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.");
+                .describe("Parameters for computing a function profile.")
+                .meta({ title: "FunctionComputeProfileParams" });
         })(Request = ComputeProfile.Request || (ComputeProfile.Request = {}));
         let Response;
         (function (Response) {
@@ -2928,20 +3137,6 @@ export var Function;
                 .describe("Statistics about the fitting process used to compute the weights for the profile.");
             let Streaming;
             (function (Streaming) {
-                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 FunctionExecutionChunk;
                 (function (FunctionExecutionChunk) {
                     function merged(a, b) {
@@ -2990,33 +3185,20 @@ export var Function;
                     }
                     FunctionExecutionChunk.mergedList = mergedList;
                 })(FunctionExecutionChunk = Streaming.FunctionExecutionChunk || (Streaming.FunctionExecutionChunk = {}));
-                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
+                Streaming.FunctionExecutionChunkSchema = Executions.Response.Streaming.FunctionExecutionChunkSchema.extend({
+                    index: 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.");
+                        .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) {
@@ -3048,6 +3230,33 @@ export var Function;
                     }
                     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 = {}));
             let Unary;
             (function (Unary) {
@@ -3211,7 +3420,9 @@ export var Function;
         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()
@@ -3219,7 +3430,9 @@ export var Function;
         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,
@@ -3253,6 +3466,9 @@ export var Function;
     }
     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({