@1claw/sdk 0.16.3 → 0.18.0

package/README.md

@@ -76,7 +76,7 @@ await client.auth.resetPassword({ token: "...", new_password: "..." });
 
 | Resource           | Methods                                                                                                             |
 | ------------------ | ------------------------------------------------------------------------------------------------------------------- |
-| `client.vault`     | `create`, `get`, `list`, `delete`                                                                                   |
+| `client.vault`     | `create`, `get`, `list`, `delete`, `enableMpc`, `disableMpc`                                                        |
 | `client.secrets`   | `set`, `get`, `delete`, `list`, `rotate`                                                                            |
 | `client.access`    | `grantHuman`, `grantAgent`, `update`, `revoke`, `listGrants`                                                        |
 | `client.agents`    | `create`, `getSelf`, `get`, `list`, `update`, `delete`, `rotateKey`, `submitTransaction`, `signTransaction`, `getTransaction`, `listTransactions`, `simulateTransaction`, `simulateBundle` |
@@ -265,6 +265,30 @@ const job = await client.vault.getRotationJobStatus(vaultId, jobId);
 console.log(job.data?.status, job.data?.processed, "/", job.data?.total_secrets);
 ```
 
+## MPC Vault Support
+
+Vaults can optionally use multi-party computation (MPC) for secret splitting. When MPC is enabled, the server holds one share and the client holds another — neither party can reconstruct the secret alone.
+
+```typescript
+// Enable MPC on a vault
+await client.vault.enableMpc(vaultId);
+
+// Store a secret — response includes the client_share
+const res = await client.secrets.set(vaultId, "my-key", "secret-value");
+const clientShare = res.data?.client_share; // Save this securely on your side
+
+// Retrieve a secret — pass client_share to reconstruct
+const secret = await client.secrets.get(vaultId, "my-key", {
+    client_share: clientShare,
+});
+console.log(secret.data?.value);
+
+// Disable MPC (converts back to standard encryption)
+await client.vault.disableMpc(vaultId);
+```
+
+When MPC is enabled, `set` responses include a `client_share` field that must be stored client-side. The `get` method accepts an optional `client_share` parameter to reconstruct the full secret. Without the client share, the server returns only its share.
+
 ## Agent Token Auto-Refresh
 
 When using agent credentials (`agentId` + `apiKey`), the SDK automatically refreshes tokens 60 seconds before expiry. No manual token management needed:
@@ -368,6 +392,39 @@ const { data } = await client.agents.create({
         network_detection: { enabled: true, action: "warn" },
         filesystem_detection: { enabled: false },  // disabled by default
 
+        // Advanced inspection (Phase 2+3)
+        tool_call_inspection: {
+            enabled: true,
+            scan_arguments: true,
+            block_credential_exfil: true,
+            action: "block",
+        },
+        output_policy: {
+            enabled: true,
+            blocked_entities: ["CompetitorCo"],
+            block_harmful_content: true,
+            harmful_categories: ["malware", "illegal"],
+            action: "warn",
+        },
+        secret_injection_detection: {
+            enabled: true,
+            action: "block",
+            sensitivity: "medium",
+        },
+        advanced_redaction: {
+            enabled: true,
+            detect_base64_encoded: true,
+            detect_split_secrets: true,
+            detect_prefix_leak: true,
+        },
+        semantic_policy: {
+            enabled: true,
+            allowed_topics: ["customer_support"],
+            denied_tasks: ["code_generation", "data_export"],
+            action: "warn",
+        },
+        flagged_request_retention_days: 30,
+
         // Global settings
         sanitization_mode: "block",     // block | surgical | log_only
         threat_logging: true,

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

@@ -539,6 +539,28 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/vaults/{vault_id}/mpc": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Enable MPC custody on a vault
+         * @description Enable MPC custody on an existing vault. Requires Business or Enterprise plan.
+         *     Splits secret encryption keys across multiple providers using the specified
+         *     custody mode (e.g. 2-of-2, 2-of-3).
+         */
+        post: operations["enableMpc"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/vaults/{vault_id}/secrets": {
         parameters: {
             query?: never;
@@ -1703,6 +1725,152 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/shroud/activity": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List Shroud activity events
+         * @description Returns recent Shroud proxy activity for the organization (LLM requests, inspections, policy actions).
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Filter by agent ID */
+                    agent_id?: string;
+                    /** @description Filter by action (allowed, blocked, warned) */
+                    action?: string;
+                    /** @description Maximum events to return */
+                    limit?: number;
+                    /** @description Pagination offset */
+                    offset?: number;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Activity events */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            events?: components["schemas"]["ShroudActivityEvent"][];
+                            total?: number;
+                        };
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Ingest Shroud activity event (internal)
+         * @description Called by the Shroud proxy to record activity events. Not intended for external use.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["IngestShroudActivityRequest"];
+                };
+            };
+            responses: {
+                /** @description Event recorded */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/shroud/threat-summary": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Shroud threat analytics summary
+         * @description Aggregated threat metrics for the organization from `shroud_activity` (detectors, blocked counts, recent flagged requests). Query `period` selects the window; the previous window of equal length is used for request volume trend.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Rolling window ending now */
+                    period?: "1h" | "24h" | "7d" | "30d";
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Threat summary */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ShroudThreatSummary"];
+                    };
+                };
+                /** @description Invalid period */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -1901,6 +2069,8 @@ export interface components {
         CreateVaultRequest: {
             name: string;
             description?: string;
+            /** @description MPC custody mode to enable at creation (e.g. "2-of-2", "2-of-3") */
+            mpc_custody?: string;
         };
         VaultResponse: {
             /** Format: uuid */
@@ -1915,6 +2085,12 @@ export interface components {
             cmek_enabled?: boolean;
             /** @description SHA-256 fingerprint of the CMEK key (64 hex chars) */
             cmek_fingerprint?: string;
+            /** @description MPC custody mode (e.g. "2-of-2", "2-of-3"), absent when MPC is not enabled */
+            mpc_custody?: string;
+            /** @description Number of shares required to reconstruct the key */
+            mpc_threshold?: number;
+            /** @description List of MPC share providers (e.g. ["server", "client"]) */
+            mpc_providers?: string[];
         };
         VaultListResponse: {
             vaults?: components["schemas"]["VaultResponse"][];
@@ -1946,6 +2122,10 @@ export interface components {
             /** Format: date-time */
             created_at: string;
         };
+        EnableMpcRequest: {
+            /** @description MPC custody mode (e.g. "2-of-2", "2-of-3") */
+            mpc_custody: string;
+        };
         PutSecretRequest: {
             /**
              * @description Secret type (generic, password, api_key, certificate, private_key, ssh_key, env)
@@ -1977,6 +2157,23 @@ export interface components {
             /** Format: date-time */
             expires_at?: string;
         };
+        /** @description Returned when a secret is created or updated. Extends SecretMetadataResponse with an optional client_share for MPC vaults. */
+        SecretCreatedResponse: {
+            /** Format: uuid */
+            id: string;
+            path: string;
+            type: string;
+            version: number;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            expires_at?: string;
+            /** @description Base64-encoded client key share. Returned only for MPC 2-of-2 vaults. The client must store this share securely — it is not persisted server-side. */
+            client_share?: string;
+        };
         SecretResponse: {
             /** Format: uuid */
             id: string;
@@ -2254,6 +2451,13 @@ export interface components {
              * @default true
              */
             threat_logging: boolean;
+            tool_call_inspection?: components["schemas"]["ToolCallPolicy"];
+            output_policy?: components["schemas"]["OutputPolicy"];
+            secret_injection_detection?: components["schemas"]["SecretInjectionConfig"];
+            advanced_redaction?: components["schemas"]["AdvancedRedactionConfig"];
+            semantic_policy?: components["schemas"]["SemanticPolicy"];
+            /** @description Number of days to retain flagged request bodies for replay/investigation */
+            flagged_request_retention_days?: number;
         };
         /** @description Unicode normalization and homoglyph detection settings */
         UnicodeNormalizationConfig: {
@@ -2384,6 +2588,129 @@ export interface components {
             /** @description Path patterns to block (e.g., /etc/passwd, ~/.ssh) */
             blocked_paths?: string[];
         };
+        /** @description Tool/function call inspection settings */
+        ToolCallPolicy: {
+            /**
+             * @description Enable tool call inspection
+             * @default false
+             */
+            enabled: boolean;
+            /** @description Allowed tool/function names (empty = all allowed) */
+            allowed_tool_names?: string[];
+            /** @description Denied tool/function names */
+            denied_tool_names?: string[];
+            /**
+             * @description Scan tool call arguments for credential exfiltration
+             * @default true
+             */
+            scan_arguments: boolean;
+            /**
+             * @description Block tool calls that appear to exfiltrate credentials
+             * @default true
+             */
+            block_credential_exfil: boolean;
+            /**
+             * @description Action when a tool call violation is detected
+             * @default block
+             * @enum {string}
+             */
+            action: "block" | "sanitize" | "warn" | "log";
+        };
+        /** @description Output content policy settings for LLM responses */
+        OutputPolicy: {
+            /**
+             * @description Enable output content policies
+             * @default false
+             */
+            enabled: boolean;
+            /** @description Custom regex patterns to block in responses */
+            blocked_patterns?: string[];
+            /** @description Named entities to block (e.g., competitor names) */
+            blocked_entities?: string[];
+            /**
+             * @description Block responses containing harmful content categories
+             * @default false
+             */
+            block_harmful_content: boolean;
+            /** @description Harm categories to block */
+            harmful_categories?: ("violence" | "self_harm" | "illegal" | "hate" | "sexual" | "malware")[];
+            /**
+             * @description Action when output policy is violated
+             * @default warn
+             * @enum {string}
+             */
+            action: "block" | "sanitize" | "warn" | "log";
+        };
+        /** @description Detects credentials injected into prompts that are not from the vault */
+        SecretInjectionConfig: {
+            /**
+             * @description Enable secret injection detection
+             * @default false
+             */
+            enabled: boolean;
+            /**
+             * @description Action when injected credentials are detected
+             * @default block
+             * @enum {string}
+             */
+            action: "block" | "sanitize" | "warn" | "log";
+            /**
+             * @description Detection sensitivity level
+             * @default medium
+             * @enum {string}
+             */
+            sensitivity: "low" | "medium" | "high";
+        };
+        /** @description Advanced secret redaction settings (base64-encoded, split, prefix leaks) */
+        AdvancedRedactionConfig: {
+            /**
+             * @description Enable advanced redaction checks
+             * @default false
+             */
+            enabled: boolean;
+            /**
+             * @description Detect base64-encoded vault secrets
+             * @default false
+             */
+            detect_base64_encoded: boolean;
+            /**
+             * @description Detect secrets split across tokens or messages
+             * @default false
+             */
+            detect_split_secrets: boolean;
+            /**
+             * @description Detect partial/prefix leaks of vault secrets
+             * @default false
+             */
+            detect_prefix_leak: boolean;
+            /**
+             * @description Minimum secret length to consider for advanced matching
+             * @default 16
+             */
+            min_secret_length: number;
+        };
+        /** @description Semantic/intent-level policy enforcement */
+        SemanticPolicy: {
+            /**
+             * @description Enable semantic policy enforcement
+             * @default false
+             */
+            enabled: boolean;
+            /** @description Topics the agent is allowed to discuss (empty = all) */
+            allowed_topics?: string[];
+            /** @description Topics to block */
+            denied_topics?: string[];
+            /** @description Tasks the agent is allowed to perform (empty = all) */
+            allowed_tasks?: string[];
+            /** @description Tasks to block (e.g., code_generation, data_export) */
+            denied_tasks?: string[];
+            /**
+             * @description Action when semantic policy is violated
+             * @default warn
+             * @enum {string}
+             */
+            action: "block" | "sanitize" | "warn" | "log";
+        };
         AgentCreatedResponse: {
             agent: components["schemas"]["AgentResponse"];
             /** @description One-time API key (only present for api_key auth method) */
@@ -2972,6 +3299,86 @@ export interface components {
             }[];
             description?: string;
         };
+        ShroudActivityEvent: {
+            /** Format: uuid */
+            id?: string;
+            /** Format: uuid */
+            org_id?: string;
+            agent_id?: string;
+            provider?: string;
+            model?: string;
+            /** @description Action taken (allowed, blocked, warned) */
+            action?: string;
+            request_tokens?: number;
+            response_tokens?: number;
+            latency_ms?: number;
+            had_secrets_redacted?: boolean;
+            had_pii_detected?: boolean;
+            injection_score?: number;
+            policy_violations?: string[];
+            metadata?: Record<string, never>;
+            /** Format: date-time */
+            timestamp?: string;
+        };
+        IngestShroudActivityRequest: {
+            agent_id: string;
+            provider?: string;
+            model?: string;
+            action: string;
+            /** @default 0 */
+            request_tokens: number;
+            /** @default 0 */
+            response_tokens: number;
+            latency_ms?: number;
+            /** @default false */
+            had_secrets_redacted: boolean;
+            /** @default false */
+            had_pii_detected: boolean;
+            /** @default 0 */
+            injection_score: number;
+            policy_violations?: string[];
+            metadata?: Record<string, never>;
+        };
+        ShroudThreatSummary: {
+            /** Format: int64 */
+            total_requests?: number;
+            /** Format: int64 */
+            total_requests_prev?: number;
+            /** Format: int64 */
+            blocked_requests?: number;
+            /** Format: int64 */
+            detectors_triggered?: number;
+            /** Format: int64 */
+            active_agents?: number;
+            detectors?: components["schemas"]["ShroudDetectorStats"][];
+            flagged_requests?: components["schemas"]["ShroudFlaggedRequest"][];
+        };
+        ShroudDetectorStats: {
+            detector?: string;
+            /** Format: int64 */
+            detections?: number;
+            /** Format: int64 */
+            blocks?: number;
+            actions?: {
+                /** Format: int64 */
+                blocked?: number;
+                /** Format: int64 */
+                warned?: number;
+                /** Format: int64 */
+                logged?: number;
+            };
+        };
+        ShroudFlaggedRequest: {
+            id?: string;
+            /** Format: date-time */
+            timestamp?: string;
+            agent_id?: string;
+            agent_name?: string;
+            score?: number;
+            reason?: string;
+            /** @enum {string} */
+            action?: "blocked" | "warned" | "logged";
+        };
         HealthResponse: {
             /** @enum {string} */
             status?: "healthy" | "degraded";
@@ -3894,6 +4301,35 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    enableMpc: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                vault_id: components["parameters"]["VaultId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EnableMpcRequest"];
+            };
+        };
+        responses: {
+            /** @description MPC custody enabled */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VaultResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     listSecrets: {
         parameters: {
             query?: {
@@ -3923,7 +4359,10 @@ export interface operations {
     getSecret: {
         parameters: {
             query?: never;
-            header?: never;
+            header?: {
+                /** @description Base64-encoded client key share for MPC 2-of-2 vaults. Required when the vault uses 2-of-2 MPC custody. */
+                "x-client-share"?: string;
+            };
             path: {
                 vault_id: components["parameters"]["VaultId"];
                 /** @description Secret path (e.g. "db/credentials") */
@@ -3969,7 +4408,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["SecretMetadataResponse"];
+                    "application/json": components["schemas"]["SecretCreatedResponse"];
                 };
             };
             400: components["responses"]["BadRequest"];