aimeat 1.16.2 → 1.18.0

package/dist/src/generated/api-types.d.ts

@@ -152,7 +152,15 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Refresh JWT */
+        /**
+         * Refresh access token
+         * @description Refresh an access token. Two modes:
+         *       * **Owner session (cookie):** send the httpOnly `aimeat_rt` refresh cookie (set at
+         *         login) plus the `X-AIMEAT-Refresh: 1` header (CSRF guard). The refresh token is
+         *         rotated one-time-use with a short grace window and a new cookie is set; replaying
+         *         a consumed token revokes the whole session. Returns `{ token, expires_in }`.
+         *       * **Legacy (Bearer):** send a valid Bearer access token (agents / pre-cookie clients).
+         */
         post: operations["refreshToken"];
         delete?: never;
         options?: never;
@@ -169,7 +177,11 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Revoke JWT */
+        /**
+         * Revoke session / logout
+         * @description Revoke the current session and clear the `aimeat_rt` refresh cookie. Accepts the
+         *     refresh cookie and/or a Bearer token, and works even after the access token expired.
+         */
         post: operations["revokeToken"];
         delete?: never;
         options?: never;
@@ -177,6 +189,76 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/access/tokens": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the owner's access tokens
+         * @description Returns active (non-revoked) tokens. The raw token is never returned.
+         */
+        get: operations["listAccessTokens"];
+        put?: never;
+        /**
+         * Create a Personal Access Token
+         * @description Owner creates a reusable, revocable token an agent uses (as `Authorization: Bearer`)
+         *     to authenticate transparently — like a logged-in user — and test the owner's apps.
+         *     The token grants either selected agent scopes (a scoped, sandboxed test identity) or,
+         *     when chosen, full owner / operator access. The raw token is returned **once**; only its
+         *     SHA-256 hash is stored. `grant_operator` requires the caller to be an operator.
+         */
+        post: operations["createAccessToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/access/tokens/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Revoke an access token
+         * @description Revocation takes effect immediately — the next request carrying the token is rejected.
+         */
+        delete: operations["revokeAccessToken"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/auth/token/exchange": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Exchange a Personal Access Token for a short access JWT
+         * @description Optional convenience: present the token (as `Authorization: Bearer` or `{ token }`) and
+         *     receive a short stateless access JWT at the token's level. The token can also be used
+         *     directly as a Bearer credential on any endpoint without exchanging.
+         */
+        post: operations["exchangeAccessToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/auth/connectivity-key": {
         parameters: {
             query?: never;
@@ -6920,6 +7002,103 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/schedules": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List all of the owner's schedules (master scheduler view)
+         * @description Aggregates the owner's AIMEAT-managed schedules (ai / agent_task / extension), the owner's extension cron jobs, and each agent's self-reported internal scheduler mirror.
+         */
+        get: operations["listSchedules"];
+        put?: never;
+        /** Create a schedule (profile-level or agent-targeted) */
+        post: operations["createSchedule"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/schedules/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a schedule plus its recent execution log */
+        get: operations["getSchedule"];
+        put?: never;
+        post?: never;
+        /** Cancel and remove a schedule (the owner may delete agent-created ones) */
+        delete: operations["deleteSchedule"];
+        options?: never;
+        head?: never;
+        /** Edit a schedule (cron, enabled/pause, timezone, constraints, input) */
+        patch: operations["updateSchedule"];
+        trace?: never;
+    };
+    "/v1/schedules/{id}/trigger": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Run a schedule immediately */
+        post: operations["triggerSchedule"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{name}/schedules": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Agent name (not full GAII) */
+                name: string;
+            };
+            cookie?: never;
+        };
+        /** List a single agent's schedules (managed + internal mirror) */
+        get: operations["listAgentSchedules"];
+        put?: never;
+        /** Create a schedule targeting this agent */
+        post: operations["createAgentSchedule"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{name}/schedule-constraints": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /** Set an agent's default budget guards for schedules (opt-in) */
+        patch: operations["setAgentScheduleConstraints"];
+        trace?: never;
+    };
     "/v1/agents/{name}/tasks": {
         parameters: {
             query?: never;
@@ -6929,7 +7108,7 @@ export interface paths {
         };
         /**
          * List tasks for an agent
-         * @description List all tasks for the specified agent, optionally filtered by status.
+         * @description List tasks for the agent. The Tasks tab splits them into triage buckets: `recent` (non-terminal + recently finished), `keep` (manually pinned), `archive` (manually archived + auto-archived old terminal tasks). Pass `bucket` to scope to one; omit it to get all. `q` searches title + description; `updated_after`/`updated_before` filter by time. The response always includes `counts` (per-bucket totals) for the tab badges.
          */
         get: operations["listAgentTasks"];
         put?: never;
@@ -7151,6 +7330,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/agents/{name}/tasks/{id}/triage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Move a task between Tasks-tab buckets
+         * @description Owner moves a task between the triage buckets. `kept` pins it to the Keep tab (never auto-archived); `archived` moves it to Archive; `null` restores it to the default (Recent / auto-archive by age). Owner-only.
+         */
+        patch: operations["triageAgentTask"];
+        trace?: never;
+    };
     "/v1/agents/{name}/tasks/{id}/todos/{todoId}": {
         parameters: {
             query?: never;
@@ -9485,6 +9684,11 @@ export interface components {
             /** @description Memory key (agent namespace) where the task's deliverable was published, if any. */
             deliverableKey?: string;
             rating?: components["schemas"]["AgentTaskRating"];
+            /**
+             * @description Tasks-tab triage bucket override (null = default Recent/auto-archive).
+             * @enum {string|null}
+             */
+            triage?: "kept" | "archived" | null;
         };
         /** @description Peer/owner review of a completed task's deliverable (Quality tab). Feeds the per-context quality rollup from GET /v1/agents/{name}/statistics. */
         AgentTaskRating: {
@@ -9677,6 +9881,85 @@ export interface components {
             validationMethod?: "automatic" | "api_call" | "owner_confirm";
             failureReason?: string;
         };
+        /** @description An opt-in budget/run guard on a schedule. type 'max_runs' or 'daily_limit' in v1. */
+        ScheduleConstraint: {
+            /** @example max_runs */
+            type: string;
+            enabled: boolean;
+            /**
+             * @example {
+             *       "limit": 7
+             *     }
+             */
+            params: Record<string, never>;
+            state?: Record<string, never>;
+        };
+        /** @description A recurring schedule owned by the server clock (reuses ScheduledJobRecord). */
+        Schedule: {
+            id?: string;
+            /** @enum {string} */
+            type?: "extension" | "core" | "ai" | "agent_task";
+            cron?: string;
+            enabled?: boolean;
+            /** @description IANA timezone */
+            timezone?: string;
+            displayName?: string;
+            description?: string;
+            purpose?: string;
+            /** @description Owner GHII */
+            ownerScope?: string;
+            agentName?: string;
+            agentGaii?: string;
+            createdByAgent?: boolean;
+            runCount?: number;
+            constraints?: components["schemas"]["ScheduleConstraint"][];
+            /** @description Kind-specific config (ai params, agent_task template, or extension input). */
+            input?: Record<string, never>;
+            /** Format: date-time */
+            lastRunAt?: string;
+            /** @enum {string} */
+            lastRunResult?: "success" | "error";
+            /** Format: date-time */
+            nextRunAt?: string;
+            /** Format: date-time */
+            createdAt?: string;
+            /** Format: date-time */
+            updatedAt?: string;
+        };
+        ScheduleCreate: {
+            /** @enum {string} */
+            kind: "ai" | "agent_task" | "extension";
+            /** @example 0 7 * * * */
+            cron: string;
+            display_name: string;
+            /** @example Europe/Helsinki */
+            timezone?: string;
+            description?: string;
+            purpose?: string;
+            /** @description Target agent (required for agent_task; optional association for ai/extension). */
+            agent_name?: string;
+            constraints?: components["schemas"]["ScheduleConstraint"][];
+            /** @description ai: instruction applied to the input memory values. */
+            prompt?: string;
+            /** @description ai: owner memory keys fed in as context. */
+            input_keys?: string[];
+            input_namespaces?: string[];
+            system_prompt?: string;
+            model?: string;
+            /** @description ai: memory key for the result (auto-generated if omitted). */
+            output_key?: string;
+            /** @enum {string} */
+            output_visibility?: "private" | "owner" | "public";
+            /** @description agent_task: the task materialised each fire. */
+            task_template?: {
+                title?: string;
+                description?: string;
+            };
+            extension_name?: string;
+            action_id?: string;
+            instance_id?: string;
+            input?: Record<string, never>;
+        };
     };
     responses: {
         /** @description Successful AIMEAT response */
@@ -10069,13 +10352,23 @@ export interface operations {
     refreshToken: {
         parameters: {
             query?: never;
-            header?: never;
+            header?: {
+                /** @description Required for cookie-mode refresh (CSRF guard). */
+                "X-AIMEAT-Refresh"?: "1";
+            };
             path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
             200: components["responses"]["AimeatSuccess"];
+            /** @description Cookie refresh missing the X-AIMEAT-Refresh header */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             401: components["responses"]["Unauthorized"];
         };
     };
@@ -10091,6 +10384,96 @@ export interface operations {
             200: components["responses"]["AimeatSuccess"];
         };
     };
+    listAccessTokens: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+        };
+    };
+    createAccessToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description User-facing name */
+                    label: string;
+                    /** @description Agent scopes (required unless grant_owner/grant_operator) */
+                    scopes?: string[];
+                    /** @description Act as the owner (full access) */
+                    grant_owner?: boolean;
+                    /** @description Owner + operator (operators only) */
+                    grant_operator?: boolean;
+                    /** @description Scoped tokens — read owner data instead of a sandbox */
+                    read_owner_data?: boolean;
+                    /** @description Optional lifetime in seconds (omit = no expiry) */
+                    expires_in?: number;
+                };
+            };
+        };
+        responses: {
+            /** @description Token created (raw token returned once) */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            /** @description Only an operator can create an operator-level token */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    revokeAccessToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    exchangeAccessToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description The access token (if not sent as a Bearer header) */
+                    token?: string;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            401: components["responses"]["Unauthorized"];
+        };
+    };
     generateConnectivityKey: {
         parameters: {
             query?: never;
@@ -20701,10 +21084,280 @@ export interface operations {
             };
         };
     };
-    listAgentTasks: {
+    listSchedules: {
         parameters: {
-            query?: {
-                status?: components["schemas"]["TaskStatus"];
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Aggregated schedules */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            managed?: components["schemas"]["Schedule"][];
+                            extensions?: components["schemas"]["Schedule"][];
+                            agentInternal?: {
+                                agentName?: string;
+                                gaii?: string;
+                                entries?: Record<string, never>[];
+                            }[];
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    createSchedule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ScheduleCreate"];
+            };
+        };
+        responses: {
+            /** @description Schedule created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            schedule?: components["schemas"]["Schedule"];
+                        };
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getSchedule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Schedule detail */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            schedule?: components["schemas"]["Schedule"];
+                            runs?: Record<string, never>[];
+                        };
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    deleteSchedule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Schedule deleted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    updateSchedule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description false = pause, true = resume */
+                    enabled?: boolean;
+                    cron?: string;
+                    timezone?: string;
+                    display_name?: string;
+                    purpose?: string;
+                    constraints?: components["schemas"]["ScheduleConstraint"][];
+                    input?: Record<string, never>;
+                };
+            };
+        };
+        responses: {
+            /** @description Schedule updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    triggerSchedule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Triggered */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listAgentSchedules: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Agent name (not full GAII) */
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Agent schedules */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            managed?: components["schemas"]["Schedule"][];
+                            agentInternal?: Record<string, never>[];
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    createAgentSchedule: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Agent name (not full GAII) */
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ScheduleCreate"];
+            };
+        };
+        responses: {
+            /** @description Schedule created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    setAgentScheduleConstraints: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    daily_spend_limit?: number | null;
+                    constraints?: components["schemas"]["ScheduleConstraint"][];
+                };
+            };
+        };
+        responses: {
+            /** @description Defaults updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listAgentTasks: {
+        parameters: {
+            query?: {
+                status?: components["schemas"]["TaskStatus"];
+                /** @description Triage bucket to return (omit for all). */
+                bucket?: "recent" | "keep" | "archive";
+                /** @description Case-insensitive substring search over title + description. */
+                q?: string;
+                updated_after?: string;
+                updated_before?: string;
                 page?: components["parameters"]["Pagination"];
                 per_page?: components["parameters"]["PerPage"];
             };
@@ -20717,7 +21370,7 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description List of tasks */
+            /** @description List of tasks (filtered) with per-bucket counts */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -20727,6 +21380,11 @@ export interface operations {
                         data?: {
                             tasks?: components["schemas"]["AgentTask"][];
                             total?: number;
+                            counts?: {
+                                recent?: number;
+                                keep?: number;
+                                archive?: number;
+                            };
                         };
                     };
                 };
@@ -21179,6 +21837,48 @@ export interface operations {
             };
         };
     };
+    triageAgentTask: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                name: string;
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @enum {string|null} */
+                    triage: "kept" | "archived" | null;
+                };
+            };
+        };
+        responses: {
+            /** @description Task triaged */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: components["schemas"]["AgentTask"];
+                    };
+                };
+            };
+            /** @description Invalid triage value. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     updateTaskTodo: {
         parameters: {
             query?: never;