aimeat 2.5.0 → 2.6.0

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

@@ -2184,6 +2184,30 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/ai/transcribe": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Transcribe audio with the owner's own speech-to-text model
+         * @description Speech-to-text on the owner's own provider key, behind the same gate as /v1/ai/complete (an owner session, or any token carrying `ai:use`). Spends the SAME daily AI budget as text completions and lands in the same usage ledger, so a budget eaten by voice messages is visible in the same place as everything else.
+         *
+         *     Audio comes from `storage_key` — resolved against the CALLER's own namespace, never an owner supplied in the body, so the endpoint cannot be pointed at another account's files (a key belonging to someone else answers 404, not 403: whether it exists is not information this route gives away). `audio_base64` is a bounded fallback for a browser recording that has not been stored yet; anything of real size goes through storage.
+         *
+         *     Requires `sttModel` in the owner's settings. There is deliberately no fallback to the default model — it is a text model, and handing it audio produces an opaque provider error instead of an instruction the owner can act on.
+         */
+        post: operations["aiTranscribe"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/ai/available": {
         parameters: {
             query?: never;
@@ -13153,7 +13177,9 @@ export interface paths {
         };
         /**
          * List available OpenRouter models
-         * @description Fetches the list of available models from OpenRouter using the configured API key. Owner-only.
+         * @description Fetches available models from the configured provider using the stored API key. Owner-only.
+         *
+         *     `modality` selects which catalogue. This is not a client-side filter behind a parameter: OpenRouter's default `/models` listing contains NO transcription or speech models (measured 2026-08-01 — 336 models, zero whisper), so `chat` and `transcription` are genuinely different listings and an STT model cannot be discovered without asking for its modality. Non-OpenRouter OpenAI-compatible providers ignore the parameter and return their whole catalogue.
          */
         get: operations["listOpenRouterModels"];
         put?: never;
@@ -14342,6 +14368,30 @@ export interface paths {
         patch: operations["markMessageRead"];
         trace?: never;
     };
+    "/v1/messages/{id}/attachments/{attId}/transcribe": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Turn a voice attachment into text
+         * @description Transcribes one audio attachment with the caller's own speech-to-text model and writes the result onto the CALLER's copy of the message. Mailbox copies are per-owner, so a recipient's transcript stays with the recipient and never travels back to the sender.
+         *
+         *     Idempotent by default: an attachment that already has a transcript returns it without calling the provider, because a second click on a button is not a request to be charged twice. Pass `force` to re-run (a different model, or a bad first result).
+         *
+         *     Never automatic anywhere in the product — transcription spends the owner's AI budget, so it is always an explicit action.
+         */
+        post: operations["transcribeMessageAttachment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/messages/{id}": {
         parameters: {
             query?: never;
@@ -14878,6 +14928,187 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/connections/providers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * External services an account can be connected at
+         * @description Enabled outbound providers only. A provider is enabled when the node has what it needs to talk to it; an unconfigured one is absent rather than half-working. capabilities are the questions an app may ask about a connection at that provider - an app never reads the provider's own scope vocabulary, because it cannot know what those names mean.
+         */
+        get: operations["listConnectionProviders"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Accounts the caller has connected
+         * @description The caller's own connections and no one else's. The credential is never part of any response; what comes back is enough to name the account in a picker and to see that it needs attention.
+         */
+        get: operations["listConnections"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connections/start": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Begin connecting an account
+         * @description Returns the URL to send the user's browser to. Consent happens at the PROVIDER, never here. The state is single-use and bound to the calling principal; the PKCE verifier stays on the node and never travels.
+         */
+        post: operations["startConnection"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connections/attach": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Connect an account by supplying a credential
+         * @description For a provider that has no authorization round. The fields to send are declared by the provider itself (attachFields in discovery), so a client renders the form without knowing about any particular provider. The two paths never overlap: attaching a provider that HAS a consent screen is refused, because it would be a way to skip that screen. The supplied secret is never echoed back, in a response or in an error.
+         */
+        post: operations["attachConnection"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connections/callback": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Provider redirect target
+         * @description Unauthenticated by necessity - the provider redirects a browser here and that browser may carry no session. Its gate is the single-use state, which is bound to the principal who started the round and consumed BEFORE the code is exchanged, so a replayed callback finds nothing rather than racing the original.
+         */
+        get: operations["connectionCallback"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connections/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Disconnect an account
+         * @description Tells the provider first where it offers a way to be told, then removes the credential locally regardless. An owner who asked to disconnect must end up disconnected even when the provider is unreachable; told_provider reports which happened.
+         */
+        delete: operations["revokeConnection"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connections/{id}/delegations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** What has been delegated over a channel */
+        get: operations["listConnectionDelegations"];
+        put?: never;
+        /**
+         * Let an app perform one named action over a shared channel
+         * @description Grants an app ONE action with the parameters it may not choose already decided. The app calls the delegation, never the connection, so it cannot retarget the channel, the visibility or the playlist. Shared-mode connections only.
+         */
+        post: operations["createConnectionDelegation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connections/delegations/{did}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Stop or resume a delegation
+         * @description The one-gesture stop. Disabling halts every publisher at once; at the moment of abuse there is no time to work through them one at a time.
+         */
+        patch: operations["setConnectionDelegationEnabled"];
+        trace?: never;
+    };
+    "/v1/connections/delegations/{did}/quota": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * How much of a shared allowance is left
+         * @description Readable BEFORE anything is refused. A ceiling a person only meets by hitting it is indistinguishable from a broken feature. limit is null when the provider's shared ceiling has not been measured - the counter still runs, so the number can later be filled in with evidence rather than a guess.
+         */
+        get: operations["getConnectionDelegationQuota"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/groups": {
         parameters: {
             query?: never;
@@ -18516,6 +18747,51 @@ export interface components {
                 record: components["schemas"]["AiProvenanceRecord"];
             };
         };
+        /**
+         * @description What a caller SAYS about how the content in this request was made — the input block, not the stored record. It is the same shape the MCP write tools take as `ai_provenance`, so a statement means one thing whichever surface it arrives on.
+         *
+         *     What is deliberately absent is identity. There is no principal, no node and no attestation here: the node fills in who you are, which node, when, and the hash of the exact bytes, and it never takes any of those from the caller. A declaration is believed about the HOW and never about the WHO.
+         *
+         *     Omitting the block is not an error. For an AGENT or ECOSYSTEM principal the node then stamps a record itself (`stampedBy: node`) — silence from a non-human writer must not read as "a human wrote it" — while an OWNER principal is never stamped.
+         */
+        AiProvenanceDeclaration: {
+            /**
+             * @description How much of this a model made. `original` = a person wrote it, no model involved. `assisted` = a person wrote it and a model edited or refined it. `synthesized` = a model combined real sources into new content at someone's direction. `ai-generated` = a model produced it.
+             * @enum {string}
+             */
+            level: "original" | "assisted" | "synthesized" | "ai-generated";
+            /**
+             * @description Optional detail under `level`.
+             * @enum {string}
+             */
+            method?: "human" | "rewritten" | "summarized" | "translated" | "synthesized" | "fully-generated" | "multi-agent";
+            /**
+             * @description Whether a person examined what the model produced. Only a step where someone reads the SUBSTANCE and can reject it counts — a skim, a spell-check or clicking publish is `light-review` at most. Omitted means `none`.
+             * @enum {string}
+             */
+            human_involvement?: "none" | "light-review" | "editorial-control" | "full-human";
+            /**
+             * @description The model that produced it, as the provider names it.
+             * @example anthropic/claude-opus-5
+             */
+            model?: string;
+            /**
+             * @description Who SERVED the model, when that is not obvious from its name. Worth stating whenever the declarer routes through an intermediary: "which model" and "who ran it" are different questions, and a router alias answers neither on its own.
+             * @example openrouter
+             */
+            provider?: string;
+            /** @description For synthesized content, where the material came from. */
+            sources?: {
+                url: string;
+                title?: string;
+                /** Format: date-time */
+                retrieved_at?: string;
+                /** @description How it was used, e.g. 'primary' or 'background'. */
+                role?: string;
+            }[];
+            /** @description Anything a reader needs to interpret the above. Never prompt text or anything private — the record is publishable alongside the content. */
+            notes?: string;
+        };
         /**
          * @description The provenance of ONE ITEM in a list, carried on the item itself.
          *
@@ -20328,6 +20604,20 @@ export interface components {
                 alert_threshold?: number;
             };
         };
+        /** @description Everything an app may see about a connection. Deliberately without the provider's scope list and without an expiry: an app cannot know what a provider's scope names mean, so capability questions are asked and answered instead. The credential appears in no projection anywhere. */
+        PublicConnection: {
+            id?: string;
+            provider?: string;
+            /** @enum {string} */
+            mode?: "personal" | "shared";
+            /** @description Fetched from the provider at connect time, never supplied by a caller. */
+            accountLabel?: string;
+            /**
+             * @description needs_reauth is a user-visible state rather than an error; scheduled work parks on it instead of retrying.
+             * @enum {string}
+             */
+            status?: "active" | "needs_reauth" | "revoked";
+        };
         SharingGroup: {
             /** Format: uuid */
             id: string;
@@ -20453,6 +20743,22 @@ export interface components {
             name?: string;
             /** @enum {string} */
             kind?: "image" | "audio" | "video" | "file";
+            /** @description Playing length of audio/video, measured when it was recorded. Lets a thread show "0:14" before any bytes are fetched. */
+            durationSeconds?: number;
+            /** @description Text of a spoken attachment. `by: sender` arrived WITH the message and is identical in both mailbox copies (so the recipient reads it without paying). `by: recipient` was produced locally with the reader's own key and exists ONLY in their copy — updateMessageAttachments is owner-keyed, so there is no path back to the sender. */
+            transcript?: {
+                text?: string;
+                /**
+                 * @description Server-set on send; a client claim of `recipient` is overwritten with `sender`.
+                 * @enum {string}
+                 */
+                by?: "sender" | "recipient";
+                model?: string;
+                lang?: string;
+                seconds?: number;
+                /** Format: date-time */
+                at?: string;
+            };
         };
         /** @description One mailbox copy of a human↔human direct message. */
         DirectMessageRecord: {
@@ -25053,6 +25359,110 @@ export interface operations {
             403: components["responses"]["AimeatError"];
         };
     };
+    aiTranscribe: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Key of an audio file in the CALLER's own storage. Preferred. */
+                    storage_key?: string;
+                    /** @description Raw base64 audio (no data: prefix). Capped well below the JSON body limit. */
+                    audio_base64?: string;
+                    /** @description Content type of the audio (e.g. audio/webm). Defaults to the stored file's. */
+                    mime?: string;
+                    filename?: string;
+                    /** @description Override the owner's configured sttModel for this call. */
+                    model?: string;
+                    /** @description ISO-639-1 hint. Omitted = the owner's sttLanguage, then auto-detect. */
+                    language?: string;
+                    /** @description Ask for segment timestamps (verbose_json). */
+                    verbose?: boolean;
+                    /** @description Attribution for the per-app quota and the spend breakdown. */
+                    app_id?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Transcription */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            text?: string;
+                            model?: string;
+                            language?: string | null;
+                            /** @description Audio duration as the provider measured it; 0 if unreported. */
+                            seconds?: number;
+                            usage?: {
+                                total_tokens?: number;
+                                /** @description The provider's reported charge. 0 with cost_exact false when the provider reports none — no estimate is derived from duration, because audio pricing units differ between providers. */
+                                cost_usd?: number;
+                                cost_exact?: boolean;
+                            };
+                            budget?: {
+                                daily_budget_usd?: number;
+                                spent_today_usd?: number;
+                                remaining_usd?: number;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Bad request (no audio, oversized audio, or NO_STT_MODEL / NO_API_KEY) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description Daily AI budget or per-app quota exhausted */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description Missing ai:use scope, app not allowlisted, or provider host not allowlisted */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description No such file in the caller's storage */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description Provider error */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+        };
+    };
     aiAvailable: {
         parameters: {
             query?: never;
@@ -31646,6 +32056,10 @@ export interface operations {
                     cortex?: {
                         agents?: components["schemas"]["CrewDef"][];
                     };
+                    /** @description How the app bundle in this request was made. Honoured in BOTH modes: sent with `mode: presigned` it rides in the signed upload token, so the declaration made at the handshake is the one recorded when the bytes arrive. A malformed block is a 400 rather than a silently dropped field. */
+                    ai_provenance?: components["schemas"]["AiProvenanceDeclaration"];
+                    /** @description Attach an ALREADY-MINTED record instead of declaring a new one. Must belong to the caller's own account. Also carried through the presigned token. */
+                    ai_provenance_id?: string;
                 };
             };
         };
@@ -32569,7 +32983,17 @@ export interface operations {
             };
             cookie?: never;
         };
-        requestBody?: never;
+        /** @description Optional. The declaration belongs to the PROMOTION rather than to the draft save: this is the call that puts the bytes in front of readers, and so the moment the publisher answers for how they were made. */
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description How the promoted bundle was made. A malformed block is a 400. */
+                    ai_provenance?: components["schemas"]["AiProvenanceDeclaration"];
+                    /** @description Attach an already-minted record of the caller's own instead. */
+                    ai_provenance_id?: string;
+                };
+            };
+        };
         responses: {
             /** @description Draft published as a new live version */
             201: {
@@ -42802,6 +43226,14 @@ export interface operations {
                             hasApiKey?: boolean;
                             /** @description Currently configured default model */
                             model?: string | null;
+                            reasoningModel?: string | null;
+                            executionModel?: string | null;
+                            /** @description Vision-capable model for image inputs */
+                            visionModel?: string | null;
+                            /** @description Transcription model; null = transcription is off */
+                            sttModel?: string | null;
+                            /** @description ISO-639-1 transcription hint; null = auto-detect */
+                            sttLanguage?: string | null;
                             /** @description Whether auto-retry is enabled */
                             autoRetry?: boolean;
                             /** @description Maximum retry count */
@@ -42817,6 +43249,18 @@ export interface operations {
                              * @description Custom API base URL
                              */
                             baseUrl?: string;
+                            temperature?: number | null;
+                            top_p?: number | null;
+                            max_tokens?: number | null;
+                            /** @description Node-level ceilings served alongside the settings that live under them, so a browser recorder stops at THIS node's number instead of one compiled into the page. */
+                            limits?: {
+                                /** @description Hard cap on one browser voice recording */
+                                voice_msg_max_seconds?: number;
+                                /** @description Largest audio file accepted for transcription */
+                                stt_max_mb?: number;
+                                /** @description Duration guideline (warned about after the fact, never withheld) */
+                                stt_max_seconds?: number;
+                            };
                         };
                     };
                 };
@@ -42849,6 +43293,20 @@ export interface operations {
                     model?: string;
                     /** @description Vision-capable model (e.g. qwen-2.5-VL) used for requests carrying image inputs (the Secretary's doc/image intake). null/'' clears it. When unset, image requests fall back to the default model (which may be text-only). */
                     visionModel?: string | null;
+                    /** @description Transcription model (e.g. openai/whisper-large-v3) used by POST /v1/ai/transcribe and voice messages. null/'' turns transcription OFF — there is deliberately no fallback to the default model, which is a text model and would only produce an opaque provider error. Discover candidates via GET /v1/openrouter/models?modality=transcription. */
+                    sttModel?: string | null;
+                    /** @description ISO-639-1 hint for transcription (e.g. "fi"). null/'' = auto-detect, which is the right choice for mixed-language speech. */
+                    sttLanguage?: string | null;
+                    /** @description Model used when a caller asks for the `reasoning` role. */
+                    reasoningModel?: string | null;
+                    /** @description Model used when a caller asks for the `execution` role. */
+                    executionModel?: string | null;
+                    /** @description Default sampling temperature (0-2). null clears it. */
+                    temperature?: number | null;
+                    /** @description Default nucleus sampling (0-1). null clears it. */
+                    top_p?: number | null;
+                    /** @description Default output ceiling. null clears it. */
+                    max_tokens?: number | null;
                     /** @description Whether to automatically retry failed completions */
                     autoRetry?: boolean;
                     /** @description Maximum number of retry attempts */
@@ -42919,7 +43377,10 @@ export interface operations {
     };
     listOpenRouterModels: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description Which slice of the provider's catalogue to list. */
+                modality?: "chat" | "transcription" | "speech";
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -42943,13 +43404,23 @@ export interface operations {
                                 description?: string;
                                 /** @description Maximum context window in tokens */
                                 context_length?: number;
+                                /** @description What the model ACCEPTS (text, image, audio, file), straight from the provider. A picker filters on this rather than guessing from the name — 180 of 336 catalogue models read images and no naming convention identifies them. */
+                                input_modalities?: string[];
+                                /** @description What the model PRODUCES (text, transcription, speech, image). */
+                                output_modalities?: string[];
+                                /** @description Provider-reported pricing. For CHAT models `prompt`/`completion` are consistently per token. For AUDIO models the unit is NOT self-describing and varies by upstream provider — the same openai/whisper-large-v3 reports 0.0015 on Together and 0.111 on Groq (per minute vs per hour) — so a derived "$/min" label would be wrong for whole providers. The trustworthy price for a transcription is `usage.cost_usd` on the actual response. */
                                 pricing?: {
-                                    /** @description Cost per prompt token */
+                                    /** @description Cost per prompt token (chat) / provider-native unit (audio) */
                                     prompt?: string;
                                     /** @description Cost per completion token */
                                     completion?: string;
                                 };
                             }[];
+                            /**
+                             * @description Which catalogue these models came from (echoes the request).
+                             * @enum {string}
+                             */
+                            modality?: "chat" | "transcription" | "speech";
                         };
                     };
                 };
@@ -45488,6 +45959,94 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    transcribeMessageAttachment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                attId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Re-transcribe even when a transcript already exists (costs again). */
+                    force?: boolean;
+                    /** @description Override the configured sttModel. */
+                    model?: string;
+                    /** @description ISO-639-1 hint. */
+                    language?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Transcript (fresh or reused) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            attachment_id?: string;
+                            /** @description Same shape as DirectMessageAttachment.transcript. */
+                            transcript?: Record<string, never>;
+                            /** @description true = returned from storage, no provider call, no charge. */
+                            reused?: boolean;
+                            usage?: {
+                                cost_usd?: number;
+                                cost_exact?: boolean;
+                                seconds?: number;
+                            };
+                            budget?: {
+                                daily_budget_usd?: number;
+                                spent_today_usd?: number;
+                                remaining_usd?: number;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Not an audio attachment, or no transcription model configured */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description Daily AI budget exhausted */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description Message or attachment not found in the caller's mailbox */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            /** @description ATTACHMENT_NOT_READY — the bytes have not been duplicated locally yet (or the attachment expired before they could be). */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+        };
+    };
     deleteDirectMessage: {
         parameters: {
             query?: never;
@@ -46670,6 +47229,412 @@ export interface operations {
             401: components["responses"]["Unauthorized"];
         };
     };
+    listConnectionProviders: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Enabled providers */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            providers?: {
+                                /** @example mastodon */
+                                id?: string;
+                                label?: string;
+                                /** @description True when client credentials are per instance and acquired at runtime. */
+                                instanceScoped?: boolean;
+                                /** @enum {string} */
+                                credentialShape?: "oauth2" | "static" | "session";
+                                capabilities?: string[];
+                            }[];
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    listConnections: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The caller's connections */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            connections?: components["schemas"]["PublicConnection"][];
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description Connections are not enabled on this node, or it has no encryption key. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    startConnection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @example mastodon */
+                    provider: string;
+                    /**
+                     * @description Required for an instance-scoped provider. Comes from the user, so it is normalised and validated, and every request to it goes through safeFetch.
+                     * @example mastodon.social
+                     */
+                    instance?: string;
+                    /**
+                     * @description personal is the caller's own account. shared is a channel the caller owns and intends to delegate to an app's users.
+                     * @default personal
+                     * @enum {string}
+                     */
+                    mode?: "personal" | "shared";
+                    /** @description Same-origin path to return to. An absolute URL is ignored. */
+                    return_url?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Authorization started */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            authorize_url?: string;
+                            state?: string;
+                        };
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /** @description No such provider. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    attachConnection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @example bluesky */
+                    provider: string;
+                    /**
+                     * @default personal
+                     * @enum {string}
+                     */
+                    mode?: "personal" | "shared";
+                    /** @description Keyed by the names the provider declared in attachFields. */
+                    fields: {
+                        [key: string]: string;
+                    };
+                };
+            };
+        };
+        responses: {
+            /** @description An account already connected was repaired with a new credential. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Connected */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            connection?: components["schemas"]["PublicConnection"];
+                            created?: boolean;
+                        };
+                    };
+                };
+            };
+            /** @description The credential was refused, a declared field was missing, or the provider uses an authorization round instead (NEEDS_AUTHORIZATION). */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description No such provider. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    connectionCallback: {
+        parameters: {
+            query?: {
+                state?: string;
+                code?: string;
+                /** @description Present when the user cancelled or the provider refused. */
+                error?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Connected; redirected back to where the flow started. */
+            302: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The authorization could not be completed, with the reason. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    revokeConnection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Revoked */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            revoked?: boolean;
+                            /** @description Whether the provider was reachable to be told. */
+                            told_provider?: boolean;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description No such connection. Identical for a connection that does not exist and one belonging to someone else - the difference between those answers would enumerate other people's accounts. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listConnectionDelegations: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Delegations over this connection */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description No such connection. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    createConnectionDelegation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    app_id: string;
+                    /** @example publish-video */
+                    action: string;
+                    /** @description Parameters the app may not override. Merged OVER whatever it sends. */
+                    fixed?: {
+                        [key: string]: unknown;
+                    };
+                    /** @description Ceiling per PUBLISHER, which is only possible because a shared publish is never anonymous. Without it one publisher drains an allowance everyone shares. */
+                    per_user_limit?: {
+                        count?: number;
+                        /** @default 24 */
+                        window_hours?: number;
+                    } | null;
+                    /**
+                     * @default hold
+                     * @enum {string}
+                     */
+                    moderation?: "hold" | "auto";
+                    /** @default true */
+                    enabled?: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Delegation created or replaced */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /** @description No such connection. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    setConnectionDelegationEnabled: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                did: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    enabled: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /** @description No such delegation. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getConnectionDelegationQuota: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                did: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Allowance */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            quota?: {
+                                limit?: number | null;
+                                usedInWindow?: number;
+                                remaining?: number | null;
+                                windowHours?: number;
+                            };
+                            per_user_limit?: Record<string, never> | null;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description No such delegation. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     listSharingGroups: {
         parameters: {
             query?: never;