@modelrelay/sdk 2.1.0 → 4.0.0

package/dist/tools-CWEBFsql.d.cts

@@ -1,1192 +0,0 @@
-declare const SDK_VERSION: string;
-declare const DEFAULT_BASE_URL = "https://api.modelrelay.ai/api/v1";
-declare const DEFAULT_CLIENT_HEADER: string;
-declare const DEFAULT_CONNECT_TIMEOUT_MS = 5000;
-declare const DEFAULT_REQUEST_TIMEOUT_MS = 60000;
-type NonEmptyArray<T> = [T, ...T[]];
-declare const StopReasons: {
-    readonly Completed: "completed";
-    readonly Stop: "stop";
-    readonly StopSequence: "stop_sequence";
-    readonly EndTurn: "end_turn";
-    readonly MaxTokens: "max_tokens";
-    readonly MaxLength: "max_len";
-    readonly MaxContext: "max_context";
-    readonly ToolCalls: "tool_calls";
-    readonly TimeLimit: "time_limit";
-    readonly ContentFilter: "content_filter";
-    readonly Incomplete: "incomplete";
-    readonly Unknown: "unknown";
-};
-type KnownStopReason = (typeof StopReasons)[keyof typeof StopReasons];
-type StopReason = KnownStopReason | {
-    other: string;
-};
-/**
- * Branded type for provider identifiers (e.g., "anthropic", "openai").
- * The brand prevents accidental use of arbitrary strings where a provider ID is expected.
- */
-type ProviderId = string & {
-    readonly __brand: "ProviderId";
-};
-/**
- * Branded type for model identifiers (e.g., "claude-3-5-sonnet-20241022").
- * The brand prevents accidental use of arbitrary strings where a model ID is expected.
- */
-type ModelId = string & {
-    readonly __brand: "ModelId";
-};
-/**
- * Branded type for tier codes (e.g., "free", "pro", "enterprise").
- * The brand prevents accidental use of arbitrary strings where a tier code is expected.
- */
-type TierCode = string & {
-    readonly __brand: "TierCode";
-};
-/**
- * Cast a string to a ProviderId. Use for known provider identifiers.
- */
-declare function asProviderId(value: string): ProviderId;
-/**
- * Cast a string to a ModelId. Use for known model identifiers.
- */
-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";
-};
-type SecretKey = string & {
-    readonly __brand: "SecretKey";
-};
-type ApiKey = PublishableKey | SecretKey;
-/**
- * TokenProvider supplies short-lived bearer tokens for ModelRelay data-plane calls.
- *
- * Providers are responsible for caching and refreshing tokens when needed.
- */
-interface TokenProvider {
-    getToken(): Promise<string>;
-}
-/**
- * Common configuration options for the ModelRelay client.
- */
-interface ModelRelayBaseOptions {
-    /**
-     * Optional base URL override. Defaults to production API.
-     */
-    baseUrl?: string;
-    fetch?: typeof fetch;
-    /**
-     * Default customer metadata used when exchanging publishable keys for frontend tokens.
-     */
-    customer?: FrontendCustomer;
-    /**
-     * Optional client header override for telemetry.
-     */
-    clientHeader?: string;
-    /**
-     * Default connect timeout in milliseconds (applies to each attempt).
-     */
-    connectTimeoutMs?: number;
-    /**
-     * Default request timeout in milliseconds (non-streaming). Set to 0 to disable.
-     */
-    timeoutMs?: number;
-    /**
-     * Retry configuration applied to all requests (can be overridden per call). Set to `false` to disable retries.
-     */
-    retry?: RetryConfig | false;
-    /**
-     * Default HTTP headers applied to every request.
-     */
-    defaultHeaders?: Record<string, string>;
-    /**
-     * Optional metrics callbacks for latency/usage.
-     */
-    metrics?: MetricsCallbacks;
-    /**
-     * Optional trace/log hooks for request + stream lifecycle.
-     */
-    trace?: TraceCallbacks;
-}
-/**
- * Configuration options requiring an API key.
- */
-interface ModelRelayKeyOptions extends ModelRelayBaseOptions {
-    /**
-     * API key (secret or publishable). Required.
-     * - Secret keys (`mr_sk_...`) are for server-side API calls.
-     * - Publishable keys (`mr_pk_...`) are for frontend token exchange.
-     */
-    key: ApiKey;
-    /**
-     * Optional bearer token (takes precedence over key for requests when provided).
-     */
-    token?: string;
-}
-/**
- * Configuration options requiring an access token.
- */
-interface ModelRelayTokenOptions extends ModelRelayBaseOptions {
-    /**
-     * Optional API key.
-     */
-    key?: ApiKey;
-    /**
-     * Bearer token to call the API directly (server or frontend token). Required.
-     */
-    token: string;
-}
-/**
- * Configuration options requiring a TokenProvider.
- */
-interface ModelRelayTokenProviderOptions extends ModelRelayBaseOptions {
-    /**
-     * Token provider used to fetch bearer tokens for `/responses`, `/runs`, and `/workflows/compile`.
-     */
-    tokenProvider: TokenProvider;
-    /**
-     * Optional API key. Useful for non-data-plane endpoints (e.g., /customers, /tiers).
-     */
-    key?: ApiKey;
-}
-/**
- * ModelRelay client configuration.
- *
- * You must provide at least one of `key` or `token` for authentication.
- * This is enforced at compile time through discriminated union types.
- *
- * @example With API key (server-side)
- * ```typescript
- * import { ModelRelay } from "@modelrelay/sdk";
- * const client = ModelRelay.fromSecretKey("mr_sk_...");
- * ```
- *
- * @example With access token (frontend or after token exchange)
- * ```typescript
- * const client = new ModelRelay({ token: frontendToken });
- * ```
- *
- * @example With publishable key (frontend token exchange)
- * ```typescript
- * import { ModelRelay, parsePublishableKey } from "@modelrelay/sdk";
- * const client = new ModelRelay({ key: parsePublishableKey("mr_pk_..."), customer: { provider: "oidc", subject: "user123" } });
- * ```
- *
- * @example With token provider (OIDC exchange, backend-minted tokens, etc.)
- * ```typescript
- * import { ModelRelay } from "@modelrelay/sdk";
- * const client = new ModelRelay({ tokenProvider });
- * ```
- */
-type ModelRelayOptions = ModelRelayKeyOptions | ModelRelayTokenOptions | ModelRelayTokenProviderOptions;
-/**
- * @deprecated Use ModelRelayOptions instead. This type allows empty configuration
- * which will fail at runtime.
- */
-interface FrontendCustomer {
-    provider: string;
-    subject: string;
-    /**
-     * Email address for auto-provisioning (if enabled for the project).
-     * If omitted and the identity isn't linked yet, the API may return EMAIL_REQUIRED.
-     */
-    email?: string;
-    deviceId?: string;
-    ttlSeconds?: number;
-}
-/**
- * Request for fetching a frontend token for an existing identity.
- */
-interface FrontendTokenRequest {
-    /** Publishable key (mr_pk_*) - required for authentication. */
-    publishableKey: PublishableKey;
-    /** Identity provider namespace (e.g. "oidc", "github", "oidc:https://issuer"). */
-    identityProvider: string;
-    /** Provider-scoped subject identifier (e.g. OIDC sub). */
-    identitySubject: string;
-    /** Optional device identifier for tracking/rate limiting. */
-    deviceId?: string;
-    /** Optional TTL in seconds for the issued token. */
-    ttlSeconds?: number;
-}
-/**
- * Request for fetching a frontend token with auto-provisioning enabled.
- * The project must explicitly enable auto-provisioning; email is required for customer creation.
- */
-interface FrontendTokenAutoProvisionRequest {
-    /** Publishable key (mr_pk_*) - required for authentication. */
-    publishableKey: PublishableKey;
-    /** Identity provider namespace (e.g. "oidc", "github", "oidc:https://issuer"). */
-    identityProvider: string;
-    /** Provider-scoped subject identifier (e.g. OIDC sub). */
-    identitySubject: string;
-    /** Email address - required for auto-provisioning a new customer. */
-    email: string;
-    /** Optional device identifier for tracking/rate limiting. */
-    deviceId?: string;
-    /** Optional TTL in seconds for the issued token. */
-    ttlSeconds?: number;
-}
-/** Token type for OAuth2 bearer tokens. */
-type TokenType = "Bearer";
-interface FrontendToken {
-    /** The bearer token for authenticating LLM requests. */
-    token: string;
-    /** When the token expires. */
-    expiresAt: Date;
-    /** Seconds until the token expires. */
-    expiresIn: number;
-    /** Token type, always "Bearer". */
-    tokenType: TokenType;
-    /** The publishable key ID that issued this token. */
-    keyId: string;
-    /** Unique session identifier for this token. */
-    sessionId: string;
-    /** The project ID this token is scoped to. */
-    projectId: string;
-    /** The internal customer ID (UUID). Only present for managed billing projects; BYOB projects have end-users but not customers. */
-    customerId?: string;
-    /** The external customer ID provided by the application. */
-    customerExternalId: string;
-    /** The tier code for the customer (e.g., "free", "pro", "enterprise").
-     * Optional for BYOB (external billing) projects where customers may not have subscriptions.
-     */
-    tierCode?: TierCode;
-    /**
-     * Publishable key used for issuance. Added client-side for caching.
-     */
-    publishableKey?: PublishableKey;
-    /**
-     * Device identifier used when issuing the token. Added client-side for caching.
-     */
-    deviceId?: string;
-    /**
-     * Identity provider used for issuance. Added client-side for caching.
-     */
-    identityProvider?: string;
-    /**
-     * Identity subject used for issuance. Added client-side for caching.
-     */
-    identitySubject?: string;
-}
-interface CustomerTokenRequest {
-    customerId?: string;
-    customerExternalId?: string;
-    ttlSeconds?: number;
-}
-interface CustomerToken {
-    token: string;
-    expiresAt: Date;
-    expiresIn: number;
-    tokenType: TokenType;
-    projectId: string;
-    /** Only present for managed billing projects; BYOB projects have end-users but not customers. */
-    customerId?: string;
-    customerExternalId: string;
-    /** Optional for BYOB (external billing) projects */
-    tierCode?: TierCode;
-}
-interface OIDCExchangeRequest {
-    idToken: string;
-    projectId?: string;
-}
-/**
- * Request options for starting a device authorization flow.
- */
-interface DeviceStartRequest {
-    /**
-     * Optional provider for native device flow.
-     * - "github": Use GitHub's native device flow (user authenticates at github.com/login/device)
-     * - undefined: Use ModelRelay's wrapped OAuth flow (default)
-     */
-    provider?: "github";
-}
-/**
- * Response from starting a device authorization flow.
- */
-interface DeviceStartResponse {
-    /** Device code used for polling /auth/device/token */
-    deviceCode: string;
-    /** Human-enterable code shown to the user */
-    userCode: string;
-    /** URL where the user enters the code and completes authorization */
-    verificationUri: string;
-    /** Convenience URL that pre-fills the user_code (optional) */
-    verificationUriComplete?: string;
-    /** When the device code expires */
-    expiresAt: Date;
-    /** Minimum polling interval in seconds */
-    interval: number;
-}
-/**
- * Successful response from polling device token endpoint.
- */
-interface DeviceTokenResponse {
-    /** Bearer token for authenticating requests */
-    token: string;
-    /** When the token expires */
-    expiresAt: Date;
-    /** Seconds until the token expires */
-    expiresIn: number;
-    /** Token type, always "Bearer" */
-    tokenType: TokenType;
-    /** The project ID this token is scoped to */
-    projectId: string;
-    /** The internal customer ID (UUID). Only present for managed billing projects; BYOB projects have end-users but not customers. */
-    customerId?: string;
-    /** The external customer ID */
-    customerExternalId: string;
-    /** The tier code for the customer (optional for BYOB projects) */
-    tierCode?: TierCode;
-}
-/**
- * Pending response from polling device token endpoint.
- * Indicates the user hasn't completed authorization yet.
- */
-interface DeviceTokenPending {
-    /** Error code from the device flow */
-    error: "authorization_pending" | "slow_down";
-    /** Human-readable error description */
-    errorDescription?: string;
-    /** Updated polling interval (when error is slow_down) */
-    interval?: number;
-}
-/**
- * Result from polling the device token endpoint.
- * Either a successful token or a pending/error state.
- */
-type DeviceTokenResult = {
-    status: "approved";
-    token: DeviceTokenResponse;
-} | {
-    status: "pending";
-    pending: DeviceTokenPending;
-} | {
-    status: "error";
-    error: string;
-    errorDescription?: string;
-};
-/**
- * Request to start an OAuth flow for customer authentication.
- */
-interface OAuthStartRequest {
-    /** Project ID to authenticate against */
-    projectId: string;
-    /** OAuth provider: "github" or "google" */
-    provider: "github" | "google";
-    /** Where to redirect after OAuth completion. Must be in project's whitelist. */
-    redirectUri: string;
-}
-/**
- * Response from starting an OAuth flow.
- */
-interface OAuthStartResponse {
-    /** URL to redirect the user to for OAuth authentication */
-    redirectUrl: string;
-}
-interface Usage {
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-}
-/**
- * Creates a Usage object with automatic totalTokens calculation if not provided.
- */
-declare function createUsage(inputTokens: number, outputTokens: number, totalTokens?: number): Usage;
-interface UsageSummary {
-    plan: string;
-    planType?: string;
-    windowStart?: Date | string;
-    windowEnd?: Date | string;
-    limit?: number;
-    used?: number;
-    images?: number;
-    actionsLimit?: number;
-    actionsUsed?: number;
-    remaining?: number;
-    state?: string;
-}
-interface Project {
-    id: string;
-    name: string;
-    description?: string;
-    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];
-declare const ContentPartTypes: {
-    readonly Text: "text";
-};
-type ContentPartType = (typeof ContentPartTypes)[keyof typeof ContentPartTypes];
-type ContentPart = {
-    type: "text";
-    text: string;
-};
-declare const InputItemTypes: {
-    readonly Message: "message";
-};
-type InputItemType = (typeof InputItemTypes)[keyof typeof InputItemTypes];
-type InputItem = {
-    type: "message";
-    role: MessageRole;
-    content: ContentPart[];
-    toolCalls?: ToolCall[];
-    toolCallId?: string;
-};
-declare const OutputItemTypes: {
-    readonly Message: "message";
-};
-type OutputItemType = (typeof OutputItemTypes)[keyof typeof OutputItemTypes];
-type OutputItem = {
-    type: "message";
-    role: MessageRole;
-    content: ContentPart[];
-    toolCalls?: ToolCall[];
-};
-declare const ToolTypes: {
-    readonly Function: "function";
-    readonly Web: "web";
-    readonly XSearch: "x_search";
-    readonly CodeExecution: "code_execution";
-};
-type ToolType = (typeof ToolTypes)[keyof typeof ToolTypes];
-declare const WebToolIntents: {
-    readonly Auto: "auto";
-    readonly SearchWeb: "search_web";
-    readonly FetchURL: "fetch_url";
-};
-type WebToolIntent = (typeof WebToolIntents)[keyof typeof WebToolIntents];
-interface FunctionTool {
-    name: string;
-    description?: string;
-    parameters?: Record<string, unknown>;
-}
-interface WebSearchConfig {
-    allowedDomains?: string[];
-    excludedDomains?: string[];
-    maxUses?: number;
-    intent?: WebToolIntent;
-}
-interface XSearchConfig {
-    allowedHandles?: string[];
-    excludedHandles?: string[];
-    fromDate?: string;
-    toDate?: string;
-}
-interface CodeExecConfig {
-    language?: string;
-    timeoutMs?: number;
-}
-interface Tool {
-    type: ToolType;
-    function?: FunctionTool;
-    web?: WebSearchConfig;
-    xSearch?: XSearchConfig;
-    codeExecution?: CodeExecConfig;
-}
-declare const ToolChoiceTypes: {
-    readonly Auto: "auto";
-    readonly Required: "required";
-    readonly None: "none";
-};
-type ToolChoiceType = (typeof ToolChoiceTypes)[keyof typeof ToolChoiceTypes];
-interface ToolChoice {
-    type: ToolChoiceType;
-    /**
-     * Optional function tool name to force.
-     * Only valid when type is "required".
-     */
-    function?: string;
-}
-interface FunctionCall {
-    name: string;
-    arguments: string;
-}
-interface ToolCall {
-    id: string;
-    type: ToolType;
-    function?: FunctionCall;
-}
-declare const OutputFormatTypes: {
-    readonly Text: "text";
-    readonly JsonSchema: "json_schema";
-};
-type OutputFormatType = (typeof OutputFormatTypes)[keyof typeof OutputFormatTypes];
-interface JSONSchemaFormat {
-    name: string;
-    description?: string;
-    schema: Record<string, unknown>;
-    strict?: boolean;
-}
-interface OutputFormat {
-    type: OutputFormatType;
-    json_schema?: JSONSchemaFormat;
-}
-interface Citation {
-    url?: string;
-    title?: string;
-}
-interface Response {
-    id: string;
-    output: OutputItem[];
-    stopReason?: StopReason;
-    model: ModelId;
-    usage: Usage;
-    requestId?: string;
-    provider?: ProviderId;
-    citations?: Citation[];
-}
-interface FieldError {
-    field?: string;
-    message: string;
-}
-interface RetryConfig {
-    maxAttempts?: number;
-    baseBackoffMs?: number;
-    maxBackoffMs?: number;
-    retryPost?: boolean;
-}
-interface RetryMetadata {
-    attempts: number;
-    lastStatus?: number;
-    lastError?: string;
-}
-type TransportErrorKind = "timeout" | "connect" | "request" | "empty_response" | "other";
-interface RequestContext {
-    method: string;
-    path: string;
-    model?: ModelId;
-    requestId?: string;
-    responseId?: string;
-}
-interface HttpRequestMetrics {
-    latencyMs: number;
-    status?: number;
-    error?: string;
-    retries?: RetryMetadata;
-    context: RequestContext;
-}
-interface StreamFirstTokenMetrics {
-    latencyMs: number;
-    error?: string;
-    context: RequestContext;
-}
-interface TokenUsageMetrics {
-    usage: Usage;
-    context: RequestContext;
-}
-interface MetricsCallbacks {
-    httpRequest?: (metrics: HttpRequestMetrics) => void;
-    streamFirstToken?: (metrics: StreamFirstTokenMetrics) => void;
-    usage?: (metrics: TokenUsageMetrics) => void;
-}
-interface TraceCallbacks {
-    requestStart?: (context: RequestContext) => void;
-    requestFinish?: (info: {
-        context: RequestContext;
-        status?: number;
-        error?: unknown;
-        retries?: RetryMetadata;
-        latencyMs: number;
-    }) => void;
-    streamEvent?: (info: {
-        context: RequestContext;
-        event: ResponseEvent;
-    }) => void;
-    streamError?: (info: {
-        context: RequestContext;
-        error: unknown;
-    }) => void;
-}
-declare function mergeMetrics(base?: MetricsCallbacks, override?: MetricsCallbacks): MetricsCallbacks | undefined;
-declare function mergeTrace(base?: TraceCallbacks, override?: TraceCallbacks): TraceCallbacks | undefined;
-declare function normalizeStopReason(value?: unknown): StopReason | undefined;
-declare function stopReasonToString(value?: StopReason): string | undefined;
-declare function normalizeModelId(value: unknown): ModelId | undefined;
-declare function modelToString(value: ModelId): string;
-type ResponseEventType = "message_start" | "message_delta" | "message_stop" | "tool_use_start" | "tool_use_delta" | "tool_use_stop" | "ping" | "custom";
-interface MessageStartData {
-    responseId?: string;
-    model?: string;
-    message?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-interface MessageDeltaData {
-    delta?: string | {
-        text?: string;
-        [key: string]: unknown;
-    };
-    responseId?: string;
-    model?: string;
-    [key: string]: unknown;
-}
-interface MessageStopData {
-    stopReason?: StopReason;
-    usage?: Usage;
-    responseId?: string;
-    model?: ModelId;
-    [key: string]: unknown;
-}
-/** Incremental update to a tool call during streaming. */
-interface ToolCallDelta {
-    index: number;
-    id?: string;
-    type?: string;
-    function?: FunctionCallDelta;
-}
-/** Incremental function call data. */
-interface FunctionCallDelta {
-    name?: string;
-    arguments?: string;
-}
-interface ResponseEvent<T = unknown> {
-    type: ResponseEventType;
-    event: string;
-    data?: T;
-    textDelta?: string;
-    /** Incremental tool call update during streaming. */
-    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;
-    usage?: Usage;
-    requestId?: string;
-    raw: string;
-}
-type StructuredJSONRecordType = "start" | "update" | "completion" | "error";
-/**
- * Recursively makes all properties optional.
- * Useful for typing partial payloads during progressive streaming before
- * all fields are complete.
- *
- * @example
- * interface Article { title: string; body: string; }
- * type PartialArticle = DeepPartial<Article>;
- * // { title?: string; body?: string; }
- */
-type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-interface StructuredJSONEvent<T> {
-    type: "update" | "completion";
-    payload: T;
-    requestId?: string;
-    /**
-     * Set of field paths that are complete (have their closing delimiter).
-     * Use dot notation for nested fields (e.g., "metadata.author").
-     * Check with completeFields.has("fieldName").
-     */
-    completeFields: Set<string>;
-}
-interface APIFrontendToken {
-    token: string;
-    expires_at: string;
-    expires_in: number;
-    token_type: TokenType;
-    key_id: string;
-    session_id: string;
-    project_id: string;
-    /** Optional for BYOB projects where customers are not created in the billing sense. */
-    customer_id?: string;
-    customer_external_id: string;
-    tier_code?: TierCode;
-}
-interface APICustomerRef {
-    id: string;
-    external_id: string;
-    owner_id: string;
-}
-interface APICheckoutSession {
-    id: string;
-    plan: string;
-    status: string;
-    url: string;
-    expires_at?: string;
-    completed_at?: string;
-}
-interface APIUsage {
-    input_tokens?: number;
-    output_tokens?: number;
-    total_tokens?: number;
-}
-interface APIResponsesResponse {
-    id?: string;
-    stop_reason?: string;
-    model?: string;
-    usage?: APIUsage;
-    provider?: string;
-    output?: OutputItem[];
-    citations?: Citation[];
-}
-interface APIKey {
-    id: string;
-    label: string;
-    kind: string;
-    createdAt: Date;
-    expiresAt?: Date;
-    lastUsedAt?: Date;
-    redactedKey: string;
-    secretKey?: string;
-}
-
-/**
- * Creates a user message.
- */
-declare function createUserMessage(content: string): InputItem;
-/**
- * Creates an assistant message.
- */
-declare function createAssistantMessage(content: string): InputItem;
-/**
- * Creates a system message.
- */
-declare function createSystemMessage(content: string): InputItem;
-/**
- * Creates a tool call object.
- */
-declare function createToolCall(id: string, name: string, args: string, type?: ToolType): ToolCall;
-/**
- * Creates a function call object.
- */
-declare function createFunctionCall(name: string, args: string): FunctionCall;
-/**
- * Interface for Zod-like schema types.
- * Compatible with Zod's ZodType and similar libraries.
- */
-interface ZodLikeSchema {
-    _def: {
-        typeName: string;
-        [key: string]: unknown;
-    };
-    parse(data: unknown): unknown;
-    safeParse(data: unknown): {
-        success: boolean;
-        data?: unknown;
-        error?: unknown;
-    };
-}
-/**
- * Options for JSON Schema generation.
- */
-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";
-}
-/**
- * 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
- */
-declare function zodToJsonSchema(schema: ZodLikeSchema, options?: JsonSchemaOptions): Record<string, unknown>;
-/**
- * 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 intent.
- */
-declare function createWebTool(options?: {
-    intent?: WebToolIntent;
-    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: Response): boolean;
-/**
- * Returns the first tool call from a response, or undefined if none exist.
- */
-declare function firstToolCall(response: Response): ToolCall | undefined;
-/**
- * Creates a message containing the result of a tool call.
- */
-declare function toolResultMessage(toolCallId: string, result: unknown): InputItem;
-/**
- * Creates a tool result message from a ToolCall.
- * Convenience wrapper around toolResultMessage using the call's ID.
- */
-declare function respondToToolCall(call: ToolCall, result: unknown): InputItem;
-/**
- * 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[]): InputItem;
-/**
- * Accumulates streaming tool call deltas into complete tool calls.
- */
-declare class ToolCallAccumulator {
-    private calls;
-    /**
-     * Processes a streaming tool call delta.
-     * Returns true if this started a new tool call.
-     */
-    processDelta(delta: ToolCallDelta): boolean;
-    /**
-     * Returns all accumulated tool calls in index order.
-     */
-    getToolCalls(): ToolCall[];
-    /**
-     * Returns a specific tool call by index, or undefined if not found.
-     */
-    getToolCall(index: number): ToolCall | undefined;
-    /**
-     * Clears all accumulated tool calls.
-     */
-    reset(): void;
-}
-/**
- * Error thrown when tool argument parsing or validation fails.
- * Contains a descriptive message suitable for sending back to the model.
- */
-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);
-}
-/**
- * Schema interface compatible with Zod, Yup, and similar validation libraries.
- * Any object with a `parse` method that returns the validated type works.
- */
-interface Schema<T> {
-    parse(data: unknown): T;
-}
-/**
- * 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.
- */
-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;
-}
-/**
- * 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 ToolRegistry {
-    private handlers;
-    /**
-     * 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
-     */
-    register<T = unknown, R = unknown>(name: string, handler: ToolHandler<T, R>): this;
-    /**
-     * Unregisters a tool handler.
-     * @param name - The tool name to unregister
-     * @returns true if the handler was removed, false if it didn't exist
-     */
-    unregister(name: string): boolean;
-    /**
-     * Checks if a handler is registered for the given tool name.
-     */
-    has(name: string): boolean;
-    /**
-     * Returns the list of registered tool names.
-     */
-    getRegisteredTools(): string[];
-    /**
-     * Executes a single tool call.
-     * @param call - The tool call to execute
-     * @returns The execution result
-     */
-    execute(call: ToolCall): Promise<ToolExecutionResult>;
-    /**
-     * 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
-     */
-    executeAll(calls: ToolCall[]): Promise<ToolExecutionResult[]>;
-    /**
-     * Converts execution results to tool result messages.
-     * Useful for appending to the conversation history.
-     * @param results - Array of execution results
-     * @returns Array of tool result input items (role "tool")
-     */
-    resultsToMessages(results: ToolExecutionResult[]): InputItem[];
-}
-/**
- * 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.
- */
-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[]): InputItem[];
-/**
- * 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: InputItem[], 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 req = client.responses
- *       .new()
- *       .model("...")
- *       .input(messages)
- *       .tools(tools)
- *       .build();
- *     const response = await client.responses.create(req);
- *     return firstToolCall(response) ? [firstToolCall(response)!] : [];
- *   },
- * });
- * ```
- *
- * @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[]>;
-
-export { createToolCall as $, type ApiKey as A, DEFAULT_BASE_URL as B, type CustomerTokenRequest as C, type DeviceStartRequest as D, createFunctionTool as E, type FrontendCustomer as F, createFunctionToolFromSchema as G, createWebTool as H, type InputItem as I, toolChoiceAuto as J, toolChoiceRequired as K, toolChoiceNone as L, type MetricsCallbacks as M, hasToolCalls as N, type OIDCExchangeRequest as O, type ProviderId as P, firstToolCall as Q, type RetryConfig as R, type StructuredJSONEvent as S, type TraceCallbacks as T, createUserMessage as U, createAssistantMessage as V, createSystemMessage as W, toolResultMessage as X, respondToToolCall as Y, type ZodLikeSchema as Z, assistantMessageWithToolCalls as _, type RequestContext as a, type ToolCall as a$, createFunctionCall as a0, ToolCallAccumulator as a1, zodToJsonSchema as a2, parseToolArgs as a3, tryParseToolArgs as a4, parseToolArgsRaw as a5, ToolArgsError as a6, formatToolErrorForModel as a7, hasRetryableErrors as a8, getRetryableErrors as a9, type DeviceTokenResponse as aA, type DeviceTokenPending as aB, type Usage as aC, createUsage as aD, type UsageSummary as aE, type Project as aF, MessageRoles as aG, type MessageRole as aH, ContentPartTypes as aI, type ContentPartType as aJ, type ContentPart as aK, InputItemTypes as aL, type InputItemType as aM, OutputItemTypes as aN, type OutputItemType as aO, type OutputItem as aP, ToolTypes as aQ, type ToolType as aR, WebToolIntents as aS, type WebToolIntent as aT, type FunctionTool as aU, type WebSearchConfig as aV, type XSearchConfig as aW, type CodeExecConfig as aX, ToolChoiceTypes as aY, type ToolChoiceType as aZ, type FunctionCall as a_, createRetryMessages as aa, executeWithRetry as ab, type JsonSchemaOptions as ac, type Schema as ad, type ToolHandler as ae, type RetryOptions as af, SDK_VERSION as ag, DEFAULT_CLIENT_HEADER as ah, DEFAULT_CONNECT_TIMEOUT_MS as ai, DEFAULT_REQUEST_TIMEOUT_MS as aj, type NonEmptyArray as ak, StopReasons as al, type KnownStopReason as am, type StopReason as an, asProviderId as ao, asModelId as ap, asTierCode as aq, SubscriptionStatuses as ar, type SubscriptionStatusKind as as, BillingProviders as at, type BillingProvider as au, type CustomerMetadata as av, type ModelRelayBaseOptions as aw, type ModelRelayTokenOptions as ax, type ModelRelayTokenProviderOptions as ay, type TokenType as az, type TokenProvider as b, OutputFormatTypes as b0, type OutputFormatType as b1, type JSONSchemaFormat as b2, type Citation as b3, type HttpRequestMetrics as b4, type StreamFirstTokenMetrics as b5, type TokenUsageMetrics as b6, mergeMetrics as b7, mergeTrace as b8, normalizeStopReason as b9, stopReasonToString as ba, normalizeModelId as bb, modelToString as bc, type ResponseEventType as bd, type MessageStartData as be, type MessageDeltaData as bf, type MessageStopData as bg, type ToolCallDelta as bh, type FunctionCallDelta as bi, type StructuredJSONRecordType as bj, type DeepPartial as bk, type APIFrontendToken as bl, type APICustomerRef as bm, type APICheckoutSession as bn, type APIUsage as bo, type APIResponsesResponse as bp, type APIKey as bq, type FrontendTokenRequest as c, type FrontendToken as d, type FrontendTokenAutoProvisionRequest as e, type CustomerToken as f, type DeviceStartResponse as g, type DeviceTokenResult as h, type OAuthStartRequest as i, type OAuthStartResponse as j, type ModelId as k, type OutputFormat as l, type Tool as m, type ToolChoice as n, type ResponseEvent as o, type Response as p, type FieldError as q, type RetryMetadata as r, type TransportErrorKind as s, ToolRegistry as t, type ToolExecutionResult as u, type TierCode as v, type PublishableKey as w, type SecretKey as x, type ModelRelayKeyOptions as y, type ModelRelayOptions as z };