objectiveai 1.1.7 → 1.1.9

package/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultichatModel = exports.ScoreModel = exports.MultichatLlm = exports.ScoreLlm = exports.Metadata = exports.Auth = exports.Models = exports.Conversation = exports.Multichat = exports.Score = exports.Chat = void 0;
+exports.MultichatModel = exports.ScoreModel = exports.MultichatLlm = exports.ScoreLlm = exports.Metadata = exports.Auth = exports.Models = exports.Apps = exports.Conversation = exports.Multichat = exports.Score = exports.Chat = void 0;
 var Chat;
 (function (Chat) {
     let Completions;
@@ -663,6 +663,126 @@ var Conversation;
         Completions.list = list;
     })(Completions = Conversation.Completions || (Conversation.Completions = {}));
 })(Conversation || (exports.Conversation = Conversation = {}));
+var Apps;
+(function (Apps) {
+    let Response;
+    (function (Response) {
+        let Streaming;
+        (function (Streaming) {
+            let CompletionChunk;
+            (function (CompletionChunk) {
+                let ScoreCompletionChunk;
+                (function (ScoreCompletionChunk) {
+                    function merged(a, b) {
+                        const [base, baseChanged] = Score.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
+                        return baseChanged
+                            ? [Object.assign(Object.assign({ type: a.type }, base), { index: a.index }), true]
+                            : [a, false];
+                    }
+                    ScoreCompletionChunk.merged = merged;
+                })(ScoreCompletionChunk = CompletionChunk.ScoreCompletionChunk || (CompletionChunk.ScoreCompletionChunk = {}));
+                let MultichatCompletionChunk;
+                (function (MultichatCompletionChunk) {
+                    function merged(a, b) {
+                        const [base, baseChanged] = Multichat.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
+                        return baseChanged
+                            ? [Object.assign(Object.assign({ type: a.type }, base), { index: a.index }), true]
+                            : [a, false];
+                    }
+                    MultichatCompletionChunk.merged = merged;
+                })(MultichatCompletionChunk = CompletionChunk.MultichatCompletionChunk || (CompletionChunk.MultichatCompletionChunk = {}));
+                function mergedList(a, b) {
+                    let merged = undefined;
+                    for (const chunk of b) {
+                        const existingIndex = a.findIndex((c) => c.index === chunk.index && c.type === chunk.type);
+                        if (existingIndex === -1) {
+                            if (merged === undefined) {
+                                merged = [...a, chunk];
+                            }
+                            else {
+                                merged.push(chunk);
+                            }
+                        }
+                        else if (chunk.type === "score") {
+                            const [mergedChunk, chunkChanged] = ScoreCompletionChunk.merged(a[existingIndex], chunk);
+                            if (chunkChanged) {
+                                if (merged === undefined) {
+                                    merged = [...a];
+                                }
+                                merged[existingIndex] = mergedChunk;
+                            }
+                        }
+                        else if (chunk.type === "multichat") {
+                            const [mergedChunk, chunkChanged] = MultichatCompletionChunk.merged(a[existingIndex], chunk);
+                            if (chunkChanged) {
+                                if (merged === undefined) {
+                                    merged = [...a];
+                                }
+                                merged[existingIndex] = mergedChunk;
+                            }
+                        }
+                    }
+                    return merged ? [merged, true] : [a, false];
+                }
+                CompletionChunk.mergedList = mergedList;
+            })(CompletionChunk = Streaming.CompletionChunk || (Streaming.CompletionChunk = {}));
+            function merged(a, b) {
+                const [completions, completionsChanged] = CompletionChunk.mergedList(a.completions, b.completions);
+                const [output, outputChanged] = merge(a.output, b.output);
+                const [retry_token, retry_tokenChanged] = merge(a.retry_token, b.retry_token);
+                const [error, errorChanged] = merge(a.error, b.error);
+                const [app_published, app_publishedChanged] = merge(a.app_published, b.app_published);
+                if (completionsChanged ||
+                    outputChanged ||
+                    retry_tokenChanged ||
+                    errorChanged ||
+                    app_publishedChanged) {
+                    return [
+                        Object.assign(Object.assign(Object.assign(Object.assign({ completions }, (output !== undefined ? { output } : {})), (retry_token !== undefined ? { retry_token } : {})), (error !== undefined ? { error } : {})), (app_published !== undefined ? { app_published } : {})),
+                        true,
+                    ];
+                }
+                else {
+                    return [a, false];
+                }
+            }
+            Streaming.merged = merged;
+        })(Streaming = Response.Streaming || (Response.Streaming = {}));
+    })(Response = Apps.Response || (Apps.Response = {}));
+    async function list(openai, listOptions, options) {
+        const response = await openai.get("/apps", Object.assign({ query: listOptions }, options));
+        return response;
+    }
+    Apps.list = list;
+    async function count(openai, options) {
+        const response = await openai.get("/apps/count", options);
+        return response;
+    }
+    Apps.count = count;
+    async function retrieve(openai, author, id, version, retrieveOptions, options) {
+        const url = version !== null && version !== undefined
+            ? `/apps/${author}/${id}/${version}`
+            : `/apps/${author}/${id}`;
+        const response = await openai.get(url, Object.assign({ query: retrieveOptions }, options));
+        return response;
+    }
+    Apps.retrieve = retrieve;
+    async function executeById(openai, author, id, version, body, options) {
+        var _a;
+        const url = version !== null && version !== undefined
+            ? `/apps/${author}/${id}/${version}`
+            : `/apps/${author}/${id}`;
+        const response = await openai.post(url, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        return response;
+    }
+    Apps.executeById = executeById;
+    async function executeByDefinition(openai, body, options) {
+        var _a;
+        const response = await openai.post("/apps", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        return response;
+    }
+    Apps.executeByDefinition = executeByDefinition;
+})(Apps || (exports.Apps = Apps = {}));
 var Models;
 (function (Models) {
     async function list(openai, listOptions, options) {
@@ -730,6 +850,19 @@ var Auth;
         }
         Credits.retrieve = retrieve;
     })(Credits = Auth.Credits || (Auth.Credits = {}));
+    let Username;
+    (function (Username) {
+        async function retrieve(openai, options) {
+            const response = await openai.get("/auth/username", options);
+            return response;
+        }
+        Username.retrieve = retrieve;
+        async function set(openai, username, options) {
+            const response = await openai.post("/auth/username", Object.assign({ body: { username } }, options));
+            return response;
+        }
+        Username.set = set;
+    })(Username = Auth.Username || (Auth.Username = {}));
 })(Auth || (exports.Auth = Auth = {}));
 var Metadata;
 (function (Metadata) {

package/dist/index.d.ts

@@ -739,6 +739,291 @@ export declare namespace Conversation {
         }>;
     }
 }
+export declare namespace Apps {
+    interface Expression {
+        $jmespath: string;
+    }
+    type WithExpression<T> = T | Expression;
+    type InputProperty = InputProperty.Array | InputProperty.String | InputProperty.Number | InputProperty.Integer | InputProperty.Boolean;
+    namespace InputProperty {
+        interface Array {
+            type: "array";
+            description?: string | null;
+            required?: boolean | null;
+            items: Array.ItemsProperty | Record<string, Array.ItemsProperty>;
+        }
+        namespace Array {
+            type ItemsProperty = InputProperty.String | InputProperty.Number | InputProperty.Integer | InputProperty.Boolean;
+        }
+        interface String {
+            type: "string";
+            description?: string | null;
+            required?: boolean | null;
+            enum?: string[] | null;
+        }
+        interface Number {
+            type: "number";
+            description?: string | null;
+            required?: boolean | null;
+        }
+        interface Integer {
+            type: "integer";
+            description?: string | null;
+            required?: boolean | null;
+        }
+        interface Boolean {
+            type: "boolean";
+            description?: string | null;
+            required?: boolean | null;
+        }
+    }
+    type OutputProperty = OutputProperty.Object | InputProperty.Array | InputProperty.String | InputProperty.Number | InputProperty.Integer | InputProperty.Boolean;
+    namespace OutputProperty {
+        interface Object {
+            type: "object";
+            required?: boolean | null;
+            properties: Record<string, OutputProperty>;
+        }
+        interface Array {
+            type: "array";
+            required?: boolean | null;
+            items: OutputProperty;
+        }
+        interface String {
+            type: "string";
+            required?: boolean | null;
+        }
+        interface Number {
+            type: "number";
+            required?: boolean | null;
+        }
+        interface Integer {
+            type: "integer";
+            required?: boolean | null;
+        }
+        interface Boolean {
+            type: "boolean";
+            required?: boolean | null;
+        }
+    }
+    type Step = Step.Score | Step.Multichat;
+    namespace Step {
+        type Message = Message.Developer | Message.System | Message.User | Message.Assistant | Message.Tool | Message.ChatCompletion | Message.ScoreCompletion | Message.MultichatCompletion;
+        namespace Message {
+            interface Developer {
+                role: Chat.Completions.Request.Message.Developer["role"];
+                content: WithExpression<SimpleContent>;
+                name?: WithExpression<Chat.Completions.Request.Message.Developer["name"]>;
+            }
+            interface System {
+                role: Chat.Completions.Request.Message.System["role"];
+                content: WithExpression<SimpleContent>;
+                name?: WithExpression<Chat.Completions.Request.Message.System["name"]>;
+            }
+            interface User {
+                role: Chat.Completions.Request.Message.User["role"];
+                content: WithExpression<RichContent>;
+                name?: WithExpression<Chat.Completions.Request.Message.User["name"]>;
+            }
+            interface Assistant {
+                role: Chat.Completions.Request.Message.Assistant["role"];
+                content?: WithExpression<RichContent> | null;
+                name?: WithExpression<Chat.Completions.Request.Message.Assistant["name"]>;
+                refusal?: WithExpression<Chat.Completions.Request.Message.Assistant["refusal"]>;
+                tool_calls?: WithExpression<WithExpression<Assistant.ToolCall>[]> | null;
+            }
+            namespace Assistant {
+                type ToolCall = ToolCall.Function;
+                namespace ToolCall {
+                    interface Function {
+                        id: WithExpression<Chat.Completions.Request.Message.Assistant.ToolCall.Function["id"]>;
+                        function: WithExpression<Function.Definition>;
+                        type: Chat.Completions.Request.Message.Assistant.ToolCall.Function["type"];
+                    }
+                    namespace Function {
+                        interface Definition {
+                            name: WithExpression<Chat.Completions.Request.Message.Assistant.ToolCall.Function.Definition["name"]>;
+                            arguments: WithExpression<Chat.Completions.Request.Message.Assistant.ToolCall.Function.Definition["arguments"]>;
+                        }
+                    }
+                }
+            }
+            interface Tool {
+                role: Chat.Completions.Request.Message.Tool["role"];
+                content: WithExpression<RichContent>;
+                tool_call_id: WithExpression<Chat.Completions.Request.Message.Tool["tool_call_id"]>;
+            }
+            interface ChatCompletion {
+                role: Chat.Completions.Request.Message.ChatCompletion["role"];
+                id: WithExpression<Chat.Completions.Request.Message.ChatCompletion["id"]>;
+                choice_index: WithExpression<Chat.Completions.Request.Message.ChatCompletion["choice_index"]>;
+                name?: WithExpression<Chat.Completions.Request.Message.ChatCompletion["name"]>;
+            }
+            interface ScoreCompletion {
+                role: Chat.Completions.Request.Message.ScoreCompletion["role"];
+                id: WithExpression<Chat.Completions.Request.Message.ScoreCompletion["id"]>;
+                choice_index: WithExpression<Chat.Completions.Request.Message.ScoreCompletion["choice_index"]>;
+                name?: WithExpression<Chat.Completions.Request.Message.ScoreCompletion["name"]>;
+            }
+            interface MultichatCompletion {
+                role: Chat.Completions.Request.Message.MultichatCompletion["role"];
+                id: WithExpression<Chat.Completions.Request.Message.MultichatCompletion["id"]>;
+                choice_index: WithExpression<Chat.Completions.Request.Message.MultichatCompletion["choice_index"]>;
+                name?: WithExpression<Chat.Completions.Request.Message.MultichatCompletion["name"]>;
+            }
+            type SimpleContent = string | WithExpression<Chat.Completions.Request.Message.SimpleContentPart>[];
+            type RichContent = string | WithExpression<Chat.Completions.Request.Message.RichContentPart>[];
+        }
+        type ResponseFormat = ResponseFormat.Text | ResponseFormat.JsonObject | ResponseFormat.JsonSchema;
+        namespace ResponseFormat {
+            interface Text {
+                type: "text";
+            }
+            interface JsonObject {
+                type: "json_object";
+            }
+            interface JsonSchema {
+                type: "json_schema";
+                json_schema: WithExpression<JsonSchema.JsonSchema>;
+            }
+            namespace JsonSchema {
+                interface JsonSchema {
+                    name: WithExpression<Chat.Completions.Request.ResponseFormat.JsonSchema.JsonSchema["name"]>;
+                    description?: WithExpression<Chat.Completions.Request.ResponseFormat.JsonSchema.JsonSchema["description"]>;
+                    schema?: WithExpression<Chat.Completions.Request.ResponseFormat.JsonSchema.JsonSchema["schema"]>;
+                    strict?: WithExpression<Chat.Completions.Request.ResponseFormat.JsonSchema.JsonSchema["strict"]>;
+                }
+            }
+        }
+        interface Multichat {
+            type: "multichat";
+            messages: WithExpression<WithExpression<Message>[]>;
+            model: WithExpression<Multichat.Completions.Request.ChatCompletionCreateParams["model"]>;
+            response_format?: WithExpression<ResponseFormat> | null;
+        }
+        interface Score {
+            type: "score";
+            messages: WithExpression<WithExpression<Message>[]>;
+            model: WithExpression<Score.Completions.Request.ChatCompletionCreateParams["model"]>;
+            choices: WithExpression<WithExpression<Score.Completions.Request.Choice>[]>;
+        }
+    }
+    namespace Request {
+        interface ExecuteByIdRequestBase {
+            arguments?: JsonValue;
+            retry_token?: string;
+            seed?: Chat.Completions.Request.ChatCompletionCreateParamsBase["seed"];
+            service_tier?: Chat.Completions.Request.ChatCompletionCreateParamsBase["service_tier"];
+            stream_options?: Chat.Completions.Request.ChatCompletionCreateParamsBase["stream_options"];
+            usage?: Chat.Completions.Request.ChatCompletionCreateParamsBase["usage"];
+        }
+        interface ExecuteByIdRequestStreaming extends ExecuteByIdRequestBase {
+            stream: true;
+        }
+        interface ExecuteByIdRequestNonStreaming extends ExecuteByIdRequestBase {
+            stream?: false | null;
+        }
+        type ExecuteByIdRequest = ExecuteByIdRequestStreaming | ExecuteByIdRequestNonStreaming;
+        interface ExecuteByDefinitionRequestBase extends ExecuteByIdRequestBase {
+            steps: WithExpression<WithExpression<Step>[]>;
+            output: Expression | Record<string, Expression>;
+            publish?: {
+                id: string;
+                description: string;
+                input: Record<string, InputProperty>;
+                output: OutputProperty;
+            } | null;
+        }
+        interface ExecuteByDefinitionRequestStreaming extends ExecuteByDefinitionRequestBase {
+            stream: true;
+        }
+        interface ExecuteByDefinitionRequestNonStreaming extends ExecuteByDefinitionRequestBase {
+            stream?: false | null;
+        }
+        type ExecuteByDefinitionRequest = ExecuteByDefinitionRequestStreaming | ExecuteByDefinitionRequestNonStreaming;
+    }
+    namespace Response {
+        namespace Streaming {
+            interface ExecuteResponseChunk {
+                completions: CompletionChunk[];
+                output?: JsonValue;
+                retry_token?: string;
+                error?: ObjectiveAIError;
+                app_published?: boolean;
+            }
+            type CompletionChunk = CompletionChunk.ScoreCompletionChunk | CompletionChunk.MultichatCompletionChunk;
+            namespace CompletionChunk {
+                interface ScoreCompletionChunk extends Score.Completions.Response.Streaming.ChatCompletionChunk {
+                    type: "score";
+                    index: number;
+                }
+                namespace ScoreCompletionChunk {
+                    function merged(a: ScoreCompletionChunk, b: ScoreCompletionChunk): [ScoreCompletionChunk, boolean];
+                }
+                interface MultichatCompletionChunk extends Multichat.Completions.Response.Streaming.ChatCompletionChunk {
+                    type: "multichat";
+                    index: number;
+                }
+                namespace MultichatCompletionChunk {
+                    function merged(a: MultichatCompletionChunk, b: MultichatCompletionChunk): [MultichatCompletionChunk, boolean];
+                }
+                function mergedList(a: CompletionChunk[], b: CompletionChunk[]): [CompletionChunk[], boolean];
+            }
+            function merged(a: ExecuteResponseChunk, b: ExecuteResponseChunk): [ExecuteResponseChunk, boolean];
+        }
+        namespace Unary {
+            interface ExecuteResponse {
+                completions: Completion[];
+                output: JsonValue;
+                retry_token: string | null;
+                error: ObjectiveAIError | null;
+                app_published?: boolean;
+            }
+            type Completion = Completion.Score | Completion.Multichat;
+            namespace Completion {
+                interface Score extends Score.Completions.Response.Unary.ChatCompletion {
+                    type: "score";
+                    index: number;
+                }
+                interface Multichat extends Multichat.Completions.Response.Unary.ChatCompletion {
+                    type: "multichat";
+                    index: number;
+                }
+            }
+        }
+    }
+    interface AppHeader {
+        author: string;
+        id: string;
+        version: number;
+        description: string;
+    }
+    interface App extends AppHeader {
+        input_schema: Record<string, InputProperty>;
+        output_schema: OutputProperty;
+        steps: WithExpression<WithExpression<Step>[]>;
+        output: Expression | Record<string, Expression>;
+    }
+    interface AppWithMetadata extends App {
+        created: string;
+        requests: number;
+        completion_tokens: number;
+        prompt_tokens: number;
+        total_cost: number;
+    }
+    function list(openai: OpenAI, listOptions?: Models.ListOptions, options?: OpenAI.RequestOptions): Promise<{
+        data: AppHeader[];
+    }>;
+    function count(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<{
+        data: number;
+    }>;
+    function retrieve(openai: OpenAI, author: string, id: string, version?: number | null, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<App>;
+    function retrieve(openai: OpenAI, author: string, id: string, version?: number | null, retrieveOptions?: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<AppWithMetadata>;
+    function executeById(openai: OpenAI, author: string, id: string, version: number | null | undefined, body: Request.ExecuteByIdRequestStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ExecuteResponseChunk>>;
+    function executeById(openai: OpenAI, author: string, id: string, version: number | null | undefined, body: Request.ExecuteByIdRequestNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ExecuteResponse>;
+    function executeByDefinition(openai: OpenAI, body: Request.ExecuteByDefinitionRequestStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ExecuteResponseChunk>>;
+    function executeByDefinition(openai: OpenAI, body: Request.ExecuteByDefinitionRequestNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ExecuteResponse>;
+}
 export declare namespace Models {
     interface Model {
         id: string;
@@ -857,6 +1142,14 @@ export declare namespace Auth {
     namespace Credits {
         function retrieve(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<Credits>;
     }
+    namespace Username {
+        function retrieve(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<{
+            username: string | null;
+        }>;
+        function set(openai: OpenAI, username: string, options?: OpenAI.RequestOptions): Promise<{
+            username: string;
+        }>;
+    }
 }
 export interface Metadata {
     score_requests: number;

package/dist/index.js

@@ -660,6 +660,126 @@ export var Conversation;
         Completions.list = list;
     })(Completions = Conversation.Completions || (Conversation.Completions = {}));
 })(Conversation || (Conversation = {}));
+export var Apps;
+(function (Apps) {
+    let Response;
+    (function (Response) {
+        let Streaming;
+        (function (Streaming) {
+            let CompletionChunk;
+            (function (CompletionChunk) {
+                let ScoreCompletionChunk;
+                (function (ScoreCompletionChunk) {
+                    function merged(a, b) {
+                        const [base, baseChanged] = Score.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
+                        return baseChanged
+                            ? [Object.assign(Object.assign({ type: a.type }, base), { index: a.index }), true]
+                            : [a, false];
+                    }
+                    ScoreCompletionChunk.merged = merged;
+                })(ScoreCompletionChunk = CompletionChunk.ScoreCompletionChunk || (CompletionChunk.ScoreCompletionChunk = {}));
+                let MultichatCompletionChunk;
+                (function (MultichatCompletionChunk) {
+                    function merged(a, b) {
+                        const [base, baseChanged] = Multichat.Completions.Response.Streaming.ChatCompletionChunk.merged(a, b);
+                        return baseChanged
+                            ? [Object.assign(Object.assign({ type: a.type }, base), { index: a.index }), true]
+                            : [a, false];
+                    }
+                    MultichatCompletionChunk.merged = merged;
+                })(MultichatCompletionChunk = CompletionChunk.MultichatCompletionChunk || (CompletionChunk.MultichatCompletionChunk = {}));
+                function mergedList(a, b) {
+                    let merged = undefined;
+                    for (const chunk of b) {
+                        const existingIndex = a.findIndex((c) => c.index === chunk.index && c.type === chunk.type);
+                        if (existingIndex === -1) {
+                            if (merged === undefined) {
+                                merged = [...a, chunk];
+                            }
+                            else {
+                                merged.push(chunk);
+                            }
+                        }
+                        else if (chunk.type === "score") {
+                            const [mergedChunk, chunkChanged] = ScoreCompletionChunk.merged(a[existingIndex], chunk);
+                            if (chunkChanged) {
+                                if (merged === undefined) {
+                                    merged = [...a];
+                                }
+                                merged[existingIndex] = mergedChunk;
+                            }
+                        }
+                        else if (chunk.type === "multichat") {
+                            const [mergedChunk, chunkChanged] = MultichatCompletionChunk.merged(a[existingIndex], chunk);
+                            if (chunkChanged) {
+                                if (merged === undefined) {
+                                    merged = [...a];
+                                }
+                                merged[existingIndex] = mergedChunk;
+                            }
+                        }
+                    }
+                    return merged ? [merged, true] : [a, false];
+                }
+                CompletionChunk.mergedList = mergedList;
+            })(CompletionChunk = Streaming.CompletionChunk || (Streaming.CompletionChunk = {}));
+            function merged(a, b) {
+                const [completions, completionsChanged] = CompletionChunk.mergedList(a.completions, b.completions);
+                const [output, outputChanged] = merge(a.output, b.output);
+                const [retry_token, retry_tokenChanged] = merge(a.retry_token, b.retry_token);
+                const [error, errorChanged] = merge(a.error, b.error);
+                const [app_published, app_publishedChanged] = merge(a.app_published, b.app_published);
+                if (completionsChanged ||
+                    outputChanged ||
+                    retry_tokenChanged ||
+                    errorChanged ||
+                    app_publishedChanged) {
+                    return [
+                        Object.assign(Object.assign(Object.assign(Object.assign({ completions }, (output !== undefined ? { output } : {})), (retry_token !== undefined ? { retry_token } : {})), (error !== undefined ? { error } : {})), (app_published !== undefined ? { app_published } : {})),
+                        true,
+                    ];
+                }
+                else {
+                    return [a, false];
+                }
+            }
+            Streaming.merged = merged;
+        })(Streaming = Response.Streaming || (Response.Streaming = {}));
+    })(Response = Apps.Response || (Apps.Response = {}));
+    async function list(openai, listOptions, options) {
+        const response = await openai.get("/apps", Object.assign({ query: listOptions }, options));
+        return response;
+    }
+    Apps.list = list;
+    async function count(openai, options) {
+        const response = await openai.get("/apps/count", options);
+        return response;
+    }
+    Apps.count = count;
+    async function retrieve(openai, author, id, version, retrieveOptions, options) {
+        const url = version !== null && version !== undefined
+            ? `/apps/${author}/${id}/${version}`
+            : `/apps/${author}/${id}`;
+        const response = await openai.get(url, Object.assign({ query: retrieveOptions }, options));
+        return response;
+    }
+    Apps.retrieve = retrieve;
+    async function executeById(openai, author, id, version, body, options) {
+        var _a;
+        const url = version !== null && version !== undefined
+            ? `/apps/${author}/${id}/${version}`
+            : `/apps/${author}/${id}`;
+        const response = await openai.post(url, Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        return response;
+    }
+    Apps.executeById = executeById;
+    async function executeByDefinition(openai, body, options) {
+        var _a;
+        const response = await openai.post("/apps", Object.assign({ body, stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false }, options));
+        return response;
+    }
+    Apps.executeByDefinition = executeByDefinition;
+})(Apps || (Apps = {}));
 export var Models;
 (function (Models) {
     async function list(openai, listOptions, options) {
@@ -727,6 +847,19 @@ export var Auth;
         }
         Credits.retrieve = retrieve;
     })(Credits = Auth.Credits || (Auth.Credits = {}));
+    let Username;
+    (function (Username) {
+        async function retrieve(openai, options) {
+            const response = await openai.get("/auth/username", options);
+            return response;
+        }
+        Username.retrieve = retrieve;
+        async function set(openai, username, options) {
+            const response = await openai.post("/auth/username", Object.assign({ body: { username } }, options));
+            return response;
+        }
+        Username.set = set;
+    })(Username = Auth.Username || (Auth.Username = {}));
 })(Auth || (Auth = {}));
 export var Metadata;
 (function (Metadata) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objectiveai",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "SDK for the ObjectiveAI API.",
   "main": "dist/index.js",
   "repository": {