aimeat 1.28.0 → 1.30.0

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

@@ -1585,6 +1585,66 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/memory/export": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Export memory (JSON backup)
+         * @description Download all of the caller's memory entries (full values) as a JSON backup. Owner sessions export across their GHII + agents + ecosystem apps; agent sessions export their own keyspace.
+         */
+        get: operations["exportMemory"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/memory/import": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Import memory (restore/merge a backup)
+         * @description Restore or merge a JSON backup produced by GET /v1/memory/export. Per-entry validation, quota, and schema checks mirror POST /v1/memory; one invalid entry does not abort the run.
+         */
+        post: operations["importMemory"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/memory/bulk-delete": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Bulk-delete memory entries
+         * @description Delete many entries at once by prefix and/or an explicit key list — avoids firing thousands of individual DELETE requests when clearing a whole namespace. Owner sessions delete across their owner-scope; agent sessions delete from their own keyspace.
+         */
+        post: operations["bulkDeleteMemory"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/librarian/search": {
         parameters: {
             query?: never;
@@ -2690,6 +2750,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/owner/usage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Owner usage & quota summary
+         * @description Quota usage (memory, files, micro-memory), resource counts (agents, organisms, apps, connected apps, extensions, cortexes, services) and morsel balance for the authenticated owner, in one call. Served from a 60-second in-memory cache so the profile dashboard can poll it cheaply without re-scanning the owner's keyspace on every visit.
+         */
+        get: operations["getOwnerUsage"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/wallet": {
         parameters: {
             query?: never;
@@ -5674,8 +5754,10 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * List access requests for a workspace you created
-         * @description The workspace creator (or an org admin) lists who has requested access and whether each is pending or approved.
+         * List access requests for a workspace you created (or all your workspaces)
+         * @description The workspace creator (or an org admin) lists who has requested access and whether each is
+         *     pending or approved. With `all=1` (and no `ws`), returns the access roster for ALL of the
+         *     caller's owned workspaces in one response (`{ workspaces: [{ ws, name, members, requests }] }`).
          */
         get: operations["listWorkspaceAccessRequests"];
         put?: never;
@@ -8038,6 +8120,75 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/organisms/{id}/comments/batch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Comment threads for many workspace objects in one request
+         * @description Returns the comment threads (or counts, with `countsOnly`) for MANY (ws, space, instance_id)
+         *     targets in one request — replacing the per-document GET /comments fan-out. Each workspace is
+         *     gated once with the same read authorization as the single GET; targets in a workspace the
+         *     caller cannot read are omitted. Response keyed by a NUL-joined composite of ws, space and instance_id.
+         */
+        post: operations["listOrganismCommentsBatch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/organisms/waiting": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Everything across your member organisms that needs your decision
+         * @description Aggregates, across the caller's member organisms in one request: pending publish reviews (per
+         *     workspace), pending join-requests (orgs the caller manages), and incoming invitations.
+         *     Replaces the home widget's per-organism approvals + join-requests + workspaces fan-out.
+         *     Response: `{ items: [ {kind:'review',n,orgId,orgName,wsId,wsName} | {kind:'join',n,orgId,orgName} | {kind:'invite',orgName,organismId} ] }`.
+         */
+        get: operations["getOrganismsWaiting"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/organisms/{id}/agents/activity": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Agent activity aggregated across all readable workspaces
+         * @description Aggregates each agent's activity (count, last-active time, workspaces touched) across EVERY
+         *     workspace the caller can read, in one request — replacing the organism Agents tab's
+         *     per-workspace activity fan-out. Same read authorization as GET /workspace/activity.
+         *     Response: `{ agents: { agentName: { count, lastAt, workspaces:[names] } } }`.
+         */
+        get: operations["getOrganismAgentsActivity"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/organisms/{id}/comments/{commentId}": {
         parameters: {
             query?: never;
@@ -10387,6 +10538,43 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/messages/agent-inbox": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List federated DMs addressed to the calling agent (recipient = the agent)
+         * @description Messages sent to an agent/eco identity are delivered to its owner's mailbox, so the agent cannot see them via the owner-only inbox. This returns messages where recipientGhii is the calling agent. Requires an external principal (agent/eco/app) with the messages:read scope.
+         */
+        get: operations["listAgentDmInbox"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/messages/agent-thread/{conversationId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Full DM thread as the calling agent sees it (sent + received) */
+        get: operations["getAgentDmThread"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/messages/inbox": {
         parameters: {
             query?: never;
@@ -11413,6 +11601,8 @@ export interface components {
         MemoryEntry: {
             key?: string;
             value?: unknown;
+            /** @description Serialized size of the value in bytes — returned in place of `value` when listed with `include=meta`. */
+            bytes?: number;
             visibility?: components["schemas"]["Visibility"];
             /** @description Sharing group ID (present when visibility is 'group') */
             group_id?: string;
@@ -13127,6 +13317,8 @@ export interface components {
             /** @description Whose mailbox copy this row is. */
             ownerGhii?: string;
             conversationId?: string;
+            /** @description Topic thread title (present only on subject threads). */
+            subject?: string;
             senderGhii?: string;
             recipientGhii?: string;
             /** @description GFM markdown; inline media via cid:{attachmentId}. */
@@ -13163,14 +13355,18 @@ export interface components {
             /** Format: date-time */
             createdAt?: string;
         };
-        /** @description Request body for sending a direct message. */
+        /** @description Request body for sending a direct message. The recipient may be a human GHII (owner@node), an agent GAII (agent#owner@node) or an app GEAI (eco:app#owner@node); messages to an agent/app are delivered to that identity's owner inbox. */
         DirectMessageSend: {
-            /** @description Recipient human GHII (owner@node). */
+            /** @description Recipient GHII/GAII/GEAI (owner@node */
             to: string;
             /** @description GFM markdown. May be empty if attachment-only. */
             body?: string;
             /** Format: uuid */
             reply_to?: string;
+            /** @description Continue a specific thread by id. Omit for the default per-pair thread. */
+            conversation_id?: string;
+            /** @description Open a NEW topic thread with this title (a fresh conversation id is minted). */
+            subject?: string;
             attachments?: {
                 storage_key: string;
                 mime: string;
@@ -13185,6 +13381,8 @@ export interface components {
         ConversationSummary: {
             conversationId?: string;
             peerGhii?: string;
+            /** @description Topic thread title (present only for subject threads). */
+            subject?: string;
             lastMessage?: string;
             /** @enum {string} */
             lastDirection?: "inbound" | "outbound";
@@ -16426,6 +16624,8 @@ export interface operations {
                 owner_scope?: "true" | "false";
                 /** @description Exclude entries with flagCount exceeding this value */
                 max_flags?: number;
+                /** @description When "meta", omit each entry's `value` and report its size in `bytes` instead — fast for listing thousands of keys (values fetched per-key on demand). */
+                include?: "meta";
             };
             header?: never;
             path?: never;
@@ -16588,6 +16788,8 @@ export interface operations {
                 visibility?: "private" | "owner" | "group" | "public";
                 /** @description Exclude entries with flagCount exceeding this value (Phase 1.5 data quality filter) */
                 max_flags?: number;
+                /** @description Scope the search to keys beginning with this prefix (e.g. a namespace/group like "organism.{id}.") */
+                prefix?: string;
                 page?: components["parameters"]["Pagination"];
                 per_page?: components["parameters"]["PerPage"];
             };
@@ -16600,6 +16802,120 @@ export interface operations {
             200: components["responses"]["AimeatSuccess"];
         };
     };
+    exportMemory: {
+        parameters: {
+            query?: {
+                /** @description GAII of a specific agent to export (owner sessions only) */
+                agent?: string;
+                /** @description Restrict the export to keys beginning with this prefix */
+                prefix?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description JSON backup: { exported_at, node_id, count, entries[] } */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    importMemory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    entries: {
+                        key: string;
+                        value: unknown;
+                        /** @enum {string} */
+                        visibility?: "private" | "owner" | "group" | "public";
+                        tags?: string[];
+                        ttl_hours?: number;
+                    }[];
+                    /**
+                     * @description How to resolve a key that already exists
+                     * @default skip
+                     * @enum {string}
+                     */
+                    mode?: "skip" | "overwrite" | "rename";
+                    /** @description Import under a specific agent GAII (owner sessions only) */
+                    agent?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Import summary: { created, updated, skipped, failed[] } */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description entries array missing */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    bulkDeleteMemory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Delete all keys beginning with this prefix */
+                    prefix?: string;
+                    /** @description Delete these specific keys (intersected with prefix if both given) */
+                    keys?: string[];
+                    /** @description Delete under a specific agent GAII (owner sessions only) */
+                    agent?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Result: { deleted } */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description prefix or keys required */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
     librarianSearch: {
         parameters: {
             query: {
@@ -18182,6 +18498,59 @@ export interface operations {
             };
         };
     };
+    getOwnerUsage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Usage summary (cached up to ttl_seconds) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            owner?: string;
+                            memory?: {
+                                used_keys?: number;
+                                max_keys?: number;
+                                used_bytes?: number;
+                                max_bytes?: number;
+                                percent?: number;
+                            };
+                            storage?: {
+                                used_files?: number;
+                                used_bytes?: number;
+                                max_bytes?: number;
+                                percent?: number;
+                            };
+                            micro_memory?: {
+                                used_sets?: number;
+                                max_sets?: number;
+                                used_bytes?: number;
+                                max_bytes?: number;
+                                percent?: number;
+                            };
+                            /** @description Resource counts; apps/extensions/services carry their per-account max. */
+                            counts?: Record<string, never>;
+                            morsels?: {
+                                balance?: number;
+                            };
+                            /** Format: date-time */
+                            cached_at?: string;
+                            ttl_seconds?: number;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
     getWallet: {
         parameters: {
             query?: never;
@@ -22640,6 +23009,8 @@ export interface operations {
                 member?: string;
                 /** @description Filter by interest tag */
                 interest?: string;
+                /** @description `counts` attaches `workspace_count` per organism (avoids a per-org workspace discovery fan-out). */
+                include?: "counts";
                 /** @description Filter by city */
                 city?: string;
                 /** @description Filter by country code */
@@ -23293,7 +23664,15 @@ export interface operations {
     };
     discoverOrganismWorkspaces: {
         parameters: {
-            query?: never;
+            query?: {
+                /**
+                 * @description `enrichment` folds the per-workspace getWorkspace+activity+participants fan-out into this one
+                 *     response: each readable workspace gains `enrichment: { hasManifest, recs, docs,
+                 *     lastEvent:{type,instance,action,at}|null, participants:[{owner,node,isLocalNode,isCreator,isSelf,agentsCount}],
+                 *     pendingReviews }`. Workspaces with `access:none` carry no enrichment.
+                 */
+                include?: "enrichment";
+            };
             header?: never;
             path: {
                 /** @description Organism ID */
@@ -23303,7 +23682,7 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Workspaces with the caller's per-workspace access status */
+            /** @description Workspaces with the caller's per-workspace access status (+ enrichment when requested) */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -23316,9 +23695,11 @@ export interface operations {
     };
     listWorkspaceAccessRequests: {
         parameters: {
-            query: {
-                /** @description Workspace id you created */
-                ws: string;
+            query?: {
+                /** @description Workspace id you created (required unless all=1) */
+                ws?: string;
+                /** @description All owned workspaces' rosters in one response */
+                all?: "1" | "true";
             };
             header?: never;
             path: {
@@ -23329,7 +23710,7 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description The workspace's access requests */
+            /** @description The workspace's access requests (or all owned workspaces' rosters) */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -26941,6 +27322,63 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    listOrganismCommentsBatch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    instances: {
+                        ws: string;
+                        space: string;
+                        instance_id: string;
+                    }[];
+                    /** @description Return only totals per target (no comment bodies) */
+                    countsOnly?: boolean;
+                };
+            };
+        };
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getOrganismsWaiting: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            403: components["responses"]["Forbidden"];
+        };
+    };
+    getOrganismAgentsActivity: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["AimeatSuccess"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     deleteOrganismComment: {
         parameters: {
             query: {
@@ -29296,14 +29734,17 @@ export interface operations {
     };
     listWorkflows: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description `health` attaches each workflow's run-health inline (avoids a per-workflow GET /:id/health fan-out). */
+                include?: "health";
+            };
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description The owner's workflow definitions */
+            /** @description The owner's workflow definitions (+ inline health when requested) */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -30720,6 +31161,80 @@ export interface operations {
             };
         };
     };
+    listAgentDmInbox: {
+        parameters: {
+            query?: {
+                page?: number;
+                per_page?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description DMs addressed to the agent */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            messages?: components["schemas"]["DirectMessageRecord"][];
+                            total?: number;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Missing messages:read scope */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getAgentDmThread: {
+        parameters: {
+            query?: {
+                page?: number;
+                per_page?: number;
+            };
+            header?: never;
+            path: {
+                conversationId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Thread page */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            messages?: components["schemas"]["DirectMessageRecord"][];
+                            total?: number;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Missing messages:read scope */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     listInbox: {
         parameters: {
             query?: {