@modelrelay/sdk 1.3.2 → 1.10.3

package/dist/index.d.cts

@@ -55,6 +55,26 @@ declare function asModelId(value: string): ModelId;
  * Cast a string to a TierCode. Use for known tier codes.
  */
 declare function asTierCode(value: string): TierCode;
+declare const SubscriptionStatuses: {
+    readonly Active: "active";
+    readonly Trialing: "trialing";
+    readonly PastDue: "past_due";
+    readonly Canceled: "canceled";
+    readonly Unpaid: "unpaid";
+    readonly Incomplete: "incomplete";
+    readonly IncompleteExpired: "incomplete_expired";
+    readonly Paused: "paused";
+};
+type SubscriptionStatusKind = (typeof SubscriptionStatuses)[keyof typeof SubscriptionStatuses];
+declare const BillingProviders: {
+    readonly Stripe: "stripe";
+    readonly Crypto: "crypto";
+    readonly AppStore: "app_store";
+    readonly External: "external";
+};
+type BillingProvider = (typeof BillingProviders)[keyof typeof BillingProviders];
+/** Arbitrary customer metadata. Values can be any JSON type. */
+type CustomerMetadata = Record<string, unknown>;
 type PublishableKey = string & {
     readonly __brand: "PublishableKey";
 };
@@ -272,7 +292,6 @@ interface FrontendToken {
     identitySubject?: string;
 }
 interface CustomerTokenRequest {
-    projectId: string;
     customerId?: string;
     customerExternalId?: string;
     ttlSeconds?: number;
@@ -383,6 +402,7 @@ interface UsageSummary {
     windowEnd?: Date | string;
     limit?: number;
     used?: number;
+    images?: number;
     actionsLimit?: number;
     actionsUsed?: number;
     remaining?: number;
@@ -640,6 +660,8 @@ interface ResponseEvent<T = unknown> {
     toolCallDelta?: ToolCallDelta;
     /** Completed tool calls when type is tool_use_stop or message_stop. */
     toolCalls?: ToolCall[];
+    /** Tool result payload when type is tool_use_stop. */
+    toolResult?: unknown;
     responseId?: string;
     model?: ModelId;
     stopReason?: StopReason;
@@ -939,7 +961,7 @@ type ResponsesRequestOptions = {
     requestId?: string;
     /**
      * Optional customer id header for customer-attributed requests.
-     * When set, the customer's tier determines the model and `model` can be omitted.
+     * When set, the customer's subscription tier determines the model and `model` can be omitted.
      */
     customerId?: string;
     /**
@@ -2135,6 +2157,7 @@ declare class RunsClient {
         metrics?: MetricsCallbacks;
         trace?: TraceCallbacks;
     });
+    private applyCustomerHeader;
     create(spec: WorkflowSpecV0, options?: RunsCreateOptions): Promise<RunsCreateResponse>;
     schemaV0(options?: {
         signal?: AbortSignal;
@@ -2295,6 +2318,33 @@ declare class WorkflowValidationError extends ModelRelayError {
         data?: unknown;
     });
 }
+/**
+ * Error thrown when tool argument parsing or validation fails.
+ * Includes context for the model to retry with corrected arguments.
+ */
+declare class ToolArgumentError extends ModelRelayError {
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly rawArguments: string;
+    constructor(opts: {
+        message: string;
+        toolCallId: string;
+        toolName: string;
+        rawArguments: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Error thrown when a tool call tries to access a path outside the sandbox.
+ */
+declare class PathEscapeError extends ModelRelayError {
+    readonly requestedPath: string;
+    readonly resolvedPath: string;
+    constructor(opts: {
+        requestedPath: string;
+        resolvedPath: string;
+    });
+}
 /**
  * Returns true if the error indicates email is required for auto-provisioning.
  */
@@ -2590,7 +2640,7 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Link an end-user identity to a customer by email
+         * Link a customer identity to a customer by email
          * @description Used when a customer subscribes via Stripe Checkout (email only) and later authenticates to the app.
          *     Links (provider, subject) to the existing customer record found by email.
          */
@@ -2601,6 +2651,84 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/customers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List customers */
+        get: operations["listCustomers"];
+        /** Upsert a customer by external_id */
+        put: operations["upsertCustomer"];
+        /** Create a customer */
+        post: operations["createProjectCustomer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/customers/{customer_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                customer_id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a customer */
+        get: operations["getCustomer"];
+        put?: never;
+        post?: never;
+        /** Delete a customer */
+        delete: operations["deleteProjectCustomer"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/customers/{customer_id}/subscribe": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                customer_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Create a customer subscription checkout session */
+        post: operations["subscribeCustomer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/customers/{customer_id}/subscription": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                customer_id: string;
+            };
+            cookie?: never;
+        };
+        /** Get a customer's subscription */
+        get: operations["getCustomerSubscription"];
+        put?: never;
+        post?: never;
+        /** Cancel a customer's subscription */
+        delete: operations["cancelCustomerSubscription"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/customers/me": {
         parameters: {
             query?: never;
@@ -2611,7 +2739,7 @@ interface paths {
         /**
          * Get the authenticated customer
          * @description Returns the current customer associated with the provided customer-scoped bearer token.
-         *     Includes the customer's tier and allowed models.
+         *     Includes the customer's subscription and tier when available.
          */
         get: operations["getCustomerMe"];
         put?: never;
@@ -2685,26 +2813,6 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/billing/webhooks": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Stripe webhook receiver
-         * @description Accepts subscription lifecycle events from Stripe.
-         */
-        post: operations["handleBillingWebhook"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/projects": {
         parameters: {
             query?: never;
@@ -2816,8 +2924,7 @@ interface paths {
             cookie?: never;
         };
         get?: never;
-        /** Update a customer */
-        put: operations["updateCustomer"];
+        put?: never;
         post?: never;
         /** Delete a customer */
         delete: operations["deleteCustomer"];
@@ -2922,6 +3029,26 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/images/generate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate images from a text prompt
+         * @description Generate images using AI models. Returns URLs by default (requires storage configuration) or base64-encoded data when response_format is 'b64_json'.
+         */
+        post: operations["generateImage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/runs": {
         parameters: {
             query?: never;
@@ -2993,6 +3120,56 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/sessions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List sessions
+         * @description Returns a paginated list of sessions for the project.
+         */
+        get: operations["listSessions"];
+        put?: never;
+        /**
+         * Create a new session
+         * @description Creates a new session for multi-turn conversation management. Sessions persist message history on the server for cross-device continuity.
+         */
+        post: operations["createSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sessions/{session_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get session with messages
+         * @description Returns a session including its full message history.
+         */
+        get: operations["getSession"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a session
+         * @description Deletes a session and all its messages. Requires a secret API key (mr_sk_*).
+         */
+        delete: operations["deleteSession"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 type webhooks = Record<string, never>;
 interface components {
@@ -3106,8 +3283,9 @@ interface components {
              */
             spend_limit_cents?: number;
             models?: components["schemas"]["TierModel"][];
-            /** @description Stripe price ID for this tier */
-            stripe_price_id?: string;
+            billing_provider?: components["schemas"]["BillingProvider"];
+            /** @description Billing provider price reference for this tier */
+            billing_price_ref?: string;
             /**
              * Format: uint64
              * @description Subscription price amount in cents
@@ -3136,6 +3314,7 @@ interface components {
              */
             spend_limit_cents: number;
             models: components["schemas"]["TierModelCreate"][];
+            billing_provider?: components["schemas"]["BillingProvider"];
             /**
              * Format: uint64
              * @description Subscription price amount in cents (paid tiers)
@@ -3158,6 +3337,7 @@ interface components {
              */
             spend_limit_cents: number;
             models?: components["schemas"]["TierModelCreate"][];
+            billing_provider?: components["schemas"]["BillingProvider"];
             /**
              * Format: uint64
              * @description Subscription price amount in cents (paid tiers)
@@ -3170,14 +3350,25 @@ interface components {
              */
             trial_days?: number;
         };
+        /** @description Arbitrary customer metadata (max 10KB). Keys are limited to 40 characters. Values can be any JSON type. Nesting depth limited to 5 levels. */
+        CustomerMetadata: {
+            [key: string]: unknown;
+        };
+        /**
+         * @description Subscription status (active, past_due, canceled, etc.)
+         * @enum {string}
+         */
+        SubscriptionStatusKind: "active" | "trialing" | "past_due" | "canceled" | "unpaid" | "incomplete" | "incomplete_expired" | "paused";
+        /**
+         * @description Billing provider backing the subscription or tier.
+         * @enum {string}
+         */
+        BillingProvider: "stripe" | "crypto" | "app_store" | "external";
         Customer: {
             /** Format: uuid */
             id?: string;
             /** Format: uuid */
             project_id?: string;
-            /** Format: uuid */
-            tier_id?: string;
-            tier_code?: components["schemas"]["TierCode"];
             /** @description External customer identifier from your system */
             external_id?: string;
             /**
@@ -3185,16 +3376,28 @@ interface components {
              * @description Customer email address
              */
             email?: string;
-            /** @description Arbitrary customer metadata (max 10KB). Keys are limited to 40 characters. Values must be JSON scalars, arrays, or objects. Nesting depth limited to 5 levels. */
-            metadata?: {
-                [key: string]: unknown;
-            };
-            /** @description Stripe customer ID */
-            stripe_customer_id?: string;
-            /** @description Stripe subscription ID */
-            stripe_subscription_id?: string;
-            /** @description Subscription status (active, past_due, canceled, etc.) */
-            subscription_status?: string;
+            metadata?: components["schemas"]["CustomerMetadata"];
+            /** Format: date-time */
+            created_at?: string;
+            /** Format: date-time */
+            updated_at?: string;
+        };
+        Subscription: {
+            /** Format: uuid */
+            id?: string;
+            /** Format: uuid */
+            project_id?: string;
+            /** Format: uuid */
+            customer_id?: string;
+            /** Format: uuid */
+            tier_id?: string;
+            tier_code?: components["schemas"]["TierCode"];
+            billing_provider?: components["schemas"]["BillingProvider"];
+            /** @description Billing customer ID from the provider */
+            billing_customer_id?: string;
+            /** @description Billing subscription ID from the provider */
+            billing_subscription_id?: string;
+            subscription_status?: components["schemas"]["SubscriptionStatusKind"];
             /**
              * Format: date-time
              * @description Start of the current billing period
@@ -3210,8 +3413,14 @@ interface components {
             /** Format: date-time */
             updated_at?: string;
         };
-        CustomerMe: components["schemas"]["Customer"] & {
-            tier: components["schemas"]["Tier"];
+        CustomerWithSubscription: {
+            customer: components["schemas"]["Customer"];
+            subscription?: components["schemas"]["Subscription"];
+        };
+        CustomerMe: {
+            customer: components["schemas"]["Customer"];
+            subscription?: components["schemas"]["Subscription"];
+            tier?: components["schemas"]["Tier"];
         };
         CustomerMeResponse: {
             customer: components["schemas"]["CustomerMe"];
@@ -3226,6 +3435,8 @@ interface components {
             requests: number;
             /** Format: int64 */
             tokens: number;
+            /** Format: int64 */
+            images?: number;
             /**
              * Format: int64
              * @description Credits used in this day bucket (only for paid tiers)
@@ -3248,6 +3459,8 @@ interface components {
             requests: number;
             /** Format: int64 */
             tokens: number;
+            /** Format: int64 */
+            images: number;
             /**
              * Format: int64
              * @description Credits granted for this billing window (only for paid tiers)
@@ -3288,11 +3501,7 @@ interface components {
             /** @description Currency code for the price (e.g., 'usd') */
             price_currency?: string;
             price_interval?: components["schemas"]["PriceInterval"];
-            /**
-             * @description Subscription status (omitted when unknown)
-             * @enum {string}
-             */
-            subscription_status?: "active" | "trialing" | "canceled" | "past_due" | "unpaid" | "incomplete";
+            subscription_status?: components["schemas"]["SubscriptionStatusKind"];
             /**
              * Format: date-time
              * @description Start of the current billing period
@@ -3308,19 +3517,14 @@ interface components {
             subscription: components["schemas"]["CustomerMeSubscription"];
         };
         CustomerCreate: {
-            /** Format: uuid */
-            tier_id: string;
             /** @description External customer identifier from your system */
             external_id: string;
             /**
              * Format: email
              * @description Customer email address
              */
-            email?: string;
-            /** @description Arbitrary customer metadata (max 10KB). Keys are limited to 40 characters. Values must be JSON scalars, arrays, or objects. Nesting depth limited to 5 levels. */
-            metadata?: {
-                [key: string]: unknown;
-            };
+            email: string;
+            metadata?: components["schemas"]["CustomerMetadata"];
         };
         /** @enum {string} */
         MessageRole: "system" | "user" | "assistant" | "tool";
@@ -3359,7 +3563,7 @@ interface components {
         };
         Tool: {
             /** @enum {string} */
-            type: "function" | "web" | "x_search" | "code_execution";
+            type: "function" | "web" | "x_search" | "code_execution" | "image_generation";
             function?: {
                 name?: components["schemas"]["ToolName"];
                 description?: string;
@@ -3376,6 +3580,11 @@ interface components {
             code_execution?: {
                 [key: string]: unknown;
             };
+            /** @description Configuration for server-side image generation tool */
+            image_generation?: {
+                /** @description Image generation model ID (e.g., gemini-2.5-flash-image) */
+                model: string;
+            };
         };
         ToolChoice: {
             /** @enum {string} */
@@ -3559,7 +3768,7 @@ interface components {
         ToolCall: {
             id: components["schemas"]["ToolCallId"];
             /** @enum {string} */
-            type: "function" | "web" | "x_search" | "code_execution";
+            type: "function" | "web" | "x_search" | "code_execution" | "image_generation";
             function?: {
                 name?: components["schemas"]["ToolName"];
                 /** @description JSON string of function arguments */
@@ -3597,6 +3806,15 @@ interface components {
             customer_external_id: string;
             tier_code: components["schemas"]["TierCode"];
         };
+        CheckoutSessionResponse: {
+            /** @description Stripe checkout session ID */
+            session_id: string;
+            /**
+             * Format: uri
+             * @description Checkout URL
+             */
+            url: string;
+        };
         DeviceStartResponse: {
             /** @description Device code used for polling /auth/device/token */
             device_code: string;
@@ -3639,8 +3857,7 @@ interface components {
             active: boolean;
             /** @description Stripe subscription ID */
             subscription_id?: string;
-            /** @description Subscription status (active, past_due, canceled, etc.) */
-            status?: string;
+            status?: components["schemas"]["SubscriptionStatusKind"];
             /**
              * Format: date-time
              * @description Start of the current billing period
@@ -3844,59 +4061,190 @@ interface components {
         NodeTypeV0: "llm.responses" | "join.all" | "transform.json";
         /** @description Tier code identifier (e.g., free, pro, enterprise). */
         TierCode: string;
-    };
-    responses: never;
-    parameters: {
-        ProjectID: string;
-        WebhookID: string;
-    };
-    requestBodies: never;
-    headers: never;
-    pathItems: never;
-}
-type $defs = Record<string, never>;
-interface operations {
-    getWorkflowV0Schema: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
+        /** @description Request to generate images from a text prompt. */
+        ImageRequest: {
+            /** @description Image generation model ID (e.g., gemini-2.5-flash-image). Optional when using a customer token with a tier that defines a default model. */
+            model?: string;
+            /** @description Text description of the image to generate */
+            prompt: string;
+            response_format?: components["schemas"]["ImageResponseFormat"];
         };
-        requestBody?: never;
-        responses: {
-            /** @description Schema document */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/schema+json": Record<string, never>;
-                };
-            };
+        /**
+         * @description Output format for generated images.
+         * @default url
+         * @enum {string}
+         */
+        ImageResponseFormat: "url" | "b64_json";
+        /** @description Response containing generated images. */
+        ImageResponse: {
+            /** @description Unique identifier for this generation request */
+            id: string;
+            /** @description Model used for generation */
+            model: string;
+            /** @description Generated images */
+            data: components["schemas"]["ImageData"][];
+            usage: components["schemas"]["ImageUsage"];
+        };
+        /** @description A single generated image. */
+        ImageData: {
+            /** @description URL of the generated image (when response_format is 'url') */
+            url?: string;
+            /** @description Base64-encoded image data (when response_format is 'b64_json') */
+            b64_json?: string;
+            /** @description MIME type of the image (e.g., 'image/png', 'image/webp') */
+            mime_type?: string;
         };
-    };
-    getRunEventV0Schema: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
+        /** @description Usage statistics for image generation. */
+        ImageUsage: {
+            /**
+             * Format: int32
+             * @description Number of images generated
+             */
+            images: number;
         };
-        requestBody?: never;
-        responses: {
-            /** @description Schema document */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/schema+json": Record<string, never>;
-                };
+        /** @description Request body for creating a session. */
+        SessionCreateRequest: {
+            /**
+             * Format: uuid
+             * @description Optional end user ID to associate with the session
+             */
+            end_user_id?: string;
+            /** @description Optional metadata for the session */
+            metadata?: {
+                [key: string]: unknown;
             };
         };
-    };
-    registerOwner: {
+        /** @description A session resource. */
+        SessionResponse: {
+            /**
+             * Format: uuid
+             * @description Session unique identifier
+             */
+            id: string;
+            /**
+             * Format: uuid
+             * @description Project the session belongs to
+             */
+            project_id: string;
+            /**
+             * Format: uuid
+             * @description End user associated with the session (if any)
+             */
+            end_user_id?: string;
+            /** @description Session metadata */
+            metadata: {
+                [key: string]: unknown;
+            };
+            /**
+             * Format: int64
+             * @description Number of messages in the session
+             */
+            message_count: number;
+            /**
+             * Format: date-time
+             * @description Session creation timestamp
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description Session last update timestamp
+             */
+            updated_at: string;
+        };
+        /** @description A message within a session. */
+        SessionMessageResponse: {
+            /**
+             * Format: uuid
+             * @description Message unique identifier
+             */
+            id: string;
+            /**
+             * Format: int32
+             * @description Sequence number within the session
+             */
+            seq: number;
+            /** @description Message role (user, assistant, tool) */
+            role: string;
+            /** @description Message content parts */
+            content: {
+                [key: string]: unknown;
+            }[];
+            /**
+             * Format: uuid
+             * @description Run ID that generated this message (for assistant messages)
+             */
+            run_id?: string;
+            /**
+             * Format: date-time
+             * @description Message creation timestamp
+             */
+            created_at: string;
+        };
+        /** @description A session with its full message history. */
+        SessionWithMessagesResponse: components["schemas"]["SessionResponse"] & {
+            /** @description All messages in the session */
+            messages: components["schemas"]["SessionMessageResponse"][];
+        };
+        /** @description Paginated list of sessions. */
+        SessionListResponse: {
+            /** @description List of sessions */
+            sessions: components["schemas"]["SessionResponse"][];
+            /** @description Cursor for fetching the next page (if more results exist) */
+            next_cursor?: string;
+        };
+    };
+    responses: never;
+    parameters: {
+        ProjectID: string;
+        WebhookID: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+type $defs = Record<string, never>;
+interface operations {
+    getWorkflowV0Schema: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Schema document */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/schema+json": Record<string, never>;
+                };
+            };
+        };
+    };
+    getRunEventV0Schema: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Schema document */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/schema+json": Record<string, never>;
+                };
+            };
+        };
+    };
+    registerOwner: {
         parameters: {
             query?: never;
             header?: never;
@@ -4034,11 +4382,6 @@ interface operations {
         requestBody: {
             content: {
                 "application/json": {
-                    /**
-                     * Format: uuid
-                     * @description Project ID the customer belongs to
-                     */
-                    project_id: string;
                     /**
                      * Format: uuid
                      * @description Internal customer UUID (provide exactly one of customer_id or customer_external_id)
@@ -4256,11 +4599,7 @@ interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": {
-                        customer?: components["schemas"]["Customer"];
-                    };
-                };
+                content?: never;
             };
             /** @description Customer not found */
             404: {
@@ -4278,7 +4617,7 @@ interface operations {
             };
         };
     };
-    getCustomerMe: {
+    listCustomers: {
         parameters: {
             query?: never;
             header?: never;
@@ -4287,113 +4626,133 @@ interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Customer details */
+            /** @description Customer list */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["CustomerMeResponse"];
-                };
-            };
-            /** @description Unauthorized */
-            401: {
-                headers: {
-                    [name: string]: unknown;
+                    "application/json": {
+                        customers?: components["schemas"]["CustomerWithSubscription"][];
+                    };
                 };
-                content?: never;
             };
         };
     };
-    getCustomerMeUsage: {
+    upsertCustomer: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CustomerCreate"];
+            };
+        };
         responses: {
-            /** @description Usage summary */
+            /** @description Customer updated */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["CustomerMeUsageResponse"];
+                    "application/json": {
+                        customer?: components["schemas"]["CustomerWithSubscription"];
+                    };
                 };
             };
-            /** @description Unauthorized */
-            401: {
+            /** @description Customer created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
-            };
-            /** @description Customer not found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
+                content: {
+                    "application/json": {
+                        customer?: components["schemas"]["CustomerWithSubscription"];
+                    };
                 };
-                content?: never;
             };
-            /** @description Failed to calculate usage */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
+        };
+    };
+    createProjectCustomer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CustomerCreate"];
             };
-            /** @description Service unavailable */
-            503: {
+        };
+        responses: {
+            /** @description Customer created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": {
+                        customer?: components["schemas"]["CustomerWithSubscription"];
+                    };
+                };
             };
         };
     };
-    getCustomerMeSubscription: {
+    getCustomer: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                customer_id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Subscription details */
+            /** @description Customer */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["CustomerMeSubscriptionResponse"];
-                };
-            };
-            /** @description Unauthorized */
-            401: {
-                headers: {
-                    [name: string]: unknown;
+                    "application/json": {
+                        customer?: components["schemas"]["CustomerWithSubscription"];
+                    };
                 };
-                content?: never;
             };
-            /** @description Customer or tier not found */
+            /** @description Customer not found */
             404: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Internal server error */
-            500: {
+        };
+    };
+    deleteProjectCustomer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                customer_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Customer deleted */
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Service unavailable */
-            503: {
+            /** @description Customer not found */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -4401,42 +4760,63 @@ interface operations {
             };
         };
     };
-    listModels: {
+    subscribeCustomer: {
         parameters: {
-            query?: {
-                /** @description Filter results to a specific provider */
-                provider?: components["schemas"]["ProviderId"];
-                /** @description Filter results to models that support a capability */
-                capability?: components["schemas"]["ModelCapability"];
-            };
+            query?: never;
             header?: never;
-            path?: never;
+            path: {
+                customer_id: string;
+            };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** Format: uuid */
+                    tier_id: string;
+                    /** Format: uri */
+                    success_url: string;
+                    /** Format: uri */
+                    cancel_url: string;
+                };
+            };
+        };
         responses: {
-            /** @description Models list */
-            200: {
+            /** @description Checkout session created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ModelsResponse"];
+                    "application/json": components["schemas"]["CheckoutSessionResponse"];
                 };
             };
         };
     };
-    handleBillingWebhook: {
+    getCustomerSubscription: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                customer_id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Event accepted */
-            202: {
+            /** @description Subscription details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        subscription?: components["schemas"]["Subscription"];
+                    };
+                };
+            };
+            /** @description Subscription not found */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -4444,17 +4824,185 @@ interface operations {
             };
         };
     };
-    listProjects: {
+    cancelCustomerSubscription: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                customer_id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Project list */
-            200: {
+            /** @description Subscription canceled */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getCustomerMe: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Customer details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerMeResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getCustomerMeUsage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Usage summary */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerMeUsageResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Customer not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Failed to calculate usage */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getCustomerMeSubscription: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Subscription details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CustomerMeSubscriptionResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Customer or tier not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listModels: {
+        parameters: {
+            query?: {
+                /** @description Filter results to a specific provider */
+                provider?: components["schemas"]["ProviderId"];
+                /** @description Filter results to models that support a capability */
+                capability?: components["schemas"]["ModelCapability"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Models list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ModelsResponse"];
+                };
+            };
+        };
+    };
+    listProjects: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Project list */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -4694,7 +5242,7 @@ interface operations {
                 };
                 content: {
                     "application/json": {
-                        customers?: components["schemas"]["Customer"][];
+                        customers?: components["schemas"]["CustomerWithSubscription"][];
                     };
                 };
             };
@@ -4722,37 +5270,12 @@ interface operations {
                 };
                 content: {
                     "application/json": {
-                        customer?: components["schemas"]["Customer"];
+                        customer?: components["schemas"]["CustomerWithSubscription"];
                     };
                 };
             };
         };
     };
-    updateCustomer: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                id: components["parameters"]["ProjectID"];
-                customer_id: string;
-            };
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["CustomerCreate"];
-            };
-        };
-        responses: {
-            /** @description Customer updated */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-        };
-    };
     deleteCustomer: {
         parameters: {
             query?: never;
@@ -4976,6 +5499,30 @@ interface operations {
             };
         };
     };
+    generateImage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ImageRequest"];
+            };
+        };
+        responses: {
+            /** @description Generated images */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageResponse"];
+                };
+            };
+        };
+    };
     createRun: {
         parameters: {
             query?: never;
@@ -5068,62 +5615,210 @@ interface operations {
             };
         };
     };
-}
-
-/**
- * Customer metadata as an arbitrary key-value object.
- */
-type CustomerMetadata = Record<string, unknown>;
-/**
- * Customer represents a customer in a ModelRelay project.
- */
-interface Customer {
-    id: string;
-    project_id: string;
-    tier_id: string;
-    tier_code?: TierCode;
-    external_id: string;
-    email: string;
-    metadata?: CustomerMetadata;
-    stripe_customer_id?: string;
-    stripe_subscription_id?: string;
-    subscription_status?: string;
-    current_period_start?: string;
-    current_period_end?: string;
-    created_at: string;
-    updated_at: string;
-}
-/**
- * Request to create a customer.
- */
-interface CustomerCreateRequest {
-    tier_id: string;
-    external_id: string;
-    email: string;
-    metadata?: CustomerMetadata;
-}
-/**
- * Request to upsert a customer by external_id.
- */
-interface CustomerUpsertRequest {
-    tier_id: string;
-    external_id: string;
-    email: string;
-    metadata?: CustomerMetadata;
-}
-/**
- * Request to link an end-user identity to a customer by email.
- * Used when a customer subscribes via Stripe Checkout (email only) and later authenticates to the app.
- */
-interface CustomerClaimRequest {
-    email: string;
-    provider: string;
+    listSessions: {
+        parameters: {
+            query?: {
+                /** @description Maximum number of sessions to return */
+                limit?: number;
+                /** @description Number of sessions to skip */
+                offset?: number;
+                /** @description Filter sessions by end user ID */
+                end_user_id?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Session list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionListResponse"];
+                };
+            };
+            /** @description API key required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    createSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SessionCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Session created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionResponse"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description API key required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Session with messages */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionWithMessagesResponse"];
+                };
+            };
+            /** @description Session not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    deleteSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Session deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Secret key required for deletion */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Session not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+}
+
+/**
+ * Customer represents a customer in a ModelRelay project.
+ */
+interface Customer {
+    id: string;
+    project_id: string;
+    external_id: string;
+    email: string;
+    metadata?: CustomerMetadata;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Subscription represents billing state for a customer.
+ */
+interface Subscription {
+    id: string;
+    project_id: string;
+    customer_id: string;
+    tier_id: string;
+    tier_code?: TierCode;
+    billing_provider?: BillingProvider;
+    billing_customer_id?: string;
+    billing_subscription_id?: string;
+    subscription_status?: SubscriptionStatusKind;
+    current_period_start?: string;
+    current_period_end?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * CustomerWithSubscription bundles customer identity with optional subscription state.
+ */
+interface CustomerWithSubscription {
+    customer: Customer;
+    subscription?: Subscription;
+}
+/**
+ * Request to create a customer.
+ */
+interface CustomerCreateRequest {
+    external_id: string;
+    email: string;
+    metadata?: CustomerMetadata;
+}
+/**
+ * Request to upsert a customer by external_id.
+ */
+interface CustomerUpsertRequest {
+    external_id: string;
+    email: string;
+    metadata?: CustomerMetadata;
+}
+/**
+ * Request to link a customer identity to a customer by email.
+ * Used when a customer subscribes via Stripe Checkout (email only) and later authenticates to the app.
+ */
+interface CustomerClaimRequest {
+    email: string;
+    provider: string;
     subject: string;
 }
 /**
- * Request to create a checkout session.
+ * Request to create a checkout session for a customer subscription.
  */
-interface CheckoutSessionRequest {
+interface CustomerSubscribeRequest {
+    tier_id: string;
     success_url: string;
     cancel_url: string;
 }
@@ -5134,16 +5829,6 @@ interface CheckoutSession {
     session_id: string;
     url: string;
 }
-/**
- * Subscription status response.
- */
-interface SubscriptionStatus {
-    active: boolean;
-    subscription_id?: string;
-    status?: string;
-    current_period_start?: string;
-    current_period_end?: string;
-}
 interface CustomersClientConfig {
     apiKey?: ApiKey;
     accessToken?: string;
@@ -5184,23 +5869,23 @@ declare class CustomersClient {
     /**
      * List all customers in the project.
      */
-    list(): Promise<Customer[]>;
+    list(): Promise<CustomerWithSubscription[]>;
     /**
      * Create a new customer in the project.
      */
-    create(request: CustomerCreateRequest): Promise<Customer>;
+    create(request: CustomerCreateRequest): Promise<CustomerWithSubscription>;
     /**
      * Get a customer by ID.
      */
-    get(customerId: string): Promise<Customer>;
+    get(customerId: string): Promise<CustomerWithSubscription>;
     /**
      * Upsert a customer by external_id.
      * If a customer with the given external_id exists, it is updated.
      * Otherwise, a new customer is created.
      */
-    upsert(request: CustomerUpsertRequest): Promise<Customer>;
+    upsert(request: CustomerUpsertRequest): Promise<CustomerWithSubscription>;
     /**
-     * Link an end-user identity (provider + subject) to a customer found by email.
+     * Link a customer identity (provider + subject) to a customer found by email.
      * Used when a customer subscribes via Stripe Checkout (email only) and later authenticates to the app.
      *
      * This is a user self-service operation that works with publishable keys,
@@ -5211,19 +5896,23 @@ declare class CustomersClient {
      * @throws {APIError} with status 404 if customer not found by email
      * @throws {APIError} with status 409 if the identity is already linked to a different customer
      */
-    claim(request: CustomerClaimRequest): Promise<Customer>;
+    claim(request: CustomerClaimRequest): Promise<void>;
     /**
      * Delete a customer by ID.
      */
     delete(customerId: string): Promise<void>;
     /**
-     * Create a Stripe checkout session for a customer.
+     * Create a Stripe checkout session for a customer subscription.
+     */
+    subscribe(customerId: string, request: CustomerSubscribeRequest): Promise<CheckoutSession>;
+    /**
+     * Get the subscription details for a customer.
      */
-    createCheckoutSession(customerId: string, request: CheckoutSessionRequest): Promise<CheckoutSession>;
+    getSubscription(customerId: string): Promise<Subscription>;
     /**
-     * Get the subscription status for a customer.
+     * Cancel a customer's subscription at period end.
      */
-    getSubscription(customerId: string): Promise<SubscriptionStatus>;
+    unsubscribe(customerId: string): Promise<void>;
 }
 
 /**
@@ -5259,7 +5948,8 @@ interface Tier {
     display_name: string;
     spend_limit_cents: number;
     models: TierModel[];
-    stripe_price_id?: string;
+    billing_provider?: components["schemas"]["BillingProvider"];
+    billing_price_ref?: string;
     price_amount_cents?: number;
     price_currency?: string;
     price_interval?: PriceInterval;
@@ -5268,7 +5958,7 @@ interface Tier {
     updated_at: string;
 }
 /**
- * Request to create a tier checkout session (Stripe-first flow).
+ * Request to create a tier checkout session (checkout-first flow).
  * Stripe collects the customer's email during checkout.
  */
 interface TierCheckoutRequest {
@@ -5297,50 +5987,707 @@ declare class TiersClient {
     private ensureApiKey;
     private ensureSecretKey;
     /**
-     * List all tiers in the project.
+     * List all tiers in the project.
+     */
+    list(): Promise<Tier[]>;
+    /**
+     * Get a tier by ID.
+     */
+    get(tierId: string): Promise<Tier>;
+    /**
+     * Create a Stripe checkout session for a tier (Stripe-first flow).
+     *
+     * This enables users to subscribe before authenticating. Stripe collects
+     * the customer's email during checkout. After checkout completes, a
+     * customer record is created with the email from Stripe. The customer
+     * can later be linked to an identity via POST /customers/claim.
+     *
+     * Requires a secret key (mr_sk_*).
+     *
+     * @param tierId - The tier ID to create a checkout session for
+     * @param request - Checkout session request with redirect URLs
+     * @returns Checkout session with Stripe URL
+     */
+    checkout(tierId: string, request: TierCheckoutRequest): Promise<TierCheckoutSession>;
+}
+
+type ModelCapability = components["schemas"]["ModelCapability"];
+type ProviderId = components["schemas"]["ProviderId"];
+type CatalogModel = components["schemas"]["Model"];
+interface ModelsListParams {
+    provider?: ProviderId;
+    capability?: ModelCapability;
+}
+/**
+ * ModelsClient provides methods to list models and their rich metadata.
+ *
+ * Note: The underlying API endpoint is public (no auth required), but the SDK's
+ * HTTP client may still send auth headers if configured.
+ */
+declare class ModelsClient {
+    private readonly http;
+    constructor(http: HTTPClient);
+    /**
+     * List active models with rich metadata.
+     */
+    list(params?: ModelsListParams): Promise<CatalogModel[]>;
+}
+
+/**
+ * Request to generate images from a text prompt.
+ */
+type ImageRequest = components["schemas"]["ImageRequest"];
+/**
+ * Response containing generated images.
+ */
+type ImageResponse = components["schemas"]["ImageResponse"];
+/**
+ * A single generated image.
+ */
+type ImageData = components["schemas"]["ImageData"];
+/**
+ * Usage statistics for image generation.
+ */
+type ImageUsage = components["schemas"]["ImageUsage"];
+/**
+ * Output format for generated images.
+ * - "url" (default): Returns hosted URLs, requires storage configuration
+ * - "b64_json": Returns base64-encoded data, for testing/development
+ */
+type ImageResponseFormat = components["schemas"]["ImageResponseFormat"];
+/**
+ * ImagesClient provides methods for generating images using AI models.
+ *
+ * @example
+ * ```typescript
+ * // Production use (default) - returns URLs
+ * const response = await client.images.generate({
+ *   model: "gemini-2.5-flash-image",
+ *   prompt: "A futuristic cityscape",
+ * });
+ * console.log(response.data[0].url);
+ * console.log(response.data[0].mime_type);
+ *
+ * // Testing/development - returns base64
+ * const testResponse = await client.images.generate({
+ *   model: "gemini-2.5-flash-image",
+ *   prompt: "A futuristic cityscape",
+ *   response_format: "b64_json"
+ * });
+ * ```
+ */
+declare class ImagesClient {
+    private readonly http;
+    private readonly auth;
+    constructor(http: HTTPClient, auth: AuthClient);
+    /**
+     * Generate images from a text prompt.
+     *
+     * By default, returns URLs (requires storage configuration).
+     * Use response_format: "b64_json" for testing without storage.
+     *
+     * @param request - Image generation request (model optional if tier defines default)
+     * @returns Generated images with URLs or base64 data
+     * @throws {Error} If prompt is empty
+     */
+    generate(request: ImageRequest): Promise<ImageResponse>;
+}
+
+/**
+ * Session types for multi-turn conversations.
+ *
+ * Sessions provide stateful multi-turn conversation management with two modes:
+ * - LocalSession: Client-managed history with optional persistence (memory, file, SQLite)
+ * - RemoteSession: Server-managed persistence with cross-device continuity
+ *
+ * Both implement the common Session interface for seamless switching.
+ *
+ * @module
+ */
+
+declare const sessionIdBrand: unique symbol;
+/**
+ * Branded type for session identifiers.
+ * Prevents accidental use of arbitrary strings where a session ID is expected.
+ */
+type SessionId = string & {
+    readonly [sessionIdBrand]: true;
+};
+/**
+ * Cast a string to a SessionId.
+ */
+declare function asSessionId(value: string): SessionId;
+/**
+ * Generate a new session ID (UUID v4).
+ */
+declare function generateSessionId(): SessionId;
+/**
+ * A message in the session history.
+ * Extends InputItem with session-specific metadata.
+ */
+interface SessionMessage extends InputItem {
+    /** Sequence number within the session (1-based). */
+    readonly seq: number;
+    /** When this message was added to the session. */
+    readonly createdAt: Date;
+    /** The run ID that produced this message (for assistant messages). */
+    readonly runId?: RunId;
+}
+/**
+ * Artifacts produced during a session (files, code, etc.).
+ */
+type SessionArtifacts = Map<string, unknown>;
+/**
+ * Options for a session run.
+ */
+interface SessionRunOptions {
+    /** Override the model for this run. */
+    model?: ModelId;
+    /** Override the provider for this run. */
+    provider?: ProviderId$1;
+    /** Additional tools for this run (merged with session defaults). */
+    tools?: Tool[];
+    /** Maximum number of LLM turns (for tool loops). */
+    maxTurns?: number;
+    /** Customer ID for attributed requests. */
+    customerId?: string;
+    /** Abort signal for cancellation. */
+    signal?: AbortSignal;
+}
+/**
+ * Status of a session run.
+ */
+type SessionRunStatus = "complete" | "waiting_for_tools" | "error" | "canceled";
+/**
+ * Pending tool call that needs client-side execution.
+ */
+interface SessionPendingToolCall {
+    readonly toolCallId: string;
+    readonly name: string;
+    readonly arguments: string;
+}
+/**
+ * Usage summary for a session run.
+ */
+interface SessionUsageSummary {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly totalTokens: number;
+    readonly llmCalls: number;
+    readonly toolCalls: number;
+}
+/**
+ * Result of a session run.
+ */
+interface SessionRunResult {
+    /** Run status. */
+    readonly status: SessionRunStatus;
+    /** Final text output (for complete runs). */
+    readonly output?: string;
+    /** Pending tool calls (when status is 'waiting_for_tools'). */
+    readonly pendingTools?: SessionPendingToolCall[];
+    /** Error message (when status is 'error'). */
+    readonly error?: string;
+    /** The run ID from the server. */
+    readonly runId: RunId;
+    /** Token and call usage. */
+    readonly usage: SessionUsageSummary;
+    /** All events from this run. */
+    readonly events: RunEventV0[];
+}
+/**
+ * Session type discriminator.
+ */
+type SessionType = "local" | "remote";
+/**
+ * Common interface for all session types.
+ *
+ * Sessions manage multi-turn conversation state, executing runs with
+ * accumulated context and optionally persisting history.
+ */
+interface Session {
+    /** Unique session identifier. */
+    readonly id: SessionId;
+    /** Session type: 'local' (client-managed) or 'remote' (server-managed). */
+    readonly type: SessionType;
+    /** Full conversation history (read-only). */
+    readonly history: readonly SessionMessage[];
+    /**
+     * Execute a prompt as a new turn in this session.
+     *
+     * The prompt is added to history, a run is created with the full context,
+     * and the response is appended to history. Tool calls are automatically
+     * handled via the session's ToolRegistry.
+     *
+     * @param prompt - The user's input for this turn
+     * @param options - Optional run configuration
+     * @returns The run result with status, output, and usage
+     */
+    run(prompt: string, options?: SessionRunOptions): Promise<SessionRunResult>;
+    /**
+     * Submit tool results for a waiting run.
+     *
+     * Called when a previous run returned status 'waiting_for_tools'.
+     * The results are submitted to continue the run.
+     *
+     * @param results - Tool execution results
+     * @returns Updated run result
+     */
+    submitToolResults(results: ToolExecutionResult[]): Promise<SessionRunResult>;
+    /**
+     * Get all artifacts produced during this session.
+     */
+    getArtifacts(): SessionArtifacts;
+    /**
+     * Close the session and release resources.
+     *
+     * For LocalSession with persistence, this flushes pending writes.
+     * For RemoteSession, this is a no-op (server manages lifecycle).
+     */
+    close(): Promise<void>;
+}
+/**
+ * Persistence mode for local sessions.
+ */
+type LocalSessionPersistence = "memory" | "file" | "sqlite";
+/**
+ * Options for creating a local session.
+ */
+interface LocalSessionOptions {
+    /** Tool registry for handling tool calls. */
+    toolRegistry?: ToolRegistry;
+    /** Default model for runs (can be overridden per-run). */
+    defaultModel?: ModelId;
+    /** Default provider for runs (can be overridden per-run). */
+    defaultProvider?: ProviderId$1;
+    /** Default tools for runs (merged with per-run tools). */
+    defaultTools?: Tool[];
+    /** Persistence mode (default: 'memory'). */
+    persistence?: LocalSessionPersistence;
+    /** Storage path for file/sqlite persistence (default: ~/.modelrelay/sessions/). */
+    storagePath?: string;
+    /** Session ID to use (default: generate new). */
+    sessionId?: SessionId;
+    /** Session metadata. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for creating a remote session.
+ */
+interface RemoteSessionOptions {
+    /** Tool registry for handling client-side tool calls. */
+    toolRegistry?: ToolRegistry;
+    /** Default model for runs (can be overridden per-run). */
+    defaultModel?: ModelId;
+    /** Default provider for runs (can be overridden per-run). */
+    defaultProvider?: ProviderId$1;
+    /** Default tools for runs (merged with per-run tools). */
+    defaultTools?: Tool[];
+    /** Session metadata (stored on server). */
+    metadata?: Record<string, unknown>;
+    /** End user ID to associate with the session. */
+    endUserId?: string;
+}
+/**
+ * Options for listing remote sessions.
+ */
+interface ListSessionsOptions {
+    /** Maximum number of sessions to return. */
+    limit?: number;
+    /** Cursor for pagination. */
+    cursor?: string;
+    /** End user ID to filter by. */
+    endUserId?: string;
+}
+/**
+ * Response from listing sessions.
+ */
+interface ListSessionsResponse {
+    sessions: RemoteSessionInfo[];
+    nextCursor?: string;
+}
+/**
+ * Summary info for a remote session (from list).
+ */
+interface RemoteSessionInfo {
+    readonly id: SessionId;
+    readonly messageCount: number;
+    readonly metadata: Record<string, unknown>;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}
+/**
+ * Serialized session state for persistence.
+ */
+interface SessionState {
+    id: SessionId;
+    messages: SessionMessage[];
+    artifacts: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Interface for session storage backends.
+ */
+interface SessionStore {
+    /** Load a session by ID. Returns null if not found. */
+    load(id: SessionId): Promise<SessionState | null>;
+    /** Save a session state. */
+    save(state: SessionState): Promise<void>;
+    /** Delete a session by ID. */
+    delete(id: SessionId): Promise<void>;
+    /** List all session IDs. */
+    list(): Promise<SessionId[]>;
+    /** Close the store and release resources. */
+    close(): Promise<void>;
+}
+
+/**
+ * Client-managed session implementation.
+ *
+ * LocalSession keeps conversation history on the client side with optional
+ * persistence to memory, file, or SQLite. Use for:
+ * - Local AI coding agents (Claude Code, Cursor)
+ * - Privacy-sensitive workflows (history never leaves device)
+ * - Offline-capable agents
+ *
+ * @module
+ */
+
+/**
+ * Client-managed session with optional persistence.
+ *
+ * @example
+ * ```typescript
+ * import { ModelRelay, LocalSession } from "modelrelay";
+ *
+ * const client = ModelRelay.fromSecretKey(process.env.MODELRELAY_SECRET_KEY!);
+ * const session = LocalSession.create(client, {
+ *   toolRegistry: createLocalFSTools({ root: process.cwd() }),
+ *   persistence: "sqlite",
+ * });
+ *
+ * const result1 = await session.run("Create a file called hello.txt with 'Hello World'");
+ * const result2 = await session.run("Now read that file back to me");
+ * ```
+ */
+declare class LocalSession implements Session {
+    readonly type: "local";
+    readonly id: SessionId;
+    private readonly client;
+    private readonly store;
+    private readonly toolRegistry?;
+    private readonly defaultModel?;
+    private readonly defaultProvider?;
+    private readonly defaultTools?;
+    private readonly metadata;
+    private messages;
+    private artifacts;
+    private nextSeq;
+    private createdAt;
+    private updatedAt;
+    private currentRunId?;
+    private currentNodeId?;
+    private currentWaiting?;
+    private currentEvents;
+    private currentUsage;
+    private constructor();
+    /**
+     * Create a new local session.
+     *
+     * @param client - ModelRelay client
+     * @param options - Session configuration
+     * @returns A new LocalSession instance
+     */
+    static create(client: ModelRelay, options?: LocalSessionOptions): LocalSession;
+    /**
+     * Resume an existing session from storage.
+     *
+     * @param client - ModelRelay client
+     * @param sessionId - ID of the session to resume
+     * @param options - Session configuration (must match original persistence settings)
+     * @returns The resumed LocalSession, or null if not found
+     */
+    static resume(client: ModelRelay, sessionId: string | SessionId, options?: LocalSessionOptions): Promise<LocalSession | null>;
+    get history(): readonly SessionMessage[];
+    run(prompt: string, options?: SessionRunOptions): Promise<SessionRunResult>;
+    submitToolResults(results: ToolExecutionResult[]): Promise<SessionRunResult>;
+    getArtifacts(): SessionArtifacts;
+    close(): Promise<void>;
+    private addMessage;
+    private buildInput;
+    private processRunEvents;
+    private executeTools;
+    private persist;
+}
+/**
+ * Create a new local session.
+ * Convenience function for LocalSession.create().
+ */
+declare function createLocalSession(client: ModelRelay, options?: LocalSessionOptions): LocalSession;
+
+/**
+ * Server-managed session implementation.
+ *
+ * RemoteSession stores conversation history on the server for:
+ * - Cross-device continuity (start on CLI, continue in browser)
+ * - Team collaboration and session sharing
+ * - Persistent audit trails
+ *
+ * @module
+ */
+
+/**
+ * Server-managed session with cross-device continuity.
+ *
+ * @example
+ * ```typescript
+ * import { ModelRelay, RemoteSession } from "modelrelay";
+ *
+ * const client = ModelRelay.fromSecretKey(process.env.MODELRELAY_SECRET_KEY!);
+ *
+ * // Create a new remote session
+ * const session = await RemoteSession.create(client, {
+ *   metadata: { name: "Feature implementation" },
+ * });
+ *
+ * // Run prompts with server-managed history
+ * const result1 = await session.run("Explain the codebase structure");
+ * const result2 = await session.run("Now implement the login feature");
+ *
+ * // Later, from another device:
+ * const resumed = await RemoteSession.get(client, session.id);
+ * const result3 = await resumed.run("Continue with the tests");
+ * ```
+ */
+declare class RemoteSession implements Session {
+    readonly type: "remote";
+    readonly id: SessionId;
+    private readonly client;
+    private readonly http;
+    private readonly toolRegistry?;
+    private readonly defaultModel?;
+    private readonly defaultProvider?;
+    private readonly defaultTools?;
+    private metadata;
+    private endUserId?;
+    private messages;
+    private artifacts;
+    private nextSeq;
+    private createdAt;
+    private updatedAt;
+    private currentRunId?;
+    private currentNodeId?;
+    private currentWaiting?;
+    private currentEvents;
+    private currentUsage;
+    private constructor();
+    /**
+     * Create a new remote session on the server.
+     *
+     * @param client - ModelRelay client
+     * @param options - Session configuration
+     * @returns A new RemoteSession instance
+     */
+    static create(client: ModelRelay, options?: RemoteSessionOptions): Promise<RemoteSession>;
+    /**
+     * Get an existing remote session by ID.
+     *
+     * @param client - ModelRelay client
+     * @param sessionId - ID of the session to retrieve
+     * @param options - Optional configuration (toolRegistry, defaults)
+     * @returns The RemoteSession instance
+     */
+    static get(client: ModelRelay, sessionId: string | SessionId, options?: RemoteSessionOptions): Promise<RemoteSession>;
+    /**
+     * List remote sessions.
+     *
+     * @param client - ModelRelay client
+     * @param options - List options
+     * @returns Paginated list of session info
+     */
+    static list(client: ModelRelay, options?: {
+        limit?: number;
+        offset?: number;
+        endUserId?: string;
+    }): Promise<{
+        sessions: RemoteSessionInfo[];
+        nextCursor?: string;
+    }>;
+    /**
+     * Delete a remote session.
+     *
+     * @param client - ModelRelay client
+     * @param sessionId - ID of the session to delete
+     */
+    static delete(client: ModelRelay, sessionId: string | SessionId): Promise<void>;
+    /**
+     * Full conversation history (read-only).
+     */
+    get history(): readonly SessionMessage[];
+    /**
+     * Execute a prompt as a new turn in this session.
+     */
+    run(prompt: string, options?: SessionRunOptions): Promise<SessionRunResult>;
+    /**
+     * Submit tool results for a waiting run.
+     */
+    submitToolResults(results: ToolExecutionResult[]): Promise<SessionRunResult>;
+    /**
+     * Get all artifacts produced during this session.
+     */
+    getArtifacts(): SessionArtifacts;
+    /**
+     * Close the session (no-op for remote sessions).
+     */
+    close(): Promise<void>;
+    /**
+     * Refresh the session state from the server.
+     */
+    refresh(): Promise<void>;
+    private addMessage;
+    private buildInput;
+    private resetRunState;
+    private processRunEvents;
+    private executeToolsLocally;
+}
+
+/**
+ * SessionsClient - Entry point for session management.
+ *
+ * Provides factory methods for creating local and remote sessions.
+ *
+ * @module
+ */
+
+/**
+ * Client for managing sessions.
+ *
+ * Provides access to both local (client-managed) and remote (server-managed) sessions.
+ *
+ * @example
+ * ```typescript
+ * import { ModelRelay } from "modelrelay";
+ *
+ * const client = ModelRelay.fromSecretKey(process.env.MODELRELAY_SECRET_KEY!);
+ *
+ * // Local session (history stays on device)
+ * const localSession = client.sessions.createLocal({
+ *   toolRegistry: createLocalFSTools({ root: process.cwd() }),
+ *   persistence: "sqlite",
+ * });
+ *
+ * // Remote session (history stored on server) - coming soon
+ * // const remoteSession = await client.sessions.create({ metadata: { name: "My Session" } });
+ * ```
+ */
+declare class SessionsClient {
+    private readonly modelRelay;
+    private readonly http;
+    private readonly auth;
+    constructor(modelRelay: ModelRelay, http: HTTPClient, auth: AuthClient);
+    /**
+     * Create a new local session.
+     *
+     * Local sessions keep history on the client side with optional persistence.
+     * Use for privacy-sensitive workflows or offline-capable agents.
+     *
+     * @param options - Session configuration
+     * @returns A new LocalSession instance
+     *
+     * @example
+     * ```typescript
+     * const session = client.sessions.createLocal({
+     *   toolRegistry: createLocalFSTools({ root: process.cwd() }),
+     *   persistence: "memory", // or "file", "sqlite"
+     * });
+     *
+     * const result = await session.run("Create a hello world file");
+     * ```
+     */
+    createLocal(options?: LocalSessionOptions): LocalSession;
+    /**
+     * Resume an existing local session from storage.
+     *
+     * @param sessionId - ID of the session to resume
+     * @param options - Session configuration (must match original persistence settings)
+     * @returns The resumed LocalSession, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const session = await client.sessions.resumeLocal("session-id", {
+     *   persistence: "sqlite",
+     * });
+     *
+     * if (session) {
+     *   console.log(`Resumed session with ${session.history.length} messages`);
+     *   const result = await session.run("Continue where we left off");
+     * }
+     * ```
      */
-    list(): Promise<Tier[]>;
+    resumeLocal(sessionId: string | SessionId, options?: LocalSessionOptions): Promise<LocalSession | null>;
     /**
-     * Get a tier by ID.
+     * Create a new remote session.
+     *
+     * Remote sessions store history on the server for cross-device continuity.
+     * Use for browser-based agents or team collaboration.
+     *
+     * @param options - Session configuration
+     * @returns A new RemoteSession instance
+     *
+     * @example
+     * ```typescript
+     * const session = await client.sessions.create({
+     *   metadata: { name: "Feature implementation" },
+     * });
+     *
+     * const result = await session.run("Implement the login feature");
+     * ```
      */
-    get(tierId: string): Promise<Tier>;
+    create(options?: RemoteSessionOptions): Promise<RemoteSession>;
     /**
-     * Create a Stripe checkout session for a tier (Stripe-first flow).
+     * Get an existing remote session by ID.
      *
-     * This enables users to subscribe before authenticating. Stripe collects
-     * the customer's email during checkout. After checkout completes, a
-     * customer record is created with the email from Stripe. The customer
-     * can later be linked to an identity via POST /customers/claim.
+     * @param sessionId - ID of the session to retrieve
+     * @param options - Optional configuration (toolRegistry, defaults)
+     * @returns The RemoteSession instance
      *
-     * Requires a secret key (mr_sk_*).
+     * @example
+     * ```typescript
+     * const session = await client.sessions.get("session-id");
+     * console.log(`Session has ${session.history.length} messages`);
+     * ```
+     */
+    get(sessionId: string | SessionId, options?: RemoteSessionOptions): Promise<RemoteSession>;
+    /**
+     * List remote sessions.
      *
-     * @param tierId - The tier ID to create a checkout session for
-     * @param request - Checkout session request with redirect URLs
-     * @returns Checkout session with Stripe URL
+     * @param options - List options (limit, cursor, endUserId)
+     * @returns Paginated list of session summaries
+     *
+     * @example
+     * ```typescript
+     * const { sessions, nextCursor } = await client.sessions.list({ limit: 10 });
+     * for (const info of sessions) {
+     *   console.log(`Session ${info.id}: ${info.messageCount} messages`);
+     * }
+     * ```
      */
-    checkout(tierId: string, request: TierCheckoutRequest): Promise<TierCheckoutSession>;
-}
-
-type ModelCapability = components["schemas"]["ModelCapability"];
-type ProviderId = components["schemas"]["ProviderId"];
-type CatalogModel = components["schemas"]["Model"];
-interface ModelsListParams {
-    provider?: ProviderId;
-    capability?: ModelCapability;
-}
-/**
- * ModelsClient provides methods to list models and their rich metadata.
- *
- * Note: The underlying API endpoint is public (no auth required), but the SDK's
- * HTTP client may still send auth headers if configured.
- */
-declare class ModelsClient {
-    private readonly http;
-    constructor(http: HTTPClient);
+    list(options?: ListSessionsOptions): Promise<ListSessionsResponse>;
     /**
-     * List active models with rich metadata.
+     * Delete a remote session.
+     *
+     * Requires a secret key (not publishable key).
+     *
+     * @param sessionId - ID of the session to delete
+     *
+     * @example
+     * ```typescript
+     * await client.sessions.delete("session-id");
+     * ```
      */
-    list(params?: ModelsListParams): Promise<CatalogModel[]>;
+    delete(sessionId: string | SessionId): Promise<void>;
 }
 
 declare class CustomerResponsesClient {
@@ -5844,6 +7191,501 @@ declare function parseSecretKey(raw: string): SecretKey;
 declare function isPublishableKey(key: ApiKey): key is PublishableKey;
 declare function isSecretKey(key: ApiKey): key is SecretKey;
 
+/**
+ * Local filesystem tool pack for client-side tool execution.
+ *
+ * Implements tools.v0 contract:
+ * - fs.read_file - Read workspace-relative files
+ * - fs.list_files - List files recursively
+ * - fs.search - Regex search (ripgrep or JS fallback)
+ *
+ * Safety features:
+ * - Root sandbox with symlink resolution
+ * - Path traversal prevention
+ * - Size limits with hard caps
+ * - Ignore patterns for common large directories
+ * - UTF-8 validation
+ *
+ * @module
+ */
+
+/** Reserved tool names from tools.v0 specification. */
+declare const ToolNames: {
+    readonly FS_READ_FILE: "fs.read_file";
+    readonly FS_LIST_FILES: "fs.list_files";
+    readonly FS_SEARCH: "fs.search";
+};
+/** Default size limits and caps from wire contract. */
+declare const FSDefaults: {
+    readonly MAX_READ_BYTES: 64000;
+    readonly HARD_MAX_READ_BYTES: 1000000;
+    readonly MAX_LIST_ENTRIES: 2000;
+    readonly HARD_MAX_LIST_ENTRIES: 20000;
+    readonly MAX_SEARCH_MATCHES: 100;
+    readonly HARD_MAX_SEARCH_MATCHES: 2000;
+    readonly SEARCH_TIMEOUT_MS: 5000;
+    readonly MAX_SEARCH_BYTES_PER_FILE: 1000000;
+};
+/** Default directories to skip during list/search operations. */
+declare const DEFAULT_IGNORE_DIRS: Set<string>;
+/** Configuration options for LocalFSToolPack. */
+interface LocalFSToolPackOptions {
+    /** Root directory for sandboxing (required). All paths are relative to this. */
+    root: string;
+    /** Directory names to skip during list/search. Defaults to DEFAULT_IGNORE_DIRS. */
+    ignoreDirs?: Set<string>;
+    /** Default max_bytes for fs.read_file. Defaults to 64KB. */
+    maxReadBytes?: number;
+    /** Hard cap for fs.read_file max_bytes. Defaults to 1MB. */
+    hardMaxReadBytes?: number;
+    /** Default max_entries for fs.list_files. Defaults to 2000. */
+    maxListEntries?: number;
+    /** Hard cap for fs.list_files max_entries. Defaults to 20000. */
+    hardMaxListEntries?: number;
+    /** Default max_matches for fs.search. Defaults to 100. */
+    maxSearchMatches?: number;
+    /** Hard cap for fs.search max_matches. Defaults to 2000. */
+    hardMaxSearchMatches?: number;
+    /** Timeout for fs.search in milliseconds. Defaults to 5000. */
+    searchTimeoutMs?: number;
+    /** Max bytes to read per file during JS fallback search. Defaults to 1MB. */
+    maxSearchBytesPerFile?: number;
+}
+/**
+ * Tool pack providing safe filesystem access for LLM workflows.
+ *
+ * @example
+ * ```typescript
+ * const pack = new LocalFSToolPack({ root: process.cwd() });
+ * const registry = pack.toRegistry();
+ *
+ * // Use tools in a workflow
+ * const response = await client.responses.create({
+ *   model: "anthropic/claude-sonnet-4-20250514",
+ *   input: [{ type: "message", role: "user", content: [{ type: "text", text: "List all TypeScript files" }] }],
+ *   tools: pack.getToolDefinitions(),
+ * });
+ *
+ * // Execute tool calls
+ * const results = await registry.executeAll(response.output.filter(o => o.type === "tool_use"));
+ * ```
+ */
+declare class LocalFSToolPack {
+    private readonly rootAbs;
+    private readonly cfg;
+    private rgPath;
+    private rgChecked;
+    constructor(options: LocalFSToolPackOptions);
+    /**
+     * Returns the tool definitions for LLM requests.
+     * Use these when constructing the tools array for /responses requests.
+     */
+    getToolDefinitions(): Tool[];
+    /**
+     * Registers handlers into an existing ToolRegistry.
+     * @param registry - The registry to register into
+     * @returns The registry for chaining
+     */
+    registerInto(registry: ToolRegistry): ToolRegistry;
+    /**
+     * Creates a new ToolRegistry with fs.* tools pre-registered.
+     */
+    toRegistry(): ToolRegistry;
+    private readFile;
+    private listFiles;
+    private search;
+    /**
+     * Resolves a workspace-relative path and validates it stays within the sandbox.
+     * @throws {ToolArgumentError} if path is invalid
+     * @throws {PathEscapeError} if resolved path escapes root
+     */
+    private resolveAndValidatePath;
+    private detectRipgrep;
+    private searchWithRipgrep;
+    private normalizeRipgrepLine;
+    private searchWithJS;
+    private parseArgs;
+    private toolArgumentError;
+    private requireString;
+    private optionalString;
+    private optionalPositiveInt;
+    private isValidUtf8;
+    /**
+     * Recursively walks a directory, calling visitor for each entry.
+     * Visitor returns true to continue, false to skip (for dirs) or stop.
+     */
+    private walkDir;
+}
+/**
+ * Creates a LocalFSToolPack with the given options.
+ *
+ * @example
+ * ```typescript
+ * const pack = createLocalFSToolPack({ root: process.cwd() });
+ * ```
+ */
+declare function createLocalFSToolPack(options: LocalFSToolPackOptions): LocalFSToolPack;
+/**
+ * Creates a ToolRegistry with fs.* tools pre-registered.
+ * Shorthand for createLocalFSToolPack(options).toRegistry().
+ *
+ * @example
+ * ```typescript
+ * const registry = createLocalFSTools({ root: process.cwd() });
+ * const result = await registry.execute(toolCall);
+ * ```
+ */
+declare function createLocalFSTools(options: LocalFSToolPackOptions): ToolRegistry;
+
+/**
+ * Browser automation tools using Playwright with accessibility tree extraction.
+ *
+ * Uses CDP (Chrome DevTools Protocol) for semantic element targeting instead of
+ * pixel-based screenshots, making it 10-100x cheaper than vision-based automation.
+ *
+ * @example
+ * ```typescript
+ * import { BrowserToolPack, createBrowserTools } from "@modelrelay/sdk";
+ *
+ * // Create a browser tool pack with domain restrictions
+ * const pack = new BrowserToolPack({
+ *   allowedDomains: ["example.com", "docs.example.com"],
+ *   headless: true,
+ * });
+ *
+ * // Initialize the browser (must be called before use)
+ * await pack.initialize();
+ *
+ * // Get tool definitions for LLM
+ * const tools = pack.getToolDefinitions();
+ *
+ * // Get registry for executing tool calls
+ * const registry = pack.toRegistry();
+ *
+ * // Clean up when done
+ * await pack.close();
+ * ```
+ *
+ * @module
+ */
+
+type Browser = any;
+type BrowserContext = any;
+/**
+ * Tool names for browser automation.
+ */
+declare const BrowserToolNames: {
+    /** Navigate to a URL and return accessibility tree */
+    readonly NAVIGATE: "browser.navigate";
+    /** Click an element by accessible name/role */
+    readonly CLICK: "browser.click";
+    /** Type text into an input field */
+    readonly TYPE: "browser.type";
+    /** Get current accessibility tree */
+    readonly SNAPSHOT: "browser.snapshot";
+    /** Scroll the page */
+    readonly SCROLL: "browser.scroll";
+    /** Capture a screenshot */
+    readonly SCREENSHOT: "browser.screenshot";
+    /** Extract data using CSS selectors */
+    readonly EXTRACT: "browser.extract";
+};
+/**
+ * Default configuration values for browser tools.
+ */
+declare const BrowserDefaults: {
+    /** Navigation timeout in milliseconds */
+    readonly NAVIGATION_TIMEOUT_MS: 30000;
+    /** Action timeout in milliseconds */
+    readonly ACTION_TIMEOUT_MS: 5000;
+    /** Maximum nodes to include in accessibility tree output */
+    readonly MAX_SNAPSHOT_NODES: 500;
+    /** Maximum screenshot size in bytes */
+    readonly MAX_SCREENSHOT_BYTES: 5000000;
+};
+/**
+ * Configuration options for BrowserToolPack.
+ */
+interface BrowserToolPackOptions {
+    /**
+     * Whitelist of allowed domains. If set, only URLs matching these domains
+     * will be allowed. Supports suffix matching (e.g., "example.com" matches
+     * "sub.example.com").
+     */
+    allowedDomains?: string[];
+    /**
+     * Blacklist of blocked domains. URLs matching these domains will be rejected.
+     * Supports suffix matching.
+     */
+    blockedDomains?: string[];
+    /**
+     * Navigation timeout in milliseconds. Default: 30000
+     */
+    navigationTimeoutMs?: number;
+    /**
+     * Action timeout in milliseconds. Default: 5000
+     */
+    actionTimeoutMs?: number;
+    /**
+     * Maximum nodes to include in accessibility tree. Default: 500
+     */
+    maxSnapshotNodes?: number;
+    /**
+     * Run browser in headless mode. Default: true
+     */
+    headless?: boolean;
+    /**
+     * Existing Browser instance to use instead of creating a new one.
+     */
+    browser?: Browser;
+    /**
+     * Existing BrowserContext to use instead of creating a new one.
+     */
+    context?: BrowserContext;
+}
+/**
+ * A tool pack for browser automation using Playwright.
+ *
+ * Uses accessibility tree extraction via CDP for efficient, semantic-based
+ * browser automation. This is much cheaper than vision-based approaches
+ * because it works with structured text instead of screenshots.
+ *
+ * @example
+ * ```typescript
+ * const pack = new BrowserToolPack({
+ *   allowedDomains: ["example.com"],
+ * });
+ * await pack.initialize();
+ *
+ * const registry = pack.toRegistry();
+ * const result = await registry.execute(toolCall);
+ *
+ * await pack.close();
+ * ```
+ */
+declare class BrowserToolPack {
+    private browser;
+    private context;
+    private page;
+    private cdpSession;
+    private ownsBrowser;
+    private ownsContext;
+    private cfg;
+    constructor(options?: BrowserToolPackOptions);
+    /**
+     * Initialize the browser. Must be called before using any tools.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Close the browser and clean up resources.
+     */
+    close(): Promise<void>;
+    /**
+     * Get tool definitions for use with LLM APIs.
+     */
+    getToolDefinitions(): Tool[];
+    /**
+     * Register tool handlers into an existing registry.
+     */
+    registerInto(registry: ToolRegistry): ToolRegistry;
+    /**
+     * Create a new registry with just this pack's tools.
+     */
+    toRegistry(): ToolRegistry;
+    private ensureInitialized;
+    private parseArgs;
+    private validateUrl;
+    /**
+     * Validates the current page URL against allowlist/blocklist.
+     * Called after navigation and before any action to catch redirects
+     * and in-session navigation to blocked domains.
+     */
+    private ensureCurrentUrlAllowed;
+    private getAccessibilityTree;
+    private formatAXTree;
+    private navigate;
+    private click;
+    private type;
+    private snapshot;
+    private scroll;
+    private screenshot;
+    private extract;
+}
+/**
+ * Create a BrowserToolPack with the given options.
+ */
+declare function createBrowserToolPack(options?: BrowserToolPackOptions): BrowserToolPack;
+/**
+ * Create a ToolRegistry with browser tools registered.
+ *
+ * Note: You must call `pack.initialize()` before using the registry.
+ *
+ * @example
+ * ```typescript
+ * const { pack, registry } = createBrowserTools({ headless: true });
+ * await pack.initialize();
+ *
+ * // Use registry to execute tool calls
+ * const result = await registry.execute(toolCall);
+ *
+ * await pack.close();
+ * ```
+ */
+declare function createBrowserTools(options?: BrowserToolPackOptions): {
+    pack: BrowserToolPack;
+    registry: ToolRegistry;
+};
+
+/**
+ * Tool runner for executing client-side tools in workflow runs.
+ *
+ * Handles node_waiting events by executing local tool handlers
+ * and submitting results back to the server.
+ *
+ * @module
+ */
+
+/** Configuration options for ToolRunner. */
+interface ToolRunnerOptions {
+    /** Tool registry containing handlers for tool names. */
+    registry: ToolRegistry;
+    /** Runs client for submitting results back to the server. */
+    runsClient: RunsClient;
+    /** Customer ID for attributed requests (optional). */
+    customerId?: string;
+    /** Called before executing each tool call (optional). */
+    onBeforeExecute?: (pending: PendingToolCallV0) => void | Promise<void>;
+    /** Called after each tool execution (optional). */
+    onAfterExecute?: (result: ToolExecutionResult) => void | Promise<void>;
+    /** Called when results are successfully submitted (optional). */
+    onSubmitted?: (runId: RunId, count: number, status: RunStatusV0) => void | Promise<void>;
+    /** Called when an error occurs during execution (optional). */
+    onError?: (error: Error, pending?: PendingToolCallV0) => void | Promise<void>;
+}
+/** Response from handling a node_waiting event. */
+interface HandleWaitingResult {
+    /** Number of results accepted by the server. */
+    accepted: number;
+    /** New run status after submitting results. */
+    status: RunStatusV0;
+    /** Execution results for each tool call. */
+    results: ToolExecutionResult[];
+}
+/**
+ * Executes client-side tools for workflow runs.
+ *
+ * Handles `node_waiting` events from the run event stream, executes the
+ * corresponding tool handlers from the registry, and submits results
+ * back to the server.
+ *
+ * @example
+ * ```typescript
+ * import { ModelRelay, createLocalFSTools, ToolRunner } from "modelrelay";
+ *
+ * const client = ModelRelay.fromSecretKey(process.env.MODELRELAY_SECRET_KEY!);
+ * const registry = createLocalFSTools({ root: process.cwd() });
+ *
+ * const runner = new ToolRunner({
+ *   registry,
+ *   runsClient: client.runs,
+ * });
+ *
+ * // Create a run and process events
+ * const run = await client.runs.create(workflowSpec);
+ * for await (const event of runner.processEvents(run.run_id, client.runs.events(run.run_id))) {
+ *   console.log(event.type);
+ * }
+ * ```
+ */
+declare class ToolRunner {
+    private readonly registry;
+    private readonly runsClient;
+    private readonly customerId?;
+    private readonly onBeforeExecute?;
+    private readonly onAfterExecute?;
+    private readonly onSubmitted?;
+    private readonly onError?;
+    constructor(options: ToolRunnerOptions);
+    /**
+     * Handles a node_waiting event by executing tools and submitting results.
+     *
+     * @param runId - The run ID
+     * @param nodeId - The node ID that is waiting
+     * @param waiting - The waiting state with pending tool calls
+     * @returns The submission response with accepted count and new status
+     *
+     * @example
+     * ```typescript
+     * for await (const event of client.runs.events(runId)) {
+     *   if (event.type === "node_waiting") {
+     *     const result = await runner.handleNodeWaiting(
+     *       runId,
+     *       event.node_id,
+     *       event.waiting
+     *     );
+     *     console.log(`Submitted ${result.accepted} results, status: ${result.status}`);
+     *   }
+     * }
+     * ```
+     */
+    handleNodeWaiting(runId: RunId, nodeId: NodeId, waiting: NodeWaitingV0): Promise<HandleWaitingResult>;
+    /**
+     * Processes a stream of run events, automatically handling node_waiting events.
+     *
+     * This is the main entry point for running a workflow with client-side tools.
+     * It yields all events through (including node_waiting after handling).
+     *
+     * @param runId - The run ID to process
+     * @param events - AsyncIterable of run events (from RunsClient.events())
+     * @yields All run events, with node_waiting events handled automatically
+     *
+     * @example
+     * ```typescript
+     * const run = await client.runs.create(workflowSpec);
+     * const eventStream = client.runs.events(run.run_id);
+     *
+     * for await (const event of runner.processEvents(run.run_id, eventStream)) {
+     *   switch (event.type) {
+     *     case "node_started":
+     *       console.log(`Node ${event.node_id} started`);
+     *       break;
+     *     case "node_succeeded":
+     *       console.log(`Node ${event.node_id} succeeded`);
+     *       break;
+     *     case "run_succeeded":
+     *       console.log("Run completed!");
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    processEvents(runId: RunId, events: AsyncIterable<RunEventV0>): AsyncGenerator<RunEventV0, void, undefined>;
+    /**
+     * Checks if a run event is a node_waiting event.
+     * Utility for filtering events when not using processEvents().
+     */
+    static isNodeWaiting(event: RunEventV0): event is RunEventNodeWaitingV0;
+    /**
+     * Checks if a run status is terminal (succeeded, failed, or canceled).
+     * Utility for determining when to stop polling.
+     */
+    static isTerminalStatus(status: RunStatusV0): boolean;
+}
+/**
+ * Creates a ToolRunner with the given options.
+ *
+ * @example
+ * ```typescript
+ * const runner = createToolRunner({
+ *   registry: createLocalFSTools({ root: process.cwd() }),
+ *   runsClient: client.runs,
+ *   onBeforeExecute: (pending) => console.log(`Executing ${pending.name}`),
+ *   onAfterExecute: (result) => console.log(`Result: ${result.result}`),
+ * });
+ * ```
+ */
+declare function createToolRunner(options: ToolRunnerOptions): ToolRunner;
+
 type index_$defs = $defs;
 type index_components = components;
 type index_operations = operations;
@@ -5853,14 +7695,50 @@ declare namespace index {
   export type { index_$defs as $defs, index_components as components, index_operations as operations, index_paths as paths, index_webhooks as webhooks };
 }
 
+/**
+ * In-memory session store.
+ *
+ * Session data is lost when the process exits. Use for:
+ * - Development/testing
+ * - Short-lived sessions that don't need persistence
+ * - Environments without filesystem access
+ *
+ * @module
+ */
+
+/**
+ * In-memory implementation of SessionStore.
+ *
+ * All operations are synchronous but wrapped in promises for interface compatibility.
+ */
+declare class MemorySessionStore implements SessionStore {
+    private readonly sessions;
+    load(id: SessionId): Promise<SessionState | null>;
+    save(state: SessionState): Promise<void>;
+    delete(id: SessionId): Promise<void>;
+    list(): Promise<SessionId[]>;
+    close(): Promise<void>;
+    /**
+     * Get the number of sessions in the store.
+     * Useful for testing.
+     */
+    get size(): number;
+}
+/**
+ * Create a new in-memory session store.
+ */
+declare function createMemorySessionStore(): MemorySessionStore;
+
 declare class ModelRelay {
     readonly responses: ResponsesClient;
     readonly runs: RunsClient;
     readonly workflows: WorkflowsClient;
+    readonly images: ImagesClient;
     readonly auth: AuthClient;
     readonly customers: CustomersClient;
     readonly tiers: TiersClient;
     readonly models: ModelsClient;
+    readonly sessions: SessionsClient;
     readonly baseUrl: string;
     static fromSecretKey(secretKey: string, options?: Omit<ModelRelayKeyOptions, "key">): ModelRelay;
     static fromPublishableKey(publishableKey: string, options?: Omit<ModelRelayKeyOptions, "key">): ModelRelay;
@@ -5869,4 +7747,4 @@ declare class ModelRelay {
     forCustomer(customerId: string): CustomerScopedModelRelay;
 }
 
-export { type APICheckoutSession, type APICustomerRef, APIError, type APIFrontendToken, type APIKey, type APIResponsesResponse, type APIUsage, type ApiKey, type AttemptRecord, AuthClient, type AuthHeaders, type CatalogModel, type CheckoutSession, type CheckoutSessionRequest, type Citation, type CodeExecConfig, ConfigError, type ContentPart, type ContentPartType, ContentPartTypes, type Customer, type CustomerClaimRequest, type CustomerCreateRequest, type CustomerMetadata, CustomerResponsesClient, CustomerScopedModelRelay, type CustomerToken, CustomerTokenProvider, type CustomerTokenRequest, type CustomerUpsertRequest, CustomersClient, DEFAULT_BASE_URL, DEFAULT_CLIENT_HEADER, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_REQUEST_TIMEOUT_MS, type DeepPartial, type DeviceStartRequest, type DeviceStartResponse, type DeviceTokenPending, type DeviceTokenResponse, type DeviceTokenResult, type ErrorCategory, type ErrorCode, ErrorCodes, type FieldError, type FrontendCustomer, type FrontendToken, type FrontendTokenAutoProvisionRequest, FrontendTokenProvider, type FrontendTokenRequest, type FunctionCall, type FunctionCallDelta, type FunctionTool, type HttpRequestMetrics, type InputItem, type InputItemType, InputItemTypes, type JSONSchemaFormat, type JsonSchemaOptions, type KnownStopReason, type MessageDeltaData, type MessageRole, MessageRoles, type MessageStartData, type MessageStopData, type MetricsCallbacks, type ModelCapability, type ModelId, ModelRelay, type ModelRelayBaseOptions, ModelRelayError, type ModelRelayKeyOptions, type ModelRelayOptions, type ModelRelayTokenOptions, type ModelRelayTokenProviderOptions, ModelsClient, type NodeErrorV0, type NodeId, type NonEmptyArray, type OAuthDeviceAuthorization, type OAuthDeviceAuthorizationRequest, type OAuthDeviceToken, type OAuthDeviceTokenPollRequest, type OIDCExchangeRequest, OIDCExchangeTokenProvider, type OutputFormat, type OutputFormatType, OutputFormatTypes, type OutputItem, type OutputItemType, OutputItemTypes, type OutputName, type PayloadInfoV0, type PlanHash, type PriceInterval, type Project, type ProviderId, type PublishableKey, type RequestContext, type Response$1 as Response, type ResponseEvent, type ResponseEventType, ResponsesClient, ResponsesStream, type RetryConfig, type RetryHandler, type RetryMetadata, type RetryOptions, type RunEventTypeV0, type RunEventV0, type RunId, type RunStatusV0, RunsClient, RunsEventStream, SDK_VERSION, type Schema, type SecretKey, type StopReason, StopReasons, type StreamFirstTokenMetrics, StreamProtocolError, StreamTimeoutError, type StreamTimeoutKind, StructuredDecodeError, type StructuredErrorKind, StructuredExhaustedError, type StructuredJSONEvent, type StructuredJSONRecordType, StructuredJSONStream, type StructuredOptions, type StructuredResult, type SubscriptionStatus, type Tier, type TierCheckoutRequest, type TierCheckoutSession, type TierCode, TiersClient, type TokenProvider, type TokenType, type TokenUsageMetrics, type Tool, ToolArgsError, type ToolCall, ToolCallAccumulator, type ToolCallDelta, type ToolChoice, type ToolChoiceType, ToolChoiceTypes, type ToolExecutionResult, type ToolHandler, ToolRegistry, type ToolType, ToolTypes, type TraceCallbacks, type TransformJSONValueV0, TransportError, type TransportErrorKind, type Usage, type UsageSummary, type ValidationIssue, WORKFLOWS_COMPILE_PATH, type WebSearchConfig, type WebToolMode, WebToolModes, WorkflowBuilderV0, type WorkflowBuilderV0State, type WorkflowEdgeV0, type WorkflowKind, WorkflowKinds, type WorkflowNodeType, WorkflowNodeTypes, type WorkflowNodeV0, type WorkflowOutputRefV0, type WorkflowSpecV0, WorkflowValidationError, type WorkflowValidationIssue, WorkflowsClient, type WorkflowsCompileOptions, type WorkflowsCompileRequestV0, type WorkflowsCompileResponseV0, type WorkflowsCompileV0Result, type XSearchConfig, type ZodLikeSchema, asModelId, asProviderId, asTierCode, assistantMessageWithToolCalls, createAccessTokenAuth, createApiKeyAuth, createAssistantMessage, createFunctionCall, createFunctionTool, createFunctionToolFromSchema, createRetryMessages, createSystemMessage, createToolCall, createUsage, createUserMessage, createWebTool, defaultRetryHandler, executeWithRetry, firstToolCall, formatToolErrorForModel, index as generated, getRetryableErrors, hasRetryableErrors, hasToolCalls, isAutoProvisionDisabled, isAutoProvisionMisconfigured, isEmailRequired, isIdentityRequired, isProvisioningError, isPublishableKey, isSecretKey, mergeMetrics, mergeTrace, modelToString, normalizeModelId, normalizeStopReason, outputFormatFromZod, parseApiKey, parseErrorResponse, parseNodeId, parseOutputName, parsePlanHash, parsePublishableKey, parseRunId, parseSecretKey, parseToolArgs, parseToolArgsRaw, pollOAuthDeviceToken, respondToToolCall, runOAuthDeviceFlowForIDToken, startOAuthDeviceAuthorization, stopReasonToString, toolChoiceAuto, toolChoiceNone, toolChoiceRequired, toolResultMessage, transformJSONMerge, transformJSONObject, transformJSONValue, tryParseToolArgs, validateWithZod, workflowV0, workflow_v0_schema as workflowV0Schema, zodToJsonSchema };
+export { type APICheckoutSession, type APICustomerRef, APIError, type APIFrontendToken, type APIKey, type APIResponsesResponse, type APIUsage, type ApiKey, type AttemptRecord, AuthClient, type AuthHeaders, type BillingProvider, BillingProviders, BrowserDefaults, BrowserToolNames, BrowserToolPack, type BrowserToolPackOptions, type CatalogModel, type CheckoutSession, type Citation, type CodeExecConfig, ConfigError, type ContentPart, type ContentPartType, ContentPartTypes, type Customer, type CustomerClaimRequest, type CustomerCreateRequest, type CustomerMetadata, CustomerResponsesClient, CustomerScopedModelRelay, type CustomerSubscribeRequest, type CustomerToken, CustomerTokenProvider, type CustomerTokenRequest, type CustomerUpsertRequest, type CustomerWithSubscription, CustomersClient, DEFAULT_BASE_URL, DEFAULT_CLIENT_HEADER, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_IGNORE_DIRS, DEFAULT_REQUEST_TIMEOUT_MS, type DeepPartial, type DeviceStartRequest, type DeviceStartResponse, type DeviceTokenPending, type DeviceTokenResponse, type DeviceTokenResult, type ErrorCategory, type ErrorCode, ErrorCodes, FSDefaults, ToolNames as FSToolNames, type FieldError, type FrontendCustomer, type FrontendToken, type FrontendTokenAutoProvisionRequest, FrontendTokenProvider, type FrontendTokenRequest, type FunctionCall, type FunctionCallDelta, type FunctionTool, type HandleWaitingResult, type HttpRequestMetrics, type ImageData, type ImageRequest, type ImageResponse, type ImageResponseFormat, type ImageUsage, ImagesClient, type InputItem, type InputItemType, InputItemTypes, type JSONSchemaFormat, type JsonSchemaOptions, type KnownStopReason, type ListSessionsOptions, type ListSessionsResponse, LocalFSToolPack, type LocalFSToolPackOptions, LocalSession, type LocalSessionOptions, type LocalSessionPersistence, MemorySessionStore, type MessageDeltaData, type MessageRole, MessageRoles, type MessageStartData, type MessageStopData, type MetricsCallbacks, type ModelCapability, type ModelId, ModelRelay, type ModelRelayBaseOptions, ModelRelayError, type ModelRelayKeyOptions, type ModelRelayOptions, type ModelRelayTokenOptions, type ModelRelayTokenProviderOptions, ModelsClient, type NodeErrorV0, type NodeId, type NonEmptyArray, type OAuthDeviceAuthorization, type OAuthDeviceAuthorizationRequest, type OAuthDeviceToken, type OAuthDeviceTokenPollRequest, type OIDCExchangeRequest, OIDCExchangeTokenProvider, type OutputFormat, type OutputFormatType, OutputFormatTypes, type OutputItem, type OutputItemType, OutputItemTypes, type OutputName, PathEscapeError, type PayloadInfoV0, type PlanHash, type PriceInterval, type Project, type ProviderId, type PublishableKey, type RemoteSessionInfo, type RemoteSessionOptions, type RequestContext, type Response$1 as Response, type ResponseEvent, type ResponseEventType, ResponsesClient, ResponsesStream, type RetryConfig, type RetryHandler, type RetryMetadata, type RetryOptions, type RunEventTypeV0, type RunEventV0, type RunId, type RunStatusV0, RunsClient, RunsEventStream, SDK_VERSION, type Schema, type SecretKey, type Session, type SessionArtifacts, type SessionId, type SessionMessage, type SessionPendingToolCall, type SessionRunOptions, type SessionRunResult, type SessionRunStatus, type SessionState, type SessionStore, type SessionType, type SessionUsageSummary, SessionsClient, type StopReason, StopReasons, type StreamFirstTokenMetrics, StreamProtocolError, StreamTimeoutError, type StreamTimeoutKind, StructuredDecodeError, type StructuredErrorKind, StructuredExhaustedError, type StructuredJSONEvent, type StructuredJSONRecordType, StructuredJSONStream, type StructuredOptions, type StructuredResult, type Subscription, type SubscriptionStatusKind, SubscriptionStatuses, type Tier, type TierCheckoutRequest, type TierCheckoutSession, type TierCode, TiersClient, type TokenProvider, type TokenType, type TokenUsageMetrics, type Tool, ToolArgsError, ToolArgumentError, type ToolCall, ToolCallAccumulator, type ToolCallDelta, type ToolChoice, type ToolChoiceType, ToolChoiceTypes, type ToolExecutionResult, type ToolHandler, ToolRegistry, ToolRunner, type ToolRunnerOptions, type ToolType, ToolTypes, type TraceCallbacks, type TransformJSONValueV0, TransportError, type TransportErrorKind, type Usage, type UsageSummary, type ValidationIssue, WORKFLOWS_COMPILE_PATH, type WebSearchConfig, type WebToolMode, WebToolModes, WorkflowBuilderV0, type WorkflowBuilderV0State, type WorkflowEdgeV0, type WorkflowKind, WorkflowKinds, type WorkflowNodeType, WorkflowNodeTypes, type WorkflowNodeV0, type WorkflowOutputRefV0, type WorkflowSpecV0, WorkflowValidationError, type WorkflowValidationIssue, WorkflowsClient, type WorkflowsCompileOptions, type WorkflowsCompileRequestV0, type WorkflowsCompileResponseV0, type WorkflowsCompileV0Result, type XSearchConfig, type ZodLikeSchema, asModelId, asProviderId, asSessionId, asTierCode, assistantMessageWithToolCalls, createAccessTokenAuth, createApiKeyAuth, createAssistantMessage, createBrowserToolPack, createBrowserTools, createFunctionCall, createFunctionTool, createFunctionToolFromSchema, createLocalFSToolPack, createLocalFSTools, createLocalSession, createMemorySessionStore, createRetryMessages, createSystemMessage, createToolCall, createToolRunner, createUsage, createUserMessage, createWebTool, defaultRetryHandler, executeWithRetry, firstToolCall, formatToolErrorForModel, generateSessionId, index as generated, getRetryableErrors, hasRetryableErrors, hasToolCalls, isAutoProvisionDisabled, isAutoProvisionMisconfigured, isEmailRequired, isIdentityRequired, isProvisioningError, isPublishableKey, isSecretKey, mergeMetrics, mergeTrace, modelToString, normalizeModelId, normalizeStopReason, outputFormatFromZod, parseApiKey, parseErrorResponse, parseNodeId, parseOutputName, parsePlanHash, parsePublishableKey, parseRunId, parseSecretKey, parseToolArgs, parseToolArgsRaw, pollOAuthDeviceToken, respondToToolCall, runOAuthDeviceFlowForIDToken, startOAuthDeviceAuthorization, stopReasonToString, toolChoiceAuto, toolChoiceNone, toolChoiceRequired, toolResultMessage, transformJSONMerge, transformJSONObject, transformJSONValue, tryParseToolArgs, validateWithZod, workflowV0, workflow_v0_schema as workflowV0Schema, zodToJsonSchema };