import * as _ai_sdk_provider from '@ai-sdk/provider';
import { EmbeddingModelV4Embedding, LanguageModelV4Source, SharedV4Warning, LanguageModelV4, LanguageModelV3, LanguageModelV2, SharedV4ProviderMetadata, JSONObject, LanguageModelV4Usage, LanguageModelV4CallOptions, LanguageModelV4Prompt, AISDKError, LanguageModelV4ToolCall, JSONSchema7, ProviderV4, ProviderV3, ProviderV2, LanguageModelV4ToolResultOutput, LanguageModelV4ToolChoice, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool } from '@ai-sdk/provider';
import { GatewayModelId } from '@ai-sdk/gateway';
import { ModelMessage, AssistantModelMessage, ToolModelMessage, ProviderOptions, ToolSet, SystemModelMessage, Context, InferToolSetContext, Arrayable, InferToolInput, InferToolOutput, ReasoningPart, ReasoningFilePart, MaybePromiseLike, ToolExecutionOptions, InferToolContext, ToolResultOutput, Tool, Experimental_SandboxSession, RetryFunction, ToolApprovalRequest, ToolApprovalResponse, ToolResultPart } from '@ai-sdk/provider-utils';
export { convertAsyncIteratorToReadableStream } from '@ai-sdk/provider-utils';

/**
 * Embedding.
 */
type Embedding = EmbeddingModelV4Embedding;

declare global {
    /**
     * Global interface that can be augmented by third-party packages to register custom model IDs.
     *
     * You can register model IDs in two ways:
     *
     * 1. Register based on Model IDs from a provider package:
     * @example
     * ```typescript
     * import { openai } from '@ai-sdk/openai';
     * type OpenAIResponsesModelId = Parameters<typeof openai>[0];
     *
     * declare global {
     *   interface RegisteredProviderModels {
     *     openai: OpenAIResponsesModelId;
     *   }
     * }
     * ```
     *
     * 2. Register individual model IDs directly as keys:
     * @example
     * ```typescript
     * declare global {
     *   interface RegisteredProviderModels {
     *     'my-provider:my-model': any;
     *     'my-provider:another-model': any;
     *   }
     * }
     * ```
     */
    interface RegisteredProviderModels {
    }
}
/**
 * Global provider model ID type that defaults to GatewayModelId but can be augmented
 * by third-party packages via declaration merging.
 */
type GlobalProviderModelId = [keyof RegisteredProviderModels] extends [
    never
] ? GatewayModelId : keyof RegisteredProviderModels | RegisteredProviderModels[keyof RegisteredProviderModels];
/**
 * Language model that is used by the AI SDK.
 */
type LanguageModel = GlobalProviderModelId | LanguageModelV4 | LanguageModelV3 | LanguageModelV2;
/**
 * Reason why a language model finished generating a response.
 *
 * Can be one of the following:
 * - `stop`: model generated stop sequence
 * - `length`: model generated maximum number of tokens
 * - `content-filter`: content filter violation stopped the model
 * - `tool-calls`: model triggered tool calls
 * - `error`: model stopped because of an error
 * - `other`: model stopped for other reasons
 */
type FinishReason = 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other';
/**
 * Warning from the model provider for this call. The call will proceed, but e.g.
 * some settings might not be supported, which can lead to suboptimal results.
 */
type CallWarning = SharedV4Warning;
/**
 * A source that has been used as input to generate the response.
 */
type Source = LanguageModelV4Source;
/**
 * Tool choice for the generation. It supports the following settings:
 *
 * - `auto` (default): the model can choose whether and which tools to call.
 * - `required`: the model must call a tool. It can choose which tool to call.
 * - `none`: the model must not call tools
 * - `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
 */
type ToolChoice<TOOLS extends Record<string, unknown>> = 'auto' | 'none' | 'required' | {
    type: 'tool';
    toolName: Extract<keyof TOOLS, string>;
};

/**
 * Metadata for a language model request.
 */
type LanguageModelRequestMetadata = {
    /**
     * The input messages that were sent to the model for this step.
     */
    readonly messages?: Array<ModelMessage>;
    /**
     * Request HTTP body that was sent to the provider API.
     */
    readonly body?: unknown;
};

/**
 * A message that was generated during the generation process.
 * It can be either an assistant message or a tool message.
 */
type ResponseMessage = AssistantModelMessage | ToolModelMessage;

/**
 * Metadata for a language model response.
 */
type LanguageModelResponseMetadata = {
    /**
     * The response messages that were generated during the call.
     * Response messages can be either assistant messages or tool messages.
     * They contain a generated id.
     */
    readonly messages: Array<ResponseMessage>;
    /**
     * ID for the generated response.
     */
    readonly id: string;
    /**
     * Timestamp for the start of the generated response.
     */
    readonly timestamp: Date;
    /**
     * The ID of the response model that was used to generate the response.
     */
    readonly modelId: string;
    /**
     * Response headers (available only for providers that use HTTP requests).
     */
    readonly headers?: Record<string, string>;
    /**
     * Response body (available only for providers that use HTTP requests).
     */
    readonly body?: unknown;
};

/**
 * Additional provider-specific metadata that is returned from the provider.
 *
 * This is needed to enable provider-specific functionality that can be
 * fully encapsulated in the provider.
 */
type ProviderMetadata = SharedV4ProviderMetadata;

/**
 * Represents the number of tokens used in a prompt and completion.
 */
type LanguageModelUsage = {
    /**
     * The total number of input (prompt) tokens used.
     */
    inputTokens: number | undefined;
    /**
     * Detailed information about the input tokens.
     */
    inputTokenDetails: {
        /**
         * The number of non-cached input (prompt) tokens used.
         */
        noCacheTokens: number | undefined;
        /**
         * The number of cached input (prompt) tokens read.
         */
        cacheReadTokens: number | undefined;
        /**
         * The number of cached input (prompt) tokens written.
         */
        cacheWriteTokens: number | undefined;
    };
    /**
     * The number of total output (completion) tokens used.
     */
    outputTokens: number | undefined;
    /**
     * Detailed information about the output tokens.
     */
    outputTokenDetails: {
        /**
         * The number of text tokens used.
         */
        textTokens: number | undefined;
        /**
         * The number of reasoning tokens used.
         */
        reasoningTokens: number | undefined;
    };
    /**
     * The total number of tokens used.
     */
    totalTokens: number | undefined;
    /**
     * Raw usage information from the provider.
     *
     * This is the usage information in the shape that the provider returns.
     * It can include additional information that is not part of the standard usage information.
     */
    raw?: JSONObject;
};
/**
 * Represents the number of tokens used in an embedding.
 */
type EmbeddingModelUsage = {
    /**
     * The number of tokens used in the embedding.
     */
    tokens: number;
};
declare function asLanguageModelUsage(usage: LanguageModelV4Usage): LanguageModelUsage;
declare function createNullLanguageModelUsage(): LanguageModelUsage;
declare function addLanguageModelUsage(usage1: LanguageModelUsage, usage2: LanguageModelUsage): LanguageModelUsage;

/**
 * Warning from the model provider for this call. The call will proceed, but e.g.
 * some settings might not be supported, which can lead to suboptimal results.
 */
type Warning = SharedV4Warning;

/**
 * A function for logging warnings.
 *
 * You can assign it to the `AI_SDK_LOG_WARNINGS` global variable to use it as the default warning logger.
 *
 * @example
 * ```ts
 * globalThis.AI_SDK_LOG_WARNINGS = (options) => {
 *   console.log('WARNINGS:', options.warnings, options.provider, options.model);
 * };
 * ```
 */
type LogWarningsFunction = (options: {
    /**
     * The warnings returned by the model provider.
     */
    warnings: Warning[];
    /**
     * The provider id used for the call, if scoped to a specific provider.
     */
    provider?: string;
    /**
     * The model id used for the call, if scoped to a specific provider.
     */
    model?: string;
}) => void;

/**
 * Event passed to the `onStart` callback for embed and embedMany operations.
 *
 * Called when the operation begins, before the embedding model is called.
 */
type EmbedStartEvent = {
    /** Unique identifier for this embed call, used to correlate events. */
    readonly callId: string;
    /** Identifies the operation type (e.g. 'ai.embed' or 'ai.embedMany'). */
    readonly operationId: string;
    /** The provider identifier (e.g., 'openai', 'anthropic'). */
    readonly provider: string;
    /** The specific model identifier (e.g., 'text-embedding-3-small'). */
    readonly modelId: string;
    /** The value(s) being embedded. A string for embed, an array for embedMany. */
    readonly value: string | Array<string>;
    /** Maximum number of retries for failed requests. */
    readonly maxRetries: number;
    /** Additional HTTP headers sent with the request. */
    readonly headers: Record<string, string | undefined> | undefined;
    /** Additional provider-specific options. */
    readonly providerOptions: ProviderOptions | undefined;
};
/**
 * Event passed to the `onEnd` callback for embed and embedMany operations.
 *
 * Called when the operation completes, after the embedding model returns.
 */
type EmbedEndEvent = {
    /** Unique identifier for this embed call, used to correlate events. */
    readonly callId: string;
    /** Identifies the operation type (e.g. 'ai.embed' or 'ai.embedMany'). */
    readonly operationId: string;
    /** The provider identifier (e.g., 'openai', 'anthropic'). */
    readonly provider: string;
    /** The specific model identifier (e.g., 'text-embedding-3-small'). */
    readonly modelId: string;
    /** The value(s) that were embedded. A string for embed, an array for embedMany. */
    readonly value: string | Array<string>;
    /** The resulting embedding(s). A single vector for embed, an array for embedMany. */
    readonly embedding: Embedding | Array<Embedding>;
    /** Token usage for the embedding operation. */
    readonly usage: EmbeddingModelUsage;
    /** Warnings from the embedding model, e.g. unsupported settings. */
    readonly warnings: Array<Warning>;
    /** Optional provider-specific metadata. */
    readonly providerMetadata: ProviderMetadata | undefined;
    /** Response data including headers and body. A single response for embed, an array for embedMany. */
    readonly response: {
        headers?: Record<string, string>;
        body?: unknown;
    } | Array<{
        headers?: Record<string, string>;
        body?: unknown;
    } | undefined> | undefined;
};
/**
 * Event fired when an individual embedding model call (inner operation doEmbed) begins.
 *
 * For `embed`, there is one call. For `embedMany`, there may be multiple
 * calls when values are chunked.
 */
type EmbeddingModelCallStartEvent = {
    /** Unique identifier for this embed call, used to correlate events. */
    readonly callId: string;
    /** Unique identifier for this individual doEmbed invocation, used to correlate start/finish within parallel chunks. */
    readonly embedCallId: string;
    /** Identifies the inner operation (e.g. 'ai.embed.doEmbed' or 'ai.embedMany.doEmbed'). */
    readonly operationId: string;
    /** The provider identifier. */
    readonly provider: string;
    /** The specific model identifier. */
    readonly modelId: string;
    /** The values being embedded in this particular model call. */
    readonly values: Array<string>;
};
/**
 * Event fired when an individual embedding model call (doEmbed) completes.
 *
 * Contains the embeddings, usage, and any warnings from the model response.
 */
type EmbeddingModelCallEndEvent = {
    /** Unique identifier for this embed call, used to correlate events. */
    readonly callId: string;
    /** Unique identifier for this individual doEmbed invocation, used to correlate start/finish within parallel chunks. */
    readonly embedCallId: string;
    /** Identifies the inner operation (e.g. 'ai.embed.doEmbed' or 'ai.embedMany.doEmbed'). */
    readonly operationId: string;
    /** The provider identifier. */
    readonly provider: string;
    /** The specific model identifier. */
    readonly modelId: string;
    /** The values that were embedded in this particular model call. */
    readonly values: Array<string>;
    /** The resulting embeddings from the model call. */
    readonly embeddings: Array<Embedding>;
    /** Token usage for this model call. */
    readonly usage: EmbeddingModelUsage;
};

/**
 * Model-facing generation controls. These settings influence how the model
 * generates its response (token limits, sampling, penalties, stop sequences,
 * seed, reasoning).
 */
type LanguageModelCallOptions = {
    /**
     * Maximum number of tokens to generate.
     */
    maxOutputTokens?: number;
    /**
     * Temperature setting. The range depends on the provider and model.
     *
     * It is recommended to set either `temperature` or `topP`, but not both.
     */
    temperature?: number;
    /**
     * Nucleus sampling. This is a number between 0 and 1.
     *
     * E.g. 0.1 would mean that only tokens with the top 10% probability mass
     * are considered.
     *
     * It is recommended to set either `temperature` or `topP`, but not both.
     */
    topP?: number;
    /**
     * Only sample from the top K options for each subsequent token.
     *
     * Used to remove "long tail" low probability responses.
     * Recommended for advanced use cases only. You usually only need to use temperature.
     */
    topK?: number;
    /**
     * Presence penalty setting. It affects the likelihood of the model to
     * repeat information that is already in the prompt.
     *
     * The presence penalty is a number between -1 (increase repetition)
     * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
     */
    presencePenalty?: number;
    /**
     * Frequency penalty setting. It affects the likelihood of the model
     * to repeatedly use the same words or phrases.
     *
     * The frequency penalty is a number between -1 (increase repetition)
     * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
     */
    frequencyPenalty?: number;
    /**
     * Stop sequences.
     * If set, the model will stop generating text when one of the stop sequences is generated.
     * Providers may have limits on the number of stop sequences.
     */
    stopSequences?: string[];
    /**
     * The seed (integer) to use for random sampling. If set and supported
     * by the model, calls will generate deterministic results.
     */
    seed?: number;
    /**
     * Reasoning effort level for the model. Controls how much reasoning
     * the model performs before generating a response.
     *
     * Use `'provider-default'` to use the provider's default reasoning level.
     * Use `'none'` to disable reasoning (if supported by the provider).
     */
    reasoning?: LanguageModelV4CallOptions['reasoning'];
};

/**
 * Timeout configuration for API calls. Can be specified as:
 * - A number representing milliseconds
 * - An object with `totalMs` property for the total timeout in milliseconds
 * - An object with `stepMs` property for the timeout of each step in milliseconds
 * - An object with `firstChunkMs` property for the timeout until the first content chunk of each step (streaming only)
 * - An object with `chunkMs` property for the timeout between content chunks (streaming only)
 * - An object with `toolMs` property for the default timeout for all tool executions
 * - An object with `tools` property for per-tool timeout overrides using `{toolName}Ms` keys
 */
type TimeoutConfiguration<TOOLS extends ToolSet> = number | {
    totalMs?: number;
    stepMs?: number;
    firstChunkMs?: number;
    chunkMs?: number;
    toolMs?: number;
    tools?: Partial<Record<`${keyof TOOLS & string}Ms`, number>>;
};

/**
 * Instructions to include in the prompt. Can be used with `prompt` or `messages`.
 */
type Instructions = string | SystemModelMessage | Array<SystemModelMessage>;
/**
 * Prompt part of the AI function options.
 * It contains instructions, a simple text prompt, or a list of messages.
 */
type Prompt = {
    /**
     * Instructions to include in the prompt. Can be used with `prompt` or `messages`.
     */
    instructions?: Instructions;
    /**
     * Instructions to include in the prompt. Can be used with `prompt` or `messages`.
     *
     * @deprecated Use `instructions` instead.
     */
    system?: Instructions;
    /**
     * Whether system messages are allowed in the `prompt` or `messages` fields.
     *
     * When disabled, system messages must be provided through the `instructions`
     * option.
     *
     * @default false
     */
    allowSystemInMessages?: boolean;
} & ({
    /**
     * A prompt. It can be either a text prompt or a list of messages.
     *
     * You can either use `prompt` or `messages` but not both.
     */
    prompt: string | Array<ModelMessage>;
    /**
     * A list of messages.
     *
     * You can either use `prompt` or `messages` but not both.
     */
    messages?: never;
} | {
    /**
     * A list of messages.
     *
     * You can either use `prompt` or `messages` but not both.
     */
    messages: Array<ModelMessage>;
    /**
     * A prompt. It can be either a text prompt or a list of messages.
     *
     * You can either use `prompt` or `messages` but not both.
     */
    prompt?: never;
});

/**
 * Event passed to the `onStart` callback of
 * `generateObject` and `streamObject`.
 *
 * Called when the operation begins, before any LLM call.
 *
 * @deprecated
 */
interface GenerateObjectStartEvent {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** Identifies the operation type (e.g. `'ai.generateObject'` or `'ai.streamObject'`). */
    readonly operationId: string;
    /** The provider identifier (e.g., 'openai', 'anthropic'). */
    readonly provider: string;
    /** The specific model identifier (e.g., 'gpt-4o'). */
    readonly modelId: string;
    /** The system message(s) provided to the model. */
    readonly system: Instructions | undefined;
    /** The prompt string or array of messages if using the prompt option. */
    readonly prompt: string | Array<ModelMessage> | undefined;
    /** The messages array if using the messages option. */
    readonly messages: Array<ModelMessage> | undefined;
    /** Maximum number of tokens to generate. */
    readonly maxOutputTokens: number | undefined;
    /** Sampling temperature for generation. */
    readonly temperature: number | undefined;
    /** Top-p (nucleus) sampling parameter. */
    readonly topP: number | undefined;
    /** Top-k sampling parameter. */
    readonly topK: number | undefined;
    /** Presence penalty for generation. */
    readonly presencePenalty: number | undefined;
    /** Frequency penalty for generation. */
    readonly frequencyPenalty: number | undefined;
    /** Random seed for reproducible generation. */
    readonly seed: number | undefined;
    /** Maximum number of retries for failed requests. */
    readonly maxRetries: number;
    /** Additional HTTP headers sent with the request. */
    readonly headers: Record<string, string | undefined> | undefined;
    /** Additional provider-specific options. */
    readonly providerOptions: ProviderOptions | undefined;
    /** The output strategy type. */
    readonly output: 'object' | 'array' | 'enum' | 'no-schema';
    /** The JSON Schema used for object generation, if any. */
    readonly schema: Record<string, unknown> | undefined;
    /** Optional name of the schema. */
    readonly schemaName: string | undefined;
    /** Optional description of the schema. */
    readonly schemaDescription: string | undefined;
}
/**
 * Event passed to the `onStepStart` callback of
 * `generateObject` and `streamObject`.
 *
 * Called when the model call (step) begins, before the provider is called.
 * For object generation, there is always exactly one step (step 0).
 *
 * @deprecated
 */
interface GenerateObjectStepStartEvent {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** Zero-based index of the current step. Always `0` for object generation. */
    readonly stepNumber: 0;
    /** The provider identifier (e.g., 'openai', 'anthropic'). */
    readonly provider: string;
    /** The specific model identifier (e.g., 'gpt-4o'). */
    readonly modelId: string;
    /** Additional provider-specific options. */
    readonly providerOptions: ProviderOptions | undefined;
    /** Additional HTTP headers sent with the request. */
    readonly headers: Record<string, string | undefined> | undefined;
    /** The prompt messages in provider format (for telemetry). */
    readonly promptMessages?: LanguageModelV4Prompt;
}
/**
 * Event passed to the `onStepEnd` callback of
 * `generateObject` and `streamObject`.
 *
 * Called when the model call (step) completes, with the raw result
 * before JSON parsing and schema validation.
 *
 * @deprecated
 */
interface GenerateObjectStepEndEvent {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** Zero-based index of the current step. Always `0` for object generation. */
    readonly stepNumber: 0;
    /** The provider identifier (e.g., 'openai', 'anthropic'). */
    readonly provider: string;
    /** The specific model identifier (e.g., 'gpt-4o'). */
    readonly modelId: string;
    /** The unified reason why the generation finished. */
    readonly finishReason: FinishReason;
    /** The token usage of the generated response. */
    readonly usage: LanguageModelUsage;
    /** The raw text output from the model (before JSON parsing). */
    readonly objectText: string;
    /** The reasoning generated by the model, if any. */
    readonly reasoning: string | undefined;
    /** Warnings from the model provider (e.g. unsupported settings). */
    readonly warnings: CallWarning[] | undefined;
    /** Additional request information. */
    readonly request: Omit<LanguageModelRequestMetadata, 'messages'>;
    /** Additional response information. */
    readonly response: Omit<LanguageModelResponseMetadata, 'messages'>;
    /** Additional provider-specific metadata. */
    readonly providerMetadata: ProviderMetadata | undefined;
    /** Milliseconds from the start of the stream to the first chunk (streaming only). */
    readonly msToFirstChunk: number | undefined;
}
/**
 * Event passed to the `onFinish` callback of
 * `generateObject` and `streamObject`.
 *
 * Called when the entire operation completes, including JSON parsing
 * and schema validation. For `streamObject`, the object may be undefined
 * if validation failed (the error is provided in that case).
 *
 * @deprecated
 */
interface GenerateObjectEndEvent<RESULT> {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /**
     * The generated object (typed according to the schema).
     * Always defined for `generateObject`. May be `undefined` for `streamObject`
     * when parsing or validation fails.
     */
    readonly object: RESULT | undefined;
    /**
     * Error from parsing or schema validation, if any.
     * Always `undefined` for `generateObject` (which throws instead).
     */
    readonly error: unknown | undefined;
    /** The reasoning generated by the model, if any. */
    readonly reasoning: string | undefined;
    /** The unified reason why the generation finished. */
    readonly finishReason: FinishReason;
    /** The token usage of the generated response. */
    readonly usage: LanguageModelUsage;
    /** Warnings from the model provider (e.g. unsupported settings). */
    readonly warnings: CallWarning[] | undefined;
    /** Additional request information. */
    readonly request: Omit<LanguageModelRequestMetadata, 'messages'>;
    /** Additional response information. */
    readonly response: Omit<LanguageModelResponseMetadata, 'messages'>;
    /** Additional provider-specific metadata. */
    readonly providerMetadata: ProviderMetadata | undefined;
}

type StandardizedPrompt = {
    /**
     * Instructions.
     */
    instructions: Instructions | undefined;
    /**
     * Messages.
     */
    messages: ModelMessage[];
};
/**
 * Converts a prompt input into a standardized prompt with validated model
 * messages.
 *
 * @param prompt - The prompt definition to standardize.
 * Set `allowSystemInMessages` to true to allow system messages in the
 * `prompt` or `messages` fields. System messages in the `instructions`
 * option are always allowed.
 * @returns The standardized prompt.
 * @throws {InvalidPromptError} When the prompt is invalid.
 */
declare function standardizePrompt({ allowSystemInMessages, system, instructions, prompt, messages, }: Prompt): Promise<StandardizedPrompt>;

/**
 * A callback function that can be used with `notify`.
 */
type Callback<EVENT> = (event: EVENT) => PromiseLike<void> | void;

/**
 * Tool names that are enabled for a generation step.
 *
 * `undefined` means no tool restriction is applied. Tool names are object keys
 * at runtime, so the type is restricted to the string keys of the configured
 * tool set.
 */
type ActiveTools<TOOLS extends ToolSet> = ReadonlyArray<keyof TOOLS & string> | undefined;

type IncludedContext<CONTEXT extends Context | unknown | never> = {
    [KEY in keyof NoInfer<CONTEXT>]?: boolean;
} | undefined;
type IncludedToolsContext<TOOLS extends ToolSet> = {
    [TOOL_NAME in keyof NoInfer<InferToolSetContext<TOOLS>>]?: IncludedContext<NoInfer<InferToolSetContext<TOOLS>[TOOL_NAME]>>;
} | undefined;
/**
 * Telemetry configuration.
 */
type TelemetryOptions<RUNTIME_CONTEXT extends Context = Context, TOOLS extends ToolSet = ToolSet> = {
    /**
     * Enable or disable telemetry. Enabled by default when a telemetry
     * integration is registered. Set to `false` to opt out.
     */
    isEnabled?: boolean;
    /**
     * Enable or disable input recording. Enabled by default.
     *
     * You might want to disable input recording to avoid recording sensitive
     * information, to reduce data transfers, or to increase performance.
     */
    recordInputs?: boolean;
    /**
     * Enable or disable output recording. Enabled by default.
     *
     * You might want to disable output recording to avoid recording sensitive
     * information, to reduce data transfers, or to increase performance.
     */
    recordOutputs?: boolean;
    /**
     * Identifier for this function. Used to group telemetry data by function.
     */
    functionId?: string;
    /**
     * Top-level runtime context properties that should be included in telemetry.
     * Runtime context properties are excluded unless they are explicitly set to `true`.
     */
    includeRuntimeContext?: IncludedContext<RUNTIME_CONTEXT>;
    /**
     * Top-level tool context properties that should be included in telemetry,
     * configured per tool.
     *
     * Tool context properties are excluded unless they are explicitly set to `true`.
     */
    includeToolsContext?: IncludedToolsContext<TOOLS>;
    /**
     * Per-call telemetry integrations that receive lifecycle events during generation.
     *
     * When provided, these integrations will take precedence over the globally registered
     * integrations for this call.
     */
    integrations?: Arrayable<Telemetry>;
};

/**
 * Download a file from a URL.
 *
 * @param url - The URL to download from.
 * @param maxBytes - Maximum allowed download size in bytes. Defaults to 100 MiB.
 * @param abortSignal - An optional abort signal to cancel the download.
 * @returns The downloaded data and media type.
 *
 * @throws DownloadError if the download fails or exceeds maxBytes.
 */
declare const download: ({ url, maxBytes, abortSignal, }: {
    url: URL;
    maxBytes?: number;
    abortSignal?: AbortSignal;
}) => Promise<{
    data: Uint8Array<ArrayBufferLike>;
    mediaType: string | undefined;
}>;

/**
 * Experimental. Can change in patch versions without warning.
 *
 * Download function. Called with the array of URLs and a boolean indicating
 * whether the URL is supported by the model.
 *
 * The download function can decide for each URL:
 * - to return null (which means that the URL should be passed to the model)
 * - to download the asset and return the data (incl. retries, authentication, etc.)
 *
 * Should throw DownloadError if the download fails.
 *
 * Should return an array of objects sorted by the order of the requested downloads.
 * For each object, the data should be a Uint8Array if the URL was downloaded.
 * For each object, the mediaType should be the media type of the downloaded asset.
 * For each object, the data should be null if the URL should be passed through as is.
 */
type DownloadFunction = (options: Array<{
    url: URL;
    isUrlSupportedByModel: boolean;
}>) => PromiseLike<Array<{
    data: Uint8Array;
    mediaType: string | undefined;
} | null>>;
/**
 * Default download function.
 * Downloads the file if it is not supported by the model.
 */
declare const createDefaultDownloadFunction: (download?: typeof download) => DownloadFunction;

/**
 * A generated file.
 */
interface GeneratedFile {
    /**
     * File as a base64 encoded string.
     */
    readonly base64: string;
    /**
     * File as a Uint8Array.
     */
    readonly uint8Array: Uint8Array;
    /**
     * The IANA media type of the file.
     *
     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
     */
    readonly mediaType: string;
    /**
     * Provider-specific metadata for this file.
     */
    readonly providerMetadata?: Record<string, JSONObject>;
}

/**
 * Reasoning output of a text generation. It contains a reasoning.
 */
interface ReasoningOutput {
    type: 'reasoning';
    /**
     * The reasoning text.
     */
    text: string;
    /**
     * Additional provider-specific metadata. They are passed through
     * to the provider from the AI SDK and enable provider-specific
     * functionality that can be fully encapsulated in the provider.
     */
    providerMetadata?: ProviderMetadata;
}
/**
 * Reasoning file output of a text generation.
 * It contains a file generated as part of reasoning.
 */
interface ReasoningFileOutput {
    type: 'reasoning-file';
    /**
     * The generated file.
     */
    file: GeneratedFile;
    /**
     * Additional provider-specific metadata. They are passed through
     * to the provider from the AI SDK and enable provider-specific
     * functionality that can be fully encapsulated in the provider.
     */
    providerMetadata?: ProviderMetadata;
}

/**
 * Create a union of the given object's values, and optionally specify which keys to get the values from.
 *
 * Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
 *
 * @example
 * ```
 * // data.json
 * {
 * 	'foo': 1,
 * 	'bar': 2,
 * 	'biz': 3
 * }
 *
 * // main.ts
 * import type {ValueOf} from 'type-fest';
 * import data = require('./data.json');
 *
 * export function getData(name: string): ValueOf<typeof data> {
 * 	return data[name];
 * }
 *
 * export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
 * 	return data[name];
 * }
 *
 * // file.ts
 * import {getData, onlyBar} from './main';
 *
 * getData('foo');
 * //=> 1
 *
 * onlyBar('foo');
 * //=> TypeError ...
 *
 * onlyBar('bar');
 * //=> 2
 * ```
 * @see https://github.com/sindresorhus/type-fest/blob/main/source/value-of.d.ts
 */
type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];

type BaseToolCall = {
    type: 'tool-call';
    toolCallId: string;
    providerExecuted?: boolean;
    providerMetadata?: ProviderMetadata;
    toolMetadata?: JSONObject;
};
/**
 * A tool call whose `toolName` maps to a tool in the declared tool set,
 * with an `input` type inferred from that tool's input schema.
 */
type StaticToolCall<TOOLS extends ToolSet> = ValueOf<{
    [NAME in keyof TOOLS]: BaseToolCall & {
        toolName: NAME & string;
        input: InferToolInput<TOOLS[NAME]>;
        dynamic?: false | undefined;
        invalid?: false | undefined;
        error?: never;
        title?: string;
    };
}>;
/**
 * A tool call whose `toolName` is only known at runtime, such as an invalid
 * or otherwise untyped call that cannot be matched to the declared tool set.
 */
type DynamicToolCall = BaseToolCall & {
    toolName: string;
    input: unknown;
    dynamic: true;
    title?: string;
    /**
     * True if this is caused by an unparsable tool call or
     * a tool that does not exist.
     */
    invalid?: boolean;
    /**
     * The error that caused the tool call to be invalid.
     */
    error?: unknown;
};
/**
 * A tool call returned by text generation, either statically typed from the
 * declared tool set or dynamically typed when the tool cannot be inferred.
 */
type TypedToolCall<TOOLS extends ToolSet> = StaticToolCall<TOOLS> | DynamicToolCall;

/**
 * Output part that indicates that a tool approval request has been made.
 *
 * The tool approval request can be approved or denied in the next tool message.
 */
type ToolApprovalRequestOutput<TOOLS extends ToolSet> = {
    type: 'tool-approval-request';
    /**
     * ID of the tool approval request.
     */
    approvalId: string;
    /**
     * Tool call that the approval request is for.
     */
    toolCall: TypedToolCall<TOOLS>;
    /**
     * Reason why the tool call requires approval.
     */
    reason?: string;
    /**
     * Flag indicating whether the tool was automatically approved or denied.
     *
     * @default false
     */
    isAutomatic?: boolean;
    /**
     * HMAC-SHA256 signature binding this approval request to its tool call.
     */
    signature?: string;
};

/**
 * Output part that indicates that a tool approval response is available.
 */
type ToolApprovalResponseOutput<TOOLS extends ToolSet> = {
    type: 'tool-approval-response';
    /**
     * ID of the tool approval.
     */
    approvalId: string;
    /**
     * Tool call that the approval response is for.
     */
    toolCall: TypedToolCall<TOOLS>;
    /**
     * Flag indicating whether the approval was granted or denied.
     */
    approved: boolean;
    /**
     * Optional reason for the approval or denial.
     */
    reason?: string;
    /**
     * Flag indicating whether the tool call is provider-executed.
     * Only provider-executed tool approval responses should be sent to the model.
     */
    providerExecuted?: boolean;
};

type StaticToolError<TOOLS extends ToolSet> = ValueOf<{
    [NAME in keyof TOOLS]: {
        type: 'tool-error';
        toolCallId: string;
        toolName: NAME & string;
        input: InferToolInput<TOOLS[NAME]>;
        error: unknown;
        providerExecuted?: boolean;
        providerMetadata?: ProviderMetadata;
        toolMetadata?: JSONObject;
        dynamic?: false | undefined;
        title?: string;
    };
}>;
type DynamicToolError = {
    type: 'tool-error';
    toolCallId: string;
    toolName: string;
    input: unknown;
    error: unknown;
    providerExecuted?: boolean;
    providerMetadata?: ProviderMetadata;
    toolMetadata?: JSONObject;
    dynamic: true;
    title?: string;
};
type TypedToolError<TOOLS extends ToolSet> = StaticToolError<TOOLS> | DynamicToolError;

type StaticToolResult<TOOLS extends ToolSet> = ValueOf<{
    [NAME in keyof TOOLS]: {
        type: 'tool-result';
        toolCallId: string;
        toolName: NAME & string;
        input: InferToolInput<TOOLS[NAME]>;
        output: InferToolOutput<TOOLS[NAME]>;
        providerExecuted?: boolean;
        providerMetadata?: ProviderMetadata;
        toolMetadata?: JSONObject;
        dynamic?: false | undefined;
        preliminary?: boolean;
        title?: string;
    };
}>;
type DynamicToolResult = {
    type: 'tool-result';
    toolCallId: string;
    toolName: string;
    input: unknown;
    output: unknown;
    providerExecuted?: boolean;
    providerMetadata?: ProviderMetadata;
    toolMetadata?: JSONObject;
    dynamic: true;
    preliminary?: boolean;
    title?: string;
};
type TypedToolResult<TOOLS extends ToolSet> = StaticToolResult<TOOLS> | DynamicToolResult;

type ContentPart<TOOLS extends ToolSet> = {
    type: 'text';
    text: string;
    providerMetadata?: ProviderMetadata;
} | {
    type: 'custom';
    kind: `${string}.${string}`;
    providerMetadata?: ProviderMetadata;
} | ReasoningOutput | ReasoningFileOutput | ({
    type: 'source';
} & Source) | {
    type: 'file';
    file: GeneratedFile;
    providerMetadata?: ProviderMetadata;
} | ({
    type: 'tool-call';
} & TypedToolCall<TOOLS> & {
    providerMetadata?: ProviderMetadata;
}) | ({
    type: 'tool-result';
} & TypedToolResult<TOOLS> & {
    providerMetadata?: ProviderMetadata;
}) | ({
    type: 'tool-error';
} & TypedToolError<TOOLS> & {
    providerMetadata?: ProviderMetadata;
}) | ToolApprovalRequestOutput<TOOLS> | ToolApprovalResponseOutput<TOOLS>;

/**
 * Timing statistics for the gaps between generated output chunks.
 */
type OutputChunkTimingStats = {
    /** Shortest observed time between output chunks in milliseconds. */
    readonly min: number;
    /** 10th percentile time between output chunks in milliseconds. */
    readonly p10: number;
    /** Median time between output chunks in milliseconds. */
    readonly median: number;
    /** Average time between output chunks in milliseconds. */
    readonly avg: number;
    /** 90th percentile time between output chunks in milliseconds. */
    readonly p90: number;
    /** Longest observed time between output chunks in milliseconds. */
    readonly max: number;
};
/**
 * Performance metrics for a single step in the generation process.
 */
type StepResultPerformance = {
    /**
     * Effective number of output tokens per second over the full language model
     * response.
     *
     * Calculated as `outputTokens / requestSeconds`.
     */
    readonly effectiveOutputTokensPerSecond: number;
    /**
     * Number of output tokens per second after the first generated output chunk
     * was received.
     *
     * Only available for streaming steps.
     *
     * Calculated as `outputTokens / outputStreamSeconds`.
     */
    readonly outputTokensPerSecond: number | undefined;
    /**
     * Number of input tokens processed per second before the first generated
     * output chunk was received.
     *
     * Only available for streaming steps.
     *
     * Calculated as `inputTokens / ttftSeconds`.
     */
    readonly inputTokensPerSecond: number | undefined;
    /**
     * Effective number of input and output tokens per second over the full
     * language model response.
     *
     * Calculated as `(inputTokens + outputTokens) / requestSeconds`.
     */
    readonly effectiveTotalTokensPerSecond: number;
    /**
     * Total time spent on the step in milliseconds.
     */
    readonly stepTimeMs: number;
    /**
     * Time spent waiting for the language model response in milliseconds.
     */
    readonly responseTimeMs: number;
    /**
     * Time spent executing each client-side tool call in milliseconds, keyed by
     * tool call ID.
     */
    readonly toolExecutionMs: Readonly<Record<string, number>>;
    /**
     * Time until the first generated output chunk was received in milliseconds.
     *
     * This includes text deltas, reasoning deltas, generated files, reasoning
     * files, tool input deltas, and tool calls.
     *
     * Only available for streaming steps.
     */
    readonly timeToFirstOutputMs: number | undefined;
    /**
     * Timing statistics for the gaps between generated output chunks in
     * milliseconds.
     *
     * Only available for streaming steps with at least two generated output
     * chunks.
     */
    readonly timeBetweenOutputChunksMs?: OutputChunkTimingStats;
};
/**
 * The result of a single step in the generation process.
 */
type StepResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context = Context> = {
    /**
     * Unique identifier for the generation call this step belongs to.
     */
    readonly callId: string;
    /**
     * Zero-based index of this step.
     */
    readonly stepNumber: number;
    /**
     * Information about the model that produced this step.
     */
    readonly model: {
        /** The provider of the model. */
        readonly provider: string;
        /** The ID of the model. */
        readonly modelId: string;
    };
    /**
     * Tool context.
     */
    readonly toolsContext: InferToolSetContext<TOOLS>;
    /**
     * The runtime context that was used as input for the step.
     */
    readonly runtimeContext: RUNTIME_CONTEXT;
    /**
     * The content that was generated in the last step.
     */
    readonly content: Array<ContentPart<TOOLS>>;
    /**
     * The concatenation of all text parts generated in this step.
     * It is an empty string if the step contains no text parts.
     */
    readonly text: string;
    /**
     * The reasoning that was generated during the generation.
     */
    readonly reasoning: Array<ReasoningPart | ReasoningFilePart>;
    /**
     * The reasoning text that was generated during the generation.
     *
     * It is a concatenation of all reasoning parts (but excluding reasoning file parts).
     * Can be undefined if the model has only generated text.
     */
    readonly reasoningText: string | undefined;
    /**
     * The files that were generated during the generation.
     */
    readonly files: Array<GeneratedFile>;
    /**
     * The sources that were used to generate the text.
     */
    readonly sources: Array<Source>;
    /**
     * The tool calls that were made during the generation.
     */
    readonly toolCalls: Array<TypedToolCall<TOOLS>>;
    /**
     * The static tool calls that were made in the last step.
     */
    readonly staticToolCalls: Array<StaticToolCall<TOOLS>>;
    /**
     * The dynamic tool calls that were made in the last step.
     */
    readonly dynamicToolCalls: Array<DynamicToolCall>;
    /**
     * The results of the tool calls.
     */
    readonly toolResults: Array<TypedToolResult<TOOLS>>;
    /**
     * The static tool results that were made in the last step.
     */
    readonly staticToolResults: Array<StaticToolResult<TOOLS>>;
    /**
     * The dynamic tool results that were made in the last step.
     */
    readonly dynamicToolResults: Array<DynamicToolResult>;
    /**
     * The unified reason why the generation finished.
     */
    readonly finishReason: FinishReason;
    /**
     * The raw reason why the generation finished (from the provider).
     */
    readonly rawFinishReason: string | undefined;
    /**
     * The token usage of the generated text.
     */
    readonly usage: LanguageModelUsage;
    /**
     * Performance metrics for the step.
     */
    readonly performance: StepResultPerformance;
    /**
     * Warnings from the model provider (e.g. unsupported settings).
     */
    readonly warnings: CallWarning[] | undefined;
    /**
     * Additional request information.
     */
    readonly request: LanguageModelRequestMetadata;
    /**
     * Additional response information.
     */
    readonly response: LanguageModelResponseMetadata;
    /**
     * Additional provider-specific metadata. They are passed through
     * from the provider to the AI SDK and enable provider-specific
     * results that can be fully encapsulated in the provider.
     */
    readonly providerMetadata: ProviderMetadata | undefined;
};
declare class DefaultStepResult<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context = Context> implements StepResult<TOOLS, RUNTIME_CONTEXT> {
    readonly callId: StepResult<TOOLS, RUNTIME_CONTEXT>['callId'];
    readonly stepNumber: StepResult<TOOLS, RUNTIME_CONTEXT>['stepNumber'];
    readonly model: StepResult<TOOLS, RUNTIME_CONTEXT>['model'];
    readonly toolsContext: StepResult<TOOLS, RUNTIME_CONTEXT>['toolsContext'];
    readonly runtimeContext: StepResult<TOOLS, RUNTIME_CONTEXT>['runtimeContext'];
    readonly content: StepResult<TOOLS, RUNTIME_CONTEXT>['content'];
    readonly finishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['finishReason'];
    readonly rawFinishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['rawFinishReason'];
    readonly usage: StepResult<TOOLS, RUNTIME_CONTEXT>['usage'];
    readonly performance: StepResult<TOOLS, RUNTIME_CONTEXT>['performance'];
    readonly warnings: StepResult<TOOLS, RUNTIME_CONTEXT>['warnings'];
    readonly request: StepResult<TOOLS, RUNTIME_CONTEXT>['request'];
    readonly response: StepResult<TOOLS, RUNTIME_CONTEXT>['response'];
    readonly providerMetadata: StepResult<TOOLS, RUNTIME_CONTEXT>['providerMetadata'];
    constructor({ callId, stepNumber, provider, modelId, runtimeContext, toolsContext, content, finishReason, rawFinishReason, usage, performance, warnings, request, response, providerMetadata, }: {
        callId: StepResult<TOOLS, RUNTIME_CONTEXT>['callId'];
        stepNumber: StepResult<TOOLS, RUNTIME_CONTEXT>['stepNumber'];
        provider: StepResult<TOOLS, RUNTIME_CONTEXT>['model']['provider'];
        modelId: StepResult<TOOLS, RUNTIME_CONTEXT>['model']['modelId'];
        runtimeContext: StepResult<TOOLS, RUNTIME_CONTEXT>['runtimeContext'];
        toolsContext: StepResult<TOOLS, RUNTIME_CONTEXT>['toolsContext'];
        content: StepResult<TOOLS, RUNTIME_CONTEXT>['content'];
        finishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['finishReason'];
        rawFinishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['rawFinishReason'];
        usage: StepResult<TOOLS, RUNTIME_CONTEXT>['usage'];
        performance: StepResult<TOOLS, RUNTIME_CONTEXT>['performance'];
        warnings: StepResult<TOOLS, RUNTIME_CONTEXT>['warnings'];
        request: StepResult<TOOLS, RUNTIME_CONTEXT>['request'];
        response: StepResult<TOOLS, RUNTIME_CONTEXT>['response'];
        providerMetadata: StepResult<TOOLS, RUNTIME_CONTEXT>['providerMetadata'];
    });
    get text(): string;
    get reasoning(): Array<ReasoningPart | ReasoningFilePart>;
    get reasoningText(): string | undefined;
    get files(): GeneratedFile[];
    get sources(): (({
        type: "source";
    } & {
        type: "source";
        sourceType: "url";
        id: string;
        url: string;
        title?: string;
        providerMetadata?: _ai_sdk_provider.SharedV4ProviderMetadata;
    }) | ({
        type: "source";
    } & {
        type: "source";
        sourceType: "document";
        id: string;
        mediaType: string;
        title: string;
        filename?: string;
        providerMetadata?: _ai_sdk_provider.SharedV4ProviderMetadata;
    }))[];
    get toolCalls(): (({
        type: "tool-call";
    } & {
        type: "tool-call";
        toolCallId: string;
        providerExecuted?: boolean;
        providerMetadata?: ProviderMetadata;
        toolMetadata?: _ai_sdk_provider.JSONObject;
    } & {
        toolName: string;
        input: unknown;
        dynamic: true;
        title?: string;
        invalid?: boolean;
        error?: unknown;
    } & {
        providerMetadata?: ProviderMetadata;
    }) | ({
        type: "tool-call";
    } & StaticToolCall<TOOLS> & {
        providerMetadata?: ProviderMetadata;
    }))[];
    get staticToolCalls(): StaticToolCall<TOOLS>[];
    get dynamicToolCalls(): DynamicToolCall[];
    get toolResults(): (({
        type: "tool-result";
    } & DynamicToolResult & {
        providerMetadata?: ProviderMetadata;
    }) | ({
        type: "tool-result";
    } & StaticToolResult<TOOLS> & {
        providerMetadata?: ProviderMetadata;
    }))[];
    get staticToolResults(): StaticToolResult<TOOLS>[];
    get dynamicToolResults(): DynamicToolResult[];
}

/**
 * Common model information used across callback events.
 */
type ModelInfo = {
    /** The provider identifier (e.g., 'openai', 'anthropic'). */
    readonly provider: string;
    /** The specific model identifier (e.g., 'gpt-4o'). */
    readonly modelId: string;
};
/**
 * Event passed to the `onLanguageModelCallStart` callback.
 *
 * Called immediately before the provider model call begins.
 * Unlike `onStepStart`, this only represents model invocation work.
 */
type LanguageModelCallStartEvent = ModelInfo & {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** Prepared tool definitions for the model call, if any. */
    readonly tools: ReadonlyArray<Record<string, unknown>> | undefined;
} & StandardizedPrompt & LanguageModelCallOptions;
/**
 * Event passed to the `onLanguageModelCallEnd` callback.
 *
 * Called after the model response has been normalized and parsed, but before
 * any client-side tool execution begins.
 */
type LanguageModelCallEndEvent<TOOLS extends ToolSet = ToolSet> = ModelInfo & {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** The unified reason why the model call finished. */
    readonly finishReason: FinishReason;
    /** The token usage reported by the model call. */
    readonly usage: LanguageModelUsage;
    /** The content parts produced by the model call. */
    readonly content: ReadonlyArray<ContentPart<TOOLS>>;
    /** The provider-returned response id for this model call. */
    readonly responseId: string;
    /** Optional provider-specific metadata for this model call. */
    readonly providerMetadata?: ProviderMetadata;
    /** Performance metrics for the model call. */
    readonly performance: {
        /** Time spent waiting for the language model response in milliseconds. */
        readonly responseTimeMs: number;
        /**
         * Effective number of output tokens per second over the full language
         * model response.
         */
        readonly effectiveOutputTokensPerSecond: number;
        /**
         * Number of output tokens per second after the first generated output
         * chunk was received.
         *
         * Only available for streaming calls.
         */
        readonly outputTokensPerSecond: number | undefined;
        /**
         * Number of input tokens processed per second before the first generated
         * output chunk was received.
         *
         * Only available for streaming calls.
         */
        readonly inputTokensPerSecond: number | undefined;
        /**
         * Effective number of input and output tokens per second over the full
         * language model response.
         */
        readonly effectiveTotalTokensPerSecond: number;
        /**
         * Time until the first generated output chunk was received in
         * milliseconds.
         */
        readonly timeToFirstOutputMs: number | undefined;
        /**
         * Timing statistics for the gaps between generated output chunks in
         * milliseconds.
         *
         * Only available for streaming calls with at least two output chunks.
         */
        readonly timeBetweenOutputChunksMs?: OutputChunkTimingStats;
    };
};
/**
 * Callback that is set using the `onLanguageModelCallStart` option.
 *
 * Called immediately before the provider model call begins.
 * Unlike step-start callbacks, this is scoped to model work only and
 * excludes any later client-side tool execution.
 *
 * @param event - The event object containing model-call-specific inputs.
 */
type OnLanguageModelCallStartCallback = Callback<LanguageModelCallStartEvent>;
/**
 * Callback that is set using the `onLanguageModelCallEnd` option.
 *
 * Called after the model response has been normalized and parsed, but before
 * any client-side tool execution begins.
 *
 * @param event - The event object containing model-call-specific outputs.
 */
type OnLanguageModelCallEndCallback<TOOLS extends ToolSet = ToolSet> = Callback<LanguageModelCallEndEvent<TOOLS>>;

/**
 * Tool names that define the order in which tools are sent to the provider.
 *
 * Tool names are object keys at runtime, so the type is restricted to the
 * string keys of the configured tool set. The list can be partial; tools not
 * listed in `toolOrder` are sent after the listed tools, sorted alphabetically.
 */
type ToolOrder<TOOLS extends ToolSet> = ReadonlyArray<keyof TOOLS & string> | undefined;

/**
 * A type that combines AsyncIterable and ReadableStream.
 * This allows a ReadableStream to be consumed using for-await-of syntax.
 */
type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
/**
 * Wraps a ReadableStream and returns an object that is both a ReadableStream and an AsyncIterable.
 * This enables consumption of the stream using for-await-of, with proper resource cleanup on early exit or error.
 *
 * @template T The type of the stream's chunks.
 * @param source The source ReadableStream to wrap.
 * @returns An AsyncIterableStream that can be used as both a ReadableStream and an AsyncIterable.
 */
declare function createAsyncIterableStream<T>(source: ReadableStream<T>): AsyncIterableStream<T>;

/**
 * Tool output when the tool execution has been denied (for static tools).
 */
type StaticToolOutputDenied<TOOLS extends ToolSet> = ValueOf<{
    [NAME in keyof TOOLS]: {
        type: 'tool-output-denied';
        toolCallId: string;
        toolName: NAME & string;
        providerExecuted?: boolean;
        dynamic?: false | undefined;
    };
}>;

type TextStreamTextDeltaPart = {
    type: 'text-delta';
    id: string;
    providerMetadata?: ProviderMetadata;
    text: string;
};
type TextStreamTextStartPart = {
    type: 'text-start';
    id: string;
    providerMetadata?: ProviderMetadata;
};
type TextStreamTextEndPart = {
    type: 'text-end';
    id: string;
    providerMetadata?: ProviderMetadata;
};
type TextStreamReasoningStartPart = {
    type: 'reasoning-start';
    id: string;
    providerMetadata?: ProviderMetadata;
};
type TextStreamReasoningEndPart = {
    type: 'reasoning-end';
    id: string;
    providerMetadata?: ProviderMetadata;
};
type TextStreamReasoningDeltaPart = {
    type: 'reasoning-delta';
    providerMetadata?: ProviderMetadata;
    id: string;
    text: string;
};
type TextStreamCustomPart = {
    type: 'custom';
    kind: `${string}.${string}`;
    providerMetadata?: ProviderMetadata;
};
type TextStreamToolInputStartPart = {
    type: 'tool-input-start';
    id: string;
    toolName: string;
    providerMetadata?: ProviderMetadata;
    toolMetadata?: JSONObject;
    providerExecuted?: boolean;
    dynamic?: boolean;
    title?: string;
};
type TextStreamToolInputEndPart = {
    type: 'tool-input-end';
    id: string;
    providerMetadata?: ProviderMetadata;
};
type TextStreamToolInputDeltaPart = {
    type: 'tool-input-delta';
    id: string;
    delta: string;
    providerMetadata?: ProviderMetadata;
};
type TextStreamSourcePart = {
    type: 'source';
} & Source;
type TextStreamFilePart = {
    type: 'file';
    file: GeneratedFile;
    providerMetadata?: ProviderMetadata;
};
type TextStreamReasoningFilePart = {
    type: 'reasoning-file';
    file: GeneratedFile;
    providerMetadata?: ProviderMetadata;
};
type TextStreamToolCallPart<TOOLS extends ToolSet> = {
    type: 'tool-call';
} & TypedToolCall<TOOLS>;
type TextStreamToolResultPart<TOOLS extends ToolSet> = {
    type: 'tool-result';
} & TypedToolResult<TOOLS>;
type TextStreamToolErrorPart<TOOLS extends ToolSet> = {
    type: 'tool-error';
} & TypedToolError<TOOLS>;
type TextStreamToolOutputDeniedPart<TOOLS extends ToolSet> = {
    type: 'tool-output-denied';
} & StaticToolOutputDenied<TOOLS>;
type TextStreamToolApprovalRequestPart<TOOLS extends ToolSet> = ToolApprovalRequestOutput<TOOLS>;
type TextStreamToolApprovalResponsePart<TOOLS extends ToolSet> = ToolApprovalResponseOutput<TOOLS>;
type TextStreamStartStepPart = {
    type: 'start-step';
    request: LanguageModelRequestMetadata;
    warnings: CallWarning[];
};
type TextStreamFinishStepPart = {
    type: 'finish-step';
    response: Omit<LanguageModelResponseMetadata, 'messages' | 'body'>;
    usage: LanguageModelUsage;
    performance: StepResultPerformance;
    finishReason: FinishReason;
    rawFinishReason: string | undefined;
    providerMetadata: ProviderMetadata | undefined;
};
type TextStreamStartPart = {
    type: 'start';
};
type TextStreamFinishPart = {
    type: 'finish';
    finishReason: FinishReason;
    rawFinishReason: string | undefined;
    totalUsage: LanguageModelUsage;
};
type TextStreamAbortPart = {
    type: 'abort';
    reason?: string;
};
type TextStreamErrorPart = {
    type: 'error';
    error: unknown;
};
type TextStreamRawPart = {
    type: 'raw';
    rawValue: unknown;
};
type TextStreamPart<TOOLS extends ToolSet> = TextStreamTextStartPart | TextStreamTextEndPart | TextStreamTextDeltaPart | TextStreamReasoningStartPart | TextStreamReasoningEndPart | TextStreamReasoningDeltaPart | TextStreamCustomPart | TextStreamToolInputStartPart | TextStreamToolInputEndPart | TextStreamToolInputDeltaPart | TextStreamSourcePart | TextStreamFilePart | TextStreamReasoningFilePart | TextStreamToolCallPart<TOOLS> | TextStreamToolResultPart<TOOLS> | TextStreamToolErrorPart<TOOLS> | TextStreamToolOutputDeniedPart<TOOLS> | TextStreamToolApprovalRequestPart<TOOLS> | TextStreamToolApprovalResponsePart<TOOLS> | TextStreamStartStepPart | TextStreamFinishStepPart | TextStreamStartPart | TextStreamFinishPart | TextStreamAbortPart | TextStreamErrorPart | TextStreamRawPart;

/**
 * The approval status of a tool configuration. This can be one of the following:
 *
 * - 'not-applicable': The tool does not require approval.
 * - 'approved': The tool is automatically approved.
 * - 'denied': The tool is automatically denied.
 * - 'user-approval': The tool requires user approval.
 *
 * In addition to the string statuses, you can also use object statuses with a reason property.
 * For approved and denied statuses, the reason is emitted on the approval response.
 * For user-approval statuses, the reason is emitted on the approval request so it can be shown to the approver.
 *
 * `undefined` is treated as the `not-applicable` status.
 */
type ToolApprovalStatus = undefined | 'not-applicable' | 'approved' | 'denied' | 'user-approval' | {
    type: 'not-applicable';
    reason?: never;
} | {
    type: 'approved';
    reason?: string;
} | {
    type: 'denied';
    reason?: string;
} | {
    type: 'user-approval';
    reason?: string;
};
/**
 * Function that is called to determine if the tool needs approval before it can be executed.
 *
 * Return `undefined` for the same effect as the `not-applicable` status.
 */
type SingleToolApprovalFunction<INPUT, TOOL_CONTEXT extends Context | unknown | never, RUNTIME_CONTEXT extends Context | unknown | never> = (input: INPUT, options: Omit<ToolExecutionOptions<TOOL_CONTEXT>, 'abortSignal' | 'context'> & {
    toolContext: TOOL_CONTEXT;
    runtimeContext: RUNTIME_CONTEXT;
}) => MaybePromiseLike<ToolApprovalStatus>;
/**
 * Function that is called to determine if a tool call needs approval before it can be executed.
 *
 * Return `undefined` for the same effect as the `not-applicable` status.
 */
type GenericToolApprovalFunction<TOOLS extends ToolSet, TOOLS_CONTEXT extends InferToolSetContext<TOOLS>, RUNTIME_CONTEXT extends Context | unknown | never> = (options: {
    /**
     * The tool call that needs approval.
     */
    toolCall: TypedToolCall<TOOLS>;
    /**
     * All tools that are available for the model to call.
     */
    tools: TOOLS | undefined;
    /**
     * Tool context for all tools that are available for the model to call.
     */
    toolsContext: TOOLS_CONTEXT;
    /**
     * Runtime context.
     */
    runtimeContext: RUNTIME_CONTEXT;
    /**
     * Messages that were sent to the language model to initiate the response that contained the tool call.
     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
     */
    messages: ModelMessage[];
}) => MaybePromiseLike<ToolApprovalStatus>;
/**
 * Configure whether individual tools require approval before they can run.
 *
 * You can either use a generic function that is called for all tool calls,
 * or you can use a per-tool function.
 *
 * For the per-tool functions, each tool can be assigned either an approval status
 * or a function that produces an approval status at runtime.
 *
 * The approval status can be one of the following:
 * - 'not-applicable': The tool does not require approval.
 * - 'approved': The tool is automatically approved.
 * - 'denied': The tool is automatically denied.
 * - 'user-approval': The tool requires user approval.
 *
 * In addition to the string statuses, you can also use object statuses with a reason property.
 * For approved and denied statuses, the reason is emitted on the approval response.
 * For user-approval statuses, the reason is emitted on the approval request so it can be shown to the approver.
 */
type ToolApprovalConfiguration<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context | unknown | never> = GenericToolApprovalFunction<TOOLS, InferToolSetContext<TOOLS>, RUNTIME_CONTEXT> | {
    [key in keyof TOOLS]?: ToolApprovalStatus | SingleToolApprovalFunction<InferToolInput<TOOLS[key]>, InferToolContext<TOOLS[key]>, RUNTIME_CONTEXT>;
};

declare const symbol$1: unique symbol;
declare class InvalidToolInputError extends AISDKError {
    private readonly [symbol$1];
    readonly toolName: string;
    readonly toolInput: string;
    constructor({ toolInput, toolName, cause, message, }: {
        message?: string;
        toolInput: string;
        toolName: string;
        cause: unknown;
    });
    static isInstance(error: unknown): error is InvalidToolInputError;
}

declare const symbol: unique symbol;
declare class NoSuchToolError extends AISDKError {
    private readonly [symbol];
    readonly toolName: string;
    readonly availableTools: string[] | undefined;
    constructor({ toolName, availableTools, message, }: {
        toolName: string;
        availableTools?: string[] | undefined;
        message?: string;
    });
    static isInstance(error: unknown): error is NoSuchToolError;
}

/**
 * A function that attempts to repair a tool call that failed to parse.
 *
 * It receives the error and the context as arguments and returns the repair
 * tool call JSON as text.
 *
 * @param options.instructions - The instructions provided to the model.
 * @param options.system - The instructions provided to the model.
 * @param options.messages - The messages in the current generation step.
 * @param options.toolCall - The tool call that failed to parse.
 * @param options.tools - The tools that are available.
 * @param options.inputSchema - A function that returns the JSON Schema for a tool.
 * @param options.error - The error that occurred while parsing the tool call.
 */
type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
    instructions: Instructions | undefined;
    /**
     * @deprecated Use `instructions` instead.
     */
    system: Instructions | undefined;
    messages: ModelMessage[];
    toolCall: LanguageModelV4ToolCall;
    tools: TOOLS;
    inputSchema: (options: {
        toolName: string;
    }) => PromiseLike<JSONSchema7>;
    error: NoSuchToolError | InvalidToolInputError;
}) => Promise<LanguageModelV4ToolCall | null>;

type ToolOutput<TOOLS extends ToolSet> = TypedToolResult<TOOLS> | TypedToolError<TOOLS>;

/**
 * Resolves a single tool's context type, falling back to `undefined` when the
 * tool does not declare a `contextSchema`.
 */
type ToolContextFor<TOOL extends ToolSet[keyof ToolSet]> = [
    InferToolContext<TOOL>
] extends [never] ? undefined : InferToolContext<TOOL>;
type BaseToolExecutionStartFields = {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /**
     * Messages that were sent to the language model to initiate the response that contained the tool call.
     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
     */
    readonly messages: ModelMessage[];
};
/**
 * Precise start event union for statically known tools.
 *
 * Each union member ties a specific `toolCall.toolName` to that tool's
 * validated `toolContext` type.
 */
type StaticToolExecutionStartEvent<TOOLS extends ToolSet> = ValueOf<{
    [NAME in keyof TOOLS]: BaseToolExecutionStartFields & {
        readonly toolCall: Extract<StaticToolCall<TOOLS>, {
            toolName: NAME;
        }>;
        readonly toolContext: ToolContextFor<TOOLS[NAME]>;
    };
}>;
/**
 * Start event shape for dynamic or untyped tool calls.
 */
type DynamicToolExecutionStartEvent = BaseToolExecutionStartFields & {
    readonly toolCall: DynamicToolCall;
    readonly toolContext: unknown;
};
/**
 * Broad start event shape used for the default `ToolSet` specialization.
 *
 * This keeps generic collectors ergonomic when the caller is not working with
 * a concrete tool set and therefore cannot benefit from per-tool narrowing.
 */
type WidenedToolExecutionStartEvent = BaseToolExecutionStartFields & {
    readonly toolCall: StaticToolCall<ToolSet> | DynamicToolCall;
    readonly toolContext: unknown;
};
/**
 * Event passed to the `onToolExecutionStart` callback.
 *
 * Called when a tool execution begins, before the tool's `execute` function is invoked.
 */
type ToolExecutionStartEvent<TOOLS extends ToolSet = ToolSet> = [
    ToolSet
] extends [TOOLS] ? WidenedToolExecutionStartEvent : StaticToolExecutionStartEvent<TOOLS> | DynamicToolExecutionStartEvent;
type BaseToolExecutionEndFields = {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** Execution time of the tool call in milliseconds. */
    readonly toolExecutionMs: number;
    /**
     * Messages that were sent to the language model to initiate the response that contained the tool call.
     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
     */
    readonly messages: ModelMessage[];
};
/**
 * Precise end event union for statically known tools.
 *
 * Each union member preserves the link between `toolCall.toolName`, the
 * corresponding validated `toolContext`, and the tool execution result.
 */
type StaticToolExecutionEndEvent<TOOLS extends ToolSet> = ValueOf<{
    [NAME in keyof TOOLS]: BaseToolExecutionEndFields & {
        readonly toolCall: Extract<StaticToolCall<TOOLS>, {
            toolName: NAME;
        }>;
        readonly toolContext: ToolContextFor<TOOLS[NAME]>;
        readonly toolOutput: ToolOutput<TOOLS>;
    };
}>;
/**
 * End event shape for dynamic or untyped tool calls.
 */
type DynamicToolExecutionEndEvent<TOOLS extends ToolSet> = BaseToolExecutionEndFields & {
    readonly toolCall: DynamicToolCall;
    readonly toolContext: unknown;
    readonly toolOutput: ToolOutput<TOOLS>;
};
/**
 * Broad end event shape used for the default `ToolSet` specialization.
 *
 * This provides an assignable catch-all event type for generic consumers while
 * the concrete-tool specialization retains full per-tool narrowing.
 */
type WidenedToolExecutionEndEvent = BaseToolExecutionEndFields & {
    readonly toolCall: StaticToolCall<ToolSet> | DynamicToolCall;
    readonly toolContext: unknown;
    readonly toolOutput: ToolOutput<ToolSet>;
};
/**
 * Event passed to the `onToolExecutionEnd` callback.
 *
 * Called when a tool execution completes, either successfully or with an error.
 * Uses the `toolOutput.type` discriminator to distinguish success and error.
 */
type ToolExecutionEndEvent<TOOLS extends ToolSet = ToolSet> = [
    ToolSet
] extends [TOOLS] ? WidenedToolExecutionEndEvent : StaticToolExecutionEndEvent<TOOLS> | DynamicToolExecutionEndEvent<TOOLS>;
/**
 * Callback that is set using the `onToolExecutionStart` option.
 *
 * Called when a tool execution begins, before the tool's `execute` function is invoked.
 * Use this for logging tool invocations, tracking tool usage, or pre-execution validation.
 *
 * @param event - The event object containing tool call information.
 */
type OnToolExecutionStartCallback<TOOLS extends ToolSet = ToolSet> = Callback<ToolExecutionStartEvent<TOOLS>>;
/**
 * Callback that is set using the `onToolExecutionEnd` option.
 *
 * Called when a tool execution completes, either successfully or with an error.
 * Use this for logging tool results, tracking execution time, or error handling.
 *
 * The event uses a discriminated union on `toolOutput.type`:
 * - When `toolOutput.type === 'tool-result'`: `toolOutput.output` contains the tool result.
 * - When `toolOutput.type === 'tool-error'`: `toolOutput.error` contains the error.
 *
 * @param event - The event object containing tool call result information.
 */
type OnToolExecutionEndCallback<TOOLS extends ToolSet = ToolSet> = Callback<ToolExecutionEndEvent<TOOLS>>;

/**
 * Mapping of tool names to functions that refine parsed tool inputs.
 *
 * Each refinement function receives the typed input for its tool and must return
 * an input with the same type shape. Refined inputs are used for tool execution,
 * output parts, lifecycle callbacks, and telemetry.
 */
type ToolInputRefinement<TOOLS extends ToolSet> = {
    [NAME in keyof TOOLS]?: (input: InferToolInput<TOOLS[NAME]>) => MaybePromiseLike<InferToolInput<TOOLS[NAME]>>;
};

type EnrichedStreamPart<TOOLS extends ToolSet, PARTIAL_OUTPUT> = {
    part: TextStreamPart<TOOLS>;
    partialOutput: PARTIAL_OUTPUT | undefined;
};

interface Output<OUTPUT = any, PARTIAL = any, ELEMENT = any> {
    /**
     * The name of the output mode.
     */
    name: string;
    /**
     * The response format to use for the model.
     */
    responseFormat: PromiseLike<LanguageModelV4CallOptions['responseFormat']>;
    /**
     * Parses the complete output of the model.
     */
    parseCompleteOutput(options: {
        text: string;
    }, context: {
        response: Omit<LanguageModelResponseMetadata, 'messages' | 'body'>;
        usage: LanguageModelUsage;
        finishReason: FinishReason;
    }): Promise<OUTPUT>;
    /**
     * Parses the partial output of the model.
     */
    parsePartialOutput(options: {
        text: string;
    }): Promise<{
        partial: PARTIAL;
    } | undefined>;
    /**
     * Creates a stream transform that emits individual elements as they complete.
     */
    createElementStreamTransform(): TransformStream<EnrichedStreamPart<any, PARTIAL>, ELEMENT> | undefined;
}

/**
 * Event passed to the `onStart` callback.
 *
 * Called when the generation operation begins, before any LLM calls.
 */
type GenerateTextStartEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends Output = Output> = {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** Identifies the operation type (e.g. 'ai.generateText' or 'ai.streamText'). */
    readonly operationId: string;
    /** The provider identifier (e.g., 'openai', 'anthropic'). */
    readonly provider: string;
    /** The specific model identifier (e.g., 'gpt-4o'). */
    readonly modelId: string;
    /** The tools available for this generation. */
    readonly tools: TOOLS | undefined;
    /** The tool choice strategy for this generation. */
    readonly toolChoice: ToolChoice<NoInfer<TOOLS>> | undefined;
    /** Limits which tools are available for the model to call. */
    readonly activeTools: ActiveTools<TOOLS>;
    /** Controls the order in which tools are sent to the provider. */
    readonly toolOrder: ToolOrder<TOOLS>;
    /** Maximum number of retries for failed requests. */
    readonly maxRetries: number;
    /**
     * Timeout configuration for the generation.
     * Can be a number (milliseconds) or an object with totalMs, stepMs,
     * firstChunkMs (streaming only), chunkMs, toolMs, and per-tool overrides via tools.
     */
    readonly timeout: TimeoutConfiguration<TOOLS> | undefined;
    /** Additional HTTP headers sent with the request. */
    readonly headers: Record<string, string | undefined> | undefined;
    /** Additional provider-specific options. */
    readonly providerOptions: ProviderOptions | undefined;
    /** The output specification for structured outputs, if configured. */
    readonly output: OUTPUT | undefined;
    /**
     * Tool context.
     */
    readonly toolsContext: InferToolSetContext<TOOLS>;
    /**
     * User-defined runtime context.
     */
    readonly runtimeContext: RUNTIME_CONTEXT;
} & LanguageModelCallOptions & StandardizedPrompt;
/**
 * Event passed to the `onStepStart` callback.
 *
 * Called when a step (LLM call) begins, before the provider is called.
 * Each step represents a single LLM invocation.
 */
type GenerateTextStepStartEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends Output = Output> = {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** The provider identifier (e.g., 'openai', 'anthropic'). */
    readonly provider: string;
    /** The specific model identifier (e.g., 'gpt-4o'). */
    readonly modelId: string;
    /** Zero-based index of the current step. */
    readonly stepNumber: number;
    /** The tools available for this generation. */
    readonly tools: TOOLS | undefined;
    /** The tool choice configuration for this step. */
    readonly toolChoice: ToolChoice<NoInfer<TOOLS>> | undefined;
    /** Limits which tools are available for this step. */
    readonly activeTools: ActiveTools<TOOLS>;
    /** Controls the order in which tools are sent to the provider for this step. */
    readonly toolOrder: ToolOrder<TOOLS>;
    /** Array of results from previous steps (empty for first step). */
    readonly steps: ReadonlyArray<StepResult<TOOLS, RUNTIME_CONTEXT>>;
    /** Additional provider-specific options for this step. */
    readonly providerOptions: ProviderOptions | undefined;
    /** The output specification for structured outputs, if configured. */
    readonly output: OUTPUT | undefined;
    /**
     * Runtime context. May be updated from `prepareStep` between steps.
     */
    readonly runtimeContext: RUNTIME_CONTEXT;
    /**
     * Tool context. May be updated from `prepareStep` between steps.
     */
    readonly toolsContext: InferToolSetContext<TOOLS>;
} & StandardizedPrompt;
/**
 * Event passed to the `onStepEnd` callback.
 *
 * Called when a step (LLM call) completes.
 * Includes the StepResult for that step along with the call identifier.
 */
type GenerateTextStepEndEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context> = StepResult<TOOLS, RUNTIME_CONTEXT>;
/**
 * Event passed to the `onEnd` callback.
 *
 * Called when the entire generation completes (all steps finished).
 * Includes the final step's result along with aggregated data from all steps.
 */
type GenerateTextEndEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context> = {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** Zero-based index of the final step. */
    readonly stepNumber: number;
    /** Information about the model that produced the final step. */
    readonly model: StepResult<TOOLS, RUNTIME_CONTEXT>['model'];
    /**
     * Tool context from the final step.
     *
     * @deprecated Use `finalStep.toolsContext` instead.
     */
    readonly toolsContext: InferToolSetContext<TOOLS>;
    /**
     * Runtime context from the final step.
     *
     * @deprecated Use `finalStep.runtimeContext` instead.
     */
    readonly runtimeContext: RUNTIME_CONTEXT;
    /** The content that was generated in all steps. */
    readonly content: StepResult<TOOLS, RUNTIME_CONTEXT>['content'];
    /** The text that was generated in the final step. */
    readonly text: StepResult<TOOLS, RUNTIME_CONTEXT>['text'];
    /**
     * The reasoning that was generated in the final step.
     *
     * @deprecated Use `finalStep.reasoning` instead.
     */
    readonly reasoning: StepResult<TOOLS, RUNTIME_CONTEXT>['reasoning'];
    /**
     * The reasoning text that was generated in the final step.
     *
     * @deprecated Use `finalStep.reasoningText` instead.
     */
    readonly reasoningText: StepResult<TOOLS, RUNTIME_CONTEXT>['reasoningText'];
    /** Files that were generated in all steps. */
    readonly files: StepResult<TOOLS, RUNTIME_CONTEXT>['files'];
    /** Sources that were used as references in all steps. */
    readonly sources: StepResult<TOOLS, RUNTIME_CONTEXT>['sources'];
    /** Tool calls that were made in all steps. */
    readonly toolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['toolCalls'];
    /** Static tool calls that were made in all steps. */
    readonly staticToolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['staticToolCalls'];
    /** Dynamic tool calls that were made in all steps. */
    readonly dynamicToolCalls: StepResult<TOOLS, RUNTIME_CONTEXT>['dynamicToolCalls'];
    /** Tool results that were generated in all steps. */
    readonly toolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['toolResults'];
    /** Static tool results that were generated in all steps. */
    readonly staticToolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['staticToolResults'];
    /** Dynamic tool results that were generated in all steps. */
    readonly dynamicToolResults: StepResult<TOOLS, RUNTIME_CONTEXT>['dynamicToolResults'];
    /** The unified reason why the generation finished. Taken from the final step. */
    readonly finishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['finishReason'];
    /** The raw reason why the generation finished. Taken from the final step. */
    readonly rawFinishReason: StepResult<TOOLS, RUNTIME_CONTEXT>['rawFinishReason'];
    /** Aggregated token usage across all steps. */
    readonly usage: LanguageModelUsage;
    /**
     * Aggregated token usage across all steps.
     *
     * @deprecated Use `usage` instead.
     */
    readonly totalUsage: LanguageModelUsage;
    /** Warnings from the model provider in all steps. */
    readonly warnings: StepResult<TOOLS, RUNTIME_CONTEXT>['warnings'];
    /**
     * Additional request information from the final step.
     *
     * @deprecated Use `finalStep.request` instead.
     */
    readonly request: StepResult<TOOLS, RUNTIME_CONTEXT>['request'];
    /**
     * Additional response information from the final step.
     *
     * @deprecated Use `finalStep.response` instead.
     */
    readonly response: StepResult<TOOLS, RUNTIME_CONTEXT>['response'];
    /**
     * Additional provider-specific metadata from the final step.
     *
     * @deprecated Use `finalStep.providerMetadata` instead.
     */
    readonly providerMetadata: StepResult<TOOLS, RUNTIME_CONTEXT>['providerMetadata'];
    /** The response messages that were generated during the call. */
    readonly responseMessages: ResponseMessage[];
    /** Array containing results from all steps in the generation. */
    readonly steps: StepResult<TOOLS, RUNTIME_CONTEXT>[];
    /** The final step. This is a shortcut for `steps.at(-1)`. */
    readonly finalStep: StepResult<TOOLS, RUNTIME_CONTEXT>;
};
/**
 * Event passed to the telemetry `onAbort` callback.
 *
 * Called when a streaming text generation operation is aborted before it
 * completes.
 */
type GenerateTextAbortEvent<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context> = {
    /** Unique identifier for this generation call, used to correlate events. */
    readonly callId: string;
    /** Details for all previously finished steps. */
    readonly steps: StepResult<TOOLS, RUNTIME_CONTEXT>[];
    /** The abort reason from the AbortSignal, when one is available. */
    readonly reason?: unknown;
};
/**
 * Callback that is set using the `onStart` option.
 *
 * Called when the generateText operation begins, before any LLM calls.
 * Use this callback for logging, analytics, or initializing state at the
 * start of a generation.
 *
 * @param event - The event object containing generation configuration.
 */
type GenerateTextOnStartCallback<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends Output = Output> = Callback<GenerateTextStartEvent<TOOLS, RUNTIME_CONTEXT, OUTPUT>>;
/**
 * Callback that is set using the `onStepStart` option.
 *
 * Called when a step (LLM call) begins, before the provider is called.
 * Each step represents a single LLM invocation. Multiple steps occur when
 * using tool calls (the model may be called multiple times in a loop).
 *
 * @param event - The event object containing step configuration.
 */
type GenerateTextOnStepStartCallback<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends Output = Output> = Callback<GenerateTextStepStartEvent<TOOLS, RUNTIME_CONTEXT, OUTPUT>>;
/**
 * Callback that is set using the `onStepEnd` option.
 *
 * Called when a step (LLM call) completes. The event includes all step result
 * properties (text, tool calls, usage, etc.) along with additional metadata.
 *
 * @param stepResult - The result of the step.
 */
type GenerateTextOnStepEndCallback<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context> = Callback<GenerateTextStepEndEvent<TOOLS, RUNTIME_CONTEXT>>;
/**
 * Callback that is set using the `onStepFinish` option.
 *
 * @deprecated Use `GenerateTextOnStepEndCallback` instead.
 */
type GenerateTextOnStepFinishCallback<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context> = GenerateTextOnStepEndCallback<TOOLS, RUNTIME_CONTEXT>;
/**
 * Callback that is set using the `onEnd` option.
 *
 * Called when the entire generation completes (all steps finished).
 * The event includes the final step's result properties along with
 * aggregated data from all steps.
 *
 * @param event - The final result along with aggregated step data.
 */
type GenerateTextOnEndCallback<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context> = Callback<GenerateTextEndEvent<TOOLS, RUNTIME_CONTEXT>>;
/**
 * Callback that is set using the telemetry `onAbort` option.
 *
 * Called when a streaming text generation operation is aborted before it
 * completes.
 *
 * @param event - The abort event, including finished steps and abort reason.
 */
type GenerateTextOnAbortCallback<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context = Context> = Callback<GenerateTextAbortEvent<TOOLS, RUNTIME_CONTEXT>>;

/**
 * Event passed to the `onStart` callback for rerank operations.
 *
 * Called when the operation begins, before the reranking model is called.
 */
type RerankStartEvent = {
    /** Unique identifier for this rerank call, used to correlate events. */
    readonly callId: string;
    /** Identifies the operation type ('ai.rerank'). */
    readonly operationId: string;
    readonly provider: string;
    /** The specific model identifier (e.g., 'gpt-4o'). */
    readonly modelId: string;
    /** The documents being reranked. */
    readonly documents: Array<JSONObject | string>;
    /** The query to rerank the documents against. */
    readonly query: string;
    /** Number of top documents to return. */
    readonly topN: number | undefined;
    /** Maximum number of retries for failed requests. */
    readonly maxRetries: number;
    /** Additional HTTP headers sent with the request. */
    readonly headers: Record<string, string | undefined> | undefined;
    /** Additional provider-specific options. */
    readonly providerOptions: ProviderOptions | undefined;
};
/**
 * Event passed to the `onEnd` callback for rerank operations.
 *
 * Called when the operation completes, after the reranking model returns.
 */
type RerankEndEvent = {
    /** Unique identifier for this rerank call, used to correlate events. */
    readonly callId: string;
    /** Identifies the operation type ('ai.rerank'). */
    readonly operationId: string;
    readonly provider: string;
    /** The specific model identifier (e.g., 'gpt-4o'). */
    readonly modelId: string;
    /** The documents that were reranked. */
    readonly documents: Array<JSONObject | string>;
    /** The query that documents were reranked against. */
    readonly query: string;
    /** The reranked results sorted by relevance score in descending order. */
    readonly ranking: Array<{
        originalIndex: number;
        score: number;
        document: JSONObject | string;
    }>;
    /** Warnings from the reranking model. */
    readonly warnings: Array<Warning>;
    /** Optional provider-specific metadata. */
    readonly providerMetadata: ProviderMetadata | undefined;
    /** Response data including headers and body. */
    readonly response: {
        id?: string;
        timestamp: Date;
        modelId: string;
        headers?: Record<string, string>;
        body?: unknown;
    };
};
/**
 * Event fired when an individual reranking model call (inner doRerank) begins.
 */
type RerankingModelCallStartEvent = {
    /** Unique identifier for this rerank call, used to correlate events. */
    readonly callId: string;
    /** Identifies the inner operation ('ai.rerank.doRerank'). */
    readonly operationId: string;
    /** The provider identifier. */
    readonly provider: string;
    /** The specific model identifier. */
    readonly modelId: string;
    /** The documents being reranked. */
    readonly documents: Array<JSONObject | string>;
    /** The type of documents ('text' or 'object'). */
    readonly documentsType: string;
    /** The query to rerank against. */
    readonly query: string;
    /** Number of top documents to return. */
    readonly topN: number | undefined;
};
/**
 * Event fired when an individual reranking model call (doRerank) completes.
 *
 * Contains the ranking results from the model response.
 */
type RerankingModelCallEndEvent = {
    /** Unique identifier for this rerank call, used to correlate events. */
    readonly callId: string;
    /** Identifies the inner operation ('ai.rerank.doRerank'). */
    readonly operationId: string;
    /** The provider identifier. */
    readonly provider: string;
    /** The specific model identifier. */
    readonly modelId: string;
    /** The type of documents ('text' or 'object'). */
    readonly documentsType: string;
    /** The ranking results from the model. */
    readonly ranking: Array<{
        index: number;
        relevanceScore: number;
    }>;
};

type TelemetryTracingEventType = 'generateText' | 'streamText' | 'step' | 'languageModelCall' | 'executeTool' | 'embed' | 'embedMany' | 'rerank';

type TracingChannelContext = {
    run<T>(execute: () => T): T;
};

type InferTelemetryEvent<EVENT> = EVENT & Omit<TelemetryOptions, 'integrations' | 'isEnabled' | 'includeRuntimeContext'>;
type OperationStartEvent = GenerateTextStartEvent | GenerateObjectStartEvent | EmbedStartEvent | RerankStartEvent;
type OperationEndEvent = GenerateTextEndEvent<ToolSet> | GenerateObjectEndEvent<unknown> | EmbedEndEvent | RerankEndEvent;
interface TelemetryDispatcher {
    /**
     * Runs awaited work inside a diagnostics-channel tracing span.
     */
    runInTracingChannelSpan?: <T>(options: {
        type: TelemetryTracingEventType;
        event: unknown;
        execute: () => PromiseLike<T>;
    }) => Promise<T>;
    /**
     * Opens a tracing span context whose completion is observed separately.
     * This is used by streamed operations that must preserve stream timing while
     * still creating child spans with the correct parent.
     */
    startTracingChannelContext?: (options: {
        type: TelemetryTracingEventType;
        event: unknown;
        completion: PromiseLike<unknown>;
    }) => TracingChannelContext | undefined;
    onStart?: Callback<OperationStartEvent>;
    onStepStart?: Callback<GenerateTextStepStartEvent>;
    onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
    onLanguageModelCallEnd?: OnLanguageModelCallEndCallback;
    onToolExecutionStart?: Callback<ToolExecutionStartEvent>;
    onToolExecutionEnd?: Callback<ToolExecutionEndEvent>;
    onStepEnd?: Callback<GenerateTextStepEndEvent>;
    /** @deprecated Use `onStepEnd` instead. */
    onStepFinish?: Callback<GenerateTextStepEndEvent>;
    onObjectStepStart?: Callback<GenerateObjectStepStartEvent>;
    onObjectStepEnd?: Callback<GenerateObjectStepEndEvent>;
    onEmbedStart?: Callback<EmbeddingModelCallStartEvent>;
    onEmbedEnd?: Callback<EmbeddingModelCallEndEvent>;
    onRerankStart?: Callback<RerankingModelCallStartEvent>;
    onRerankEnd?: Callback<RerankingModelCallEndEvent>;
    onEnd?: Callback<OperationEndEvent>;
    onAbort?: Callback<GenerateTextAbortEvent<ToolSet>>;
    onError?: Callback<unknown>;
    executeLanguageModelCall?: Telemetry['executeLanguageModelCall'];
    executeTool?: Telemetry['executeTool'];
}
/**
 * Implement this interface to create custom telemetry integrations.
 * Methods can be sync or return a PromiseLike.
 */
interface Telemetry {
    /**
     * Called when an operation begins. Fired for text generation
     * (generateText/streamText), object generation (generateObject/streamObject),
     * embedding (embed/embedMany), and reranking operations.
     *
     * Use the `operationId` field to distinguish between operation types.
     */
    onStart?: Callback<InferTelemetryEvent<OperationStartEvent>>;
    /**
     * Called when an individual step (single LLM invocation) begins.
     * A generation may consist of multiple steps (e.g. when tool calls trigger
     * follow-up LLM calls). Use this to create per-step spans or record
     * step-level inputs.
     *
     * The event includes the step number, accumulated previous step results,
     * and the messages that will be sent to the model.
     */
    onStepStart?: Callback<InferTelemetryEvent<GenerateTextStepStartEvent>>;
    /**
     * Called immediately before the provider model call begins.
     * Unlike `onStepStart`, this callback is scoped to model work only and
     * excludes any later client-side tool execution.
     */
    onLanguageModelCallStart?: Callback<InferTelemetryEvent<LanguageModelCallStartEvent>>;
    /**
     * Called after the model response has been normalized and parsed, but before
     * any client-side tool execution begins.
     */
    onLanguageModelCallEnd?: Callback<InferTelemetryEvent<LanguageModelCallEndEvent>>;
    /**
     * Called when a tool execution begins, before the tool's `execute` function
     * is invoked. Use this to create tool-level spans or log tool invocations.
     */
    onToolExecutionStart?: Callback<InferTelemetryEvent<ToolExecutionStartEvent>>;
    /**
     * Called when a tool execution completes, either successfully or with an error.
     * The event uses a discriminated union on the `success` field — check
     * `event.success` to determine whether `output` or `error` is available.
     *
     * The event includes execution time (`toolExecutionMs`) for performance tracking.
     */
    onToolExecutionEnd?: Callback<InferTelemetryEvent<ToolExecutionEndEvent>>;
    /**
     * Called when an individual step (single LLM invocation) completes.
     * The event is a `StepResult` containing the model's response, tool calls
     * and results, usage statistics, finish reason, and optional request/response
     * bodies.
     */
    onStepEnd?: Callback<InferTelemetryEvent<GenerateTextStepEndEvent>>;
    /**
     * Called when an individual step (single LLM invocation) completes.
     *
     * @deprecated Use `onStepEnd` instead.
     */
    onStepFinish?: Callback<InferTelemetryEvent<GenerateTextStepEndEvent>>;
    /**
     * Called when an object generation step (single LLM invocation) begins.
     * For generateObject/streamObject there is always exactly one step.
     *
     * @deprecated
     */
    onObjectStepStart?: Callback<InferTelemetryEvent<GenerateObjectStepStartEvent>>;
    /**
     * Called when an object generation step (single LLM invocation) completes,
     * with the raw result before JSON parsing and schema validation.
     *
     * @deprecated
     */
    onObjectStepEnd?: Callback<InferTelemetryEvent<GenerateObjectStepEndEvent>>;
    /**
     * Called when an individual embedding model call (doEmbed) begins.
     * For `embed`, there is one call. For `embedMany`, there may be multiple
     * calls when values are chunked.
     */
    onEmbedStart?: Callback<InferTelemetryEvent<EmbeddingModelCallStartEvent>>;
    /**
     * Called when an individual embedding model call (doEmbed) completes.
     * Contains the embeddings, usage, and any warnings from the model response.
     */
    onEmbedEnd?: Callback<InferTelemetryEvent<EmbeddingModelCallEndEvent>>;
    /**
     * Called when an individual reranking model call (doRerank) begins.
     * There is one call per `rerank` invocation.
     */
    onRerankStart?: Callback<InferTelemetryEvent<RerankingModelCallStartEvent>>;
    /**
     * Called when an individual reranking model call (doRerank) completes.
     * Contains the ranking results from the model response.
     */
    onRerankEnd?: Callback<InferTelemetryEvent<RerankingModelCallEndEvent>>;
    /**
     * Called when an operation completes. Fired for text generation
     * (generateText/streamText), object generation (generateObject/streamObject),
     * embedding (embed/embedMany), and reranking operations.
     *
     * Use the event shape or `operationId` to distinguish between operation types.
     */
    onEnd?: Callback<InferTelemetryEvent<OperationEndEvent>>;
    /**
     * Called when a streaming text generation operation is aborted before it
     * completes.
     */
    onAbort?: Callback<InferTelemetryEvent<GenerateTextAbortEvent<ToolSet>>>;
    /**
     * Called when an unrecoverable error occurs during the generation lifecycle.
     * The error value is untyped — it may be an `Error` instance, an `AISDKError`,
     * or any thrown value.
     *
     * Use this to record error details on telemetry spans and set error status.
     */
    onError?: Callback<unknown>;
    /**
     * Optionally runs the language model call in a telemetry-integration-specific context. This enables
     * auto-instrumented model provider requests to become children of the current
     * model-call span.
     *
     * The options carry the model-call start-event content as context (the event
     * fields are optional), alongside the always-present `callId` and the
     * `execute` function that performs the model call.
     */
    executeLanguageModelCall?: <T>(options: Partial<InferTelemetryEvent<LanguageModelCallStartEvent>> & {
        callId: string;
        execute: () => PromiseLike<T>;
    }) => PromiseLike<T>;
    /**
     * Optionally runs the tool execute function in a telemetry-integration-specific context. This enables
     * nested traces — e.g. when a tool's `execute` function calls `generateText`,
     * the inner call's spans become children of the tool span.
     *
     * The options carry the tool-execution start-event content as context (the
     * event fields are optional), alongside the always-present `callId`,
     * `toolCallId`, and the `execute` function to run.
     */
    executeTool?: <T>(options: Partial<InferTelemetryEvent<ToolExecutionStartEvent>> & {
        callId: string;
        toolCallId: string;
        execute: () => PromiseLike<T>;
    }) => PromiseLike<T>;
}

declare global {
    /**
     * The default provider to use for the AI SDK.
     * String model ids are resolved to the default provider and model id.
     *
     * If not set, the default provider is the Vercel AI gateway provider.
     *
     * @see https://ai-sdk.dev/docs/ai-sdk-core/provider-management#global-provider-configuration
     */
    var AI_SDK_DEFAULT_PROVIDER: ProviderV4 | ProviderV3 | ProviderV2 | undefined;
    /**
     * The warning logger to use for the AI SDK.
     *
     * If not set, the default logger is the console.warn function.
     *
     * If set to false, no warnings are logged.
     */
    var AI_SDK_LOG_WARNINGS: LogWarningsFunction | undefined | false;
    /**
     * Globally registered telemetry integrations for the AI SDK.
     *
     * Integrations registered here receive lifecycle events (onStart, onStepStart,
     * etc.) from every `generateText`, `streamText`, and similar call.
     *
     * Prefer using `registerTelemetry()` from `'ai'` instead of
     * assigning this directly.
     */
    var AI_SDK_TELEMETRY_INTEGRATIONS: Telemetry[] | undefined;
}

declare function convertToLanguageModelPrompt({ prompt, supportedUrls, download, provider, }: {
    prompt: StandardizedPrompt;
    supportedUrls: Record<string, RegExp[]>;
    download: DownloadFunction | undefined;
    provider?: string;
}): Promise<LanguageModelV4Prompt>;
/**
 * Downloads files from URLs in the user messages.
 */
declare function downloadAssets(messages: ModelMessage[], download: DownloadFunction, supportedUrls: Record<string, RegExp[]>): Promise<Record<string, {
    mediaType: string | undefined;
    data: Uint8Array;
}>>;
declare function mapToolResultOutput({ output, provider, warnings, downloadedAssets, }: {
    output: ToolResultOutput;
    provider?: string;
    warnings?: Warning[];
    downloadedAssets: Record<string, {
        mediaType: string | undefined;
        data: Uint8Array;
    }>;
}): LanguageModelV4ToolResultOutput;

declare function createToolModelOutput({ toolCallId, input, output, tool, errorMode, }: {
    toolCallId: string;
    input: unknown;
    output: unknown;
    tool: Tool | undefined;
    errorMode: 'none' | 'text' | 'json';
}): Promise<ToolResultOutput>;

declare function prepareToolChoice({ toolChoice, }: {
    toolChoice: ToolChoice<any> | undefined;
}): LanguageModelV4ToolChoice;

declare function prepareTools<TOOLS extends ToolSet>({ tools, toolOrder, toolsContext, experimental_sandbox: sandbox, }: {
    tools: TOOLS | undefined;
    toolOrder?: ToolOrder<TOOLS>;
    toolsContext?: InferToolSetContext<TOOLS>;
    experimental_sandbox?: Experimental_SandboxSession;
}): Promise<Array<LanguageModelV4FunctionTool | LanguageModelV4ProviderTool> | undefined>;

/**
 * Validates model call options and returns a new object with normalized values.
 */
declare function prepareLanguageModelCallOptions({ maxOutputTokens, temperature, topP, topK, presencePenalty, frequencyPenalty, seed, stopSequences, reasoning, }: LanguageModelCallOptions): LanguageModelCallOptions;

/**
 * Validate and prepare retries.
 */
declare function prepareRetries({ maxRetries, abortSignal, }: {
    maxRetries: number | undefined;
    abortSignal: AbortSignal | undefined;
}): {
    maxRetries: number;
    retry: RetryFunction;
};

declare function resolveLanguageModel(model: LanguageModel): LanguageModelV4;

/**
 * Merges multiple abort sources into a single `AbortSignal`.
 * The returned signal will abort when any input signal aborts or when any
 * numeric timeout elapses, using the reason from the first source to abort.
 *
 * @param signals - Abort signals or timeout durations in milliseconds.
 * `null` and `undefined` values are ignored.
 * @returns An `AbortSignal` that aborts when any valid source aborts,
 * or `undefined` if no valid sources are provided.
 */
declare function mergeAbortSignals(...signals: (AbortSignal | null | undefined | number)[]): AbortSignal | undefined;

/**
 * Creates an async callback that invokes the provided callbacks in parallel.
 * Undefined callbacks are skipped, and thrown or rejected callback errors are
 * ignored.
 *
 * @param callbacks The callbacks to invoke for each event.
 * @returns A callback that forwards each event to all callbacks and waits for
 * them to settle.
 */
declare function mergeCallbacks<EVENT>(...callbacks: Array<Callback<EVENT> | undefined>): Callback<EVENT>;

/**
 * Creates a telemetry dispatcher that sends telemetry events
 * to the resolved set of integrations.
 *
 * When per-call integrations are provided, they take precedence over the globally
 * registered integrations for that call. When no per-call integrations are
 * provided, the globally registered integrations are used.
 *
 * @param args.telemetry - Optional per-call telemetry settings and integrations.
 *
 * @returns A telemetry dispatcher that fans out lifecycle events to the
 * resolved set of integrations.
 */
declare function createTelemetryDispatcher({ telemetry, }: {
    telemetry?: TelemetryOptions;
}): TelemetryDispatcher;

/**
 * Telemetry dispatcher for text generation with callbacks typed to the
 * operation-specific tool set, runtime context, and output shape.
 */
type RestrictedTelemetryDispatcher<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends Output> = Omit<TelemetryDispatcher, 'onStart' | 'onStepStart' | 'onStepEnd' | 'onStepFinish' | 'onEnd' | 'onAbort' | 'onToolExecutionStart' | 'onToolExecutionEnd'> & {
    onStart: GenerateTextOnStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
    onStepStart: GenerateTextOnStepStartCallback<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
    onStepEnd: GenerateTextOnStepEndCallback<TOOLS, RUNTIME_CONTEXT>;
    /** @deprecated Use `onStepEnd` instead. */
    onStepFinish: GenerateTextOnStepFinishCallback<TOOLS, RUNTIME_CONTEXT>;
    onEnd: GenerateTextOnEndCallback<TOOLS, RUNTIME_CONTEXT>;
    onAbort?: GenerateTextOnAbortCallback<TOOLS, RUNTIME_CONTEXT>;
    onToolExecutionStart?: OnToolExecutionStartCallback<TOOLS>;
    onToolExecutionEnd?: OnToolExecutionEndCallback<TOOLS>;
};
/**
 * Creates a telemetry dispatcher that only includes configured runtime context
 * properties in text-generation lifecycle events before dispatching them.
 */
declare function createRestrictedTelemetryDispatcher<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context, OUTPUT extends Output>({ telemetry, includeRuntimeContext, includeToolsContext, }: {
    telemetry?: TelemetryOptions<RUNTIME_CONTEXT, TOOLS>;
    includeRuntimeContext: IncludedContext<RUNTIME_CONTEXT>;
    includeToolsContext?: IncludedToolsContext<TOOLS>;
}): RestrictedTelemetryDispatcher<TOOLS, RUNTIME_CONTEXT, OUTPUT>;

declare function parseToolCall<TOOLS extends ToolSet>({ toolCall, tools, repairToolCall, refineToolInput, messages, instructions, }: {
    toolCall: LanguageModelV4ToolCall;
    tools: TOOLS | undefined;
    repairToolCall: ToolCallRepairFunction<TOOLS> | undefined;
    refineToolInput?: ToolInputRefinement<TOOLS> | undefined;
    instructions: Instructions | undefined;
    messages: ModelMessage[];
}): Promise<TypedToolCall<TOOLS>>;

type CollectedToolApprovals<TOOLS extends ToolSet> = {
    approvalRequest: ToolApprovalRequest;
    approvalResponse: ToolApprovalResponse;
    toolCall: TypedToolCall<TOOLS>;
    existingToolResult?: ToolResultPart;
};
/**
 * If the last message is a tool message, this function collects all tool approvals
 * from that message.
 */
declare function collectToolApprovals<TOOLS extends ToolSet>({ messages, }: {
    messages: ModelMessage[];
}): {
    approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
    deniedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
};

declare function signToolApproval({ secret, approvalId, toolCallId, toolName, input, }: {
    secret: string | Uint8Array;
    approvalId: string;
    toolCallId: string;
    toolName: string;
    input: unknown;
}): Promise<string>;
declare function verifyToolApprovalSignature({ secret, signature, approvalId, toolCallId, toolName, input, }: {
    secret: string | Uint8Array;
    signature: string;
    approvalId: string;
    toolCallId: string;
    toolName: string;
    input: unknown;
}): Promise<boolean>;

/**
 * Re-validates approved tool approvals reconstructed from client-supplied
 * message history before they are executed. Checks HMAC signature (when
 * configured), input schema, and approval policy.
 */
declare function validateApprovedToolApprovals<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context | unknown | never>({ approvedToolApprovals, tools, toolApproval, messages, toolsContext, runtimeContext, toolApprovalSecret, }: {
    approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
    tools: TOOLS | undefined;
    toolApproval: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT> | undefined;
    messages: ModelMessage[];
    toolsContext: InferToolSetContext<TOOLS>;
    runtimeContext: RUNTIME_CONTEXT;
    toolApprovalSecret?: string | Uint8Array;
}): Promise<{
    approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
    deniedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
    invalidToolApprovals: Array<CollectedToolApprovals<TOOLS> & {
        error: InvalidToolInputError;
    }>;
}>;

/**
 * Converts the result of a `generateText` or `streamText` call to a list of response messages.
 */
declare function toResponseMessages<TOOLS extends ToolSet>({ content: inputContent, tools, }: {
    content: Array<ContentPart<TOOLS>>;
    tools: TOOLS | undefined;
}): Promise<Array<AssistantModelMessage | ToolModelMessage>>;

export { type CollectedToolApprovals, DefaultStepResult, type DownloadFunction, addLanguageModelUsage, asLanguageModelUsage, collectToolApprovals, convertToLanguageModelPrompt, createAsyncIterableStream, createDefaultDownloadFunction, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, createTelemetryDispatcher, createToolModelOutput, downloadAssets, mapToolResultOutput, mergeAbortSignals, mergeCallbacks, parseToolCall, prepareLanguageModelCallOptions as prepareCallSettings, prepareLanguageModelCallOptions, prepareRetries, prepareToolChoice, prepareTools, resolveLanguageModel, signToolApproval, standardizePrompt, toResponseMessages, validateApprovedToolApprovals, verifyToolApprovalSignature };