@1claw/sdk 0.60.0 → 0.61.0

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

@@ -6497,6 +6497,180 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/agents/{agent_id}/pay/settings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Set an agent's payment guardrails
+         * @description Human callers only. These are the numbers every payment decision is measured against — the per-payment cap, the daily limit, the recipient allowlist, whether a passkey is required at all, and whether the agent may hold a spending grant. An agent that could set them would be setting its own ceiling. Omitted fields are left alone; values can currently be set but not cleared.
+         */
+        patch: operations["updatePaySettings"];
+        trace?: never;
+    };
+    "/v1/agents/{agent_id}/pay/prepare": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Prepare an x402 payment from a 402 challenge
+         * @description Send the exact bytes the paywall served. The vault parses them, pins the amount that will actually be signed (not the `maxAmountRequired` ceiling), computes the digest a person will authorize, and stores the preimage so the authorize page renders from what the vault saw rather than what the caller claims. `authorization` in the response says what the payment needs next: `allow`, `require_passkey`, `require_grant`, or `deny: <reason>`.
+         */
+        post: operations["preparePayment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{agent_id}/pay/sign": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Sign a prepared x402 payment
+         * @description Evaluates the agent's payment policy, redeems a passkey assertion or consumes a spending grant, then signs. The daily limit is charged at signing time: a payment that is signed and then lost still consumed authority, and only a vault-verified reconciliation returns it. Returns the `X-PAYMENT` header value, never a key.
+         */
+        post: operations["signPayment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{agent_id}/pay/grants": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create a spending grant
+         * @description Human callers only. Requires a passkey assertion over the digest of exactly these terms, and stays within the agent's own maximum cap and window — a grant is a delegation inside the limits already set, not a way around them.
+         */
+        post: operations["createPayGrant"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{agent_id}/pay/{payment_id}/result": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Report the outcome of a payment
+         * @description Best-effort reporting. Moves the audit trail forward and nothing else — `settled: false` does **not** release daily-limit headroom, and the response says `limit_released: false` so the caller need not infer it.
+         */
+        post: operations["reportPaymentResult"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{agent_id}/pay/{payment_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Payment status */
+        get: operations["getPayment"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/pay-sessions/{session_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read a pay session (authorize page and CLI poll)
+         * @description Requires the token of the human the session was raised for, not an agent token and not merely a member of the same org. A session UUID is not authorization once the response can carry signing credentials.
+         */
+        get: operations["getPaySession"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/pay-sessions/{session_id}/authorize": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Authorize a pay session with a passkey assertion
+         * @description Called by the authorize page after the person touches their authenticator. The assertion is redeemed here against this session's own payment digest and the session is marked authorized; no token is handed back to be polled for, so nothing worth stealing is left in the row. Requires the token of the human the session was raised for.
+         */
+        post: operations["authorizePaySession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/pay-grants/{grant_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Revoke a spending grant */
+        delete: operations["revokePayGrant"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/agents/{agent_id}/cards/order": {
         parameters: {
             query?: never;
@@ -7670,6 +7844,179 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/directory/jobs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List directory jobs
+         * @description Open jobs across every org (the board is cross-org by design). Pass `mine=true` to list this org's own jobs in every status instead.
+         */
+        get: operations["listDirectoryJobs"];
+        put?: never;
+        /**
+         * Post a job to the directory board
+         * @description Posts a task other orgs' agents can bid on.
+         *
+         *     **`title` and `description` are inspected before they are stored.** They will be
+         *     read by other parties' language models, which makes this board a prompt-injection
+         *     distribution channel. High-confidence injection is refused with 400 naming the
+         *     field; lower-confidence content is stored with `content_warning: true` and every
+         *     response wraps it in an untrusted-content envelope.
+         *
+         *     Limit: 10 open jobs per org.
+         */
+        post: operations["createDirectoryJob"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/directory/jobs/{job_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get one job
+         * @description Open jobs are public. A job in any other status is visible only to the org that posted it — an awarded or cancelled job is not board content.
+         */
+        get: operations["getDirectoryJob"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/directory/jobs/{job_id}/bids": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List bids on a job (poster only)
+         * @description Bid contents belong to the poster alone — a competing bidder reading this list would learn every rival's price.
+         */
+        get: operations["listDirectoryJobBids"];
+        put?: never;
+        /**
+         * Bid on a job
+         * @description **Agents only** — a human posts work, an agent offers to do it. The agent must be
+         *     `discoverable`: appearing on someone's bid list is a public act.
+         *
+         *     `summary` is inspected exactly as job text is. One bid per agent per job —
+         *     re-bidding replaces the previous bid rather than stacking, because a poster
+         *     reading five bids from one agent cannot tell which is current.
+         *
+         *     Limit: 50 bids per agent per day.
+         */
+        post: operations["createDirectoryJobBid"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/directory/jobs/{job_id}/accept/{bid_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Award a job to a bid (poster only)
+         * @description Awards the job and returns an A2A handoff pointing at the bidder's own `a2a_url`. **1Claw does not execute the task** — it says where to send it. The award is atomic and guarded on the job still being open, so two posters racing to award different bids cannot both succeed; the loser gets 409.
+         */
+        post: operations["acceptDirectoryJobBid"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/directory/jobs/{job_id}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cancel a job (poster only) */
+        post: operations["cancelDirectoryJob"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/directory/jobs/{job_id}/complete": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Mark a job complete (poster or awarded agent) */
+        post: operations["completeDirectoryJob"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{agent_id}/policy-preset/cedar": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * The Cedar a preset compiles to (Feature 6 Phase B)
+         * @description Returns the Cedar policy text a preset produces for this agent, already
+         *     validated against the deployed Cedar schema. **Read-only — it creates no
+         *     policy.** The wizard's Advanced tab shows this before anything is written.
+         *
+         *     **The text is not the whole policy.** The presets denominate limits in USD
+         *     ("$100 a day", "ask above $25") and the Cedar schema exposes transaction
+         *     value only as `value_gwei`, a native-token amount. Converting needs a live
+         *     price, and a price baked into policy text is wrong the moment it is written
+         *     and stays wrong silently — so the compiler does not convert. The USD limits
+         *     come back in `residual_guardrails`, still enforced by the agent's guardrail
+         *     columns where a live price is applied at evaluation time.
+         *
+         *     A UI must show `residual_guardrails` alongside the text. Presenting the
+         *     Cedar alone would read as complete while permitting every amount.
+         *
+         *     Policies are created in **shadow** mode: they report what they would decide
+         *     without deciding it, until an operator promotes them.
+         */
+        post: operations["exportPolicyPresetCedar"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/agents/{agent_id}/policy-preset": {
         parameters: {
             query?: never;
@@ -10342,6 +10689,86 @@ export interface paths {
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
+        UpdatePayGuardrailsRequest: {
+            pay_enabled?: boolean;
+            pay_max_usd?: string | null;
+            pay_daily_limit_usd?: string | null;
+            /** @description Recipients an unattended agent may pay. Null is not a wildcard — for an unattended agent it means no one. */
+            pay_payto_allowlist?: string[] | null;
+            /** @description Defaults true. Turning it off is what "unattended" means. */
+            pay_require_passkey?: boolean;
+            pay_require_approval?: boolean;
+            pay_grant_mode_enabled?: boolean;
+            pay_grant_max_usd?: string | null;
+            pay_grant_max_ttl_secs?: number | null;
+        };
+        PayPrepareRequest: {
+            /** @description The exact bytes the paywall served, base64. Sent verbatim rather than parsed by the caller: the digest a person authorizes is computed from this preimage, so anything reinterpreted first would fall outside the binding. */
+            challenge_b64: string;
+            /** @example GET */
+            method: string;
+            /** Format: uri */
+            resource_url: string;
+            /** @description Reused by a caller retrying after a crash so one 402 cannot become two payments. Generated server-side when absent. */
+            idempotency_key?: string;
+            /**
+             * @description A request, not an instruction — the vault decides.
+             * @enum {string}
+             */
+            mode?: "strict" | "session" | "auto";
+        };
+        PayPrepareResponse: {
+            /** Format: uuid */
+            session_id?: string;
+            payment_digest?: string;
+            sign_idempotency_key?: string;
+            quote?: {
+                [key: string]: unknown;
+            };
+            /** Format: date-time */
+            valid_before?: string | null;
+            /** Format: date-time */
+            expires_at?: string;
+            /** @description allow | require_passkey | require_grant | deny: <reason> */
+            authorization?: string;
+            /** @description The paywall's window is under 30 seconds and may expire while a person is reading the authorize page. */
+            short_window?: boolean;
+        };
+        PaySignRequest: {
+            /** Format: uuid */
+            session_id: string;
+            /** @enum {string} */
+            mode?: "strict" | "session" | "auto";
+            /**
+             * Format: uuid
+             * @description Offer a specific grant; absent means the newest live one.
+             */
+            grant_id?: string;
+        };
+        PaySignResponse: {
+            /** Format: uuid */
+            payment_id?: string;
+            /** @description The X-PAYMENT header value. The signature, never the key. */
+            payment_header?: string;
+            amount_usd?: string;
+            pay_to?: string;
+            /** Format: uuid */
+            grant_id?: string | null;
+        };
+        PayResultRequest: {
+            http_status?: number;
+            /** @description Null means the caller could not tell — a timeout after the header was sent, where the payment may or may not have been presented. */
+            settled?: boolean | null;
+            error?: string | null;
+        };
+        CreatePayGrantRequest: {
+            cap_usd: string;
+            ttl_secs: number;
+            /** @description Null means any recipient; an empty list means none. The two stay distinguishable all the way down to the digest. */
+            allowed_paytos?: string[] | null;
+            /** @description The digest the person actually asserted over. Compared against the digest of the terms being stored, so a token obtained for a small, tightly scoped grant cannot create a large open one. */
+            grant_digest: string;
+        };
         OrderCardRequest: {
             /** @enum {string} */
             kind: "prepaid" | "gift_card";
@@ -13397,20 +13824,84 @@ export interface components {
              */
             spec: Record<string, never>;
         };
-        PlatformTemplateResponse: {
+        PlatformTemplateResponse: {
+            /** Format: uuid */
+            id?: string;
+            /** Format: uuid */
+            platform_app_id?: string;
+            name?: string;
+            description?: string;
+            version?: number;
+            spec?: Record<string, never>;
+            is_active?: boolean;
+            /** Format: date-time */
+            created_at?: string;
+            /** Format: date-time */
+            updated_at?: string;
+        };
+        DirectoryJob: {
+            /** Format: uuid */
+            id?: string;
+            title?: string | {
+                /** @enum {boolean} */
+                untrusted_content?: true;
+                source?: string;
+                id?: string;
+                field?: string;
+                raw_text?: string;
+                system_prefix?: string;
+            };
+            description?: string | {
+                /** @enum {boolean} */
+                untrusted_content?: true;
+                source?: string;
+                id?: string;
+                field?: string;
+                raw_text?: string;
+                system_prefix?: string;
+            };
+            tags?: string[];
+            required_capabilities?: string[];
+            budget?: Record<string, never>;
+            /** Format: date-time */
+            deadline_at?: string | null;
+            /** @enum {string} */
+            status?: "open" | "awarded" | "completed" | "cancelled" | "expired";
+            /** Format: int64 */
+            bid_count?: number;
+            /** @description Inspection found threats below the blocking threshold. When true, title and description are envelopes rather than strings. */
+            content_warning?: boolean;
+            /** Format: uuid */
+            awarded_agent_id?: string | null;
+            a2a_handoff?: Record<string, never>;
+            /** Format: date-time */
+            expires_at?: string;
+            /** Format: date-time */
+            created_at?: string;
+        };
+        DirectoryJobBid: {
             /** Format: uuid */
             id?: string;
             /** Format: uuid */
-            platform_app_id?: string;
-            name?: string;
-            description?: string;
-            version?: number;
-            spec?: Record<string, never>;
-            is_active?: boolean;
+            job_id?: string;
+            /** Format: uuid */
+            bidder_agent_id?: string;
+            summary?: string | {
+                /** @enum {boolean} */
+                untrusted_content?: true;
+                source?: string;
+                id?: string;
+                field?: string;
+                raw_text?: string;
+                system_prefix?: string;
+            };
+            proposed_cost?: Record<string, never>;
+            estimated_duration_mins?: number | null;
+            /** @enum {string} */
+            status?: "pending" | "accepted" | "rejected" | "withdrawn";
+            content_warning?: boolean;
             /** Format: date-time */
             created_at?: string;
-            /** Format: date-time */
-            updated_at?: string;
         };
         FleetSummaryResponse: {
             /** Format: uuid */
@@ -25121,28 +25612,304 @@ export interface operations {
                     "application/json": components["schemas"]["KnownToken"];
                 };
             };
-            403: components["responses"]["Forbidden"];
+            403: components["responses"]["Forbidden"];
+        };
+    };
+    deleteKnownToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                token_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Token deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            403: components["responses"]["Forbidden"];
+        };
+    };
+    updatePaySettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                agent_id: components["parameters"]["AgentId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdatePayGuardrailsRequest"];
+            };
+        };
+        responses: {
+            /** @description Updated guardrails */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not a human caller */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    preparePayment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                agent_id: components["parameters"]["AgentId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PayPrepareRequest"];
+            };
+        };
+        responses: {
+            /** @description Session created; digest and quote returned */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PayPrepareResponse"];
+                };
+            };
+            /** @description Not a usable 402 challenge */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description pay is not enabled for this agent */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    signPayment: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description A passkey assertion bound to this payment's digest, when required. */
+                "X-Passkey-Token"?: string;
+            };
+            path: {
+                agent_id: components["parameters"]["AgentId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PaySignRequest"];
+            };
+        };
+        responses: {
+            /** @description Signed; payment header returned */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PaySignResponse"];
+                };
+            };
+            /** @description Policy refused */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description ChallengeExpired. Re-fetch the resource for a fresh 402 and prepare again — re-preparing from the stored bytes would reproduce the same expired window. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    createPayGrant: {
+        parameters: {
+            query?: never;
+            header: {
+                "X-Passkey-Token": string;
+            };
+            path: {
+                agent_id: components["parameters"]["AgentId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreatePayGrantRequest"];
+            };
+        };
+        responses: {
+            /** @description Grant created */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not a human caller */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    reportPaymentResult: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                agent_id: components["parameters"]["AgentId"];
+                payment_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PayResultRequest"];
+            };
+        };
+        responses: {
+            /** @description Outcome recorded */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getPayment: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                agent_id: components["parameters"]["AgentId"];
+                payment_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Payment status */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getPaySession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Quote and status */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not a human caller */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    authorizePaySession: {
+        parameters: {
+            query?: never;
+            header: {
+                "X-Passkey-Token": string;
+            };
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Session authorized */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not a human caller, the session belongs to someone else, or the assertion does not authorize this payment. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
-    deleteKnownToken: {
+    revokePayGrant: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                token_id: string;
+                grant_id: string;
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Token deleted */
-            204: {
+            /** @description Revoked */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Not found */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            403: components["responses"]["Forbidden"];
         };
     };
     orderCard: {
@@ -27040,6 +27807,313 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    listDirectoryJobs: {
+        parameters: {
+            query?: {
+                /** @description Comma-separated. */
+                tags?: string;
+                q?: string;
+                limit?: number;
+                offset?: number;
+                mine?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Jobs */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        jobs?: components["schemas"]["DirectoryJob"][];
+                        count?: number;
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    createDirectoryJob: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    title: string;
+                    description: string;
+                    tags?: string[];
+                    required_capabilities?: string[];
+                    /** @description { "amount": "10", "currency": "USD" } — optional. */
+                    budget?: Record<string, never>;
+                    /** Format: date-time */
+                    deadline_at?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Job posted */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DirectoryJob"];
+                };
+            };
+            /** @description Content refused by inspection, or the open-job limit reached */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getDirectoryJob: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                job_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Job */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DirectoryJob"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listDirectoryJobBids: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                job_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Bids */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        bids?: components["schemas"]["DirectoryJobBid"][];
+                        count?: number;
+                    };
+                };
+            };
+            403: components["responses"]["Forbidden"];
+        };
+    };
+    createDirectoryJobBid: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                job_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    summary: string;
+                    proposed_cost?: Record<string, never>;
+                    estimated_duration_mins?: number;
+                    a2a_task_ref?: Record<string, never>;
+                };
+            };
+        };
+        responses: {
+            /** @description Bid placed */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DirectoryJobBid"];
+                };
+            };
+            /** @description Not an agent, or the agent is not discoverable */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The job is not open */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    acceptDirectoryJobBid: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                job_id: string;
+                bid_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Awarded */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        job_id?: string;
+                        /** Format: uuid */
+                        awarded_bid_id?: string;
+                        /** Format: uuid */
+                        awarded_agent_id?: string;
+                        a2a_handoff?: Record<string, never>;
+                        next_step?: string;
+                    };
+                };
+            };
+            /** @description The job is no longer open */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    cancelDirectoryJob: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                job_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Cancelled */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description A job in this status cannot be cancelled */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    completeDirectoryJob: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                job_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Completed */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Only an awarded job can be completed */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    exportPolicyPresetCedar: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                agent_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @example treasury-operator */
+                    preset: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Generated Cedar plus the limits it cannot carry */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        preset?: string;
+                        /** Format: uuid */
+                        agent_id?: string;
+                        /** @description Cedar text, validated against the deployed schema. */
+                        cedar?: string;
+                        /** @description Limits Cedar cannot express, still enforced by guardrails. Show these next to the text. */
+                        residual_guardrails?: string[];
+                        /** @enum {string} */
+                        enforcement_mode?: "shadow";
+                        /** @description Intermediate representation, so a caller can render a different policy backend without re-deriving the preset. */
+                        ir?: {
+                            preset_slug?: string;
+                            permit_actions?: string[];
+                            forbid_actions?: string[];
+                            secret_paths?: string[];
+                            residual_guardrails?: string[];
+                        };
+                    };
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     applyPolicyPreset: {
         parameters: {
             query?: never;