@modelrelay/sdk 0.23.0 → 0.25.1

package/dist/index.d.cts

@@ -271,8 +271,18 @@ interface Project {
     createdAt?: Date;
     updatedAt?: Date;
 }
+/**
+ * Valid roles for chat messages.
+ */
+declare const MessageRoles: {
+    readonly User: "user";
+    readonly Assistant: "assistant";
+    readonly System: "system";
+    readonly Tool: "tool";
+};
+type MessageRole = (typeof MessageRoles)[keyof typeof MessageRoles];
 interface ChatMessage {
-    role: string;
+    role: MessageRole;
     content: string;
     toolCalls?: ToolCall[];
     toolCallId?: string;
@@ -354,6 +364,10 @@ interface ResponseFormat {
     type: ResponseFormatType;
     json_schema?: ResponseJSONSchemaFormat;
 }
+/**
+ * Parameters for direct chat completions (owner PAYGO mode).
+ * Model is required - the developer specifies which model to use.
+ */
 interface ChatCompletionCreateParams {
     model: ModelId;
     messages: NonEmptyArray<ChatMessage>;
@@ -371,9 +385,38 @@ interface ChatCompletionCreateParams {
      */
     toolChoice?: ToolChoice;
     /**
-     * When using publishable keys, a customer id is required to mint a frontend token.
+     * Structured outputs configuration. When set with type `json_object` or
+     * `json_schema`, the backend validates and returns structured JSON.
+     */
+    responseFormat?: ResponseFormat;
+    /**
+     * Opt out of SSE streaming and request a blocking JSON response.
+     */
+    stream?: boolean;
+    /**
+     * Optional request id to set on the call. If omitted, the server will generate one.
+     */
+    requestId?: string;
+}
+/**
+ * Parameters for customer-attributed chat completions.
+ * Model is NOT included - the customer's tier determines the model.
+ */
+interface CustomerChatParams {
+    messages: NonEmptyArray<ChatMessage>;
+    maxTokens?: number;
+    temperature?: number;
+    metadata?: Record<string, string>;
+    stop?: string[];
+    stopSequences?: string[];
+    /**
+     * Tools available for the model to call.
+     */
+    tools?: Tool[];
+    /**
+     * Controls how the model responds to tool calls.
      */
-    customerId?: string;
+    toolChoice?: ToolChoice;
     /**
      * Structured outputs configuration. When set with type `json_object` or
      * `json_schema`, the backend validates and returns structured JSON.
@@ -709,845 +752,1128 @@ declare class AuthClient {
 }
 declare function isPublishableKey(value?: string | null): boolean;
 
-interface ChatRequestOptions {
-    /**
-     * Abort the HTTP request and stream consumption.
-     */
-    signal?: AbortSignal;
-    /**
-     * Override the Accept header to switch between streaming and blocking responses.
-     */
-    stream?: boolean;
-    /**
-     * Optional request id header. `params.requestId` takes precedence if provided.
-     */
-    requestId?: string;
-    /**
-     * Additional HTTP headers for this request.
-     */
-    headers?: Record<string, string>;
-    /**
-     * Additional metadata merged into the request body.
-     */
-    metadata?: Record<string, string>;
-    /**
-     * Override the per-request timeout in milliseconds (set to 0 to disable).
-     */
-    timeoutMs?: number;
-    /**
-     * Override the connect timeout in milliseconds (set to 0 to disable).
-     */
-    connectTimeoutMs?: number;
-    /**
-     * Override retry behavior for this call. Set to `false` to disable retries.
-     */
-    retry?: RetryConfig | false;
-    /**
-     * Per-call metrics callbacks (merged over client defaults).
-     */
-    metrics?: MetricsCallbacks;
-    /**
-     * Per-call trace/log hooks (merged over client defaults).
-     */
-    trace?: TraceCallbacks;
-}
-declare class ChatClient {
-    readonly completions: ChatCompletionsClient;
-    constructor(http: HTTPClient, auth: AuthClient, cfg?: {
-        defaultMetadata?: Record<string, string>;
-        metrics?: MetricsCallbacks;
-        trace?: TraceCallbacks;
-    });
-}
-declare class ChatCompletionsClient {
-    private readonly http;
-    private readonly auth;
-    private readonly defaultMetadata?;
-    private readonly metrics?;
-    private readonly trace?;
-    constructor(http: HTTPClient, auth: AuthClient, defaultMetadata?: Record<string, string>, metrics?: MetricsCallbacks, trace?: TraceCallbacks);
-    create(params: ChatCompletionCreateParams & {
-        stream: false;
-    }, options?: ChatRequestOptions): Promise<ChatCompletionResponse>;
-    create(params: ChatCompletionCreateParams, options: ChatRequestOptions & {
-        stream: false;
-    }): Promise<ChatCompletionResponse>;
-    create(params: ChatCompletionCreateParams, options?: ChatRequestOptions): Promise<ChatCompletionsStream>;
-    /**
-     * Stream structured JSON responses using the NDJSON contract defined for
-     * /llm/proxy. The request must include a structured responseFormat.
-     */
-    streamJSON<T>(params: ChatCompletionCreateParams & {
-        responseFormat: ResponseFormat;
-    }, options?: ChatRequestOptions): Promise<StructuredJSONStream<T>>;
-}
-declare class ChatCompletionsStream implements AsyncIterable<ChatCompletionEvent> {
-    private readonly response;
-    private readonly requestId?;
-    private context;
-    private readonly metrics?;
-    private readonly trace?;
-    private readonly startedAt;
-    private firstTokenEmitted;
-    private closed;
-    constructor(response: Response, requestId: string | undefined, context: RequestContext, metrics?: MetricsCallbacks, trace?: TraceCallbacks);
-    cancel(reason?: unknown): Promise<void>;
-    [Symbol.asyncIterator](): AsyncIterator<ChatCompletionEvent>;
-    private handleStreamEvent;
-    private enrichContext;
-    private recordFirstToken;
-}
-declare class StructuredJSONStream<T> implements AsyncIterable<StructuredJSONEvent<T>> {
-    private readonly response;
-    private readonly requestId?;
-    private context;
-    private readonly metrics?;
-    private readonly trace?;
-    private closed;
-    private sawTerminal;
-    constructor(response: Response, requestId: string | undefined, context: RequestContext, metrics?: MetricsCallbacks, trace?: TraceCallbacks);
-    cancel(reason?: unknown): Promise<void>;
-    [Symbol.asyncIterator](): AsyncIterator<StructuredJSONEvent<T>>;
-    collect(): Promise<T>;
-    private parseRecord;
-    private traceStructuredEvent;
-}
-
 /**
- * Customer metadata as an arbitrary key-value object.
+ * Creates a user message.
  */
-type CustomerMetadata = Record<string, unknown>;
+declare function createUserMessage(content: string): ChatMessage;
 /**
- * Customer represents a customer in a ModelRelay project.
+ * Creates an assistant message.
  */
-interface Customer {
-    id: string;
-    project_id: string;
-    tier_id: string;
-    tier_code?: string;
-    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;
-}
+declare function createAssistantMessage(content: string): ChatMessage;
 /**
- * Request to create a customer.
+ * Creates a system message.
  */
-interface CustomerCreateRequest {
-    tier_id: string;
-    external_id: string;
-    email: string;
-    metadata?: CustomerMetadata;
-}
+declare function createSystemMessage(content: string): ChatMessage;
 /**
- * Request to upsert a customer by external_id.
+ * Creates a tool call object.
  */
-interface CustomerUpsertRequest {
-    tier_id: string;
-    external_id: string;
-    email: string;
-    metadata?: CustomerMetadata;
-}
+declare function createToolCall(id: string, name: string, args: string, type?: ToolType): ToolCall;
 /**
- * Request to claim a customer by email, setting their external_id.
- * Used when a customer subscribes via Stripe Checkout (email only) and later
- * authenticates to the app, needing to link their identity.
+ * Creates a function call object.
  */
-interface CustomerClaimRequest {
-    email: string;
-    external_id: string;
-}
+declare function createFunctionCall(name: string, args: string): FunctionCall;
 /**
- * Request to create a checkout session.
+ * Interface for Zod-like schema types.
+ * Compatible with Zod's ZodType and similar libraries.
  */
-interface CheckoutSessionRequest {
-    success_url: string;
-    cancel_url: string;
+interface ZodLikeSchema {
+    _def: {
+        typeName: string;
+        [key: string]: unknown;
+    };
+    parse(data: unknown): unknown;
+    safeParse(data: unknown): {
+        success: boolean;
+        data?: unknown;
+        error?: unknown;
+    };
 }
 /**
- * Checkout session response.
+ * Options for JSON Schema generation.
  */
-interface CheckoutSession {
-    session_id: string;
-    url: string;
+interface JsonSchemaOptions {
+    /** Whether to include $schema property. Defaults to false. */
+    includeSchema?: boolean;
+    /** Target JSON Schema version. Defaults to "draft-07". */
+    target?: "draft-04" | "draft-07" | "draft-2019-09" | "draft-2020-12";
 }
 /**
- * Subscription status response.
+ * Converts a Zod schema to JSON Schema.
+ * This is a simplified implementation that handles common Zod types.
+ * For full Zod support, consider using the 'zod-to-json-schema' package.
+ *
+ * @param schema - A Zod schema
+ * @param options - Optional JSON Schema generation options
+ * @returns A JSON Schema object
  */
-interface SubscriptionStatus {
-    active: boolean;
-    subscription_id?: string;
-    status?: string;
-    current_period_start?: string;
-    current_period_end?: string;
-}
-interface CustomersClientConfig {
-    apiKey?: string;
-}
+declare function zodToJsonSchema(schema: ZodLikeSchema, options?: JsonSchemaOptions): Record<string, unknown>;
 /**
- * CustomersClient provides methods to manage customers in a project.
- * Requires a secret key (mr_sk_*) for authentication.
- */
-declare class CustomersClient {
-    private readonly http;
-    private readonly apiKey?;
-    constructor(http: HTTPClient, cfg: CustomersClientConfig);
-    private ensureSecretKey;
-    /**
-     * List all customers in the project.
-     */
-    list(): Promise<Customer[]>;
-    /**
-     * Create a new customer in the project.
-     */
-    create(request: CustomerCreateRequest): Promise<Customer>;
-    /**
-     * Get a customer by ID.
-     */
-    get(customerId: string): Promise<Customer>;
-    /**
-     * 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>;
+ * Creates a function tool from a Zod schema.
+ *
+ * This function automatically converts a Zod schema to a JSON Schema
+ * and creates a tool definition. It eliminates the need to manually
+ * write JSON schemas for tool parameters.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createFunctionToolFromSchema } from "@modelrelay/sdk";
+ *
+ * const weatherParams = z.object({
+ *   location: z.string().describe("City name"),
+ *   unit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
+ * });
+ *
+ * const weatherTool = createFunctionToolFromSchema(
+ *   "get_weather",
+ *   "Get weather for a location",
+ *   weatherParams
+ * );
+ * ```
+ *
+ * @param name - The tool name
+ * @param description - A description of what the tool does
+ * @param schema - A Zod schema defining the tool's parameters
+ * @param options - Optional JSON Schema generation options
+ * @returns A Tool definition with the JSON schema derived from the Zod schema
+ */
+declare function createFunctionToolFromSchema(name: string, description: string, schema: ZodLikeSchema, options?: JsonSchemaOptions): Tool;
+/**
+ * Creates a function tool with the given name, description, and JSON schema.
+ */
+declare function createFunctionTool(name: string, description: string, parameters?: Record<string, unknown>): Tool;
+/**
+ * Creates a web tool with optional domain filters and mode.
+ */
+declare function createWebTool(options?: {
+    mode?: WebToolMode;
+    allowedDomains?: string[];
+    excludedDomains?: string[];
+    maxUses?: number;
+}): Tool;
+/**
+ * Returns a ToolChoice that lets the model decide when to use tools.
+ */
+declare function toolChoiceAuto(): ToolChoice;
+/**
+ * Returns a ToolChoice that forces the model to use a tool.
+ */
+declare function toolChoiceRequired(): ToolChoice;
+/**
+ * Returns a ToolChoice that prevents the model from using tools.
+ */
+declare function toolChoiceNone(): ToolChoice;
+/**
+ * Returns true if the response contains tool calls.
+ */
+declare function hasToolCalls(response: ChatCompletionResponse): boolean;
+/**
+ * Returns the first tool call from a response, or undefined if none exist.
+ */
+declare function firstToolCall(response: ChatCompletionResponse): ToolCall | undefined;
+/**
+ * Creates a message containing the result of a tool call.
+ */
+declare function toolResultMessage(toolCallId: string, result: unknown): ChatMessage;
+/**
+ * Creates a tool result message from a ToolCall.
+ * Convenience wrapper around toolResultMessage using the call's ID.
+ */
+declare function respondToToolCall(call: ToolCall, result: unknown): ChatMessage;
+/**
+ * Creates an assistant message that includes tool calls.
+ * Used to include the assistant's tool-calling turn in conversation history.
+ */
+declare function assistantMessageWithToolCalls(content: string, toolCalls: ToolCall[]): ChatMessage;
+/**
+ * Accumulates streaming tool call deltas into complete tool calls.
+ */
+declare class ToolCallAccumulator {
+    private calls;
     /**
-     * Claim a customer by email, setting their external_id.
-     * Used when a customer subscribes via Stripe Checkout (email only) and later
-     * authenticates to the app, needing to link their identity.
-     *
-     * @throws {APIError} with status 404 if customer not found by email
-     * @throws {APIError} with status 409 if customer already claimed or external_id in use
+     * Processes a streaming tool call delta.
+     * Returns true if this started a new tool call.
      */
-    claim(request: CustomerClaimRequest): Promise<Customer>;
+    processDelta(delta: ToolCallDelta): boolean;
     /**
-     * Delete a customer by ID.
+     * Returns all accumulated tool calls in index order.
      */
-    delete(customerId: string): Promise<void>;
+    getToolCalls(): ToolCall[];
     /**
-     * Create a Stripe checkout session for a customer.
+     * Returns a specific tool call by index, or undefined if not found.
      */
-    createCheckoutSession(customerId: string, request: CheckoutSessionRequest): Promise<CheckoutSession>;
+    getToolCall(index: number): ToolCall | undefined;
     /**
-     * Get the subscription status for a customer.
+     * Clears all accumulated tool calls.
      */
-    getSubscription(customerId: string): Promise<SubscriptionStatus>;
+    reset(): void;
 }
-
 /**
- * Billing interval for a tier.
+ * Error thrown when tool argument parsing or validation fails.
+ * Contains a descriptive message suitable for sending back to the model.
  */
-type PriceInterval = "month" | "year";
+declare class ToolArgsError extends Error {
+    /** The tool call ID for correlation */
+    readonly toolCallId: string;
+    /** The tool name that was called */
+    readonly toolName: string;
+    /** The raw arguments string that failed to parse */
+    readonly rawArguments: string;
+    constructor(message: string, toolCallId: string, toolName: string, rawArguments: string);
+}
 /**
- * Tier represents a pricing tier in a ModelRelay project.
+ * Schema interface compatible with Zod, Yup, and similar validation libraries.
+ * Any object with a `parse` method that returns the validated type works.
  */
-interface Tier {
-    id: string;
-    project_id: string;
-    tier_code: string;
-    display_name: string;
-    spend_limit_cents: number;
-    stripe_price_id?: string;
-    price_amount?: number;
-    price_currency?: string;
-    price_interval?: PriceInterval;
-    trial_days?: number;
-    created_at: string;
-    updated_at: string;
+interface Schema<T> {
+    parse(data: unknown): T;
 }
 /**
- * Request to create a tier checkout session (Stripe-first flow).
- * Stripe collects the customer's email during checkout.
+ * Parses and validates tool call arguments using a schema.
+ *
+ * Works with any schema library that has a `parse` method (Zod, Yup, etc.).
+ * Throws a descriptive ToolArgsError if parsing or validation fails.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ *
+ * const WeatherArgs = z.object({
+ *   location: z.string(),
+ *   unit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
+ * });
+ *
+ * // In your tool handler:
+ * const args = parseToolArgs(toolCall, WeatherArgs);
+ * // args is typed as { location: string; unit: "celsius" | "fahrenheit" }
+ * ```
+ *
+ * @param call - The tool call containing arguments to parse
+ * @param schema - A schema with a `parse` method (Zod, Yup, etc.)
+ * @returns The parsed and validated arguments with proper types
+ * @throws {ToolArgsError} If JSON parsing or schema validation fails
  */
-interface TierCheckoutRequest {
-    success_url: string;
-    cancel_url: string;
-}
+declare function parseToolArgs<T>(call: ToolCall, schema: Schema<T>): T;
 /**
- * Tier checkout session response.
+ * Attempts to parse tool arguments, returning a result object instead of throwing.
+ *
+ * @example
+ * ```typescript
+ * const result = tryParseToolArgs(toolCall, WeatherArgs);
+ * if (result.success) {
+ *   console.log(result.data.location);
+ * } else {
+ *   console.error(result.error.message);
+ * }
+ * ```
+ *
+ * @param call - The tool call containing arguments to parse
+ * @param schema - A schema with a `parse` method
+ * @returns An object with either { success: true, data: T } or { success: false, error: ToolArgsError }
  */
-interface TierCheckoutSession {
-    session_id: string;
-    url: string;
-}
-interface TiersClientConfig {
-    apiKey?: string;
+declare function tryParseToolArgs<T>(call: ToolCall, schema: Schema<T>): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ToolArgsError;
+};
+/**
+ * Parses raw JSON arguments without schema validation.
+ * Useful when you want JSON parsing error handling but not schema validation.
+ *
+ * @param call - The tool call containing arguments to parse
+ * @returns The parsed JSON as an unknown type
+ * @throws {ToolArgsError} If JSON parsing fails
+ */
+declare function parseToolArgsRaw(call: ToolCall): unknown;
+/**
+ * Handler function type for tool execution.
+ * Can be sync or async, receives parsed arguments and returns a result.
+ */
+type ToolHandler<T = unknown, R = unknown> = (args: T, call: ToolCall) => R | Promise<R>;
+/**
+ * Result of executing a tool call.
+ */
+interface ToolExecutionResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    error?: string;
+    /**
+     * True if the error is due to malformed arguments (JSON parse or validation failure)
+     * and the model should be given a chance to retry with corrected arguments.
+     */
+    isRetryable?: boolean;
 }
 /**
- * TiersClient provides methods to query tiers in a project.
- * Works with both publishable keys (mr_pk_*) and secret keys (mr_sk_*).
+ * Registry for mapping tool names to handler functions with automatic dispatch.
+ *
+ * @example
+ * ```typescript
+ * const registry = new ToolRegistry()
+ *   .register("get_weather", async (args) => {
+ *     return { temp: 72, unit: "fahrenheit" };
+ *   })
+ *   .register("search", async (args) => {
+ *     return { results: ["result1", "result2"] };
+ *   });
+ *
+ * // Execute all tool calls from a response
+ * const results = await registry.executeAll(response.toolCalls);
+ *
+ * // Convert results to messages for the next request
+ * const messages = registry.resultsToMessages(results);
+ * ```
  */
-declare class TiersClient {
-    private readonly http;
-    private readonly apiKey?;
-    constructor(http: HTTPClient, cfg: TiersClientConfig);
-    private ensureApiKey;
-    private ensureSecretKey;
+declare class ToolRegistry {
+    private handlers;
     /**
-     * List all tiers in the project.
+     * Registers a handler function for a tool name.
+     * @param name - The tool name (must match the function name in the tool definition)
+     * @param handler - Function to execute when this tool is called
+     * @returns this for chaining
      */
-    list(): Promise<Tier[]>;
+    register<T = unknown, R = unknown>(name: string, handler: ToolHandler<T, R>): this;
     /**
-     * Get a tier by ID.
+     * Unregisters a tool handler.
+     * @param name - The tool name to unregister
+     * @returns true if the handler was removed, false if it didn't exist
      */
-    get(tierId: string): Promise<Tier>;
+    unregister(name: string): boolean;
     /**
-     * Create a Stripe checkout session for a tier (Stripe-first flow).
-     *
-     * This enables users to subscribe before authenticating. Stripe collects
-     * the customer's email during checkout. After checkout completes, a
-     * customer record is created with the email from Stripe. The customer
-     * can later be linked to an identity via POST /customers/claim.
-     *
-     * Requires a secret key (mr_sk_*).
-     *
-     * @param tierId - The tier ID to create a checkout session for
-     * @param request - Checkout session request with redirect URLs
-     * @returns Checkout session with Stripe URL
+     * Checks if a handler is registered for the given tool name.
      */
-    checkout(tierId: string, request: TierCheckoutRequest): Promise<TierCheckoutSession>;
-}
-
-/**
- * API error codes returned by the server.
- * These constants can be used for programmatic error handling.
- */
-declare const ErrorCodes: {
-    readonly NOT_FOUND: "NOT_FOUND";
-    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
-    readonly RATE_LIMIT: "RATE_LIMIT";
-    readonly UNAUTHORIZED: "UNAUTHORIZED";
-    readonly FORBIDDEN: "FORBIDDEN";
-    readonly CONFLICT: "CONFLICT";
-    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
-    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
-    readonly INVALID_INPUT: "INVALID_INPUT";
-    readonly PAYMENT_REQUIRED: "PAYMENT_REQUIRED";
-    readonly METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED";
-    /** No tiers configured for the project - create a tier first. */
-    readonly NO_TIERS: "NO_TIERS";
-    /** No free tier available for auto-provisioning - create a free tier or use checkout flow. */
-    readonly NO_FREE_TIER: "NO_FREE_TIER";
-    /** Email required for auto-provisioning a new customer. */
-    readonly EMAIL_REQUIRED: "EMAIL_REQUIRED";
-};
-type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
-type ErrorCategory = "config" | "transport" | "api";
-declare class ModelRelayError extends Error {
-    category: ErrorCategory;
-    status?: number;
-    code?: string;
-    requestId?: string;
-    fields?: FieldError[];
-    data?: unknown;
-    retries?: RetryMetadata;
-    cause?: unknown;
-    constructor(message: string, opts: {
-        category: ErrorCategory;
-        status?: number;
-        code?: string;
-        requestId?: string;
-        fields?: FieldError[];
-        data?: unknown;
-        retries?: RetryMetadata;
-        cause?: unknown;
-    });
-}
-declare class ConfigError extends ModelRelayError {
-    constructor(message: string, data?: unknown);
-}
-declare class TransportError extends ModelRelayError {
-    kind: TransportErrorKind;
-    constructor(message: string, opts: {
-        kind: TransportErrorKind;
-        retries?: RetryMetadata;
-        cause?: unknown;
-    });
-}
-declare class APIError extends ModelRelayError {
-    constructor(message: string, opts: {
-        status: number;
-        code?: string;
-        requestId?: string;
-        fields?: FieldError[];
-        data?: unknown;
-        retries?: RetryMetadata;
-    });
-    /** Returns true if the error is a not found error. */
-    isNotFound(): boolean;
-    /** Returns true if the error is a validation error. */
-    isValidation(): boolean;
-    /** Returns true if the error is a rate limit error. */
-    isRateLimit(): boolean;
-    /** Returns true if the error is an unauthorized error. */
-    isUnauthorized(): boolean;
-    /** Returns true if the error is a forbidden error. */
-    isForbidden(): boolean;
-    /** Returns true if the error is a service unavailable error. */
-    isUnavailable(): boolean;
+    has(name: string): boolean;
     /**
-     * Returns true if the error indicates no tiers are configured.
-     * To resolve: create at least one tier in your project dashboard.
+     * Returns the list of registered tool names.
      */
-    isNoTiers(): boolean;
+    getRegisteredTools(): string[];
     /**
-     * Returns true if the error indicates no free tier is available for auto-provisioning.
-     * To resolve: either create a free tier for automatic customer creation,
-     * or use the checkout flow to create paying customers first.
+     * Executes a single tool call.
+     * @param call - The tool call to execute
+     * @returns The execution result
      */
-    isNoFreeTier(): boolean;
+    execute(call: ToolCall): Promise<ToolExecutionResult>;
     /**
-     * Returns true if email is required for auto-provisioning a new customer.
-     * To resolve: provide the 'email' field in FrontendTokenRequest.
+     * Executes multiple tool calls in parallel.
+     * @param calls - Array of tool calls to execute
+     * @returns Array of execution results in the same order as input
      */
-    isEmailRequired(): boolean;
+    executeAll(calls: ToolCall[]): Promise<ToolExecutionResult[]>;
     /**
-     * Returns true if this is a customer provisioning error (NO_TIERS, NO_FREE_TIER, or EMAIL_REQUIRED).
-     * These errors occur when calling frontendToken() with a customer that doesn't exist
-     * and automatic provisioning cannot complete.
+     * Converts execution results to tool result messages.
+     * Useful for appending to the conversation history.
+     * @param results - Array of execution results
+     * @returns Array of ChatMessage objects with role "tool"
      */
-    isProvisioningError(): boolean;
+    resultsToMessages(results: ToolExecutionResult[]): ChatMessage[];
 }
 /**
- * Returns true if the error indicates email is required for auto-provisioning.
+ * Formats a tool execution error into a message suitable for sending back to the model.
+ * The message is designed to help the model understand what went wrong and correct it.
+ *
+ * @example
+ * ```typescript
+ * const result = await registry.execute(toolCall);
+ * if (result.error && result.isRetryable) {
+ *   const errorMessage = formatToolErrorForModel(result);
+ *   messages.push(toolResultMessage(result.toolCallId, errorMessage));
+ *   // Continue conversation to let model retry
+ * }
+ * ```
  */
-declare function isEmailRequired(err: unknown): boolean;
+declare function formatToolErrorForModel(result: ToolExecutionResult): string;
 /**
- * Returns true if the error indicates no free tier is available.
+ * Checks if any results have retryable errors.
+ *
+ * @example
+ * ```typescript
+ * const results = await registry.executeAll(toolCalls);
+ * if (hasRetryableErrors(results)) {
+ *   // Send error messages back to model and continue conversation
+ * }
+ * ```
+ */
+declare function hasRetryableErrors(results: ToolExecutionResult[]): boolean;
+/**
+ * Filters results to only those with retryable errors.
+ */
+declare function getRetryableErrors(results: ToolExecutionResult[]): ToolExecutionResult[];
+/**
+ * Creates tool result messages for retryable errors, formatted to help the model correct them.
+ *
+ * @example
+ * ```typescript
+ * const results = await registry.executeAll(toolCalls);
+ * if (hasRetryableErrors(results)) {
+ *   const retryMessages = createRetryMessages(results);
+ *   messages.push(...retryMessages);
+ *   // Make another API call to let model retry
+ * }
+ * ```
+ */
+declare function createRetryMessages(results: ToolExecutionResult[]): ChatMessage[];
+/**
+ * Options for executeWithRetry.
+ */
+interface RetryOptions {
+    /**
+     * Maximum number of retry attempts for parse/validation errors.
+     * @default 2
+     */
+    maxRetries?: number;
+    /**
+     * Callback invoked when a retryable error occurs.
+     * Should return new tool calls from the model's response.
+     * If not provided, executeWithRetry will not retry automatically.
+     *
+     * @param errorMessages - Messages to send back to the model
+     * @param attempt - Current attempt number (1-based)
+     * @returns New tool calls from the model, or empty array to stop retrying
+     */
+    onRetry?: (errorMessages: ChatMessage[], attempt: number) => Promise<ToolCall[]>;
+}
+/**
+ * Executes tool calls with automatic retry on parse/validation errors.
+ *
+ * This is a higher-level utility that wraps registry.executeAll with retry logic.
+ * When a retryable error occurs, it calls the onRetry callback to get new tool calls
+ * from the model and continues execution.
+ *
+ * **Result Preservation**: Successful results are preserved across retries. If you
+ * execute multiple tool calls and only some fail, the successful results are kept
+ * and merged with the results from retry attempts. Results are keyed by toolCallId,
+ * so if a retry returns a call with the same ID as a previous result, the newer
+ * result will replace it.
+ *
+ * @example
+ * ```typescript
+ * const results = await executeWithRetry(registry, toolCalls, {
+ *   maxRetries: 2,
+ *   onRetry: async (errorMessages, attempt) => {
+ *     console.log(`Retry attempt ${attempt}`);
+ *     // Add error messages to conversation and call the model again
+ *     messages.push(assistantMessageWithToolCalls("", toolCalls));
+ *     messages.push(...errorMessages);
+ *     const response = await client.chat.completions.create({ messages, tools });
+ *     return response.toolCalls ?? [];
+ *   },
+ * });
+ * ```
+ *
+ * @param registry - The tool registry to use for execution
+ * @param toolCalls - Initial tool calls to execute
+ * @param options - Retry configuration
+ * @returns Final execution results after all retries, including preserved successes
+ */
+declare function executeWithRetry(registry: ToolRegistry, toolCalls: ToolCall[], options?: RetryOptions): Promise<ToolExecutionResult[]>;
+
+/**
+ * Ergonomic structured output API with Zod schema inference and validation.
+ *
+ * This module provides type-safe structured outputs using Zod schemas for
+ * automatic JSON schema generation. The API handles schema construction,
+ * validation retries with error feedback, and strongly-typed result parsing.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const PersonSchema = z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ * });
+ *
+ * const result = await client.chat.completions.structured(
+ *   PersonSchema,
+ *   { model: "claude-sonnet-4-20250514", messages: [...] },
+ *   { maxRetries: 2 }
+ * );
+ *
+ * console.log(result.value.name, result.value.age);
+ * ```
  */
-declare function isNoFreeTier(err: unknown): boolean;
+
 /**
- * Returns true if the error indicates no tiers are configured.
+ * Record of a single structured output attempt.
  */
-declare function isNoTiers(err: unknown): boolean;
+interface AttemptRecord {
+    /** Which attempt (1-based). */
+    attempt: number;
+    /** Raw JSON returned by the model. */
+    rawJson: string;
+    /** The error that occurred. */
+    error: StructuredErrorKind;
+}
 /**
- * Returns true if the error is a customer provisioning error.
+ * Specific kind of structured output error.
  */
-declare function isProvisioningError(err: unknown): boolean;
-declare function parseErrorResponse(response: Response, retries?: RetryMetadata): Promise<APIError>;
-
+type StructuredErrorKind = {
+    kind: "decode";
+    message: string;
+} | {
+    kind: "validation";
+    issues: ValidationIssue[];
+};
 /**
- * Creates a user message.
+ * A single field-level validation issue.
  */
-declare function createUserMessage(content: string): ChatMessage;
+interface ValidationIssue {
+    /** JSON path to the problematic field (e.g., "person.address.city"). */
+    path?: string;
+    /** Description of the issue. */
+    message: string;
+}
 /**
- * Creates an assistant message.
+ * Error returned when structured output fails on first attempt (before retries).
  */
-declare function createAssistantMessage(content: string): ChatMessage;
+declare class StructuredDecodeError extends Error {
+    readonly rawJson: string;
+    readonly attempt: number;
+    constructor(message: string, rawJson: string, attempt: number);
+}
 /**
- * Creates a system message.
+ * Error returned when all retry attempts are exhausted.
  */
-declare function createSystemMessage(content: string): ChatMessage;
+declare class StructuredExhaustedError extends Error {
+    readonly lastRawJson: string;
+    readonly allAttempts: AttemptRecord[];
+    readonly finalError: StructuredErrorKind;
+    constructor(lastRawJson: string, allAttempts: AttemptRecord[], finalError: StructuredErrorKind);
+}
 /**
- * Creates a tool call object.
+ * Handler for customizing retry behavior on validation failures.
+ *
+ * Implement this interface to customize how retry messages are constructed
+ * when validation fails. The default implementation appends a simple
+ * error message asking the model to correct its output.
  */
-declare function createToolCall(id: string, name: string, args: string, type?: ToolType): ToolCall;
+interface RetryHandler {
+    /**
+     * Called when validation fails. Returns messages to append to the conversation
+     * for the retry, or `null` to stop retrying immediately.
+     *
+     * @param attempt - Current attempt number (1-based)
+     * @param rawJson - The raw JSON that failed validation
+     * @param error - The validation/decode error that occurred
+     * @param originalMessages - The original conversation messages
+     */
+    onValidationError(attempt: number, rawJson: string, error: StructuredErrorKind, originalMessages: ChatMessage[]): ChatMessage[] | null;
+}
 /**
- * Creates a function call object.
+ * Default retry handler that appends a simple error correction message.
  */
-declare function createFunctionCall(name: string, args: string): FunctionCall;
+declare const defaultRetryHandler: RetryHandler;
 /**
- * Interface for Zod-like schema types.
- * Compatible with Zod's ZodType and similar libraries.
+ * Options for structured output requests.
  */
-interface ZodLikeSchema {
-    _def: {
-        typeName: string;
-        [key: string]: unknown;
-    };
-    parse(data: unknown): unknown;
-    safeParse(data: unknown): {
-        success: boolean;
-        data?: unknown;
-        error?: unknown;
-    };
+interface StructuredOptions {
+    /** Maximum number of retry attempts on validation failure (default: 0). */
+    maxRetries?: number;
+    /** Handler for customizing retry messages. */
+    retryHandler?: RetryHandler;
+    /** Override the schema name (defaults to "response"). */
+    schemaName?: string;
 }
 /**
- * Options for JSON Schema generation.
+ * Result of a successful structured output request.
  */
-interface JsonSchemaOptions {
-    /** Whether to include $schema property. Defaults to false. */
-    includeSchema?: boolean;
-    /** Target JSON Schema version. Defaults to "draft-07". */
-    target?: "draft-04" | "draft-07" | "draft-2019-09" | "draft-2020-12";
+interface StructuredResult<T> {
+    /** The parsed, validated value. */
+    value: T;
+    /** Number of attempts made (1 = first attempt succeeded). */
+    attempts: number;
+    /** Request ID from the server (if available). */
+    requestId?: string;
 }
 /**
- * Converts a Zod schema to JSON Schema.
- * This is a simplified implementation that handles common Zod types.
- * For full Zod support, consider using the 'zod-to-json-schema' package.
+ * Creates a ResponseFormat from a Zod schema with automatic JSON schema generation.
  *
- * @param schema - A Zod schema
- * @param options - Optional JSON Schema generation options
- * @returns A JSON Schema object
- */
-declare function zodToJsonSchema(schema: ZodLikeSchema, options?: JsonSchemaOptions): Record<string, unknown>;
-/**
- * Creates a function tool from a Zod schema.
+ * This function uses `zodToJsonSchema` to convert a Zod schema to JSON Schema,
+ * then wraps it in a ResponseFormat with `type = "json_schema"` and `strict = true`.
  *
- * This function automatically converts a Zod schema to a JSON Schema
- * and creates a tool definition. It eliminates the need to manually
- * write JSON schemas for tool parameters.
+ * @param schema - A Zod schema
+ * @param name - Optional schema name (defaults to "response")
+ * @returns A ResponseFormat configured for structured outputs
  *
  * @example
  * ```typescript
- * import { z } from "zod";
- * import { createFunctionToolFromSchema } from "@modelrelay/sdk";
+ * import { z } from 'zod';
  *
- * const weatherParams = z.object({
- *   location: z.string().describe("City name"),
- *   unit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
+ * const WeatherSchema = z.object({
+ *   temperature: z.number(),
+ *   conditions: z.string(),
  * });
  *
- * const weatherTool = createFunctionToolFromSchema(
- *   "get_weather",
- *   "Get weather for a location",
- *   weatherParams
- * );
+ * const format = responseFormatFromZod(WeatherSchema, "weather");
  * ```
- *
- * @param name - The tool name
- * @param description - A description of what the tool does
- * @param schema - A Zod schema defining the tool's parameters
- * @param options - Optional JSON Schema generation options
- * @returns A Tool definition with the JSON schema derived from the Zod schema
  */
-declare function createFunctionToolFromSchema(name: string, description: string, schema: ZodLikeSchema, options?: JsonSchemaOptions): Tool;
+declare function responseFormatFromZod(schema: ZodLikeSchema, name?: string): ResponseFormat;
 /**
- * Creates a function tool with the given name, description, and JSON schema.
+ * Validates parsed data against a Zod schema.
+ *
+ * @param schema - A Zod schema to validate against
+ * @param data - The data to validate
+ * @returns A result object with success/failure and data/error
  */
-declare function createFunctionTool(name: string, description: string, parameters?: Record<string, unknown>): Tool;
+declare function validateWithZod<T>(schema: ZodLikeSchema, data: unknown): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+
+interface ChatRequestOptions {
+    /**
+     * Abort the HTTP request and stream consumption.
+     */
+    signal?: AbortSignal;
+    /**
+     * Override the Accept header to switch between streaming and blocking responses.
+     */
+    stream?: boolean;
+    /**
+     * Optional request id header. `params.requestId` takes precedence if provided.
+     */
+    requestId?: string;
+    /**
+     * Additional HTTP headers for this request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Additional metadata merged into the request body.
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Override the per-request timeout in milliseconds (set to 0 to disable).
+     */
+    timeoutMs?: number;
+    /**
+     * Override the connect timeout in milliseconds (set to 0 to disable).
+     */
+    connectTimeoutMs?: number;
+    /**
+     * Override retry behavior for this call. Set to `false` to disable retries.
+     */
+    retry?: RetryConfig | false;
+    /**
+     * Per-call metrics callbacks (merged over client defaults).
+     */
+    metrics?: MetricsCallbacks;
+    /**
+     * Per-call trace/log hooks (merged over client defaults).
+     */
+    trace?: TraceCallbacks;
+}
+declare class ChatClient {
+    readonly completions: ChatCompletionsClient;
+    private readonly http;
+    private readonly auth;
+    private readonly defaultMetadata?;
+    private readonly metrics?;
+    private readonly trace?;
+    constructor(http: HTTPClient, auth: AuthClient, cfg?: {
+        defaultMetadata?: Record<string, string>;
+        metrics?: MetricsCallbacks;
+        trace?: TraceCallbacks;
+    });
+    /**
+     * Create a customer-attributed chat client for the given customer ID.
+     * The customer's tier determines the model - no model parameter is needed or allowed.
+     *
+     * @example
+     * ```typescript
+     * const stream = await client.chat.forCustomer("user-123").create({
+     *   messages: [{ role: "user", content: "Hello!" }],
+     * });
+     * ```
+     */
+    forCustomer(customerId: string): CustomerChatClient;
+}
+declare class ChatCompletionsClient {
+    private readonly http;
+    private readonly auth;
+    private readonly defaultMetadata?;
+    private readonly metrics?;
+    private readonly trace?;
+    constructor(http: HTTPClient, auth: AuthClient, defaultMetadata?: Record<string, string>, metrics?: MetricsCallbacks, trace?: TraceCallbacks);
+    create(params: ChatCompletionCreateParams & {
+        stream: false;
+    }, options?: ChatRequestOptions): Promise<ChatCompletionResponse>;
+    create(params: ChatCompletionCreateParams, options: ChatRequestOptions & {
+        stream: false;
+    }): Promise<ChatCompletionResponse>;
+    create(params: ChatCompletionCreateParams, options?: ChatRequestOptions): Promise<ChatCompletionsStream>;
+    /**
+     * Stream structured JSON responses using the NDJSON contract defined for
+     * /llm/proxy. The request must include a structured responseFormat.
+     */
+    streamJSON<T>(params: ChatCompletionCreateParams & {
+        responseFormat: ResponseFormat;
+    }, options?: ChatRequestOptions): Promise<StructuredJSONStream<T>>;
+    /**
+     * Send a structured output request with a Zod schema.
+     *
+     * Auto-generates JSON schema from the Zod schema, validates the response,
+     * and retries on validation failure if configured.
+     *
+     * @param schema - A Zod schema defining the expected response structure
+     * @param params - Chat completion parameters (excluding responseFormat)
+     * @param options - Request options including retry configuration
+     * @returns A typed result with the parsed value
+     *
+     * @example
+     * ```typescript
+     * import { z } from 'zod';
+     *
+     * const PersonSchema = z.object({
+     *   name: z.string(),
+     *   age: z.number(),
+     * });
+     *
+     * const result = await client.chat.completions.structured(
+     *   PersonSchema,
+     *   { model: "claude-sonnet-4-20250514", messages: [...] },
+     *   { maxRetries: 2 }
+     * );
+     * ```
+     */
+    structured<T>(schema: ZodLikeSchema, params: Omit<ChatCompletionCreateParams, "responseFormat">, options?: ChatRequestOptions & StructuredOptions): Promise<StructuredResult<T>>;
+    /**
+     * Stream structured output with a Zod schema.
+     *
+     * Auto-generates JSON schema from the Zod schema. Note that streaming
+     * does not support retries - for retry behavior, use `structured()`.
+     *
+     * @param schema - A Zod schema defining the expected response structure
+     * @param params - Chat completion parameters (excluding responseFormat)
+     * @param options - Request options
+     * @returns A structured JSON stream
+     *
+     * @example
+     * ```typescript
+     * import { z } from 'zod';
+     *
+     * const PersonSchema = z.object({
+     *   name: z.string(),
+     *   age: z.number(),
+     * });
+     *
+     * const stream = await client.chat.completions.streamStructured(
+     *   PersonSchema,
+     *   { model: "claude-sonnet-4-20250514", messages: [...] },
+     * );
+     *
+     * for await (const event of stream) {
+     *   console.log(event.type, event.payload);
+     * }
+     * ```
+     */
+    streamStructured<T>(schema: ZodLikeSchema, params: Omit<ChatCompletionCreateParams, "responseFormat">, options?: ChatRequestOptions & Pick<StructuredOptions, "schemaName">): Promise<StructuredJSONStream<T>>;
+}
 /**
- * Creates a web tool with optional domain filters and mode.
+ * Client for customer-attributed chat completions.
+ * The customer's tier determines the model - no model parameter is needed or allowed.
  */
-declare function createWebTool(options?: {
-    mode?: WebToolMode;
-    allowedDomains?: string[];
-    excludedDomains?: string[];
-    maxUses?: number;
-}): Tool;
+declare class CustomerChatClient {
+    private readonly http;
+    private readonly auth;
+    private readonly customerId;
+    private readonly defaultMetadata?;
+    private readonly metrics?;
+    private readonly trace?;
+    constructor(http: HTTPClient, auth: AuthClient, customerId: string, defaultMetadata?: Record<string, string>, metrics?: MetricsCallbacks, trace?: TraceCallbacks);
+    create(params: CustomerChatParams & {
+        stream: false;
+    }, options?: ChatRequestOptions): Promise<ChatCompletionResponse>;
+    create(params: CustomerChatParams, options: ChatRequestOptions & {
+        stream: false;
+    }): Promise<ChatCompletionResponse>;
+    create(params: CustomerChatParams, options?: ChatRequestOptions): Promise<ChatCompletionsStream>;
+    /**
+     * Stream structured JSON responses using the NDJSON contract.
+     * The request must include a structured responseFormat.
+     */
+    streamJSON<T>(params: CustomerChatParams & {
+        responseFormat: ResponseFormat;
+    }, options?: ChatRequestOptions): Promise<StructuredJSONStream<T>>;
+    /**
+     * Send a structured output request with a Zod schema for customer-attributed calls.
+     *
+     * Auto-generates JSON schema from the Zod schema, validates the response,
+     * and retries on validation failure if configured.
+     *
+     * @param schema - A Zod schema defining the expected response structure
+     * @param params - Customer chat parameters (excluding responseFormat)
+     * @param options - Request options including retry configuration
+     * @returns A typed result with the parsed value
+     */
+    structured<T>(schema: ZodLikeSchema, params: Omit<CustomerChatParams, "responseFormat">, options?: ChatRequestOptions & StructuredOptions): Promise<StructuredResult<T>>;
+    /**
+     * Stream structured output with a Zod schema for customer-attributed calls.
+     *
+     * Auto-generates JSON schema from the Zod schema. Note that streaming
+     * does not support retries - for retry behavior, use `structured()`.
+     *
+     * @param schema - A Zod schema defining the expected response structure
+     * @param params - Customer chat parameters (excluding responseFormat)
+     * @param options - Request options
+     * @returns A structured JSON stream
+     */
+    streamStructured<T>(schema: ZodLikeSchema, params: Omit<CustomerChatParams, "responseFormat">, options?: ChatRequestOptions & Pick<StructuredOptions, "schemaName">): Promise<StructuredJSONStream<T>>;
+}
+declare class ChatCompletionsStream implements AsyncIterable<ChatCompletionEvent> {
+    private readonly response;
+    private readonly requestId?;
+    private context;
+    private readonly metrics?;
+    private readonly trace?;
+    private readonly startedAt;
+    private firstTokenEmitted;
+    private closed;
+    constructor(response: Response, requestId: string | undefined, context: RequestContext, metrics?: MetricsCallbacks, trace?: TraceCallbacks);
+    cancel(reason?: unknown): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<ChatCompletionEvent>;
+    private handleStreamEvent;
+    private enrichContext;
+    private recordFirstToken;
+}
+declare class StructuredJSONStream<T> implements AsyncIterable<StructuredJSONEvent<T>> {
+    private readonly response;
+    private readonly requestId?;
+    private context;
+    private readonly metrics?;
+    private readonly trace?;
+    private closed;
+    private sawTerminal;
+    constructor(response: Response, requestId: string | undefined, context: RequestContext, metrics?: MetricsCallbacks, trace?: TraceCallbacks);
+    cancel(reason?: unknown): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<StructuredJSONEvent<T>>;
+    collect(): Promise<T>;
+    private parseRecord;
+    private traceStructuredEvent;
+}
+
 /**
- * Returns a ToolChoice that lets the model decide when to use tools.
+ * Customer metadata as an arbitrary key-value object.
  */
-declare function toolChoiceAuto(): ToolChoice;
+type CustomerMetadata = Record<string, unknown>;
 /**
- * Returns a ToolChoice that forces the model to use a tool.
+ * Customer represents a customer in a ModelRelay project.
  */
-declare function toolChoiceRequired(): ToolChoice;
+interface Customer {
+    id: string;
+    project_id: string;
+    tier_id: string;
+    tier_code?: string;
+    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;
+}
 /**
- * Returns a ToolChoice that prevents the model from using tools.
+ * Request to create a customer.
  */
-declare function toolChoiceNone(): ToolChoice;
+interface CustomerCreateRequest {
+    tier_id: string;
+    external_id: string;
+    email: string;
+    metadata?: CustomerMetadata;
+}
 /**
- * Returns true if the response contains tool calls.
+ * Request to upsert a customer by external_id.
  */
-declare function hasToolCalls(response: ChatCompletionResponse): boolean;
+interface CustomerUpsertRequest {
+    tier_id: string;
+    external_id: string;
+    email: string;
+    metadata?: CustomerMetadata;
+}
 /**
- * Returns the first tool call from a response, or undefined if none exist.
+ * Request to claim a customer by email, setting their external_id.
+ * Used when a customer subscribes via Stripe Checkout (email only) and later
+ * authenticates to the app, needing to link their identity.
  */
-declare function firstToolCall(response: ChatCompletionResponse): ToolCall | undefined;
+interface CustomerClaimRequest {
+    email: string;
+    external_id: string;
+}
 /**
- * Creates a message containing the result of a tool call.
+ * Request to create a checkout session.
  */
-declare function toolResultMessage(toolCallId: string, result: unknown): ChatMessage;
+interface CheckoutSessionRequest {
+    success_url: string;
+    cancel_url: string;
+}
 /**
- * Creates a tool result message from a ToolCall.
- * Convenience wrapper around toolResultMessage using the call's ID.
+ * Checkout session response.
  */
-declare function respondToToolCall(call: ToolCall, result: unknown): ChatMessage;
+interface CheckoutSession {
+    session_id: string;
+    url: string;
+}
 /**
- * Creates an assistant message that includes tool calls.
- * Used to include the assistant's tool-calling turn in conversation history.
+ * Subscription status response.
  */
-declare function assistantMessageWithToolCalls(content: string, toolCalls: ToolCall[]): ChatMessage;
+interface SubscriptionStatus {
+    active: boolean;
+    subscription_id?: string;
+    status?: string;
+    current_period_start?: string;
+    current_period_end?: string;
+}
+interface CustomersClientConfig {
+    apiKey?: string;
+}
 /**
- * Accumulates streaming tool call deltas into complete tool calls.
+ * CustomersClient provides methods to manage customers in a project.
+ * Requires a secret key (mr_sk_*) for authentication.
  */
-declare class ToolCallAccumulator {
-    private calls;
+declare class CustomersClient {
+    private readonly http;
+    private readonly apiKey?;
+    constructor(http: HTTPClient, cfg: CustomersClientConfig);
+    private ensureSecretKey;
     /**
-     * Processes a streaming tool call delta.
-     * Returns true if this started a new tool call.
+     * List all customers in the project.
      */
-    processDelta(delta: ToolCallDelta): boolean;
+    list(): Promise<Customer[]>;
     /**
-     * Returns all accumulated tool calls in index order.
+     * Create a new customer in the project.
      */
-    getToolCalls(): ToolCall[];
+    create(request: CustomerCreateRequest): Promise<Customer>;
     /**
-     * Returns a specific tool call by index, or undefined if not found.
+     * Get a customer by ID.
      */
-    getToolCall(index: number): ToolCall | undefined;
+    get(customerId: string): Promise<Customer>;
     /**
-     * Clears all accumulated tool calls.
+     * Upsert a customer by external_id.
+     * If a customer with the given external_id exists, it is updated.
+     * Otherwise, a new customer is created.
      */
-    reset(): void;
+    upsert(request: CustomerUpsertRequest): Promise<Customer>;
+    /**
+     * Claim a customer by email, setting their external_id.
+     * Used when a customer subscribes via Stripe Checkout (email only) and later
+     * authenticates to the app, needing to link their identity.
+     *
+     * @throws {APIError} with status 404 if customer not found by email
+     * @throws {APIError} with status 409 if customer already claimed or external_id in use
+     */
+    claim(request: CustomerClaimRequest): Promise<Customer>;
+    /**
+     * Delete a customer by ID.
+     */
+    delete(customerId: string): Promise<void>;
+    /**
+     * Create a Stripe checkout session for a customer.
+     */
+    createCheckoutSession(customerId: string, request: CheckoutSessionRequest): Promise<CheckoutSession>;
+    /**
+     * Get the subscription status for a customer.
+     */
+    getSubscription(customerId: string): Promise<SubscriptionStatus>;
 }
+
 /**
- * Error thrown when tool argument parsing or validation fails.
- * Contains a descriptive message suitable for sending back to the model.
+ * Billing interval for a tier.
  */
-declare class ToolArgsError extends Error {
-    /** The tool call ID for correlation */
-    readonly toolCallId: string;
-    /** The tool name that was called */
-    readonly toolName: string;
-    /** The raw arguments string that failed to parse */
-    readonly rawArguments: string;
-    constructor(message: string, toolCallId: string, toolName: string, rawArguments: string);
-}
+type PriceInterval = "month" | "year";
 /**
- * Schema interface compatible with Zod, Yup, and similar validation libraries.
- * Any object with a `parse` method that returns the validated type works.
+ * Tier represents a pricing tier in a ModelRelay project.
  */
-interface Schema<T> {
-    parse(data: unknown): T;
+interface Tier {
+    id: string;
+    project_id: string;
+    tier_code: string;
+    display_name: string;
+    spend_limit_cents: number;
+    stripe_price_id?: string;
+    price_amount?: number;
+    price_currency?: string;
+    price_interval?: PriceInterval;
+    trial_days?: number;
+    created_at: string;
+    updated_at: string;
 }
 /**
- * Parses and validates tool call arguments using a schema.
- *
- * Works with any schema library that has a `parse` method (Zod, Yup, etc.).
- * Throws a descriptive ToolArgsError if parsing or validation fails.
- *
- * @example
- * ```typescript
- * import { z } from "zod";
- *
- * const WeatherArgs = z.object({
- *   location: z.string(),
- *   unit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
- * });
- *
- * // In your tool handler:
- * const args = parseToolArgs(toolCall, WeatherArgs);
- * // args is typed as { location: string; unit: "celsius" | "fahrenheit" }
- * ```
- *
- * @param call - The tool call containing arguments to parse
- * @param schema - A schema with a `parse` method (Zod, Yup, etc.)
- * @returns The parsed and validated arguments with proper types
- * @throws {ToolArgsError} If JSON parsing or schema validation fails
- */
-declare function parseToolArgs<T>(call: ToolCall, schema: Schema<T>): T;
-/**
- * Attempts to parse tool arguments, returning a result object instead of throwing.
- *
- * @example
- * ```typescript
- * const result = tryParseToolArgs(toolCall, WeatherArgs);
- * if (result.success) {
- *   console.log(result.data.location);
- * } else {
- *   console.error(result.error.message);
- * }
- * ```
- *
- * @param call - The tool call containing arguments to parse
- * @param schema - A schema with a `parse` method
- * @returns An object with either { success: true, data: T } or { success: false, error: ToolArgsError }
- */
-declare function tryParseToolArgs<T>(call: ToolCall, schema: Schema<T>): {
-    success: true;
-    data: T;
-} | {
-    success: false;
-    error: ToolArgsError;
-};
-/**
- * Parses raw JSON arguments without schema validation.
- * Useful when you want JSON parsing error handling but not schema validation.
- *
- * @param call - The tool call containing arguments to parse
- * @returns The parsed JSON as an unknown type
- * @throws {ToolArgsError} If JSON parsing fails
- */
-declare function parseToolArgsRaw(call: ToolCall): unknown;
-/**
- * Handler function type for tool execution.
- * Can be sync or async, receives parsed arguments and returns a result.
- */
-type ToolHandler<T = unknown, R = unknown> = (args: T, call: ToolCall) => R | Promise<R>;
-/**
- * Result of executing a tool call.
+ * Request to create a tier checkout session (Stripe-first flow).
+ * Stripe collects the customer's email during checkout.
  */
-interface ToolExecutionResult {
-    toolCallId: string;
-    toolName: string;
-    result: unknown;
-    error?: string;
-    /**
-     * True if the error is due to malformed arguments (JSON parse or validation failure)
-     * and the model should be given a chance to retry with corrected arguments.
-     */
-    isRetryable?: boolean;
+interface TierCheckoutRequest {
+    success_url: string;
+    cancel_url: string;
 }
 /**
- * Registry for mapping tool names to handler functions with automatic dispatch.
- *
- * @example
- * ```typescript
- * const registry = new ToolRegistry()
- *   .register("get_weather", async (args) => {
- *     return { temp: 72, unit: "fahrenheit" };
- *   })
- *   .register("search", async (args) => {
- *     return { results: ["result1", "result2"] };
- *   });
- *
- * // Execute all tool calls from a response
- * const results = await registry.executeAll(response.toolCalls);
- *
- * // Convert results to messages for the next request
- * const messages = registry.resultsToMessages(results);
- * ```
+ * Tier checkout session response.
  */
-declare class ToolRegistry {
-    private handlers;
+interface TierCheckoutSession {
+    session_id: string;
+    url: string;
+}
+interface TiersClientConfig {
+    apiKey?: string;
+}
+/**
+ * TiersClient provides methods to query tiers in a project.
+ * Works with both publishable keys (mr_pk_*) and secret keys (mr_sk_*).
+ */
+declare class TiersClient {
+    private readonly http;
+    private readonly apiKey?;
+    constructor(http: HTTPClient, cfg: TiersClientConfig);
+    private ensureApiKey;
+    private ensureSecretKey;
     /**
-     * Registers a handler function for a tool name.
-     * @param name - The tool name (must match the function name in the tool definition)
-     * @param handler - Function to execute when this tool is called
-     * @returns this for chaining
+     * List all tiers in the project.
      */
-    register<T = unknown, R = unknown>(name: string, handler: ToolHandler<T, R>): this;
+    list(): Promise<Tier[]>;
     /**
-     * Unregisters a tool handler.
-     * @param name - The tool name to unregister
-     * @returns true if the handler was removed, false if it didn't exist
+     * Get a tier by ID.
      */
-    unregister(name: string): boolean;
+    get(tierId: string): Promise<Tier>;
     /**
-     * Checks if a handler is registered for the given tool name.
+     * Create a Stripe checkout session for a tier (Stripe-first flow).
+     *
+     * This enables users to subscribe before authenticating. Stripe collects
+     * the customer's email during checkout. After checkout completes, a
+     * customer record is created with the email from Stripe. The customer
+     * can later be linked to an identity via POST /customers/claim.
+     *
+     * Requires a secret key (mr_sk_*).
+     *
+     * @param tierId - The tier ID to create a checkout session for
+     * @param request - Checkout session request with redirect URLs
+     * @returns Checkout session with Stripe URL
      */
-    has(name: string): boolean;
+    checkout(tierId: string, request: TierCheckoutRequest): Promise<TierCheckoutSession>;
+}
+
+/**
+ * API error codes returned by the server.
+ * These constants can be used for programmatic error handling.
+ */
+declare const ErrorCodes: {
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly RATE_LIMIT: "RATE_LIMIT";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly CONFLICT: "CONFLICT";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly PAYMENT_REQUIRED: "PAYMENT_REQUIRED";
+    readonly METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED";
+    /** No tiers configured for the project - create a tier first. */
+    readonly NO_TIERS: "NO_TIERS";
+    /** No free tier available for auto-provisioning - create a free tier or use checkout flow. */
+    readonly NO_FREE_TIER: "NO_FREE_TIER";
+    /** Email required for auto-provisioning a new customer. */
+    readonly EMAIL_REQUIRED: "EMAIL_REQUIRED";
+};
+type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+type ErrorCategory = "config" | "transport" | "api";
+declare class ModelRelayError extends Error {
+    category: ErrorCategory;
+    status?: number;
+    code?: string;
+    requestId?: string;
+    fields?: FieldError[];
+    data?: unknown;
+    retries?: RetryMetadata;
+    cause?: unknown;
+    constructor(message: string, opts: {
+        category: ErrorCategory;
+        status?: number;
+        code?: string;
+        requestId?: string;
+        fields?: FieldError[];
+        data?: unknown;
+        retries?: RetryMetadata;
+        cause?: unknown;
+    });
+}
+declare class ConfigError extends ModelRelayError {
+    constructor(message: string, data?: unknown);
+}
+declare class TransportError extends ModelRelayError {
+    kind: TransportErrorKind;
+    constructor(message: string, opts: {
+        kind: TransportErrorKind;
+        retries?: RetryMetadata;
+        cause?: unknown;
+    });
+}
+declare class APIError extends ModelRelayError {
+    constructor(message: string, opts: {
+        status: number;
+        code?: string;
+        requestId?: string;
+        fields?: FieldError[];
+        data?: unknown;
+        retries?: RetryMetadata;
+    });
+    /** Returns true if the error is a not found error. */
+    isNotFound(): boolean;
+    /** Returns true if the error is a validation error. */
+    isValidation(): boolean;
+    /** Returns true if the error is a rate limit error. */
+    isRateLimit(): boolean;
+    /** Returns true if the error is an unauthorized error. */
+    isUnauthorized(): boolean;
+    /** Returns true if the error is a forbidden error. */
+    isForbidden(): boolean;
+    /** Returns true if the error is a service unavailable error. */
+    isUnavailable(): boolean;
     /**
-     * Returns the list of registered tool names.
+     * Returns true if the error indicates no tiers are configured.
+     * To resolve: create at least one tier in your project dashboard.
      */
-    getRegisteredTools(): string[];
+    isNoTiers(): boolean;
     /**
-     * Executes a single tool call.
-     * @param call - The tool call to execute
-     * @returns The execution result
+     * Returns true if the error indicates no free tier is available for auto-provisioning.
+     * To resolve: either create a free tier for automatic customer creation,
+     * or use the checkout flow to create paying customers first.
      */
-    execute(call: ToolCall): Promise<ToolExecutionResult>;
+    isNoFreeTier(): boolean;
     /**
-     * Executes multiple tool calls in parallel.
-     * @param calls - Array of tool calls to execute
-     * @returns Array of execution results in the same order as input
+     * Returns true if email is required for auto-provisioning a new customer.
+     * To resolve: provide the 'email' field in FrontendTokenRequest.
      */
-    executeAll(calls: ToolCall[]): Promise<ToolExecutionResult[]>;
+    isEmailRequired(): boolean;
     /**
-     * Converts execution results to tool result messages.
-     * Useful for appending to the conversation history.
-     * @param results - Array of execution results
-     * @returns Array of ChatMessage objects with role "tool"
+     * Returns true if this is a customer provisioning error (NO_TIERS, NO_FREE_TIER, or EMAIL_REQUIRED).
+     * These errors occur when calling frontendToken() with a customer that doesn't exist
+     * and automatic provisioning cannot complete.
      */
-    resultsToMessages(results: ToolExecutionResult[]): ChatMessage[];
+    isProvisioningError(): boolean;
 }
 /**
- * Formats a tool execution error into a message suitable for sending back to the model.
- * The message is designed to help the model understand what went wrong and correct it.
- *
- * @example
- * ```typescript
- * const result = await registry.execute(toolCall);
- * if (result.error && result.isRetryable) {
- *   const errorMessage = formatToolErrorForModel(result);
- *   messages.push(toolResultMessage(result.toolCallId, errorMessage));
- *   // Continue conversation to let model retry
- * }
- * ```
- */
-declare function formatToolErrorForModel(result: ToolExecutionResult): string;
-/**
- * Checks if any results have retryable errors.
- *
- * @example
- * ```typescript
- * const results = await registry.executeAll(toolCalls);
- * if (hasRetryableErrors(results)) {
- *   // Send error messages back to model and continue conversation
- * }
- * ```
- */
-declare function hasRetryableErrors(results: ToolExecutionResult[]): boolean;
-/**
- * Filters results to only those with retryable errors.
+ * Returns true if the error indicates email is required for auto-provisioning.
  */
-declare function getRetryableErrors(results: ToolExecutionResult[]): ToolExecutionResult[];
+declare function isEmailRequired(err: unknown): boolean;
 /**
- * Creates tool result messages for retryable errors, formatted to help the model correct them.
- *
- * @example
- * ```typescript
- * const results = await registry.executeAll(toolCalls);
- * if (hasRetryableErrors(results)) {
- *   const retryMessages = createRetryMessages(results);
- *   messages.push(...retryMessages);
- *   // Make another API call to let model retry
- * }
- * ```
+ * Returns true if the error indicates no free tier is available.
  */
-declare function createRetryMessages(results: ToolExecutionResult[]): ChatMessage[];
+declare function isNoFreeTier(err: unknown): boolean;
 /**
- * Options for executeWithRetry.
+ * Returns true if the error indicates no tiers are configured.
  */
-interface RetryOptions {
-    /**
-     * Maximum number of retry attempts for parse/validation errors.
-     * @default 2
-     */
-    maxRetries?: number;
-    /**
-     * Callback invoked when a retryable error occurs.
-     * Should return new tool calls from the model's response.
-     * If not provided, executeWithRetry will not retry automatically.
-     *
-     * @param errorMessages - Messages to send back to the model
-     * @param attempt - Current attempt number (1-based)
-     * @returns New tool calls from the model, or empty array to stop retrying
-     */
-    onRetry?: (errorMessages: ChatMessage[], attempt: number) => Promise<ToolCall[]>;
-}
+declare function isNoTiers(err: unknown): boolean;
 /**
- * Executes tool calls with automatic retry on parse/validation errors.
- *
- * This is a higher-level utility that wraps registry.executeAll with retry logic.
- * When a retryable error occurs, it calls the onRetry callback to get new tool calls
- * from the model and continues execution.
- *
- * **Result Preservation**: Successful results are preserved across retries. If you
- * execute multiple tool calls and only some fail, the successful results are kept
- * and merged with the results from retry attempts. Results are keyed by toolCallId,
- * so if a retry returns a call with the same ID as a previous result, the newer
- * result will replace it.
- *
- * @example
- * ```typescript
- * const results = await executeWithRetry(registry, toolCalls, {
- *   maxRetries: 2,
- *   onRetry: async (errorMessages, attempt) => {
- *     console.log(`Retry attempt ${attempt}`);
- *     // Add error messages to conversation and call the model again
- *     messages.push(assistantMessageWithToolCalls("", toolCalls));
- *     messages.push(...errorMessages);
- *     const response = await client.chat.completions.create({ messages, tools });
- *     return response.toolCalls ?? [];
- *   },
- * });
- * ```
- *
- * @param registry - The tool registry to use for execution
- * @param toolCalls - Initial tool calls to execute
- * @param options - Retry configuration
- * @returns Final execution results after all retries, including preserved successes
+ * Returns true if the error is a customer provisioning error.
  */
-declare function executeWithRetry(registry: ToolRegistry, toolCalls: ToolCall[], options?: RetryOptions): Promise<ToolExecutionResult[]>;
+declare function isProvisioningError(err: unknown): boolean;
+declare function parseErrorResponse(response: Response, retries?: RetryMetadata): Promise<APIError>;
 
 declare class ModelRelay {
     readonly chat: ChatClient;
@@ -1558,4 +1884,4 @@ declare class ModelRelay {
     constructor(options: ModelRelayOptions);
 }
 
-export { type APIChatResponse, type APIChatUsage, type APICheckoutSession, type APICustomerRef, APIError, type APIFrontendToken, type APIKey, AuthClient, type AuthHeaders, ChatClient, type ChatCompletionCreateParams, type ChatCompletionEvent, type ChatCompletionResponse, ChatCompletionsStream, type ChatEventType, type ChatMessage, type CheckoutSession, type CheckoutSessionRequest, type CodeExecConfig, ConfigError, type Customer, type CustomerClaimRequest, type CustomerCreateRequest, type CustomerMetadata, type CustomerUpsertRequest, CustomersClient, DEFAULT_BASE_URL, DEFAULT_CLIENT_HEADER, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_REQUEST_TIMEOUT_MS, type ErrorCategory, type ErrorCode, ErrorCodes, type FieldError, type FrontendCustomer, type FrontendToken, type FrontendTokenAutoProvisionRequest, type FrontendTokenRequest, type FunctionCall, type FunctionCallDelta, type FunctionTool, type HttpRequestMetrics, type JsonSchemaOptions, type KnownStopReason, type MessageDeltaData, type MessageStartData, type MessageStopData, type MetricsCallbacks, type ModelId, ModelRelay, type ModelRelayBaseOptions, ModelRelayError, type ModelRelayKeyOptions, type ModelRelayOptions, type ModelRelayOptionsLegacy, type ModelRelayTokenOptions, type NonEmptyArray, type PriceInterval, type Project, type ProviderId, type RequestContext, type ResponseFormat, type ResponseFormatType, ResponseFormatTypes, type ResponseJSONSchemaFormat, type RetryConfig, type RetryMetadata, type RetryOptions, SDK_VERSION, type Schema, type StopReason, StopReasons, type StreamFirstTokenMetrics, type StructuredJSONEvent, type StructuredJSONRecordType, StructuredJSONStream, type SubscriptionStatus, type Tier, type TierCheckoutRequest, type TierCheckoutSession, TiersClient, 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, TransportError, type TransportErrorKind, type Usage, type UsageSummary, type WebSearchConfig, type WebToolMode, WebToolModes, type XSearchConfig, type ZodLikeSchema, assistantMessageWithToolCalls, createAccessTokenAuth, createApiKeyAuth, createAssistantMessage, createFunctionCall, createFunctionTool, createFunctionToolFromSchema, createRetryMessages, createSystemMessage, createToolCall, createUsage, createUserMessage, createWebTool, executeWithRetry, firstToolCall, formatToolErrorForModel, getRetryableErrors, hasRetryableErrors, hasToolCalls, isEmailRequired, isNoFreeTier, isNoTiers, isProvisioningError, isPublishableKey, mergeMetrics, mergeTrace, modelToString, normalizeModelId, normalizeStopReason, parseErrorResponse, parseToolArgs, parseToolArgsRaw, respondToToolCall, stopReasonToString, toolChoiceAuto, toolChoiceNone, toolChoiceRequired, toolResultMessage, tryParseToolArgs, zodToJsonSchema };
+export { type APIChatResponse, type APIChatUsage, type APICheckoutSession, type APICustomerRef, APIError, type APIFrontendToken, type APIKey, type AttemptRecord, AuthClient, type AuthHeaders, ChatClient, type ChatCompletionCreateParams, type ChatCompletionEvent, type ChatCompletionResponse, ChatCompletionsStream, type ChatEventType, type ChatMessage, type CheckoutSession, type CheckoutSessionRequest, type CodeExecConfig, ConfigError, type Customer, CustomerChatClient, type CustomerChatParams, type CustomerClaimRequest, type CustomerCreateRequest, type CustomerMetadata, type CustomerUpsertRequest, CustomersClient, DEFAULT_BASE_URL, DEFAULT_CLIENT_HEADER, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_REQUEST_TIMEOUT_MS, type ErrorCategory, type ErrorCode, ErrorCodes, type FieldError, type FrontendCustomer, type FrontendToken, type FrontendTokenAutoProvisionRequest, type FrontendTokenRequest, type FunctionCall, type FunctionCallDelta, type FunctionTool, type HttpRequestMetrics, type JsonSchemaOptions, type KnownStopReason, type MessageDeltaData, type MessageRole, MessageRoles, type MessageStartData, type MessageStopData, type MetricsCallbacks, type ModelId, ModelRelay, type ModelRelayBaseOptions, ModelRelayError, type ModelRelayKeyOptions, type ModelRelayOptions, type ModelRelayOptionsLegacy, type ModelRelayTokenOptions, type NonEmptyArray, type PriceInterval, type Project, type ProviderId, type RequestContext, type ResponseFormat, type ResponseFormatType, ResponseFormatTypes, type ResponseJSONSchemaFormat, type RetryConfig, type RetryHandler, type RetryMetadata, type RetryOptions, SDK_VERSION, type Schema, type StopReason, StopReasons, type StreamFirstTokenMetrics, StructuredDecodeError, type StructuredErrorKind, StructuredExhaustedError, type StructuredJSONEvent, type StructuredJSONRecordType, StructuredJSONStream, type StructuredOptions, type StructuredResult, type SubscriptionStatus, type Tier, type TierCheckoutRequest, type TierCheckoutSession, TiersClient, 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, TransportError, type TransportErrorKind, type Usage, type UsageSummary, type ValidationIssue, type WebSearchConfig, type WebToolMode, WebToolModes, type XSearchConfig, type ZodLikeSchema, assistantMessageWithToolCalls, createAccessTokenAuth, createApiKeyAuth, createAssistantMessage, createFunctionCall, createFunctionTool, createFunctionToolFromSchema, createRetryMessages, createSystemMessage, createToolCall, createUsage, createUserMessage, createWebTool, defaultRetryHandler, executeWithRetry, firstToolCall, formatToolErrorForModel, getRetryableErrors, hasRetryableErrors, hasToolCalls, isEmailRequired, isNoFreeTier, isNoTiers, isProvisioningError, isPublishableKey, mergeMetrics, mergeTrace, modelToString, normalizeModelId, normalizeStopReason, parseErrorResponse, parseToolArgs, parseToolArgsRaw, respondToToolCall, responseFormatFromZod, stopReasonToString, toolChoiceAuto, toolChoiceNone, toolChoiceRequired, toolResultMessage, tryParseToolArgs, validateWithZod, zodToJsonSchema };