@modelrelay/sdk 1.3.3 → 1.14.0

package/dist/index.d.ts

@@ -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;
     /**
@@ -1744,25 +1766,25 @@ declare class ResponsesClient {
 }
 
 declare const runIdBrand: unique symbol;
-type RunId = string & {
+type RunId$1 = string & {
     readonly [runIdBrand]: true;
 };
 declare const nodeIdBrand: unique symbol;
-type NodeId = string & {
+type NodeId$1 = string & {
     readonly [nodeIdBrand]: true;
 };
 declare const planHashBrand: unique symbol;
-type PlanHash = string & {
+type PlanHash$1 = string & {
     readonly [planHashBrand]: true;
 };
 declare const outputNameBrand: unique symbol;
-type OutputName = string & {
+type OutputName$1 = string & {
     readonly [outputNameBrand]: true;
 };
-declare function parseRunId(raw: string): RunId;
-declare function parseNodeId(raw: string): NodeId;
-declare function parsePlanHash(raw: string): PlanHash;
-declare function parseOutputName(raw: string): OutputName;
+declare function parseRunId(raw: string): RunId$1;
+declare function parseNodeId(raw: string): NodeId$1;
+declare function parsePlanHash(raw: string): PlanHash$1;
+declare function parseOutputName(raw: string): OutputName$1;
 
 declare const WorkflowKinds: {
     readonly WorkflowV0: "workflow.v0";
@@ -1787,52 +1809,52 @@ type WorkflowSpecV0 = {
     outputs: ReadonlyArray<WorkflowOutputRefV0>;
 };
 type WorkflowNodeV0 = {
-    id: NodeId;
+    id: NodeId$1;
     type: typeof WorkflowNodeTypes.LLMResponses;
     input: {
         request: WireResponsesRequest;
         stream?: boolean;
-        tool_execution?: ToolExecutionV0;
+        tool_execution?: ToolExecutionV0$1;
         tool_limits?: LLMResponsesToolLimitsV0;
         bindings?: ReadonlyArray<LLMResponsesBindingV0>;
     };
 } | {
-    id: NodeId;
+    id: NodeId$1;
     type: typeof WorkflowNodeTypes.JoinAll;
     input?: Record<string, unknown>;
 } | {
-    id: NodeId;
+    id: NodeId$1;
     type: typeof WorkflowNodeTypes.TransformJSON;
     input: {
         object?: Record<string, {
-            from: NodeId;
+            from: NodeId$1;
             pointer?: string;
         }>;
         merge?: Array<{
-            from: NodeId;
+            from: NodeId$1;
             pointer?: string;
         }>;
     };
 };
 type WorkflowEdgeV0 = {
-    from: NodeId;
-    to: NodeId;
+    from: NodeId$1;
+    to: NodeId$1;
 };
 type WorkflowOutputRefV0 = {
-    name: OutputName;
-    from: NodeId;
+    name: OutputName$1;
+    from: NodeId$1;
     pointer?: string;
 };
 type LLMResponsesBindingEncodingV0 = "json" | "json_string";
 type LLMResponsesBindingV0 = {
-    from: NodeId;
+    from: NodeId$1;
     pointer?: string;
     to: string;
     encoding?: LLMResponsesBindingEncodingV0;
 };
-type ToolExecutionModeV0 = "server" | "client";
-type ToolExecutionV0 = {
-    mode: ToolExecutionModeV0;
+type ToolExecutionModeV0$1 = "server" | "client";
+type ToolExecutionV0$1 = {
+    mode: ToolExecutionModeV0$1;
 };
 type LLMResponsesToolLimitsV0 = {
     max_llm_calls?: number;
@@ -1840,147 +1862,147 @@ type LLMResponsesToolLimitsV0 = {
     wait_ttl_ms?: number;
 };
 type RunStatusV0 = "running" | "waiting" | "succeeded" | "failed" | "canceled";
-type PayloadInfoV0 = {
+type PayloadInfoV0$1 = {
     bytes: number;
     sha256: string;
     included: boolean;
 };
 type RunEventTypeV0 = "run_compiled" | "run_started" | "run_completed" | "run_failed" | "run_canceled" | "node_llm_call" | "node_tool_call" | "node_tool_result" | "node_waiting" | "node_started" | "node_succeeded" | "node_failed" | "node_output_delta" | "node_output";
-type NodeErrorV0 = {
+type NodeErrorV0$1 = {
     code?: string;
     message: string;
 };
 /**
  * Stream event kind from an LLM provider.
  */
-type StreamEventKind = string;
-type NodeOutputDeltaV0 = {
-    kind: StreamEventKind;
+type StreamEventKind$1 = string;
+type NodeOutputDeltaV0$1 = {
+    kind: StreamEventKind$1;
     text_delta?: string;
     response_id?: string;
     model?: string;
 };
-type TokenUsageV0 = {
+type TokenUsageV0$1 = {
     input_tokens?: number;
     output_tokens?: number;
     total_tokens?: number;
 };
-type NodeLLMCallV0 = {
+type NodeLLMCallV0$1 = {
     step: number;
     request_id: string;
     provider?: string;
     model?: string;
     response_id?: string;
     stop_reason?: string;
-    usage?: TokenUsageV0;
+    usage?: TokenUsageV0$1;
 };
-type FunctionToolCallV0 = {
+type FunctionToolCallV0$1 = {
     id: string;
     name: string;
     arguments: string;
 };
-type NodeToolCallV0 = {
+type NodeToolCallV0$1 = {
     step: number;
     request_id: string;
-    tool_call: FunctionToolCallV0;
+    tool_call: FunctionToolCallV0$1;
 };
-type NodeToolResultV0 = {
+type NodeToolResultV0$1 = {
     step: number;
     request_id: string;
     tool_call_id: string;
     name: string;
     output: string;
 };
-type PendingToolCallV0 = {
+type PendingToolCallV0$1 = {
     tool_call_id: string;
     name: string;
     arguments: string;
 };
-type NodeWaitingV0 = {
+type NodeWaitingV0$1 = {
     step: number;
     request_id: string;
-    pending_tool_calls: PendingToolCallV0[];
+    pending_tool_calls: PendingToolCallV0$1[];
     reason: string;
 };
 type RunEventBaseV0 = {
     envelope_version: "v0";
-    run_id: RunId;
+    run_id: RunId$1;
     seq: number;
     ts: string;
 };
 type RunEventRunCompiledV0 = RunEventBaseV0 & {
     type: "run_compiled";
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
 };
 type RunEventRunStartedV0 = RunEventBaseV0 & {
     type: "run_started";
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
 };
 type RunEventRunCompletedV0 = RunEventBaseV0 & {
     type: "run_completed";
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
     outputs_artifact_key: string;
-    outputs_info: PayloadInfoV0;
+    outputs_info: PayloadInfoV0$1;
 };
 type RunEventRunFailedV0 = RunEventBaseV0 & {
     type: "run_failed";
-    plan_hash: PlanHash;
-    error: NodeErrorV0;
+    plan_hash: PlanHash$1;
+    error: NodeErrorV0$1;
 };
 type RunEventRunCanceledV0 = RunEventBaseV0 & {
     type: "run_canceled";
-    plan_hash: PlanHash;
-    error: NodeErrorV0;
+    plan_hash: PlanHash$1;
+    error: NodeErrorV0$1;
 };
 type RunEventNodeStartedV0 = RunEventBaseV0 & {
     type: "node_started";
-    node_id: NodeId;
+    node_id: NodeId$1;
 };
 type RunEventNodeSucceededV0 = RunEventBaseV0 & {
     type: "node_succeeded";
-    node_id: NodeId;
+    node_id: NodeId$1;
 };
 type RunEventNodeFailedV0 = RunEventBaseV0 & {
     type: "node_failed";
-    node_id: NodeId;
-    error: NodeErrorV0;
+    node_id: NodeId$1;
+    error: NodeErrorV0$1;
 };
 type RunEventNodeLLMCallV0 = RunEventBaseV0 & {
     type: "node_llm_call";
-    node_id: NodeId;
-    llm_call: NodeLLMCallV0;
+    node_id: NodeId$1;
+    llm_call: NodeLLMCallV0$1;
 };
 type RunEventNodeToolCallV0 = RunEventBaseV0 & {
     type: "node_tool_call";
-    node_id: NodeId;
-    tool_call: NodeToolCallV0;
+    node_id: NodeId$1;
+    tool_call: NodeToolCallV0$1;
 };
 type RunEventNodeToolResultV0 = RunEventBaseV0 & {
     type: "node_tool_result";
-    node_id: NodeId;
-    tool_result: NodeToolResultV0;
+    node_id: NodeId$1;
+    tool_result: NodeToolResultV0$1;
 };
 type RunEventNodeWaitingV0 = RunEventBaseV0 & {
     type: "node_waiting";
-    node_id: NodeId;
-    waiting: NodeWaitingV0;
+    node_id: NodeId$1;
+    waiting: NodeWaitingV0$1;
 };
 type RunEventNodeOutputDeltaV0 = RunEventBaseV0 & {
     type: "node_output_delta";
-    node_id: NodeId;
-    delta: NodeOutputDeltaV0;
+    node_id: NodeId$1;
+    delta: NodeOutputDeltaV0$1;
 };
 type RunEventNodeOutputV0 = RunEventBaseV0 & {
     type: "node_output";
-    node_id: NodeId;
+    node_id: NodeId$1;
     artifact_key: string;
-    output_info: PayloadInfoV0;
+    output_info: PayloadInfoV0$1;
 };
 type RunEventV0 = RunEventRunCompiledV0 | RunEventRunStartedV0 | RunEventRunCompletedV0 | RunEventRunFailedV0 | RunEventRunCanceledV0 | RunEventNodeLLMCallV0 | RunEventNodeToolCallV0 | RunEventNodeToolResultV0 | RunEventNodeWaitingV0 | RunEventNodeStartedV0 | RunEventNodeSucceededV0 | RunEventNodeFailedV0 | RunEventNodeOutputDeltaV0 | RunEventNodeOutputV0;
 
 type NodeStatusV0 = "pending" | "running" | "waiting" | "succeeded" | "failed" | "canceled";
 type RunsToolResultsRequest = {
-    node_id: NodeId;
+    node_id: NodeId$1;
     step: number;
     request_id: string;
     results: Array<{
@@ -1994,9 +2016,9 @@ type RunsToolResultsResponse = {
     status: RunStatusV0;
 };
 type RunsPendingToolsResponse = {
-    run_id: RunId;
+    run_id: RunId$1;
     pending: Array<{
-        node_id: NodeId;
+        node_id: NodeId$1;
         step: number;
         request_id: string;
         tool_calls: Array<{
@@ -2007,14 +2029,14 @@ type RunsPendingToolsResponse = {
     }>;
 };
 type RunsCreateResponse = {
-    run_id: RunId;
+    run_id: RunId$1;
     status: RunStatusV0;
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
 };
 type RunsGetResponse = {
-    run_id: RunId;
+    run_id: RunId$1;
     status: RunStatusV0;
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
     cost_summary: RunCostSummaryV0;
     nodes?: NodeResultV0[];
     outputs?: Record<string, unknown>;
@@ -2032,7 +2054,7 @@ type RunCostLineItemV0 = {
     usd_cents: number;
 };
 type NodeResultV0 = {
-    id: NodeId;
+    id: NodeId$1;
     type: string;
     status: NodeStatusV0;
     started_at?: 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;
@@ -2154,11 +2177,11 @@ declare class RunsClient {
         metrics?: MetricsCallbacks;
         trace?: TraceCallbacks;
     }): Promise<unknown>;
-    get(runId: RunId, options?: RunsGetOptions): Promise<RunsGetResponse>;
-    events(runId: RunId, options?: RunsEventsOptions): Promise<RunsEventStream>;
-    listEvents(runId: RunId, options?: Omit<RunsEventsOptions, "wait">): Promise<RunEventV0[]>;
-    submitToolResults(runId: RunId, req: RunsToolResultsRequest, options?: RunsToolResultsOptions): Promise<RunsToolResultsResponse>;
-    pendingTools(runId: RunId, options?: RunsPendingToolsOptions): Promise<RunsPendingToolsResponse>;
+    get(runId: RunId$1, options?: RunsGetOptions): Promise<RunsGetResponse>;
+    events(runId: RunId$1, options?: RunsEventsOptions): Promise<RunsEventStream>;
+    listEvents(runId: RunId$1, options?: Omit<RunsEventsOptions, "wait">): Promise<RunEventV0[]>;
+    submitToolResults(runId: RunId$1, req: RunsToolResultsRequest, options?: RunsToolResultsOptions): Promise<RunsToolResultsResponse>;
+    pendingTools(runId: RunId$1, options?: RunsPendingToolsOptions): Promise<RunsPendingToolsResponse>;
 }
 
 /**
@@ -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.
  */
@@ -2335,7 +2385,7 @@ type WorkflowsCompileOptions = {
 };
 type WorkflowsCompileResponseV0 = {
     plan_json: unknown;
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
 };
 type WorkflowsCompileV0Result = ({
     ok: true;
@@ -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,78 @@ 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;
+    };
+    "/sessions/{session_id}/messages": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Append a session message
+         * @description Appends a message to an existing session.
+         */
+        post: operations["addSessionMessage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 type webhooks = Record<string, never>;
 interface components {
@@ -3106,8 +3305,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 +3336,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 +3359,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 +3372,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 +3398,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 +3435,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 +3457,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 +3481,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 +3523,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 +3539,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 +3585,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 +3602,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 +3790,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 +3828,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 +3879,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,44 +4083,194 @@ 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;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Schema document */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/schema+json": Record<string, 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;
+            /**
+             * @description Number of images to generate (1-10, default 1)
+             * @default 1
+             */
+            n: number;
+            response_format?: components["schemas"]["ImageResponseFormat"];
         };
-    };
-    getRunEventV0Schema: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: 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;
+        };
+        /** @description Usage statistics for image generation. */
+        ImageUsage: {
+            /**
+             * Format: int32
+             * @description Number of images generated
+             */
+            images: number;
+        };
+        /** @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;
+            };
+        };
+        /** @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;
+        };
+        /** @description Request body for appending a message to a session. */
+        SessionMessageCreateRequest: {
+            /** @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;
+        };
+    };
+    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: {
@@ -4034,11 +4423,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 +4640,7 @@ interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": {
-                        customer?: components["schemas"]["Customer"];
-                    };
-                };
+                content?: never;
             };
             /** @description Customer not found */
             404: {
@@ -4278,7 +4658,7 @@ interface operations {
             };
         };
     };
-    getCustomerMe: {
+    listCustomers: {
         parameters: {
             query?: never;
             header?: never;
@@ -4287,113 +4667,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 +4801,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,16 +4865,184 @@ interface operations {
             };
         };
     };
-    listProjects: {
+    cancelCustomerSubscription: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                customer_id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Project list */
+            /** @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 +5283,7 @@ interface operations {
                 };
                 content: {
                     "application/json": {
-                        customers?: components["schemas"]["Customer"][];
+                        customers?: components["schemas"]["CustomerWithSubscription"][];
                     };
                 };
             };
@@ -4722,37 +5311,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 +5540,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 +5656,257 @@ 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;
-    subject: 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;
+            };
+        };
+    };
+    addSessionMessage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SessionMessageCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Message appended */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionMessageResponse"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description API key required */
+            401: {
+                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 +5917,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 +5957,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 +5984,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 +6036,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 +6046,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 {
@@ -5343,30 +6121,690 @@ declare class ModelsClient {
     list(params?: ModelsListParams): Promise<CatalogModel[]>;
 }
 
-declare class CustomerResponsesClient {
-    private readonly base;
-    private readonly customerId;
-    constructor(base: ResponsesClient, customerId: string);
-    get id(): string;
-    new(): ResponseBuilder;
-    private ensureRequestCustomer;
-    create(request: ResponsesRequest, options?: ResponsesRequestOptions): Promise<Response$1>;
-    stream(request: ResponsesRequest, options?: ResponsesRequestOptions): Promise<ResponsesStream>;
-    streamJSON<T>(request: ResponsesRequest, options?: ResponsesRequestOptions): Promise<StructuredJSONStream<T>>;
-    text(system: string, user: string, options?: ResponsesRequestOptions): Promise<string>;
-    streamTextDeltas(system: string, user: string, options?: ResponsesRequestOptions): Promise<AsyncIterable<string>>;
-}
-declare class CustomerScopedModelRelay {
-    readonly responses: CustomerResponsesClient;
-    readonly customerId: string;
-    readonly baseUrl: string;
-    constructor(responses: ResponsesClient, customerId: string, baseUrl: string);
+/**
+ * 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>;
 }
 
-declare class FrontendTokenProvider implements TokenProvider {
-    private readonly auth;
-    private readonly customer?;
-    private readonly publishableKey;
+/**
+ * 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$1;
+}
+/**
+ * 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$1;
+    /** 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 pendingMessages;
+    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;
+    private flushPendingMessages;
+    private appendMessageToServer;
+}
+
+/**
+ * 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");
+     * }
+     * ```
+     */
+    resumeLocal(sessionId: string | SessionId, options?: LocalSessionOptions): Promise<LocalSession | null>;
+    /**
+     * 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");
+     * ```
+     */
+    create(options?: RemoteSessionOptions): Promise<RemoteSession>;
+    /**
+     * Get an existing remote session by ID.
+     *
+     * @param sessionId - ID of the session to retrieve
+     * @param options - Optional configuration (toolRegistry, defaults)
+     * @returns The RemoteSession instance
+     *
+     * @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 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`);
+     * }
+     * ```
+     */
+    list(options?: ListSessionsOptions): Promise<ListSessionsResponse>;
+    /**
+     * 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");
+     * ```
+     */
+    delete(sessionId: string | SessionId): Promise<void>;
+}
+
+declare class CustomerResponsesClient {
+    private readonly base;
+    private readonly customerId;
+    constructor(base: ResponsesClient, customerId: string);
+    get id(): string;
+    new(): ResponseBuilder;
+    private ensureRequestCustomer;
+    create(request: ResponsesRequest, options?: ResponsesRequestOptions): Promise<Response$1>;
+    stream(request: ResponsesRequest, options?: ResponsesRequestOptions): Promise<ResponsesStream>;
+    streamJSON<T>(request: ResponsesRequest, options?: ResponsesRequestOptions): Promise<StructuredJSONStream<T>>;
+    text(system: string, user: string, options?: ResponsesRequestOptions): Promise<string>;
+    streamTextDeltas(system: string, user: string, options?: ResponsesRequestOptions): Promise<AsyncIterable<string>>;
+}
+declare class CustomerScopedModelRelay {
+    readonly responses: CustomerResponsesClient;
+    readonly customerId: string;
+    readonly baseUrl: string;
+    constructor(responses: ResponsesClient, customerId: string, baseUrl: string);
+}
+
+declare class FrontendTokenProvider implements TokenProvider {
+    private readonly auth;
+    private readonly customer?;
+    private readonly publishableKey;
     constructor(cfg: {
         baseUrl?: string;
         fetch?: typeof fetch;
@@ -5469,11 +6907,19 @@ declare function runOAuthDeviceFlowForIDToken(cfg: {
     signal?: AbortSignal;
 }): Promise<string>;
 
+/**
+ * Semantic JSON pointer constants for LLM responses nodes.
+ * These eliminate magic strings and make bindings self-documenting.
+ */
+/** JSON pointer to extract text content from an LLM response output. */
+declare const LLM_TEXT_OUTPUT$1: "/output/0/content/0/text";
+/** JSON pointer to inject text into the user message of an LLM request. */
+declare const LLM_USER_MESSAGE_TEXT$1: "/request/input/1/content/0/text";
 type TransformJSONValueV0 = {
-    from: NodeId;
+    from: NodeId$1;
     pointer?: string;
 };
-declare function transformJSONValue(from: NodeId, pointer?: string): TransformJSONValueV0;
+declare function transformJSONValue(from: NodeId$1, pointer?: string): TransformJSONValueV0;
 declare function transformJSONObject(object: Record<string, TransformJSONValueV0>): {
     object: Record<string, TransformJSONValueV0>;
 };
@@ -5495,31 +6941,190 @@ declare class WorkflowBuilderV0 {
     name(name: string): WorkflowBuilderV0;
     execution(execution: WorkflowSpecV0["execution"]): WorkflowBuilderV0;
     node(node: WorkflowNodeV0): WorkflowBuilderV0;
-    llmResponses(id: NodeId, request: WireResponsesRequest | ResponsesRequest, options?: {
+    llmResponses(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest, options?: {
         stream?: boolean;
-        toolExecution?: ToolExecutionModeV0;
+        toolExecution?: ToolExecutionModeV0$1;
         toolLimits?: LLMResponsesToolLimitsV0;
         bindings?: ReadonlyArray<LLMResponsesBindingV0>;
     }): WorkflowBuilderV0;
-    joinAll(id: NodeId): WorkflowBuilderV0;
-    transformJSON(id: NodeId, input: Extract<WorkflowNodeV0, {
+    joinAll(id: NodeId$1): WorkflowBuilderV0;
+    transformJSON(id: NodeId$1, input: Extract<WorkflowNodeV0, {
         type: typeof WorkflowNodeTypes.TransformJSON;
     }>["input"]): WorkflowBuilderV0;
-    edge(from: NodeId, to: NodeId): WorkflowBuilderV0;
-    output(name: OutputName, from: NodeId, pointer?: string): WorkflowBuilderV0;
+    edge(from: NodeId$1, to: NodeId$1): WorkflowBuilderV0;
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): WorkflowBuilderV0;
     build(): WorkflowSpecV0;
 }
 declare function workflowV0(): WorkflowBuilderV0;
-
-var $id = "https://modelrelay.ai/schemas/workflow_v0.schema.json";
-var $schema = "http://json-schema.org/draft-07/schema#";
-var additionalProperties = false;
-var definitions = {
-	edge: {
-		additionalProperties: false,
-		properties: {
-			from: {
-				minLength: 1,
+type PendingLLMNode = {
+    id: NodeId$1;
+    request: WireResponsesRequest;
+    stream?: boolean;
+    bindings: LLMResponsesBindingV0[];
+    toolExecution?: ToolExecutionModeV0$1;
+    toolLimits?: LLMResponsesToolLimitsV0;
+};
+/**
+ * Ergonomic workflow builder with auto-edge inference from bindings.
+ *
+ * @example
+ * ```typescript
+ * const spec = newWorkflow("tier_generation")
+ *   .addLLMNode("tier_generator", tierReq).stream(true)
+ *   .addLLMNode("business_summary", summaryReq)
+ *     .bindFrom("tier_generator", "/output/0/content/0/text")
+ *   .output("tiers", "tier_generator")
+ *   .output("summary", "business_summary")
+ *   .build();
+ * ```
+ */
+declare class Workflow {
+    private _name?;
+    private _execution?;
+    private readonly _nodes;
+    private readonly _edges;
+    private readonly _outputs;
+    private _pendingNode;
+    private constructor();
+    /**
+     * Create a new workflow builder with the given name.
+     */
+    static create(name?: string): Workflow;
+    /**
+     * Set the workflow execution configuration.
+     */
+    execution(exec: WorkflowSpecV0["execution"]): Workflow;
+    /**
+     * Add an LLM responses node and return a node builder for configuration.
+     */
+    addLLMNode(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest): LLMNodeBuilder;
+    /**
+     * Add a join.all node that waits for all incoming edges.
+     */
+    addJoinAllNode(id: NodeId$1): Workflow;
+    /**
+     * Add a transform.json node and return a builder for configuration.
+     */
+    addTransformJSONNode(id: NodeId$1): TransformJSONNodeBuilder;
+    /**
+     * Add an output reference extracting the full node output.
+     */
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): Workflow;
+    /**
+     * Add an output reference extracting text content from an LLM response.
+     * This is a convenience method that uses the LLM_TEXT_OUTPUT pointer.
+     */
+    outputText(name: OutputName$1, from: NodeId$1): Workflow;
+    /**
+     * Explicitly add an edge between nodes.
+     * Note: edges are automatically inferred from bindings, so this is rarely needed.
+     */
+    edge(from: NodeId$1, to: NodeId$1): Workflow;
+    /**
+     * Build the workflow specification.
+     */
+    build(): WorkflowSpecV0;
+    /** @internal */
+    _getPendingNode(): PendingLLMNode | null;
+    /** @internal */
+    _addEdge(from: NodeId$1, to: NodeId$1): void;
+    /** @internal */
+    _addNode(node: WorkflowNodeV0): void;
+    private flushPendingNode;
+}
+/**
+ * Builder for configuring an LLM responses node.
+ */
+declare class LLMNodeBuilder {
+    private readonly workflow;
+    constructor(workflow: Workflow);
+    /**
+     * Enable or disable streaming for this node.
+     */
+    stream(enabled: boolean): LLMNodeBuilder;
+    /**
+     * Add a binding from another LLM node's text output to this node's user message.
+     * This is the most common binding pattern: LLM text → user message with json_string encoding.
+     * The edge from the source node is automatically inferred.
+     */
+    bindTextFrom(from: NodeId$1): LLMNodeBuilder;
+    /**
+     * Add a binding from another node's output to this node's user message text.
+     * Use bindTextFrom for the common case of binding LLM text output.
+     * The edge from the source node is automatically inferred.
+     */
+    bindFrom(from: NodeId$1, pointer?: string): LLMNodeBuilder;
+    /**
+     * Add a full binding with explicit source/destination pointers and encoding.
+     * The edge from the source node is automatically inferred.
+     */
+    bindFromTo(from: NodeId$1, fromPointer: string | undefined, toPointer: string, encoding?: LLMResponsesBindingEncodingV0): LLMNodeBuilder;
+    /**
+     * Set the tool execution mode (server or client).
+     */
+    toolExecution(mode: ToolExecutionModeV0$1): LLMNodeBuilder;
+    /**
+     * Set the tool execution limits.
+     */
+    toolLimits(limits: LLMResponsesToolLimitsV0): LLMNodeBuilder;
+    addLLMNode(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest): LLMNodeBuilder;
+    addJoinAllNode(id: NodeId$1): Workflow;
+    addTransformJSONNode(id: NodeId$1): TransformJSONNodeBuilder;
+    edge(from: NodeId$1, to: NodeId$1): Workflow;
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): Workflow;
+    outputText(name: OutputName$1, from: NodeId$1): Workflow;
+    execution(exec: WorkflowSpecV0["execution"]): Workflow;
+    build(): WorkflowSpecV0;
+}
+/**
+ * Builder for configuring a transform.json node.
+ */
+declare class TransformJSONNodeBuilder {
+    private readonly workflow;
+    private readonly id;
+    private _object?;
+    private _merge?;
+    constructor(workflow: Workflow, id: NodeId$1);
+    /**
+     * Set the object transformation with field mappings.
+     */
+    object(fields: Record<string, TransformJSONValueV0>): TransformJSONNodeBuilder;
+    /**
+     * Set the merge transformation with source references.
+     */
+    merge(items: TransformJSONValueV0[]): TransformJSONNodeBuilder;
+    private finalize;
+    addLLMNode(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest): LLMNodeBuilder;
+    addJoinAllNode(id: NodeId$1): Workflow;
+    edge(from: NodeId$1, to: NodeId$1): Workflow;
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): Workflow;
+    execution(exec: WorkflowSpecV0["execution"]): Workflow;
+    build(): WorkflowSpecV0;
+}
+/**
+ * Create a new ergonomic workflow builder with the given name.
+ *
+ * @example
+ * ```typescript
+ * const spec = newWorkflow("my_workflow")
+ *   .addLLMNode("generator", request).stream(true)
+ *   .addLLMNode("summarizer", summaryReq)
+ *     .bindFrom("generator", "/output/0/content/0/text")
+ *   .output("result", "summarizer")
+ *   .build();
+ * ```
+ */
+declare function newWorkflow(name?: string): Workflow;
+
+var $id = "https://modelrelay.ai/schemas/workflow_v0.schema.json";
+var $schema = "http://json-schema.org/draft-07/schema#";
+var additionalProperties = false;
+var definitions = {
+	edge: {
+		additionalProperties: false,
+		properties: {
+			from: {
+				minLength: 1,
 				type: "string"
 			},
 			to: {
@@ -5838,29 +7443,979 @@ var workflow_v0_schema = {
 declare const WORKFLOWS_COMPILE_PATH = "/workflows/compile";
 type WorkflowsCompileRequestV0 = WorkflowSpecV0;
 
+/**
+ * High-level workflow pattern helpers for common workflow structures.
+ *
+ * These helpers reduce boilerplate for common patterns like sequential chains,
+ * parallel execution with aggregation, and map-reduce processing.
+ *
+ * All builders are immutable - each method returns a new builder instance.
+ *
+ * @example
+ * ```typescript
+ * import { Chain, Parallel, MapReduce, LLMStep, MapItem } from 'modelrelay';
+ *
+ * // Chain pattern - sequential steps
+ * const chainSpec = Chain('summarize-translate', [
+ *   LLMStep('summarize', summarizeReq),
+ *   LLMStep('translate', translateReq).withStream(),
+ * ])
+ *   .outputLast('result')
+ *   .build();
+ *
+ * // Parallel pattern - concurrent steps with aggregation
+ * const parallelSpec = Parallel('multi-model', [
+ *   LLMStep('gpt4', gpt4Req),
+ *   LLMStep('claude', claudeReq),
+ * ])
+ *   .aggregate('synthesize', synthesizeReq)
+ *   .output('result', 'synthesize')
+ *   .build();
+ *
+ * // MapReduce pattern - parallel mappers with reducer
+ * const mapReduceSpec = MapReduce('process-docs', [
+ *   MapItem('doc1', doc1Req),
+ *   MapItem('doc2', doc2Req),
+ * ])
+ *   .reduce('combine', combineReq)
+ *   .output('result', 'combine')
+ *   .build();
+ * ```
+ */
+
+/**
+ * Configuration for an LLM step in a workflow pattern.
+ */
+type LLMStepConfig = {
+    readonly id: NodeId$1;
+    readonly request: WireResponsesRequest;
+    readonly stream: boolean;
+};
+/**
+ * Creates an LLM step configuration for use with Chain or Parallel patterns.
+ *
+ * @param id - Unique node identifier
+ * @param request - The LLM request configuration
+ * @returns A step configuration object with fluent methods
+ *
+ * @example
+ * ```typescript
+ * const step = LLMStep('summarize', {
+ *   model: 'claude-sonnet-4-20250514',
+ *   input: [{ type: 'message', role: 'user', content: [{ type: 'text', text: 'Summarize...' }] }],
+ * });
+ *
+ * // Enable streaming
+ * const streamingStep = step.withStream();
+ * ```
+ */
+declare function LLMStep(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): LLMStepConfig & {
+    withStream(): LLMStepConfig;
+};
+/**
+ * Immutable builder for sequential workflow where each step's output feeds into the next.
+ */
+declare class ChainBuilder {
+    private readonly state;
+    private constructor();
+    static create(name: string, steps: readonly LLMStepConfig[]): ChainBuilder;
+    private with;
+    /**
+     * Sets the workflow execution configuration.
+     */
+    execution(exec: WorkflowSpecV0["execution"]): ChainBuilder;
+    /**
+     * Adds an output reference from a specific step.
+     */
+    output(name: OutputName$1 | string, from: NodeId$1 | string): ChainBuilder;
+    /**
+     * Adds an output reference from the last step.
+     */
+    outputLast(name: OutputName$1 | string): ChainBuilder;
+    /**
+     * Builds and returns the compiled workflow spec.
+     * @throws Error if no steps are provided
+     */
+    build(): WorkflowSpecV0;
+}
+/**
+ * Creates a workflow builder for sequential LLM steps.
+ * Each step after the first automatically binds its input from the previous step's text output.
+ *
+ * @param name - Workflow name
+ * @param steps - Array of LLMStep configurations
+ * @returns A ChainBuilder for further configuration
+ *
+ * @example
+ * ```typescript
+ * const spec = Chain('summarize-translate', [
+ *   LLMStep('summarize', summarizeReq),
+ *   LLMStep('translate', translateReq).withStream(),
+ *   LLMStep('format', formatReq),
+ * ])
+ *   .outputLast('result')
+ *   .build();
+ * ```
+ */
+declare function Chain(name: string, steps: readonly LLMStepConfig[]): ChainBuilder;
+/**
+ * Immutable builder for workflow where multiple LLM steps execute in parallel,
+ * with optional aggregation.
+ */
+declare class ParallelBuilder {
+    private readonly state;
+    private constructor();
+    static create(name: string, steps: readonly LLMStepConfig[]): ParallelBuilder;
+    private with;
+    /**
+     * Sets the workflow execution configuration.
+     */
+    execution(exec: WorkflowSpecV0["execution"]): ParallelBuilder;
+    /**
+     * Adds a join node that waits for all parallel steps,
+     * followed by an aggregator LLM node that receives the combined output.
+     * The join node ID is automatically generated as "<id>_join".
+     */
+    aggregate(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): ParallelBuilder;
+    /**
+     * Like aggregate() but enables streaming on the aggregator node.
+     */
+    aggregateWithStream(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): ParallelBuilder;
+    /**
+     * Adds an output reference from a specific step.
+     */
+    output(name: OutputName$1 | string, from: NodeId$1 | string): ParallelBuilder;
+    /**
+     * Builds and returns the compiled workflow spec.
+     * @throws Error if no steps are provided
+     */
+    build(): WorkflowSpecV0;
+}
+/**
+ * Creates a workflow builder for parallel LLM steps.
+ * All steps execute concurrently with no dependencies between them.
+ *
+ * @param name - Workflow name
+ * @param steps - Array of LLMStep configurations
+ * @returns A ParallelBuilder for further configuration
+ *
+ * @example
+ * ```typescript
+ * // Without aggregation - just parallel execution
+ * const spec = Parallel('multi-model', [
+ *   LLMStep('gpt4', gpt4Req),
+ *   LLMStep('claude', claudeReq),
+ * ])
+ *   .output('gpt4_result', 'gpt4')
+ *   .output('claude_result', 'claude')
+ *   .build();
+ *
+ * // With aggregation - parallel then combine
+ * const spec = Parallel('multi-model', [
+ *   LLMStep('gpt4', gpt4Req),
+ *   LLMStep('claude', claudeReq),
+ * ])
+ *   .aggregate('synthesize', synthesizeReq)
+ *   .output('result', 'synthesize')
+ *   .build();
+ * ```
+ */
+declare function Parallel(name: string, steps: readonly LLMStepConfig[]): ParallelBuilder;
+/**
+ * Configuration for a map item in MapReduce.
+ */
+type MapItemConfig = {
+    readonly id: string;
+    readonly request: WireResponsesRequest;
+    readonly stream: boolean;
+};
+/**
+ * Creates a map item configuration for use with MapReduce pattern.
+ * Each item becomes a separate mapper node that runs in parallel.
+ *
+ * @param id - Unique identifier for this item (becomes part of node ID: "map_<id>")
+ * @param request - The LLM request for processing this item
+ * @returns A map item configuration object with fluent methods
+ *
+ * @example
+ * ```typescript
+ * const item = MapItem('doc1', {
+ *   model: 'claude-sonnet-4-20250514',
+ *   input: [{ type: 'message', role: 'user', content: [{ type: 'text', text: 'Summarize doc1...' }] }],
+ * });
+ *
+ * // Enable streaming
+ * const streamingItem = item.withStream();
+ * ```
+ */
+declare function MapItem(id: string, request: WireResponsesRequest | ResponsesRequest): MapItemConfig & {
+    withStream(): MapItemConfig;
+};
+/**
+ * Immutable builder for workflow where items are processed in parallel by mapper nodes,
+ * then combined by a reducer node.
+ *
+ * The pattern creates:
+ * - N mapper nodes (one per item), running in parallel
+ * - A join.all node to collect all mapper outputs
+ * - A reducer LLM node that receives the combined outputs
+ *
+ * Note: Items must be known at workflow build time. For dynamic array
+ * processing at runtime, server-side support for dynamic node instantiation
+ * would be required.
+ */
+declare class MapReduceBuilder {
+    private readonly state;
+    private constructor();
+    static create(name: string, items: readonly MapItemConfig[]): MapReduceBuilder;
+    private with;
+    /**
+     * Adds a mapper item to the workflow.
+     * Each item becomes a separate LLM node that runs in parallel.
+     */
+    item(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): MapReduceBuilder;
+    /**
+     * Adds a mapper item with streaming enabled.
+     */
+    itemWithStream(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): MapReduceBuilder;
+    /**
+     * Sets the workflow execution configuration.
+     */
+    execution(exec: WorkflowSpecV0["execution"]): MapReduceBuilder;
+    /**
+     * Adds a reducer node that receives all mapper outputs.
+     * The reducer receives a JSON object mapping each mapper ID to its text output.
+     * The join node ID is automatically generated as "<id>_join".
+     */
+    reduce(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): MapReduceBuilder;
+    /**
+     * Like reduce() but enables streaming on the reducer node.
+     */
+    reduceWithStream(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): MapReduceBuilder;
+    /**
+     * Adds an output reference from a specific node.
+     * Typically used to output from the reducer node.
+     */
+    output(name: OutputName$1 | string, from: NodeId$1 | string): MapReduceBuilder;
+    /**
+     * Builds and returns the compiled workflow spec.
+     * @throws Error if no items are provided or no reducer is configured
+     */
+    build(): WorkflowSpecV0;
+}
+/**
+ * Creates a workflow builder for parallel map-reduce processing.
+ * Each item is processed by a separate mapper node, and results are combined
+ * by a reducer node.
+ *
+ * @param name - Workflow name
+ * @param items - Optional array of MapItem configurations (can also use .item() builder)
+ * @returns A MapReduceBuilder for further configuration
+ *
+ * @example
+ * ```typescript
+ * // Fluent builder pattern (preferred)
+ * const spec = mapReduce('summarize-docs')
+ *   .item('doc1', doc1Req)
+ *   .item('doc2', doc2Req)
+ *   .reduce('combine', combineReq)
+ *   .output(parseOutputName('result'), 'combine')
+ *   .build();
+ * ```
+ */
+declare function MapReduce(name: string, items?: readonly MapItemConfig[]): MapReduceBuilder;
+
 declare function parseApiKey(raw: string): ApiKey;
 declare function parsePublishableKey(raw: string): PublishableKey;
 declare function parseSecretKey(raw: string): SecretKey;
 declare function isPublishableKey(key: ApiKey): key is PublishableKey;
 declare function isSecretKey(key: ApiKey): key is SecretKey;
 
-type index_$defs = $defs;
-type index_components = components;
-type index_operations = operations;
-type index_paths = paths;
-type index_webhooks = webhooks;
+/**
+ * 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$1) => 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$1, count: number, status: RunStatusV0) => void | Promise<void>;
+    /** Called when an error occurs during execution (optional). */
+    onError?: (error: Error, pending?: PendingToolCallV0$1) => 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$1, nodeId: NodeId$1, waiting: NodeWaitingV0$1): 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$1, 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$1_$defs = $defs;
+type index$1_components = components;
+type index$1_operations = operations;
+type index$1_paths = paths;
+type index$1_webhooks = webhooks;
+declare namespace index$1 {
+  export type { index$1_$defs as $defs, index$1_components as components, index$1_operations as operations, index$1_paths as paths, index$1_webhooks as webhooks };
+}
+
+/**
+ * Workflow types with clean naming (no Workflow prefix).
+ *
+ * @example
+ * ```typescript
+ * import { workflow } from "@modelrelay/sdk";
+ *
+ * const spec: workflow.SpecV0 = {
+ *   kind: workflow.KindV0,
+ *   nodes: [{ id: "my_node", type: workflow.NodeTypes.LLMResponses, input: {...} }],
+ *   outputs: [],
+ * };
+ * ```
+ */
+
+type NodeId = NodeId$1;
+type OutputName = OutputName$1;
+type RunId = RunId$1;
+type PlanHash = PlanHash$1;
+
+type Kind = WorkflowKind;
+type SpecV0 = WorkflowSpecV0;
+type NodeV0 = WorkflowNodeV0;
+type EdgeV0 = WorkflowEdgeV0;
+type OutputRefV0 = WorkflowOutputRefV0;
+type BindingV0 = LLMResponsesBindingV0;
+type BindingEncodingV0 = LLMResponsesBindingEncodingV0;
+type ToolLimitsV0 = LLMResponsesToolLimitsV0;
+type ToolExecutionV0 = ToolExecutionV0$1;
+type ToolExecutionModeV0 = ToolExecutionModeV0$1;
+type StatusV0 = RunStatusV0;
+type EventTypeV0 = RunEventTypeV0;
+type EventV0 = RunEventV0;
+type EventBaseV0 = RunEventBaseV0;
+type EventRunCompiledV0 = RunEventRunCompiledV0;
+type EventRunStartedV0 = RunEventRunStartedV0;
+type EventRunCompletedV0 = RunEventRunCompletedV0;
+type EventRunFailedV0 = RunEventRunFailedV0;
+type EventRunCanceledV0 = RunEventRunCanceledV0;
+type EventNodeStartedV0 = RunEventNodeStartedV0;
+type EventNodeSucceededV0 = RunEventNodeSucceededV0;
+type EventNodeFailedV0 = RunEventNodeFailedV0;
+type EventNodeLLMCallV0 = RunEventNodeLLMCallV0;
+type EventNodeToolCallV0 = RunEventNodeToolCallV0;
+type EventNodeToolResultV0 = RunEventNodeToolResultV0;
+type EventNodeWaitingV0 = RunEventNodeWaitingV0;
+type EventNodeOutputDeltaV0 = RunEventNodeOutputDeltaV0;
+type EventNodeOutputV0 = RunEventNodeOutputV0;
+type NodeErrorV0 = NodeErrorV0$1;
+type NodeOutputDeltaV0 = NodeOutputDeltaV0$1;
+type NodeLLMCallV0 = NodeLLMCallV0$1;
+type NodeToolCallV0 = NodeToolCallV0$1;
+type NodeToolResultV0 = NodeToolResultV0$1;
+type NodeWaitingV0 = NodeWaitingV0$1;
+type PendingToolCallV0 = PendingToolCallV0$1;
+type FunctionToolCallV0 = FunctionToolCallV0$1;
+type TokenUsageV0 = TokenUsageV0$1;
+type PayloadInfoV0 = PayloadInfoV0$1;
+type StreamEventKind = StreamEventKind$1;
+declare const KindV0: "workflow.v0";
+declare const NodeTypes: {
+    readonly LLMResponses: "llm.responses";
+    readonly JoinAll: "join.all";
+    readonly TransformJSON: "transform.json";
+};
+type NodeType = (typeof NodeTypes)[keyof typeof NodeTypes];
+declare const BindingEncodings: {
+    readonly JSON: "json";
+    readonly JSONString: "json_string";
+};
+declare const ToolExecutionModes: {
+    readonly Server: "server";
+    readonly Client: "client";
+};
+/** JSON pointer to extract text content from an LLM response output. */
+declare const LLM_TEXT_OUTPUT = "/output/0/content/0/text";
+/** JSON pointer to inject text into the user message of an LLM request. */
+declare const LLM_USER_MESSAGE_TEXT = "/request/input/1/content/0/text";
+
+type index_BindingEncodingV0 = BindingEncodingV0;
+declare const index_BindingEncodings: typeof BindingEncodings;
+type index_BindingV0 = BindingV0;
+type index_EdgeV0 = EdgeV0;
+type index_EventBaseV0 = EventBaseV0;
+type index_EventNodeFailedV0 = EventNodeFailedV0;
+type index_EventNodeLLMCallV0 = EventNodeLLMCallV0;
+type index_EventNodeOutputDeltaV0 = EventNodeOutputDeltaV0;
+type index_EventNodeOutputV0 = EventNodeOutputV0;
+type index_EventNodeStartedV0 = EventNodeStartedV0;
+type index_EventNodeSucceededV0 = EventNodeSucceededV0;
+type index_EventNodeToolCallV0 = EventNodeToolCallV0;
+type index_EventNodeToolResultV0 = EventNodeToolResultV0;
+type index_EventNodeWaitingV0 = EventNodeWaitingV0;
+type index_EventRunCanceledV0 = EventRunCanceledV0;
+type index_EventRunCompiledV0 = EventRunCompiledV0;
+type index_EventRunCompletedV0 = EventRunCompletedV0;
+type index_EventRunFailedV0 = EventRunFailedV0;
+type index_EventRunStartedV0 = EventRunStartedV0;
+type index_EventTypeV0 = EventTypeV0;
+type index_EventV0 = EventV0;
+type index_FunctionToolCallV0 = FunctionToolCallV0;
+type index_Kind = Kind;
+declare const index_KindV0: typeof KindV0;
+declare const index_LLM_TEXT_OUTPUT: typeof LLM_TEXT_OUTPUT;
+declare const index_LLM_USER_MESSAGE_TEXT: typeof LLM_USER_MESSAGE_TEXT;
+type index_NodeErrorV0 = NodeErrorV0;
+type index_NodeId = NodeId;
+type index_NodeLLMCallV0 = NodeLLMCallV0;
+type index_NodeOutputDeltaV0 = NodeOutputDeltaV0;
+type index_NodeToolCallV0 = NodeToolCallV0;
+type index_NodeToolResultV0 = NodeToolResultV0;
+type index_NodeType = NodeType;
+declare const index_NodeTypes: typeof NodeTypes;
+type index_NodeV0 = NodeV0;
+type index_NodeWaitingV0 = NodeWaitingV0;
+type index_OutputName = OutputName;
+type index_OutputRefV0 = OutputRefV0;
+type index_PayloadInfoV0 = PayloadInfoV0;
+type index_PendingToolCallV0 = PendingToolCallV0;
+type index_PlanHash = PlanHash;
+type index_RunId = RunId;
+type index_SpecV0 = SpecV0;
+type index_StatusV0 = StatusV0;
+type index_StreamEventKind = StreamEventKind;
+type index_TokenUsageV0 = TokenUsageV0;
+type index_ToolExecutionModeV0 = ToolExecutionModeV0;
+declare const index_ToolExecutionModes: typeof ToolExecutionModes;
+type index_ToolExecutionV0 = ToolExecutionV0;
+type index_ToolLimitsV0 = ToolLimitsV0;
+declare const index_parseNodeId: typeof parseNodeId;
+declare const index_parseOutputName: typeof parseOutputName;
+declare const index_parsePlanHash: typeof parsePlanHash;
+declare const index_parseRunId: typeof parseRunId;
 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 };
+  export { type index_BindingEncodingV0 as BindingEncodingV0, index_BindingEncodings as BindingEncodings, type index_BindingV0 as BindingV0, type index_EdgeV0 as EdgeV0, type index_EventBaseV0 as EventBaseV0, type index_EventNodeFailedV0 as EventNodeFailedV0, type index_EventNodeLLMCallV0 as EventNodeLLMCallV0, type index_EventNodeOutputDeltaV0 as EventNodeOutputDeltaV0, type index_EventNodeOutputV0 as EventNodeOutputV0, type index_EventNodeStartedV0 as EventNodeStartedV0, type index_EventNodeSucceededV0 as EventNodeSucceededV0, type index_EventNodeToolCallV0 as EventNodeToolCallV0, type index_EventNodeToolResultV0 as EventNodeToolResultV0, type index_EventNodeWaitingV0 as EventNodeWaitingV0, type index_EventRunCanceledV0 as EventRunCanceledV0, type index_EventRunCompiledV0 as EventRunCompiledV0, type index_EventRunCompletedV0 as EventRunCompletedV0, type index_EventRunFailedV0 as EventRunFailedV0, type index_EventRunStartedV0 as EventRunStartedV0, type index_EventTypeV0 as EventTypeV0, type index_EventV0 as EventV0, type index_FunctionToolCallV0 as FunctionToolCallV0, type index_Kind as Kind, index_KindV0 as KindV0, index_LLM_TEXT_OUTPUT as LLM_TEXT_OUTPUT, index_LLM_USER_MESSAGE_TEXT as LLM_USER_MESSAGE_TEXT, type index_NodeErrorV0 as NodeErrorV0, type index_NodeId as NodeId, type index_NodeLLMCallV0 as NodeLLMCallV0, type index_NodeOutputDeltaV0 as NodeOutputDeltaV0, type index_NodeToolCallV0 as NodeToolCallV0, type index_NodeToolResultV0 as NodeToolResultV0, type index_NodeType as NodeType, index_NodeTypes as NodeTypes, type index_NodeV0 as NodeV0, type index_NodeWaitingV0 as NodeWaitingV0, type index_OutputName as OutputName, type index_OutputRefV0 as OutputRefV0, type index_PayloadInfoV0 as PayloadInfoV0, type index_PendingToolCallV0 as PendingToolCallV0, type index_PlanHash as PlanHash, type index_RunId as RunId, type index_SpecV0 as SpecV0, type index_StatusV0 as StatusV0, type index_StreamEventKind as StreamEventKind, type index_TokenUsageV0 as TokenUsageV0, type index_ToolExecutionModeV0 as ToolExecutionModeV0, index_ToolExecutionModes as ToolExecutionModes, type index_ToolExecutionV0 as ToolExecutionV0, type index_ToolLimitsV0 as ToolLimitsV0, index_parseNodeId as parseNodeId, index_parseOutputName as parseOutputName, index_parsePlanHash as parsePlanHash, index_parseRunId as parseRunId };
+}
+
+/**
+ * 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 +8424,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, Chain, ChainBuilder, 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, LLMNodeBuilder, LLMStep, type LLMStepConfig, LLM_TEXT_OUTPUT$1 as LLM_TEXT_OUTPUT, LLM_USER_MESSAGE_TEXT$1 as LLM_USER_MESSAGE_TEXT, type ListSessionsOptions, type ListSessionsResponse, LocalFSToolPack, type LocalFSToolPackOptions, LocalSession, type LocalSessionOptions, type LocalSessionPersistence, MapItem, type MapItemConfig, MapReduce, MapReduceBuilder, 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$1 as NodeErrorV0, type NodeId$1 as 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$1 as OutputName, Parallel, ParallelBuilder, PathEscapeError, type PayloadInfoV0$1 as PayloadInfoV0, type PlanHash$1 as 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$1 as 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, TransformJSONNodeBuilder, type TransformJSONValueV0, TransportError, type TransportErrorKind, type Usage, type UsageSummary, type ValidationIssue, WORKFLOWS_COMPILE_PATH, type WebSearchConfig, type WebToolMode, WebToolModes, Workflow, 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$1 as generated, getRetryableErrors, hasRetryableErrors, hasToolCalls, isAutoProvisionDisabled, isAutoProvisionMisconfigured, isEmailRequired, isIdentityRequired, isProvisioningError, isPublishableKey, isSecretKey, mergeMetrics, mergeTrace, modelToString, newWorkflow, 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, index as workflow, workflowV0, workflow_v0_schema as workflowV0Schema, zodToJsonSchema };