asteroid-odyssey 1.0.7

package/dist/generated/platform/services/ApiKeyService.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class ApiKeyService {
+    /**
+     * Validate an API key
+     * @returns User API key is valid, returns a validated user object
+     * @throws ApiError
+     */
+    static validateApiKey() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/api_key/validate',
+            errors: {
+                401: `API key is invalid`,
+            },
+        });
+    }
+    /**
+     * Get all API keys for the current user
+     * @returns APIKey API keys
+     * @throws ApiError
+     */
+    static getApiKeys() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/api_key',
+        });
+    }
+    /**
+     * Create an API key
+     * @param requestBody
+     * @returns APIKey API key created
+     * @throws ApiError
+     */
+    static createApiKey(requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/api_key',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Revoke an API key
+     * @param requestBody
+     * @returns any API key revoked
+     * @throws ApiError
+     */
+    static revokeApiKey(requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/api_key',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+            },
+        });
+    }
+}
+exports.ApiKeyService = ApiKeyService;

package/dist/generated/platform/services/ApiService.d.ts

@@ -0,0 +1,9 @@
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class ApiService {
+    /**
+     * Get the OpenAPI schema
+     * @returns any OpenAPI schema
+     * @throws ApiError
+     */
+    static getOpenApi(): CancelablePromise<any>;
+}

package/dist/generated/platform/services/ApiService.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class ApiService {
+    /**
+     * Get the OpenAPI schema
+     * @returns any OpenAPI schema
+     * @throws ApiError
+     */
+    static getOpenApi() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/openapi.yaml',
+        });
+    }
+}
+exports.ApiService = ApiService;

package/dist/generated/platform/services/ImproveService.d.ts

@@ -0,0 +1,20 @@
+import type { Feedback } from '../models/Feedback';
+import type { FeedbackRequest } from '../models/FeedbackRequest';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class ImproveService {
+    /**
+     * Get feedback for a run
+     * @param runId
+     * @returns Feedback Feedback
+     * @throws ApiError
+     */
+    static getFeedback(runId: string): CancelablePromise<Array<Feedback>>;
+    /**
+     * Create feedback for a run
+     * @param runId
+     * @param requestBody
+     * @returns any Feedback created
+     * @throws ApiError
+     */
+    static createFeedback(runId: string, requestBody: FeedbackRequest): CancelablePromise<any>;
+}

package/dist/generated/platform/services/ImproveService.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImproveService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class ImproveService {
+    /**
+     * Get feedback for a run
+     * @param runId
+     * @returns Feedback Feedback
+     * @throws ApiError
+     */
+    static getFeedback(runId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/run/{run_id}/feedback',
+            path: {
+                'run_id': runId,
+            },
+            errors: {
+                404: `Run not found`,
+            },
+        });
+    }
+    /**
+     * Create feedback for a run
+     * @param runId
+     * @param requestBody
+     * @returns any Feedback created
+     * @throws ApiError
+     */
+    static createFeedback(runId, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/run/{run_id}/feedback',
+            path: {
+                'run_id': runId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Run not found`,
+            },
+        });
+    }
+}
+exports.ImproveService = ImproveService;

package/dist/generated/platform/services/ProjectService.d.ts

@@ -0,0 +1,34 @@
+import type { Project } from '../models/Project';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class ProjectService {
+    /**
+     * Get all projects
+     * @returns Project List of projects
+     * @throws ApiError
+     */
+    static getProjects(): CancelablePromise<Array<Project>>;
+    /**
+     * Create a new project
+     * @param requestBody
+     * @returns string Project found
+     * @throws ApiError
+     */
+    static createProject(requestBody: {
+        name: string;
+        run_result_tags: Array<string>;
+    }): CancelablePromise<string>;
+    /**
+     * Get a project
+     * @param projectId
+     * @returns Project Project
+     * @throws ApiError
+     */
+    static getProject(projectId: string): CancelablePromise<Project>;
+    /**
+     * Delete a project
+     * @param projectId
+     * @returns any Project deleted
+     * @throws ApiError
+     */
+    static deleteProject(projectId: string): CancelablePromise<any>;
+}

package/dist/generated/platform/services/ProjectService.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class ProjectService {
+    /**
+     * Get all projects
+     * @returns Project List of projects
+     * @throws ApiError
+     */
+    static getProjects() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/project',
+        });
+    }
+    /**
+     * Create a new project
+     * @param requestBody
+     * @returns string Project found
+     * @throws ApiError
+     */
+    static createProject(requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/project',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+            },
+        });
+    }
+    /**
+     * Get a project
+     * @param projectId
+     * @returns Project Project
+     * @throws ApiError
+     */
+    static getProject(projectId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/project/{projectId}',
+            path: {
+                'projectId': projectId,
+            },
+            errors: {
+                404: `Project not found`,
+            },
+        });
+    }
+    /**
+     * Delete a project
+     * @param projectId
+     * @returns any Project deleted
+     * @throws ApiError
+     */
+    static deleteProject(projectId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/project/{projectId}',
+            path: {
+                'projectId': projectId,
+            },
+            errors: {
+                404: `Project not found`,
+            },
+        });
+    }
+}
+exports.ProjectService = ProjectService;

package/dist/generated/platform/services/RunService.d.ts

@@ -0,0 +1,103 @@
+import type { AsteroidChat } from '../models/AsteroidChat';
+import type { AsteroidMessage } from '../models/AsteroidMessage';
+import type { ChatIds } from '../models/ChatIds';
+import type { Run } from '../models/Run';
+import type { Status } from '../models/Status';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class RunService {
+    /**
+     * Get all runs for a task
+     * @param taskId
+     * @returns Run List of runs
+     * @throws ApiError
+     */
+    static getTaskRuns(taskId: string): CancelablePromise<Array<Run>>;
+    /**
+     * Create a new run for a task
+     * @param taskId
+     * @param requestBody
+     * @returns string Run created
+     * @throws ApiError
+     */
+    static createRun(taskId: string, requestBody?: {
+        name?: string;
+        run_id?: string;
+    }): CancelablePromise<string>;
+    /**
+     * Get a run
+     * @param runId
+     * @returns Run Run
+     * @throws ApiError
+     */
+    static getRun(runId: string): CancelablePromise<Run>;
+    /**
+     * Delete a run
+     * @param runId
+     * @returns any Run deleted
+     * @throws ApiError
+     */
+    static deleteRun(runId: string): CancelablePromise<any>;
+    /**
+     * Update the metadata of a run
+     * @param runId
+     * @param requestBody
+     * @returns void
+     * @throws ApiError
+     */
+    static updateRunMetadata(runId: string, requestBody: Record<string, any>): CancelablePromise<void>;
+    /**
+     * Get the status of a run
+     * @param runId
+     * @returns Status Run status
+     * @throws ApiError
+     */
+    static getRunStatus(runId: string): CancelablePromise<Status>;
+    /**
+     * Update the status of a run
+     * @param runId
+     * @param requestBody
+     * @returns void
+     * @throws ApiError
+     */
+    static updateRunStatus(runId: string, requestBody: Status): CancelablePromise<void>;
+    /**
+     * Update a run with a result
+     * @param runId
+     * @param requestBody
+     * @returns any Run result created
+     * @throws ApiError
+     */
+    static updateRunResult(runId: string, requestBody: {
+        result?: string;
+    }): CancelablePromise<any>;
+    /**
+     * Get the image messages for a run
+     * @param runId
+     * @returns AsteroidMessage Run image messages
+     * @throws ApiError
+     */
+    static getRunImageMessages(runId: string): CancelablePromise<Array<AsteroidMessage>>;
+    /**
+     * Create a new chat completion request from an existing run
+     * @param runId
+     * @param requestBody
+     * @returns ChatIds New chat completion created
+     * @throws ApiError
+     */
+    static createNewChat(runId: string, requestBody: AsteroidChat): CancelablePromise<ChatIds>;
+    /**
+     * Get the messages for a run
+     * @param runId
+     * @param index
+     * @returns AsteroidMessage Run messages
+     * @throws ApiError
+     */
+    static getRunMessages(runId: string, index: number): CancelablePromise<Array<AsteroidMessage>>;
+    /**
+     * Count the number of chat entries for a run
+     * @param runId
+     * @returns number Number of chat entries for the run
+     * @throws ApiError
+     */
+    static getRunChatCount(runId: string): CancelablePromise<number>;
+}

package/dist/generated/platform/services/RunService.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class RunService {
+    /**
+     * Get all runs for a task
+     * @param taskId
+     * @returns Run List of runs
+     * @throws ApiError
+     */
+    static getTaskRuns(taskId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/task/{taskId}/run',
+            path: {
+                'taskId': taskId,
+            },
+        });
+    }
+    /**
+     * Create a new run for a task
+     * @param taskId
+     * @param requestBody
+     * @returns string Run created
+     * @throws ApiError
+     */
+    static createRun(taskId, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/task/{taskId}/run',
+            path: {
+                'taskId': taskId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Get a run
+     * @param runId
+     * @returns Run Run
+     * @throws ApiError
+     */
+    static getRun(runId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/run/{runId}',
+            path: {
+                'runId': runId,
+            },
+            errors: {
+                404: `Run not found`,
+            },
+        });
+    }
+    /**
+     * Delete a run
+     * @param runId
+     * @returns any Run deleted
+     * @throws ApiError
+     */
+    static deleteRun(runId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/run/{runId}',
+            path: {
+                'runId': runId,
+            },
+        });
+    }
+    /**
+     * Update the metadata of a run
+     * @param runId
+     * @param requestBody
+     * @returns void
+     * @throws ApiError
+     */
+    static updateRunMetadata(runId, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'PUT',
+            url: '/run/{runId}/metadata',
+            path: {
+                'runId': runId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Run not found`,
+            },
+        });
+    }
+    /**
+     * Get the status of a run
+     * @param runId
+     * @returns Status Run status
+     * @throws ApiError
+     */
+    static getRunStatus(runId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/run/{runId}/status',
+            path: {
+                'runId': runId,
+            },
+            errors: {
+                404: `Run not found`,
+            },
+        });
+    }
+    /**
+     * Update the status of a run
+     * @param runId
+     * @param requestBody
+     * @returns void
+     * @throws ApiError
+     */
+    static updateRunStatus(runId, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'PUT',
+            url: '/run/{runId}/status',
+            path: {
+                'runId': runId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update a run with a result
+     * @param runId
+     * @param requestBody
+     * @returns any Run result created
+     * @throws ApiError
+     */
+    static updateRunResult(runId, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'PUT',
+            url: '/run/{runId}/result',
+            path: {
+                'runId': runId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+            },
+        });
+    }
+    /**
+     * Get the image messages for a run
+     * @param runId
+     * @returns AsteroidMessage Run image messages
+     * @throws ApiError
+     */
+    static getRunImageMessages(runId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/run/{run_id}/image_messages',
+            path: {
+                'run_id': runId,
+            },
+            errors: {
+                404: `Run not found`,
+            },
+        });
+    }
+    /**
+     * Create a new chat completion request from an existing run
+     * @param runId
+     * @param requestBody
+     * @returns ChatIds New chat completion created
+     * @throws ApiError
+     */
+    static createNewChat(runId, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/run/{run_id}/chat',
+            path: {
+                'run_id': runId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad request`,
+                404: `Run not found`,
+            },
+        });
+    }
+    /**
+     * Get the messages for a run
+     * @param runId
+     * @param index
+     * @returns AsteroidMessage Run messages
+     * @throws ApiError
+     */
+    static getRunMessages(runId, index) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/run/{run_id}/messages/{index}',
+            path: {
+                'run_id': runId,
+                'index': index,
+            },
+            errors: {
+                404: `Run not found`,
+            },
+        });
+    }
+    /**
+     * Count the number of chat entries for a run
+     * @param runId
+     * @returns number Number of chat entries for the run
+     * @throws ApiError
+     */
+    static getRunChatCount(runId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/run/{run_id}/chat_count',
+            path: {
+                'run_id': runId,
+            },
+        });
+    }
+}
+exports.RunService = RunService;

package/dist/generated/platform/services/StatsService.d.ts

@@ -0,0 +1,10 @@
+import type { HubStats } from '../models/HubStats';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class StatsService {
+    /**
+     * Get hub stats
+     * @returns HubStats Hub stats
+     * @throws ApiError
+     */
+    static getHubStats(): CancelablePromise<HubStats>;
+}

package/dist/generated/platform/services/StatsService.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class StatsService {
+    /**
+     * Get hub stats
+     * @returns HubStats Hub stats
+     * @throws ApiError
+     */
+    static getHubStats() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/stats',
+            errors: {
+                400: `Invalid request`,
+            },
+        });
+    }
+}
+exports.StatsService = StatsService;

package/dist/generated/platform/services/SupervisionService.d.ts

@@ -0,0 +1,46 @@
+import type { ReviewPayload } from '../models/ReviewPayload';
+import type { SupervisionRequest } from '../models/SupervisionRequest';
+import type { SupervisionResult } from '../models/SupervisionResult';
+import type { SupervisionStatus } from '../models/SupervisionStatus';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class SupervisionService {
+    /**
+     * Create a supervision request for a supervisor in a chain on a tool call
+     * @param toolCallId
+     * @param chainId
+     * @param supervisorId
+     * @param requestBody
+     * @returns string Supervision request created
+     * @throws ApiError
+     */
+    static createSupervisionRequest(toolCallId: string, chainId: string, supervisorId: string, requestBody: SupervisionRequest): CancelablePromise<string>;
+    /**
+     * Get a supervision request status
+     * @param supervisionRequestId
+     * @returns SupervisionStatus Get the supervision request status
+     * @throws ApiError
+     */
+    static getSupervisionRequestStatus(supervisionRequestId: string): CancelablePromise<SupervisionStatus>;
+    /**
+     * Get a supervision result
+     * @param supervisionRequestId
+     * @returns SupervisionResult Get the supervision result for a supervision request
+     * @throws ApiError
+     */
+    static getSupervisionResult(supervisionRequestId: string): CancelablePromise<SupervisionResult>;
+    /**
+     * Create a supervision result for a supervision request
+     * @param supervisionRequestId
+     * @param requestBody
+     * @returns string Supervision result created
+     * @throws ApiError
+     */
+    static createSupervisionResult(supervisionRequestId: string, requestBody: SupervisionResult): CancelablePromise<string>;
+    /**
+     * Get the review payload for a supervision request
+     * @param supervisionRequestId
+     * @returns ReviewPayload Review payload for the supervision request
+     * @throws ApiError
+     */
+    static getSupervisionReviewPayload(supervisionRequestId: string): CancelablePromise<ReviewPayload>;
+}