@1claw/sdk 0.59.0 → 0.59.5

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

@@ -2360,6 +2360,46 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/org/onboarding/status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Onboarding funnel status
+         * @description Returns welcome-bundle and MCP connection progress for the connect wizard.
+         */
+        get: operations["getOnboardingStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/onboarding/provision": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Provision MCP onboarding bundle
+         * @description Creates welcome vault + sample secret, MCP agent, and default ** policy. Returns one-time API key and stdio MCP config.
+         */
+        post: operations["provisionOnboarding"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/org/status": {
         parameters: {
             query?: never;
@@ -3620,6 +3660,29 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/shroud/inspect-content": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Inspect text for security threats
+         * @description Standalone content inspection (MCP `inspect_content` parity). Scans for command
+         *     injection, encoding tricks, social engineering, PII, and suspicious URLs.
+         *     Fail-closed — returns `safe: false` when high/critical threats match.
+         *     Accepts plt_ platform keys, agent JWTs, and user JWTs.
+         */
+        post: operations["inspectContent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/shroud/activity": {
         parameters: {
             query?: never;
@@ -4053,6 +4116,28 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/platform/apps/{appId}/webhooks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Platform webhook delivery catalog
+         * @description Returns whether `webhook_url` is configured and the event types delivered to
+         *     the platform app webhook (payload includes `connection_id` when applicable).
+         *     Org-scoped webhook subscriptions (`GET /v1/webhooks`) are separate.
+         */
+        get: operations["getPlatformWebhooks"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/platform/apps/{appId}/rotate-webhook-secret": {
         parameters: {
             query?: never;
@@ -5192,7 +5277,15 @@ export interface paths {
          */
         get: operations["listConnectionPendingApprovals"];
         put?: never;
-        post?: never;
+        /**
+         * Create a pending consensus approval for a connection agent
+         * @description Platform apps submit over-cap or consensus-gated actions on behalf of a
+         *     connected user's agent. When `policy_id` is omitted, the server resolves the
+         *     matching agent `consensus_trigger` policy from `action_payload` (chain, to, value).
+         *     Returns **202** with `pending_approval_id` and `payload_hash` for decide/execute.
+         *     Requires plt_ auth; agent must be provisioned on the connection.
+         */
+        post: operations["createConnectionPendingApproval"];
         delete?: never;
         options?: never;
         head?: never;
@@ -5261,6 +5354,28 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/platform/connections/{connectionId}/signing-keys": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List signing keys for a connection agent
+         * @description Returns public signing-key metadata (chain, address, public_key, curve) for
+         *     agent(s) provisioned on the connection. Never includes private keys.
+         *     When multiple agents exist, pass `agent_id` query param. plt_ auth only.
+         */
+        get: operations["listConnectionSigningKeys"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/platform/connections/{connectionId}/signing-keys/{chain}": {
         parameters: {
             query?: never;
@@ -5268,7 +5383,13 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /**
+         * Get a signing key for a connection agent by chain
+         * @description Returns public signing-key metadata for one chain on a connection agent.
+         *     Network names (e.g. `base`, `sepolia`) resolve to canonical signing keys
+         *     (e.g. `ethereum`). Never includes private keys. plt_ auth only.
+         */
+        get: operations["getConnectionSigningKey"];
         put?: never;
         post?: never;
         /**
@@ -5282,6 +5403,123 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/platform/connections/{connectionId}/agents/{agentId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Update limited agent settings for a connection
+         * @description Platform-scoped agent update for connected end-users. Allows enabling Intents API,
+         *     Execution Intents, and updating the default system prompt without human dashboard access.
+         *     Agent must be provisioned on the connection. plt_ auth only.
+         */
+        patch: operations["patchConnectionAgent"];
+        trace?: never;
+    };
+    "/v1/platform/connections/{connectionId}/portfolio": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Portfolio for connection agents
+         * @description Aggregates signing-key and smart-account balances for agents provisioned on
+         *     the connection. plt_ auth only.
+         */
+        get: operations["getConnectionPortfolio"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/platform/connections/{connectionId}/balances": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Balances alias for connection portfolio
+         * @description Alias of `GET .../portfolio`. plt_ auth only.
+         */
+        get: operations["getConnectionBalances"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/platform/connections/{connectionId}/automations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List automations for connection agents */
+        get: operations["listConnectionAutomations"];
+        put?: never;
+        /** Create automation for a connection agent */
+        post: operations["createConnectionAutomation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/platform/connections/{connectionId}/automations/{automationId}/runs/{runId}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cancel an automation run (connection-scoped) */
+        post: operations["cancelConnectionAutomationRun"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/platform/connections/{connectionId}/memory/{namespace}/{key}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get agent memory entry (connection-scoped) */
+        get: operations["getConnectionMemory"];
+        /** Upsert agent memory entry (connection-scoped) */
+        put: operations["putConnectionMemory"];
+        post?: never;
+        /** Delete agent memory entry (connection-scoped) */
+        delete: operations["deleteConnectionMemory"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/platform/connections/{connectionId}/runtimes": {
         parameters: {
             query?: never;
@@ -9624,6 +9862,37 @@ export interface components {
         SigningKeyListResponse: {
             keys?: components["schemas"]["SigningKeyResponse"][];
         };
+        ConnectionSigningKeyPublic: {
+            chain?: string;
+            address?: string;
+            public_key?: string;
+            curve?: string;
+        };
+        ConnectionSigningKeyListResponse: {
+            /** Format: uuid */
+            agent_id?: string;
+            keys?: components["schemas"]["ConnectionSigningKeyPublic"][];
+        };
+        ConnectionSigningKeyDetailResponse: {
+            /** Format: uuid */
+            agent_id?: string;
+            chain?: string;
+            address?: string;
+            public_key?: string;
+            curve?: string;
+        };
+        PatchConnectionAgentRequest: {
+            intents_api_enabled?: boolean;
+            execution_intents_enabled?: boolean;
+            system_prompt?: string | null;
+        };
+        PatchConnectionAgentResponse: {
+            /** Format: uuid */
+            agent_id?: string;
+            intents_api_enabled?: boolean;
+            execution_intents_enabled?: boolean;
+            system_prompt?: string | null;
+        };
         LeaseBankrKeyRequest: {
             /** @description Bankr wallet ID (wlt_...). Uses org default if omitted. */
             wallet_id?: string;
@@ -9984,6 +10253,29 @@ export interface components {
             message?: string;
             email?: string;
         };
+        OnboardingStatus: {
+            has_vault: boolean;
+            has_agent: boolean;
+            has_policy: boolean;
+            has_sample_secret: boolean;
+            first_secret_read: boolean;
+            welcome_bundle_complete: boolean;
+            /** Format: uuid */
+            default_vault_id?: string | null;
+        };
+        OnboardingProvisionRequest: {
+            agent_name?: string;
+            client?: string;
+        };
+        OnboardingProvisionResponse: {
+            /** Format: uuid */
+            agent_id: string;
+            api_key: string;
+            /** Format: uuid */
+            vault_id: string;
+            mcp_stdio_config: Record<string, never>;
+            verify_prompt: string;
+        };
         AgentKeysVaultResponse: {
             /** Format: uuid */
             vault_id?: string;
@@ -10780,6 +11072,8 @@ export interface components {
              * @description Optional expiration time for the platform API key. Set to null to clear.
              */
             api_key_expires_at?: string | null;
+            /** @description Hostname allowed in SIWE messages for wallet sign-in (EIP-4361). */
+            siwe_domain?: string | null;
         };
         PlatformAppDeleteResponse: {
             deleted: boolean;
@@ -10832,6 +11126,8 @@ export interface components {
              * @description When the platform API key was last rotated.
              */
             api_key_rotated_at?: string | null;
+            /** @description Hostname allowed in SIWE messages for wallet sign-in (EIP-4361). */
+            siwe_domain?: string | null;
             /** Format: date-time */
             created_at?: string;
             /** Format: date-time */
@@ -10846,12 +11142,21 @@ export interface components {
             description?: string;
             /**
              * @description Template specification defining vault, agents, policies, and signing keys to bootstrap.
-             *     Top-level fields: `vault` (object with name, description), `agents` (array of agent specs
-             *     with name, description, shroud_enabled, intents, shroud_config), `policies` (array with
-             *     vault_ref, principal_ref, paths, permissions, conditions), and `signing_keys` (array of
-             *     `{ chain }` objects — supported chains: ethereum, bitcoin, solana, xrp, cardano, tron).
-             *     When `signing_keys` is present, HSM-backed signing keys are auto-provisioned for the
-             *     bootstrapped agent.
+             *     Top-level fields: `vault` (object with name, description), `agents` (array of agent specs),
+             *     `policies` (array with vault_ref, principal_ref, paths, permissions, conditions), and
+             *     `signing_keys` (array of `{ chain }` objects — supported chains: ethereum, bitcoin, solana,
+             *     xrp, cardano, tron). When `signing_keys` is present, HSM-backed signing keys are
+             *     auto-provisioned for the bootstrapped agent.
+             *
+             *     Each agent entry accepts Intents API and Execution Intents flags under any of these aliases
+             *     (direct API field name, boolean shorthand, or `{ enabled: true }` object):
+             *     - Intents API → `intents_api_enabled`, `intents: true`, or `intents: { enabled: true }`
+             *       (maps to `agents.intents_api_enabled`)
+             *     - Execution Intents → `execution_intents_enabled`, `execution: true`, or
+             *       `execution: { enabled: true }` (maps to `agents.execution_intents_enabled`)
+             *
+             *     Other agent fields: `name`, `description`, `shroud_enabled`, `shroud_config`, `system_prompt`,
+             *     `environment`, `signing_keys`, `provision_eoa`, `memory`, `runtime`, `default_llm_provider`.
              */
             spec: Record<string, never>;
         };
@@ -13037,6 +13342,53 @@ export interface components {
             action: string;
             action_payload: Record<string, never>;
         };
+        ConnectionSubmitPendingApprovalRequest: {
+            /**
+             * Format: uuid
+             * @description Required when the connection has multiple agents
+             */
+            agent_id?: string;
+            /**
+             * Format: uuid
+             * @description Optional — auto-resolved from agent consensus policies when omitted
+             */
+            policy_id?: string;
+            /** @default transaction */
+            action: string;
+            /** @description Transaction/intent fields (chain, to, value, …) hashed for decide binding */
+            action_payload: Record<string, never>;
+            /** @description Human-readable label included in webhook payloads */
+            summary?: string;
+        };
+        InspectContentRequest: {
+            content: string;
+            /**
+             * @description Inspection context (reserved for future rules)
+             * @enum {string}
+             */
+            context?: "input" | "output";
+        };
+        InspectContentResponse: {
+            safe?: boolean;
+            /** @enum {string} */
+            verdict?: "clean" | "malicious";
+            threat_count?: number;
+            threats?: {
+                type?: string;
+                pattern?: string;
+                severity?: string;
+            }[];
+            unicode_normalized?: boolean;
+            normalized_content?: string;
+        };
+        PlatformWebhookInfoResponse: {
+            /** Format: uuid */
+            app_id?: string;
+            webhook_configured?: boolean;
+            webhook_url_host?: string;
+            platform_events?: string[];
+            org_webhooks_note?: string;
+        };
         SubmitPendingApprovalResponse: {
             /** Format: uuid */
             pending_approval_id?: string;
@@ -17623,7 +17975,7 @@ export interface operations {
             };
         };
     };
-    getOrgStatus: {
+    getOnboardingStatus: {
         parameters: {
             query?: never;
             header?: never;
@@ -17632,47 +17984,91 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Current org status */
+            /** @description Onboarding status */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
-                        /** Format: uuid */
-                        org_id: string;
-                        /** @enum {string} */
-                        status: "active" | "frozen";
-                        /** Format: date-time */
-                        frozen_at?: string | null;
-                    };
-                };
-            };
-            /** @description Forbidden */
-            403: {
-                headers: {
-                    [name: string]: unknown;
+                    "application/json": components["schemas"]["OnboardingStatus"];
                 };
-                content?: never;
             };
         };
     };
-    freezeOrg: {
+    provisionOnboarding: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["OnboardingProvisionRequest"];
+            };
+        };
         responses: {
-            /** @description Organization frozen */
+            /** @description Provisioned resources */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
+                    "application/json": components["schemas"]["OnboardingProvisionResponse"];
+                };
+            };
+        };
+    };
+    getOrgStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Current org status */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        org_id: string;
+                        /** @enum {string} */
+                        status: "active" | "frozen";
+                        /** Format: date-time */
+                        frozen_at?: string | null;
+                    };
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    freezeOrg: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Organization frozen */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
                         /** @enum {string} */
                         status?: "frozen";
                         /** Format: uuid */
@@ -19629,6 +20025,31 @@ export interface operations {
             };
         };
     };
+    inspectContent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["InspectContentRequest"];
+            };
+        };
+        responses: {
+            /** @description Inspection report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InspectContentResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+        };
+    };
     transferPlatformAppOwnership: {
         parameters: {
             query?: never;
@@ -19684,6 +20105,29 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    getPlatformWebhooks: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                appId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Webhook configuration summary */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PlatformWebhookInfoResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
     rotatePlatformWebhookSecret: {
         parameters: {
             query?: never;
@@ -20121,6 +20565,34 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    createConnectionPendingApproval: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                connectionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ConnectionSubmitPendingApprovalRequest"];
+            };
+        };
+        responses: {
+            /** @description Pending approval created */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SubmitPendingApprovalResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     getConnectionPendingApproval: {
         parameters: {
             query?: never;
@@ -20222,6 +20694,71 @@ export interface operations {
             };
         };
     };
+    listConnectionSigningKeys: {
+        parameters: {
+            query?: {
+                agent_id?: string;
+            };
+            header?: never;
+            path: {
+                connectionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Signing keys for the connection agent */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ConnectionSigningKeyListResponse"];
+                };
+            };
+            /** @description Multiple agents — agent_id required */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getConnectionSigningKey: {
+        parameters: {
+            query?: {
+                agent_id?: string;
+            };
+            header?: never;
+            path: {
+                connectionId: string;
+                chain: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Signing key metadata */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ConnectionSigningKeyDetailResponse"];
+                };
+            };
+            /** @description Multiple agents — agent_id required */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
     deactivateConnectionSigningKey: {
         parameters: {
             query?: {
@@ -20253,6 +20790,243 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    patchConnectionAgent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                connectionId: string;
+                agentId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PatchConnectionAgentRequest"];
+            };
+        };
+        responses: {
+            /** @description Updated agent settings */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PatchConnectionAgentResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getConnectionPortfolio: {
+        parameters: {
+            query?: {
+                chains?: string;
+                include_tokens?: boolean;
+            };
+            header?: never;
+            path: {
+                connectionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Connection-scoped portfolio */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PortfolioResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getConnectionBalances: {
+        parameters: {
+            query?: {
+                chains?: string;
+            };
+            header?: never;
+            path: {
+                connectionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Connection-scoped portfolio */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PortfolioResponse"];
+                };
+            };
+        };
+    };
+    listConnectionAutomations: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                connectionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Automations scoped to connection agents */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AutomationListResponse"];
+                };
+            };
+        };
+    };
+    createConnectionAutomation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                connectionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateAutomationRequest"];
+            };
+        };
+        responses: {
+            /** @description Automation created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AutomationCreatedResponse"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+        };
+    };
+    cancelConnectionAutomationRun: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                connectionId: string;
+                automationId: string;
+                runId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Run cancelled */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AutomationRunResponse"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getConnectionMemory: {
+        parameters: {
+            query?: {
+                agent_id?: string;
+            };
+            header?: never;
+            path: {
+                connectionId: string;
+                namespace: string;
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Memory entry */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MemoryEntry"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    putConnectionMemory: {
+        parameters: {
+            query?: {
+                agent_id?: string;
+            };
+            header?: never;
+            path: {
+                connectionId: string;
+                namespace: string;
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PutMemoryRequest"];
+            };
+        };
+        responses: {
+            /** @description Memory entry stored */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MemoryEntry"];
+                };
+            };
+        };
+    };
+    deleteConnectionMemory: {
+        parameters: {
+            query?: {
+                agent_id?: string;
+            };
+            header?: never;
+            path: {
+                connectionId: string;
+                namespace: string;
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
     createConnectionRuntime: {
         parameters: {
             query?: never;