objectiveai 1.2.0 → 1.2.2

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 ToolsSchema = z
+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."),
@@ -670,141 +912,6 @@ export const EnsembleLlmWithFallbacksAndCountSchema = EnsembleLlmSchema.extend({
         .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(),
-    })
-        .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 = {}));
 // Ensemble
 export const EnsembleBaseSchema = z
     .object({
@@ -860,46 +967,14 @@ export var Ensemble;
         return response;
     }
     Ensemble.retrieveUsage = retrieveUsage;
-})(Ensemble || (Ensemble = {}));
-// Chat Completions
-export var Chat;
-(function (Chat) {
-    let Completions;
-    (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.");
+})(Ensemble || (Ensemble = {}));
+// Chat Completions
+export var Chat;
+(function (Chat) {
+    let Completions;
+    (function (Completions) {
+        let Request;
+        (function (Request) {
             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) {
@@ -1970,9 +2099,6 @@ export var Vector;
     })(Completions = Vector.Completions || (Vector.Completions = {}));
 })(Vector || (Vector = {}));
 // Function
-export const FunctionSchema = z
-    .discriminatedUnion("type", [Function.ScalarSchema, Function.VectorSchema])
-    .describe("A function.");
 export var Function;
 (function (Function_1) {
     Function_1.VectorCompletionProfileSchema = z
@@ -1981,54 +2107,53 @@ export var Function;
         profile: Vector.Completions.Request.ProfileSchema,
     })
         .describe("A vector completion profile containing an Ensemble and array of weights.");
-    Function_1.FunctionProfileVersionRequiredSchema = z
+    Function_1.FunctionProfileCommitRequiredSchema = z
         .union([
         z.object({
-            function_author: z
+            owner: z
+                .string()
+                .describe("The owner of the GitHub repository containing the profile."),
+            repository: z
                 .string()
-                .describe("The author of the function the profile was published to."),
-            function_id: z
+                .describe("The name of the GitHub repository containing the profile."),
+            commit: z
                 .string()
-                .describe("The unique identifier of the function the profile was published to."),
-            author: z.string().describe("The author of the profile."),
-            id: z.string().describe("The unique identifier of the profile."),
-            version: z.uint32().describe("The version of the profile."),
+                .describe("The commit SHA of the GitHub repository containing the profile."),
         }),
-        z.lazy(() => z.array(Function_1.ProfileVersionRequiredSchema)),
+        z.lazy(() => z.array(Function_1.ProfileCommitRequiredSchema).meta({
+            title: "ProfileCommitRequiredArray",
+            recursive: true,
+        })),
     ])
-        .describe("A function profile where remote profiles must specify a version.");
-    Function_1.FunctionProfileVersionOptionalSchema = z
+        .describe("A function profile where remote profiles must specify a commit.");
+    Function_1.FunctionProfileCommitOptionalSchema = z
         .union([
         z.object({
-            function_author: z
+            owner: z
                 .string()
-                .describe("The author of the function the profile was published to."),
-            function_id: z
+                .describe("The owner of the GitHub repository containing the profile."),
+            repository: z
                 .string()
-                .describe("The unique identifier of the function the profile was published to."),
-            author: z.string().describe("The author of the profile."),
-            id: z.string().describe("The unique identifier of the profile."),
-            version: z
-                .uint32()
-                .optional()
-                .nullable()
-                .describe("The version of the profile."),
+                .describe("The name of the GitHub repository containing the profile."),
+            commit: z
+                .string()
+                .describe("The commit SHA of the GitHub repository containing the profile.")
+                .optional(),
+        }),
+        z
+            .lazy(() => z.array(Function_1.ProfileCommitOptionalSchema))
+            .meta({
+            title: "ProfileCommitOptionalArray",
+            recursive: true,
         }),
-        z.lazy(() => z.array(Function_1.ProfileVersionOptionalSchema)),
-    ])
-        .describe("A function profile where remote profiles may omit a version.");
-    Function_1.ProfileVersionRequiredSchema = z
-        .union([
-        Function_1.FunctionProfileVersionRequiredSchema,
-        Function_1.VectorCompletionProfileSchema,
-    ])
-        .describe("A profile where remote function profiles must specify a version.");
-    Function_1.ProfileVersionOptionalSchema = z
-        .union([
-        Function_1.FunctionProfileVersionOptionalSchema,
-        Function_1.VectorCompletionProfileSchema,
     ])
-        .describe("A profile where remote function profiles may omit a version.");
+        .describe("A function profile where remote profiles may omit a commit.");
+    Function_1.ProfileCommitRequiredSchema = z
+        .union([Function_1.FunctionProfileCommitRequiredSchema, Function_1.VectorCompletionProfileSchema])
+        .describe("A profile where remote function profiles must specify a commit.");
+    Function_1.ProfileCommitOptionalSchema = z
+        .union([Function_1.FunctionProfileCommitOptionalSchema, Function_1.VectorCompletionProfileSchema])
+        .describe("A profile where remote function profiles may omit a commit.");
     Function_1.InputSchemaSchema = z.lazy(() => z
         .union([
         InputSchema.ObjectSchema,
@@ -2054,7 +2179,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 +2209,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 +2324,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 +2340,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 +2362,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.");
@@ -2235,15 +2371,15 @@ export var Function;
         TaskExpression.ScalarFunctionSchema = z
             .object({
             type: z.literal("scalar.function"),
-            author: z
+            owner: z
                 .string()
-                .describe("The author of the remote published scalar function."),
-            id: z
+                .describe("The owner of the GitHub repository containing the function."),
+            repository: z
                 .string()
-                .describe("The unique identifier of the remote published scalar function."),
-            version: z
-                .uint32()
-                .describe("The version of the remote published scalar function."),
+                .describe("The name of the GitHub repository containing the function."),
+            commit: z
+                .string()
+                .describe("The commit SHA of the GitHub repository containing the function."),
             skip: TaskExpression.SkipSchema.optional().nullable(),
             map: TaskExpression.MapSchema.optional().nullable(),
             input: Function_1.InputExpressionSchema,
@@ -2252,15 +2388,15 @@ export var Function;
         TaskExpression.VectorFunctionSchema = z
             .object({
             type: z.literal("vector.function"),
-            author: z
+            owner: z
                 .string()
-                .describe("The author of the remote published vector function."),
-            id: z
+                .describe("The owner of the GitHub repository containing the function."),
+            repository: z
                 .string()
-                .describe("The unique identifier of the remote published vector function."),
-            version: z
-                .uint32()
-                .describe("The version of the remote published vector function."),
+                .describe("The name of the GitHub repository containing the function."),
+            commit: z
+                .string()
+                .describe("The commit SHA of the GitHub repository containing the function."),
             skip: TaskExpression.SkipSchema.optional().nullable(),
             map: TaskExpression.MapSchema.optional().nullable(),
             input: Function_1.InputExpressionSchema,
@@ -2279,15 +2415,19 @@ 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.");
     Function_1.ScalarSchema = z
         .object({
         type: z.literal("scalar.function"),
-        author: z.string().describe("The author of the scalar function."),
-        id: z.string().describe("The unique identifier of the scalar function."),
-        version: z.uint32().describe("The version of the scalar function."),
         description: z
             .string()
             .describe("The description of the scalar function."),
@@ -2301,13 +2441,11 @@ 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"),
-        author: z.string().describe("The author of the vector function."),
-        id: z.string().describe("The unique identifier of the vector function."),
-        version: z.uint32().describe("The version of the vector function."),
         description: z
             .string()
             .describe("The description of the vector function."),
@@ -2327,12 +2465,14 @@ 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;
         (function (Request) {
-            Request.FunctionExecutionParamsBaseSchema = z
+            // Remote Function Remote Profile
+            Request.FunctionExecutionParamsRemoteFunctionRemoteProfileBaseSchema = z
                 .object({
                 retry_token: z
                     .string()
@@ -2346,197 +2486,104 @@ export var Function;
                 first_chunk_timeout: Chat.Completions.Request.FirstChunkTimeoutSchema.optional().nullable(),
                 other_chunk_timeout: Chat.Completions.Request.OtherChunkTimeoutSchema.optional().nullable(),
             })
-                .describe("Base parameters for executing a function.");
-            // Execute Inline Function
-            Request.FunctionExecutionParamsExecuteInlineBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                function: FunctionSchema,
-                profile: Function_1.FunctionProfileVersionOptionalSchema,
-            }).describe("Base parameters for executing an inline function.");
-            Request.FunctionExecutionParamsExecuteInlineStreamingSchema = Request.FunctionExecutionParamsExecuteInlineBaseSchema.extend({
+                .describe("Base parameters for executing a remote function with a remote profile.");
+            Request.FunctionExecutionParamsRemoteFunctionRemoteProfileStreamingSchema = Request.FunctionExecutionParamsRemoteFunctionRemoteProfileBaseSchema.extend({
                 stream: Chat.Completions.Request.StreamTrueSchema,
-            }).describe("Parameters for executing an inline function and streaming the response.");
-            Request.FunctionExecutionParamsExecuteInlineNonStreamingSchema = Request.FunctionExecutionParamsExecuteInlineBaseSchema.extend({
-                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
-            }).describe("Parameters for executing an inline function with a unary response.");
-            Request.FunctionExecutionParamsExecuteInlineSchema = z
-                .union([
-                Request.FunctionExecutionParamsExecuteInlineStreamingSchema,
-                Request.FunctionExecutionParamsExecuteInlineNonStreamingSchema,
-            ])
-                .describe("Parameters for executing an inline function.");
-            // 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.");
-            Request.FunctionExecutionParamsExecuteNonStreamingSchema = Request.FunctionExecutionParamsExecuteBaseSchema.extend({
+            })
+                .describe("Parameters for executing a remote function with a remote profile and streaming the response.")
+                .meta({
+                title: "FunctionExecutionParamsRemoteFunctionRemoteProfileStreaming",
+            });
+            Request.FunctionExecutionParamsRemoteFunctionRemoteProfileNonStreamingSchema = Request.FunctionExecutionParamsRemoteFunctionRemoteProfileBaseSchema.extend({
                 stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
-            }).describe("Parameters for executing a remote published function with a unary response.");
-            Request.FunctionExecutionParamsExecuteSchema = z
+            })
+                .describe("Parameters for executing a remote function with a remote profile with a unary response.")
+                .meta({
+                title: "FunctionExecutionParamsRemoteFunctionRemoteProfileNonStreaming",
+            });
+            Request.FunctionExecutionParamsRemoteFunctionRemoteProfileSchema = z
                 .union([
-                Request.FunctionExecutionParamsExecuteStreamingSchema,
-                Request.FunctionExecutionParamsExecuteNonStreamingSchema,
+                Request.FunctionExecutionParamsRemoteFunctionRemoteProfileStreamingSchema,
+                Request.FunctionExecutionParamsRemoteFunctionRemoteProfileNonStreamingSchema,
             ])
-                .describe("Parameters for executing a remote published function.");
-            // Publish Scalar Function
-            Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                function: Function_1.ScalarSchema,
-                publish_function: z
-                    .object({
-                    description: z
-                        .string()
-                        .describe("The description of the published scalar function."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                    input_schema: Function_1.InputSchemaSchema,
-                })
-                    .describe("Details about the scalar function to be published."),
-                profile: Function_1.FunctionProfileVersionRequiredSchema,
-                publish_profile: z
-                    .object({
-                    id: z
-                        .literal("default")
-                        .describe('The identifier of the profile to publish. Must be "default" when publishing a function.'),
-                    version: z
-                        .uint32()
-                        .describe("The version of the profile to publish. Must match the function's version."),
-                    description: z
-                        .string()
-                        .describe("The description of the published profile."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                })
-                    .describe("Details about the profile to be published."),
-            }).describe("Base parameters for executing and publishing an inline scalar function.");
-            Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema = Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema.extend({
+                .describe("Parameters for executing a remote function with a remote profile.")
+                .meta({ title: "FunctionExecutionParamsRemoteFunctionRemoteProfile" });
+            // Remote Function Inline Profile
+            Request.FunctionExecutionParamsRemoteFunctionInlineProfileBaseSchema = Request.FunctionExecutionParamsRemoteFunctionRemoteProfileBaseSchema.extend({
+                profile: Function_1.FunctionProfileCommitOptionalSchema,
+            }).describe("Base parameters for executing a remote function with an inline profile.");
+            Request.FunctionExecutionParamsRemoteFunctionInlineProfileStreamingSchema = Request.FunctionExecutionParamsRemoteFunctionInlineProfileBaseSchema.extend({
                 stream: Chat.Completions.Request.StreamTrueSchema,
-            }).describe("Parameters for executing and publishing an inline scalar function and streaming the response.");
-            Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema = Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema.extend({
+            })
+                .describe("Parameters for executing a remote function with an inline profile and streaming the response.")
+                .meta({
+                title: "FunctionExecutionParamsRemoteFunctionInlineProfileStreaming",
+            });
+            Request.FunctionExecutionParamsRemoteFunctionInlineProfileNonStreamingSchema = Request.FunctionExecutionParamsRemoteFunctionInlineProfileBaseSchema.extend({
                 stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
-            }).describe("Parameters for executing and publishing an inline scalar function with a unary response.");
-            Request.FunctionExecutionParamsPublishScalarFunctionSchema = z
+            })
+                .describe("Parameters for executing a remote function with an inline profile with a unary response.")
+                .meta({
+                title: "FunctionExecutionParamsRemoteFunctionInlineProfileNonStreaming",
+            });
+            Request.FunctionExecutionParamsRemoteFunctionInlineProfileSchema = z
                 .union([
-                Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema,
-                Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema,
+                Request.FunctionExecutionParamsRemoteFunctionInlineProfileStreamingSchema,
+                Request.FunctionExecutionParamsRemoteFunctionInlineProfileNonStreamingSchema,
             ])
-                .describe("Parameters for executing and publishing an inline scalar function.");
-            // Publish Vector Function
-            Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                function: Function_1.VectorSchema,
-                publish_function: z
-                    .object({
-                    description: z
-                        .string()
-                        .describe("The description of the published vector function."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                    input_schema: Function_1.InputSchemaSchema,
-                    output_length: z
-                        .union([
-                        z.uint32().describe("The fixed length of the output vector."),
-                        ExpressionSchema.describe("An expression which evaluates to the length of the output vector. Will only be provided with the function input. The output length must be determinable from the input alone."),
-                    ])
-                        .describe("The length of the output vector."),
-                })
-                    .describe("Details about the vector function to be published."),
-                profile: Function_1.FunctionProfileVersionRequiredSchema,
-                publish_profile: z
-                    .object({
-                    id: z
-                        .literal("default")
-                        .describe('The identifier of the profile to publish. Must be "default" when publishing a function.'),
-                    version: z
-                        .uint32()
-                        .describe("The version of the profile to publish. Must match the function's version."),
-                    description: z
-                        .string()
-                        .describe("The description of the published profile."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                })
-                    .describe("Details about the profile to be published."),
-            }).describe("Base parameters for executing and publishing an inline vector function.");
-            Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema = Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema.extend({
+                .describe("Parameters for executing a remote function with an inline profile.")
+                .meta({ title: "FunctionExecutionParamsRemoteFunctionInlineProfile" });
+            // Inline Function Remote Profile
+            Request.FunctionExecutionParamsInlineFunctionRemoteProfileBaseSchema = Request.FunctionExecutionParamsRemoteFunctionRemoteProfileBaseSchema.extend({
+                function: z.lazy(() => FunctionSchema),
+            }).describe("Base parameters for executing an inline function with a remote profile.");
+            Request.FunctionExecutionParamsInlineFunctionRemoteProfileStreamingSchema = Request.FunctionExecutionParamsInlineFunctionRemoteProfileBaseSchema.extend({
                 stream: Chat.Completions.Request.StreamTrueSchema,
-            }).describe("Parameters for executing and publishing an inline vector function and streaming the response.");
-            Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema = Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema.extend({
+            })
+                .describe("Parameters for executing an inline function with a remote profile and streaming the response.")
+                .meta({
+                title: "FunctionExecutionParamsInlineFunctionRemoteProfileStreaming",
+            });
+            Request.FunctionExecutionParamsInlineFunctionRemoteProfileNonStreamingSchema = Request.FunctionExecutionParamsInlineFunctionRemoteProfileBaseSchema.extend({
                 stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
-            }).describe("Parameters for executing and publishing an inline vector function with a unary response.");
-            Request.FunctionExecutionParamsPublishVectorFunctionSchema = z
-                .union([
-                Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema,
-                Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema,
-            ])
-                .describe("Parameters for executing and publishing an inline vector function.");
-            // Publish Function
-            Request.FunctionExecutionParamsPublishFunctionStreamingSchema = z
-                .union([
-                Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema,
-                Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema,
-            ])
-                .describe("Parameters for executing and publishing an inline function and streaming the response.");
-            Request.FunctionExecutionParamsPublishFunctionNonStreamingSchema = z
-                .union([
-                Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema,
-                Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema,
-            ])
-                .describe("Parameters for executing and publishing an inline function with a unary response.");
-            Request.FunctionExecutionParamsPublishFunctionSchema = z
+            })
+                .describe("Parameters for executing an inline function with a remote profile with a unary response.")
+                .meta({
+                title: "FunctionExecutionParamsInlineFunctionRemoteProfileNonStreaming",
+            });
+            Request.FunctionExecutionParamsInlineFunctionRemoteProfileSchema = z
                 .union([
-                Request.FunctionExecutionParamsPublishScalarFunctionSchema,
-                Request.FunctionExecutionParamsPublishVectorFunctionSchema,
-            ])
-                .describe("Parameters for executing and publishing an inline function.");
-            // Publish Profile
-            Request.FunctionExecutionParamsPublishProfileBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                profile: z
-                    .array(Function_1.ProfileVersionRequiredSchema)
-                    .describe("The profile to publish."),
-                publish_profile: z
-                    .object({
-                    id: z
-                        .string()
-                        .describe("The unique identifier of the profile to publish."),
-                    version: z
-                        .uint32()
-                        .describe("The version of the profile to publish."),
-                    description: z
-                        .string()
-                        .describe("The description of the published profile."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                })
-                    .describe("Details about the profile to be published."),
-            }).describe("Base parameters for executing a remote published function and publishing a profile.");
-            Request.FunctionExecutionParamsPublishProfileStreamingSchema = Request.FunctionExecutionParamsPublishProfileBaseSchema.extend({
+                Request.FunctionExecutionParamsInlineFunctionRemoteProfileStreamingSchema,
+                Request.FunctionExecutionParamsInlineFunctionRemoteProfileNonStreamingSchema,
+            ])
+                .describe("Parameters for executing an inline function with a remote profile.")
+                .meta({ title: "FunctionExecutionParamsInlineFunctionRemoteProfile" });
+            // Inline Function Inline Profile
+            Request.FunctionExecutionParamsInlineFunctionInlineProfileBaseSchema = Request.FunctionExecutionParamsRemoteFunctionRemoteProfileBaseSchema.extend({
+                function: z.lazy(() => FunctionSchema),
+                profile: Function_1.FunctionProfileCommitOptionalSchema,
+            }).describe("Base parameters for executing an inline function with an inline profile.");
+            Request.FunctionExecutionParamsInlineFunctionInlineProfileStreamingSchema = Request.FunctionExecutionParamsInlineFunctionInlineProfileBaseSchema.extend({
                 stream: Chat.Completions.Request.StreamTrueSchema,
-            }).describe("Parameters for executing a remote published function, publishing a profile, and streaming the response.");
-            Request.FunctionExecutionParamsPublishProfileNonStreamingSchema = Request.FunctionExecutionParamsPublishProfileBaseSchema.extend({
+            })
+                .describe("Parameters for executing an inline function with an inline profile and streaming the response.")
+                .meta({
+                title: "FunctionExecutionParamsInlineFunctionInlineProfileStreaming",
+            });
+            Request.FunctionExecutionParamsInlineFunctionInlineProfileNonStreamingSchema = Request.FunctionExecutionParamsInlineFunctionInlineProfileBaseSchema.extend({
                 stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
-            }).describe("Parameters for executing a remote published function and publishing a profile with a unary response.");
-            Request.FunctionExecutionParamsPublishProfileSchema = z
+            })
+                .describe("Parameters for executing an inline function with an inline profile with a unary response.")
+                .meta({
+                title: "FunctionExecutionParamsInlineFunctionInlineProfileNonStreaming",
+            });
+            Request.FunctionExecutionParamsInlineFunctionInlineProfileSchema = z
                 .union([
-                Request.FunctionExecutionParamsPublishProfileStreamingSchema,
-                Request.FunctionExecutionParamsPublishProfileNonStreamingSchema,
+                Request.FunctionExecutionParamsInlineFunctionInlineProfileStreamingSchema,
+                Request.FunctionExecutionParamsInlineFunctionInlineProfileNonStreamingSchema,
             ])
-                .describe("Parameters for executing a remote published function and publishing a profile.");
+                .describe("Parameters for executing an inline function with an inline profile.")
+                .meta({ title: "FunctionExecutionParamsInlineFunctionInlineProfile" });
         })(Request = Executions.Request || (Executions.Request = {}));
         let Response;
         (function (Response) {
@@ -2554,9 +2601,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 +2637,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 +2658,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 +2694,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 +2802,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 +2812,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 +2828,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 +2890,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 +2913,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 +2955,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 +2994,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 +3042,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 +3087,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.ProfileCommitRequiredSchema)
+                        .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) {
@@ -3077,7 +3143,7 @@ export var Function;
                         .boolean()
                         .describe("When true, indicates that one or more function executions encountered errors during profile computation."),
                     profile: z
-                        .array(Function_1.ProfileVersionRequiredSchema)
+                        .array(Function_1.ProfileCommitRequiredSchema)
                         .describe("The computed function profile."),
                     fitting_stats: Response.FittingStatsSchema,
                     created: z
@@ -3096,48 +3162,21 @@ export var Function;
     let Profile;
     (function (Profile) {
         Profile.ListItemSchema = z.object({
-            function_author: z
+            owner: z
+                .string()
+                .describe("The owner of the GitHub repository containing the profile."),
+            repository: z
                 .string()
-                .describe("The author of the function the profile was published to."),
-            function_id: z
+                .describe("The name of the GitHub repository containing the profile."),
+            commit: z
                 .string()
-                .describe("The unique identifier of the function the profile was published to."),
-            author: z.string().describe("The author of the profile."),
-            id: z.string().describe("The unique identifier of the profile."),
-            version: z.uint32().describe("The version of the profile."),
+                .describe("The commit SHA of the GitHub repository containing the profile."),
         });
         async function list(openai, options) {
             const response = await openai.get("/functions/profiles", options);
             return response;
         }
         Profile.list = list;
-        Profile.RetrieveItemSchema = z.object({
-            created: z
-                .uint32()
-                .describe("The UNIX timestamp (in seconds) when the profile was created."),
-            shape: z
-                .string()
-                .describe("The shape of the profile. Unless Task Skip expressions work out favorably, profiles only work for functions with the same shape."),
-            function_author: z
-                .string()
-                .describe("The author of the function the profile was published to."),
-            function_id: z
-                .string()
-                .describe("The unique identifier of the function the profile was published to."),
-            author: z.string().describe("The author of the profile."),
-            id: z.string().describe("The unique identifier of the profile."),
-            version: z.uint32().describe("The version of the profile."),
-            profile: z
-                .array(Function.ProfileVersionRequiredSchema)
-                .describe("The function profile."),
-        });
-        async function retrieve(openai, function_author, function_id, author, id, version, options) {
-            const response = await openai.get(version !== null && version !== undefined
-                ? `/functions/${function_author}/${function_id}/profiles/${author}/${id}/${version}`
-                : `/functions/${function_author}/${function_id}/profiles/${author}/${id}`, options);
-            return response;
-        }
-        Profile.retrieve = retrieve;
         Profile.HistoricalUsageSchema = z.object({
             requests: z
                 .uint32()
@@ -3152,85 +3191,102 @@ export var Function;
                 .number()
                 .describe("The total cost incurred by using this Profile."),
         });
-        async function retrieveUsage(openai, function_author, function_id, author, id, version, options) {
-            const response = await openai.get(version !== null && version !== undefined
-                ? `/functions/${function_author}/${function_id}/profiles/${author}/${id}/${version}/usage`
-                : `/functions/${function_author}/${function_id}/profiles/${author}/${id}/usage`, options);
+        async function retrieveUsage(openai, powner, prepository, pcommit, options) {
+            const response = await openai.get(pcommit !== null && pcommit !== undefined
+                ? `/functions/profiles/${powner}/${prepository}/${pcommit}/usage`
+                : `/functions/profiles/${powner}/${prepository}/usage`, options);
             return response;
         }
         Profile.retrieveUsage = retrieveUsage;
     })(Profile = Function_1.Profile || (Function_1.Profile = {}));
-    async function executeInline(openai, body, options) {
+    async function executeInlineFunctionInlineProfile(openai, body, options) {
         var _a;
         const response = await openai.post("/functions", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
-    Function_1.executeInline = executeInline;
-    async function execute(openai, author, id, version, body, options) {
+    Function_1.executeInlineFunctionInlineProfile = executeInlineFunctionInlineProfile;
+    async function executeRemoteFunctionInlineProfile(openai, fowner, frepository, fcommit, body, options) {
         var _a;
-        const response = await openai.post(version !== null && version !== undefined
-            ? `/functions/${author}/${id}/${version}`
-            : `/functions/${author}/${id}`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        const response = await openai.post(fcommit !== null && fcommit !== undefined
+            ? `/functions/${fowner}/${frepository}/${fcommit}`
+            : `/functions/${fowner}/${frepository}`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
-    Function_1.execute = execute;
-    async function publishFunction(openai, author, id, version, body, options) {
+    Function_1.executeRemoteFunctionInlineProfile = executeRemoteFunctionInlineProfile;
+    async function executeInlineFunctionRemoteProfile(openai, powner, prepository, pcommit, body, options) {
         var _a;
-        const response = await openai.post(`/functions/${author}/${id}/${version}/publish`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        const response = await openai.post(pcommit !== null && pcommit !== undefined
+            ? `/functions/profiles/${powner}/${prepository}/${pcommit}`
+            : `/functions/profiles/${powner}/${prepository}`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
-    Function_1.publishFunction = publishFunction;
-    async function publishProfile(openai, function_author, function_id, body, options) {
+    Function_1.executeInlineFunctionRemoteProfile = executeInlineFunctionRemoteProfile;
+    async function executeRemoteFunctionRemoteProfile(openai, fowner, frepository, fcommit, powner, prepository, pcommit, body, options) {
         var _a;
-        const response = await openai.post(`/functions/${function_author}/${function_id}/profiles/publish`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        let url;
+        if (fcommit !== null && fcommit !== undefined) {
+            if (pcommit !== null && pcommit !== undefined) {
+                url = `/functions/${fowner}/${frepository}/${fcommit}/profiles/${powner}/${prepository}/${pcommit}`;
+            }
+            else {
+                url = `/functions/${fowner}/${frepository}/${fcommit}/profiles/${powner}/${prepository}`;
+            }
+        }
+        else if (pcommit !== null && pcommit !== undefined) {
+            url = `/functions/${fowner}/${frepository}/profiles/${powner}/${prepository}/${pcommit}`;
+        }
+        else {
+            url = `/functions/${fowner}/${frepository}/profiles/${powner}/${prepository}`;
+        }
+        const response = await openai.post(url, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
-    Function_1.publishProfile = publishProfile;
-    async function computeProfile(openai, author, id, version, body, options) {
+    Function_1.executeRemoteFunctionRemoteProfile = executeRemoteFunctionRemoteProfile;
+    async function execute(openai, function_, profile, body, options) {
+        if ("owner" in function_ && "repository" in function_) {
+            if ("owner" in profile && "repository" in profile) {
+                const requestBody = body;
+                return executeRemoteFunctionRemoteProfile(openai, function_.owner, function_.repository, function_.commit, profile.owner, profile.repository, profile.commit, requestBody, options);
+            }
+            else {
+                const requestBody = Object.assign(Object.assign({}, body), { profile });
+                return executeRemoteFunctionInlineProfile(openai, function_.owner, function_.repository, function_.commit, requestBody, options);
+            }
+        }
+        else if ("owner" in profile && "repository" in profile) {
+            const requestBody = Object.assign(Object.assign({}, body), { function: function_ });
+            return executeInlineFunctionRemoteProfile(openai, profile.owner, profile.repository, profile.commit, requestBody, options);
+        }
+        else {
+            const requestBody = Object.assign(Object.assign({}, body), { function: function_, profile });
+            return executeInlineFunctionInlineProfile(openai, requestBody, options);
+        }
+    }
+    Function_1.execute = execute;
+    async function computeProfile(openai, fowner, frepository, fcommit, body, options) {
         var _a;
-        const response = await openai.post(version !== null && version !== undefined
-            ? `/functions/${author}/${id}/${version}/profiles/compute`
-            : `/functions/${author}/${id}/profiles/compute`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        const response = await openai.post(fcommit !== null && fcommit !== undefined
+            ? `/functions/${fowner}/${frepository}/${fcommit}/profiles/compute`
+            : `/functions/${fowner}/${frepository}/profiles/compute`, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
         return response;
     }
     Function_1.computeProfile = computeProfile;
     Function_1.ListItemSchema = z.object({
-        author: z.string().describe("The author of the function."),
-        id: z.string().describe("The unique identifier of the function."),
-        version: z.uint32().describe("The version of the function."),
+        owner: z
+            .string()
+            .describe("The owner of the GitHub repository containing the function."),
+        repository: z
+            .string()
+            .describe("The name of the GitHub repository containing the function."),
+        commit: z
+            .string()
+            .describe("The commit SHA of the GitHub repository containing the function."),
     });
     async function list(openai, options) {
         const response = await openai.get("/functions", options);
         return response;
     }
     Function_1.list = list;
-    Function_1.ScalarRetrieveItemSchema = Function_1.ScalarSchema.extend({
-        created: z
-            .uint32()
-            .describe("The UNIX timestamp (in seconds) when the function was created."),
-        shape: z
-            .string()
-            .describe("The shape of the function. Unless Task Skip expressions work out favorably, functions only work with profiles that have the same shape."),
-    });
-    Function_1.VectorRetrieveItemSchema = Function_1.VectorSchema.extend({
-        created: z
-            .uint32()
-            .describe("The UNIX timestamp (in seconds) when the function was created."),
-        shape: z
-            .string()
-            .describe("The shape of the function. Unless Task Skip expressions work out favorably, functions only work with profiles that have the same shape."),
-    });
-    Function_1.RetrieveItemSchema = z.discriminatedUnion("type", [
-        Function_1.ScalarRetrieveItemSchema,
-        Function_1.VectorRetrieveItemSchema,
-    ]);
-    async function retrieve(openai, author, id, version, options) {
-        const response = await openai.get(version !== null && version !== undefined
-            ? `/functions/${author}/${id}/${version}`
-            : `/functions/${author}/${id}`, options);
-        return response;
-    }
-    Function_1.retrieve = retrieve;
     Function_1.HistoricalUsageSchema = z.object({
         requests: z
             .uint32()
@@ -3245,14 +3301,17 @@ export var Function;
             .number()
             .describe("The total cost incurred by using this Function."),
     });
-    async function retrieveUsage(openai, author, id, version, options) {
-        const response = await openai.get(version !== null && version !== undefined
-            ? `/functions/${author}/${id}/${version}/usage`
-            : `/functions/${author}/${id}/usage`, options);
+    async function retrieveUsage(openai, fowner, frepository, fcommit, options) {
+        const response = await openai.get(fcommit !== null && fcommit !== undefined
+            ? `/functions/${fowner}/${frepository}/${fcommit}/usage`
+            : `/functions/${fowner}/${frepository}/usage`, options);
         return response;
     }
     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({