objectiveai 1.2.1 → 1.2.2

package/dist/index.js

@@ -2107,62 +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 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().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."),
         }),
-        z.lazy(() => z.array(Function_1.ProfileVersionRequiredSchema).meta({
-            title: "ProfileVersionRequiredArray",
+        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.ProfileVersionOptionalSchema))
+            .lazy(() => z.array(Function_1.ProfileCommitOptionalSchema))
             .meta({
-            title: "ProfileVersionOptionalArray",
+            title: "ProfileCommitOptionalArray",
             recursive: true,
         }),
     ])
-        .describe("A function profile where remote profiles may omit a version.");
-    Function_1.ProfileVersionRequiredSchema = z
-        .union([
-        Function_1.FunctionProfileVersionRequiredSchema,
-        Function_1.VectorCompletionProfileSchema,
-    ])
-        .describe("A profile where remote function profiles must specify a version.");
-    Function_1.ProfileVersionOptionalSchema = z
-        .union([
-        Function_1.FunctionProfileVersionOptionalSchema,
-        Function_1.VectorCompletionProfileSchema,
-    ])
-        .describe("A profile where remote function profiles may omit a version.");
+        .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,
@@ -2380,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,
@@ -2397,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,
@@ -2437,9 +2428,6 @@ export var 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."),
@@ -2458,9 +2446,6 @@ export var Function;
     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."),
@@ -2486,7 +2471,8 @@ export var Function;
     (function (Executions) {
         let Request;
         (function (Request) {
-            Request.FunctionExecutionParamsBaseSchema = z
+            // Remote Function Remote Profile
+            Request.FunctionExecutionParamsRemoteFunctionRemoteProfileBaseSchema = z
                 .object({
                 retry_token: z
                     .string()
@@ -2500,233 +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: z.lazy(() => 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.")
-                .meta({ title: "FunctionExecutionParamsExecuteInlineStreaming" });
-            Request.FunctionExecutionParamsExecuteInlineNonStreamingSchema = Request.FunctionExecutionParamsExecuteInlineBaseSchema.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 an inline function with a unary response.")
-                .meta({ title: "FunctionExecutionParamsExecuteInlineNonStreaming" });
-            Request.FunctionExecutionParamsExecuteInlineSchema = z
+                .describe("Parameters for executing a remote function with a remote profile with a unary response.")
+                .meta({
+                title: "FunctionExecutionParamsRemoteFunctionRemoteProfileNonStreaming",
+            });
+            Request.FunctionExecutionParamsRemoteFunctionRemoteProfileSchema = z
                 .union([
-                Request.FunctionExecutionParamsExecuteInlineStreamingSchema,
-                Request.FunctionExecutionParamsExecuteInlineNonStreamingSchema,
+                Request.FunctionExecutionParamsRemoteFunctionRemoteProfileStreamingSchema,
+                Request.FunctionExecutionParamsRemoteFunctionRemoteProfileNonStreamingSchema,
             ])
-                .describe("Parameters for executing an inline function.")
-                .meta({ title: "FunctionExecutionParamsExecuteInline" });
-            // Execute Published Function
-            Request.FunctionExecutionParamsExecuteBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                profile: Function_1.FunctionProfileVersionOptionalSchema.optional().nullable(),
-            }).describe("Base parameters for executing a remote published function.");
-            Request.FunctionExecutionParamsExecuteStreamingSchema = Request.FunctionExecutionParamsExecuteBaseSchema.extend({
+                .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 a remote published function and streaming the response.")
-                .meta({ title: "FunctionExecutionParamsExecuteStreaming" });
-            Request.FunctionExecutionParamsExecuteNonStreamingSchema = Request.FunctionExecutionParamsExecuteBaseSchema.extend({
-                stream: Chat.Completions.Request.StreamFalseSchema.optional().nullable(),
-            })
-                .describe("Parameters for executing a remote published function with a unary response.")
-                .meta({ title: "FunctionExecutionParamsExecuteNonStreaming" });
-            Request.FunctionExecutionParamsExecuteSchema = z
-                .union([
-                Request.FunctionExecutionParamsExecuteStreamingSchema,
-                Request.FunctionExecutionParamsExecuteNonStreamingSchema,
-            ])
-                .describe("Parameters for executing a remote published function.")
-                .meta({ title: "FunctionExecutionParamsExecute" });
-            // Publish Scalar Function
-            Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                function: Function_1.ScalarSchema,
-                publish_function: z
-                    .object({
-                    description: z
-                        .string()
-                        .describe("The description of the published scalar function."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                    input_schema: Function_1.InputSchemaSchema,
-                })
-                    .describe("Details about the scalar function to be published."),
-                profile: Function_1.FunctionProfileVersionRequiredSchema,
-                publish_profile: z
-                    .object({
-                    id: z
-                        .literal("default")
-                        .describe('The identifier of the profile to publish. Must be "default" when publishing a function.'),
-                    version: z
-                        .uint32()
-                        .describe("The version of the profile to publish. Must match the function's version."),
-                    description: z
-                        .string()
-                        .describe("The description of the published profile."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                })
-                    .describe("Details about the profile to be published."),
-            }).describe("Base parameters for executing and publishing an inline scalar function.");
-            Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema = Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema.extend({
-                stream: Chat.Completions.Request.StreamTrueSchema,
-            })
-                .describe("Parameters for executing and publishing an inline scalar function and streaming the response.")
+                .describe("Parameters for executing a remote function with an inline profile and streaming the response.")
                 .meta({
-                title: "FunctionExecutionParamsPublishScalarFunctionStreaming",
+                title: "FunctionExecutionParamsRemoteFunctionInlineProfileStreaming",
             });
-            Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema = Request.FunctionExecutionParamsPublishScalarFunctionBaseSchema.extend({
+            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.")
+                .describe("Parameters for executing a remote function with an inline profile with a unary response.")
                 .meta({
-                title: "FunctionExecutionParamsPublishScalarFunctionNonStreaming",
+                title: "FunctionExecutionParamsRemoteFunctionInlineProfileNonStreaming",
             });
-            Request.FunctionExecutionParamsPublishScalarFunctionSchema = z
+            Request.FunctionExecutionParamsRemoteFunctionInlineProfileSchema = z
                 .union([
-                Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema,
-                Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema,
+                Request.FunctionExecutionParamsRemoteFunctionInlineProfileStreamingSchema,
+                Request.FunctionExecutionParamsRemoteFunctionInlineProfileNonStreamingSchema,
             ])
-                .describe("Parameters for executing and publishing an inline scalar function.")
-                .meta({ title: "FunctionExecutionParamsPublishScalarFunction" });
-            // Publish Vector Function
-            Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                function: Function_1.VectorSchema,
-                publish_function: z
-                    .object({
-                    description: z
-                        .string()
-                        .describe("The description of the published vector function."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                    input_schema: Function_1.InputSchemaSchema,
-                    output_length: z
-                        .union([
-                        z.uint32().describe("The fixed length of the output vector."),
-                        ExpressionSchema.describe("An expression which evaluates to the length of the output vector. Will only be provided with the function input. The output length must be determinable from the input alone."),
-                    ])
-                        .describe("The length of the output vector."),
-                })
-                    .describe("Details about the vector function to be published."),
-                profile: Function_1.FunctionProfileVersionRequiredSchema,
-                publish_profile: z
-                    .object({
-                    id: z
-                        .literal("default")
-                        .describe('The identifier of the profile to publish. Must be "default" when publishing a function.'),
-                    version: z
-                        .uint32()
-                        .describe("The version of the profile to publish. Must match the function's version."),
-                    description: z
-                        .string()
-                        .describe("The description of the published profile."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                })
-                    .describe("Details about the profile to be published."),
-            }).describe("Base parameters for executing and publishing an inline vector function.");
-            Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema = Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema.extend({
+                .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.")
+                .describe("Parameters for executing an inline function with a remote profile and streaming the response.")
                 .meta({
-                title: "FunctionExecutionParamsPublishVectorFunctionStreaming",
+                title: "FunctionExecutionParamsInlineFunctionRemoteProfileStreaming",
             });
-            Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema = Request.FunctionExecutionParamsPublishVectorFunctionBaseSchema.extend({
+            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.")
+                .describe("Parameters for executing an inline function with a remote profile with a unary response.")
                 .meta({
-                title: "FunctionExecutionParamsPublishVectorFunctionNonStreaming",
+                title: "FunctionExecutionParamsInlineFunctionRemoteProfileNonStreaming",
             });
-            Request.FunctionExecutionParamsPublishVectorFunctionSchema = z
-                .union([
-                Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema,
-                Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema,
-            ])
-                .describe("Parameters for executing and publishing an inline vector function.")
-                .meta({ title: "FunctionExecutionParamsPublishVectorFunction" });
-            // Publish Function
-            Request.FunctionExecutionParamsPublishFunctionStreamingSchema = z
+            Request.FunctionExecutionParamsInlineFunctionRemoteProfileSchema = z
                 .union([
-                Request.FunctionExecutionParamsPublishScalarFunctionStreamingSchema,
-                Request.FunctionExecutionParamsPublishVectorFunctionStreamingSchema,
+                Request.FunctionExecutionParamsInlineFunctionRemoteProfileStreamingSchema,
+                Request.FunctionExecutionParamsInlineFunctionRemoteProfileNonStreamingSchema,
             ])
-                .describe("Parameters for executing and publishing an inline function and streaming the response.")
-                .meta({ title: "FunctionExecutionParamsPublishFunctionStreaming" });
-            Request.FunctionExecutionParamsPublishFunctionNonStreamingSchema = z
-                .union([
-                Request.FunctionExecutionParamsPublishScalarFunctionNonStreamingSchema,
-                Request.FunctionExecutionParamsPublishVectorFunctionNonStreamingSchema,
-            ])
-                .describe("Parameters for executing and publishing an inline function with a unary response.")
-                .meta({ title: "FunctionExecutionParamsPublishFunctionNonStreaming" });
-            Request.FunctionExecutionParamsPublishFunctionSchema = z
-                .union([
-                Request.FunctionExecutionParamsPublishScalarFunctionSchema,
-                Request.FunctionExecutionParamsPublishVectorFunctionSchema,
-            ])
-                .describe("Parameters for executing and publishing an inline function.")
-                .meta({ title: "FunctionExecutionParamsPublishFunction" });
-            // Publish Profile
-            Request.FunctionExecutionParamsPublishProfileBaseSchema = Request.FunctionExecutionParamsBaseSchema.extend({
-                profile: z
-                    .array(Function_1.ProfileVersionRequiredSchema)
-                    .describe("The profile to publish."),
-                publish_profile: z
-                    .object({
-                    id: z
-                        .string()
-                        .describe("The unique identifier of the profile to publish."),
-                    version: z
-                        .uint32()
-                        .describe("The version of the profile to publish."),
-                    description: z
-                        .string()
-                        .describe("The description of the published profile."),
-                    changelog: z
-                        .string()
-                        .optional()
-                        .nullable()
-                        .describe("When present, describes changes from the previous version or versions."),
-                })
-                    .describe("Details about the profile to be published."),
-            }).describe("Base parameters for executing a remote published function and publishing a profile.");
-            Request.FunctionExecutionParamsPublishProfileStreamingSchema = Request.FunctionExecutionParamsPublishProfileBaseSchema.extend({
+                .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.")
-                .meta({ title: "FunctionExecutionParamsPublishProfileStreaming" });
-            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.")
-                .meta({ title: "FunctionExecutionParamsPublishProfileNonStreaming" });
-            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.")
-                .meta({ title: "FunctionExecutionParamsPublishProfile" });
+                .describe("Parameters for executing an inline function with an inline profile.")
+                .meta({ title: "FunctionExecutionParamsInlineFunctionInlineProfile" });
         })(Request = Executions.Request || (Executions.Request = {}));
         let Response;
         (function (Response) {
@@ -3243,7 +3100,7 @@ export var Function;
                         .optional()
                         .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)
                         .optional()
                         .describe("The computed function profile."),
                     fitting_stats: Response.FittingStatsSchema.optional(),
@@ -3286,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
@@ -3305,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()
@@ -3361,89 +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."),
-    })
-        .describe("A retrieved scalar function.")
-        .meta({ title: "RetrievedScalarFunction" });
-    Function_1.VectorRetrieveItemSchema = Function_1.VectorSchema.extend({
-        created: z
-            .uint32()
-            .describe("The UNIX timestamp (in seconds) when the function was created."),
-        shape: z
-            .string()
-            .describe("The shape of the function. Unless Task Skip expressions work out favorably, functions only work with profiles that have the same shape."),
-    })
-        .describe("A retrieved vector function.")
-        .meta({ title: "RetrievedVectorFunction" });
-    Function_1.RetrieveItemSchema = z.discriminatedUnion("type", [
-        Function_1.ScalarRetrieveItemSchema,
-        Function_1.VectorRetrieveItemSchema,
-    ]);
-    async function retrieve(openai, author, id, version, options) {
-        const response = await openai.get(version !== null && version !== undefined
-            ? `/functions/${author}/${id}/${version}`
-            : `/functions/${author}/${id}`, options);
-        return response;
-    }
-    Function_1.retrieve = retrieve;
     Function_1.HistoricalUsageSchema = z.object({
         requests: z
             .uint32()
@@ -3458,10 +3301,10 @@ 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;