mirascope 2.0.0-alpha.0

package/dist/index.d.cts

@@ -0,0 +1,4859 @@
+import { T as ToolSchema, a as ToolParameterSchema, J as JsonSchemaProperty } from './tool-schema-Dh-RLHhC.cjs';
+
+/**
+ * A type that represents JSON-serializable values.
+ *
+ * This includes primitives (null, string, number, boolean),
+ * arrays of Jsonable values, and objects with string keys and Jsonable values.
+ */
+type Jsonable = null | string | number | boolean | readonly Jsonable[] | {
+    readonly [key: string]: Jsonable;
+};
+
+/**
+ * Type representing no variables for prompts and calls.
+ * `Record<never, never>` creates an object type with no keys,
+ * ensuring `keyof NoVars` is `never`.
+ */
+type NoVars = Record<never, never>;
+
+/**
+ * Anthropic model information.
+ *
+ * This file is auto-generated by typescript/scripts/codegen/anthropic.ts
+ * Do not edit manually - run `bun run codegen` to update.
+ */
+/**
+ * Array of all known Anthropic model IDs.
+ * This is the source of truth - the type and Set are derived from it.
+ */
+declare const ANTHROPIC_KNOWN_MODELS_ARRAY: readonly ["anthropic/claude-3-5-haiku", "anthropic/claude-3-5-haiku-20241022", "anthropic/claude-3-5-haiku-latest", "anthropic/claude-3-7-sonnet", "anthropic/claude-3-7-sonnet-20250219", "anthropic/claude-3-7-sonnet-latest", "anthropic/claude-3-haiku", "anthropic/claude-3-haiku-20240307", "anthropic/claude-3-haiku-latest", "anthropic/claude-3-opus", "anthropic/claude-3-opus-20240229", "anthropic/claude-3-opus-latest", "anthropic/claude-haiku-4-5", "anthropic/claude-haiku-4-5-0", "anthropic/claude-haiku-4-5-0-20251001", "anthropic/claude-haiku-4-5-0-latest", "anthropic/claude-haiku-4-5-20251001", "anthropic/claude-haiku-4-5-latest", "anthropic/claude-opus-4", "anthropic/claude-opus-4-0", "anthropic/claude-opus-4-0-20250514", "anthropic/claude-opus-4-0-latest", "anthropic/claude-opus-4-1", "anthropic/claude-opus-4-1-0", "anthropic/claude-opus-4-1-0-20250805", "anthropic/claude-opus-4-1-0-latest", "anthropic/claude-opus-4-1-20250805", "anthropic/claude-opus-4-1-latest", "anthropic/claude-opus-4-20250514", "anthropic/claude-opus-4-5", "anthropic/claude-opus-4-5-0", "anthropic/claude-opus-4-5-0-20251101", "anthropic/claude-opus-4-5-0-latest", "anthropic/claude-opus-4-5-20251101", "anthropic/claude-opus-4-5-latest", "anthropic/claude-opus-4-latest", "anthropic/claude-sonnet-4", "anthropic/claude-sonnet-4-0", "anthropic/claude-sonnet-4-0-20250514", "anthropic/claude-sonnet-4-0-latest", "anthropic/claude-sonnet-4-20250514", "anthropic/claude-sonnet-4-5", "anthropic/claude-sonnet-4-5-0", "anthropic/claude-sonnet-4-5-0-20250929", "anthropic/claude-sonnet-4-5-0-latest", "anthropic/claude-sonnet-4-5-20250929", "anthropic/claude-sonnet-4-5-latest", "anthropic/claude-sonnet-4-latest"];
+/**
+ * Valid Anthropic model IDs.
+ */
+type AnthropicKnownModels = (typeof ANTHROPIC_KNOWN_MODELS_ARRAY)[number];
+
+/**
+ * Anthropic registered LLM models.
+ */
+
+/**
+ * The Anthropic model IDs registered with Mirascope.
+ */
+type AnthropicModelId = AnthropicKnownModels | (string & {});
+
+/**
+ * Context for LLM calls with dependency injection.
+ *
+ * Context allows you to pass dependencies (like database connections, user info,
+ * configuration, etc.) through to your prompts and tools in a type-safe way.
+ */
+/**
+ * Symbol marker used to identify Context objects at runtime.
+ * This enables reliable detection of Context instances in unified call/prompt functions.
+ */
+declare const CONTEXT_MARKER: unique symbol;
+/**
+ * Context for LLM calls with dependency injection.
+ *
+ * @template DepsT - The type of dependencies contained in the context.
+ *
+ * @example
+ * ```typescript
+ * interface MyDeps {
+ *   userId: string;
+ *   db: Database;
+ * }
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123', db: myDb });
+ * const response = await myPrompt(model, ctx, { greeting: 'Hello' });
+ * ```
+ */
+interface Context<DepsT> {
+    /**
+     * Marker property for runtime Context detection.
+     * @internal
+     */
+    readonly [CONTEXT_MARKER]: true;
+    /**
+     * The dependencies available in this context.
+     */
+    readonly deps: DepsT;
+}
+/**
+ * Type guard to check if a value is a Context object.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a Context, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * const maybeCtx = getArgument();
+ * if (isContext(maybeCtx)) {
+ *   console.log(maybeCtx.deps); // TypeScript knows this is a Context
+ * }
+ * ```
+ */
+declare function isContext(value: unknown): value is Context<unknown>;
+/**
+ * Create a context with the given dependencies.
+ *
+ * @template DepsT - The type of dependencies.
+ * @param deps - The dependencies to include in the context.
+ * @returns A Context containing the provided dependencies.
+ *
+ * @example
+ * ```typescript
+ * interface MyDeps {
+ *   userId: string;
+ *   db: Database;
+ * }
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123', db: myDb });
+ * ```
+ */
+declare function createContext<DepsT>(deps: DepsT): Context<DepsT>;
+
+/**
+ * Tool call content from an assistant message.
+ *
+ * Represents a request from the assistant to call a tool/function.
+ * The args field contains the stringified JSON arguments.
+ */
+type ToolCall = {
+    readonly type: "tool_call";
+    /** A unique identifier for this tool call. */
+    readonly id: string;
+    /** The name of the tool to call. */
+    readonly name: string;
+    /** The arguments to pass to the tool, stored as stringified JSON. */
+    readonly args: string;
+};
+/**
+ * Signals the start of a tool call in the stream.
+ */
+type ToolCallStartChunk = {
+    readonly type: "tool_call_start_chunk";
+    readonly contentType: "tool_call";
+    /** Unique identifier for this tool call. */
+    readonly id: string;
+    /** The name of the tool to call. */
+    readonly name: string;
+};
+/**
+ * Contains incremental tool call arguments (JSON).
+ */
+type ToolCallChunk = {
+    readonly type: "tool_call_chunk";
+    readonly contentType: "tool_call";
+    /** Unique identifier for this tool call. */
+    readonly id: string;
+    /** The incremental JSON args added in this chunk. */
+    readonly delta: string;
+};
+/**
+ * Signals the end of a tool call in the stream.
+ */
+type ToolCallEndChunk = {
+    readonly type: "tool_call_end_chunk";
+    readonly contentType: "tool_call";
+    /** Unique identifier for this tool call. */
+    readonly id: string;
+};
+/** Create a ToolCallStartChunk */
+declare function toolCallStart(id: string, name: string): ToolCallStartChunk;
+/** Create a ToolCallChunk */
+declare function toolCallChunk(id: string, delta: string): ToolCallChunk;
+/** Create a ToolCallEndChunk */
+declare function toolCallEnd(id: string): ToolCallEndChunk;
+
+/**
+ * Tool output content representing the result of a tool call.
+ *
+ * Contains the result of executing a tool, or an error if the tool failed.
+ * The generic type T allows for typed results when the tool output type is known.
+ */
+type ToolOutput<T extends Jsonable = Jsonable> = {
+    readonly type: "tool_output";
+    /** The ID of the tool call that this output is for. */
+    readonly id: string;
+    /** The name of the tool that created this output. */
+    readonly name: string;
+    /**
+     * The result of calling the tool.
+     *
+     * If the tool executed successfully, this will be the tool output.
+     * If the tool errored, this will be the error message, as a string.
+     */
+    readonly result: T | string;
+    /** The error from calling the tool, if any. */
+    readonly error: Error | null;
+};
+/**
+ * Factory methods for creating ToolOutput instances.
+ */
+declare const ToolOutput: {
+    /**
+     * Create a ToolOutput with explicit parameters.
+     */
+    create: <T extends Jsonable>(id: string, name: string, result: T | string, error?: Error | null) => ToolOutput<T>;
+    /**
+     * Create a successful ToolOutput.
+     */
+    success: <T extends Jsonable>(id: string, name: string, result: T) => ToolOutput<T>;
+    /**
+     * Create a failed ToolOutput.
+     */
+    failure: (id: string, name: string, error: Error) => ToolOutput;
+};
+
+/**
+ * Base class for provider-native tools.
+ *
+ * Unlike regular tools which define functions that you execute locally,
+ * provider tools are capabilities built into the provider's API.
+ * The provider handles execution entirely server-side.
+ */
+declare class ProviderTool {
+    readonly name: string;
+    constructor(name: string);
+}
+/**
+ * Type guard to check if a value is a ProviderTool.
+ */
+declare function isProviderTool(value: unknown): value is ProviderTool;
+
+/**
+ * Tool type definitions for LLM function calling.
+ *
+ * Provides interfaces for tools that can be called by LLMs,
+ * including base types for toolkit storage and callable types
+ * for direct invocation.
+ */
+
+/**
+ * Duck-typed Zod schema interface for optional Zod support.
+ *
+ * This allows accepting Zod schemas without requiring Zod as a dependency.
+ * We detect Zod schemas at runtime by checking for these properties.
+ *
+ * Compatible with both Zod 3 (description in _def.description) and
+ * Zod 4 (description may be at schema.description or _def.description).
+ */
+interface ZodLike {
+    /** Internal Zod definition - structure varies by version */
+    readonly _def: any;
+    /** Description may be at top level in Zod 4 */
+    readonly description?: string;
+    /** Output type for type inference (Zod internal) */
+    readonly _output?: unknown;
+    safeParse(data: unknown): {
+        success: boolean;
+        data?: unknown;
+        error?: unknown;
+    };
+}
+/**
+ * Infer the output type from a Zod-like schema.
+ *
+ * Uses Zod's internal `_output` property for type inference.
+ * This allows TypeScript to infer tool argument types from Zod schemas.
+ *
+ * @template Z - The Zod schema type.
+ */
+type InferZod<Z extends ZodLike> = Z extends {
+    _output: infer T;
+} ? T & Record<string, unknown> : Record<string, unknown>;
+/**
+ * Type discriminator for regular tools.
+ * Used at runtime to distinguish from context tools.
+ */
+declare const TOOL_TYPE: "tool";
+/**
+ * Type discriminator for context tools.
+ * Used at runtime to distinguish from regular tools.
+ */
+declare const CONTEXT_TOOL_TYPE: "context_tool";
+/**
+ * Base interface for tools without the callable signature.
+ *
+ * This is used by Toolkit to store tools without variance issues.
+ * The callable signature in Tool<T> causes contravariance problems
+ * when storing tools with different argument types in a collection.
+ */
+interface BaseTool extends ToolSchema {
+    /**
+     * Type discriminator - always 'tool' for regular tools.
+     * Used at runtime to distinguish from context tools.
+     */
+    readonly __toolType: typeof TOOL_TYPE;
+    /**
+     * Execute the tool from a ToolCall.
+     *
+     * @param toolCall - The tool call from the LLM.
+     * @returns A ToolOutput with the result or error.
+     */
+    execute(toolCall: ToolCall): Promise<ToolOutput<Jsonable>>;
+    /**
+     * The Zod validator used for this tool, if any.
+     * Present when tool was created with `validator` option.
+     */
+    readonly validator: ZodLike | undefined;
+}
+/**
+ * A defined tool that can be called by an LLM.
+ *
+ * Tools extend ToolSchema (a tool IS a schema) and are callable.
+ * Calling a tool directly executes it with the provided arguments.
+ *
+ * @template T - The type of arguments the tool accepts.
+ */
+interface Tool<T extends Record<string, unknown> = Record<string, unknown>> extends BaseTool {
+    /**
+     * Call the tool directly with arguments.
+     * This is equivalent to Python's `tool.__call__(*args, **kwargs)`.
+     *
+     * @param args - The arguments to pass to the tool.
+     * @returns The tool result.
+     */
+    (args: T): Promise<Jsonable>;
+}
+/**
+ * Base interface for context tools without the callable signature.
+ *
+ * This is used by ContextToolkit to store tools without variance issues.
+ *
+ * @template DepsT - The type of dependencies in the context.
+ */
+interface BaseContextTool<DepsT = unknown> extends ToolSchema {
+    /**
+     * Type discriminator - always 'context_tool' for context tools.
+     * Used at runtime to distinguish from regular tools.
+     */
+    readonly __toolType: typeof CONTEXT_TOOL_TYPE;
+    /**
+     * Execute the tool from a ToolCall with context.
+     *
+     * @param ctx - The context containing dependencies.
+     * @param toolCall - The tool call from the LLM.
+     * @returns A ToolOutput with the result or error.
+     */
+    execute(ctx: Context<DepsT>, toolCall: ToolCall): Promise<ToolOutput<Jsonable>>;
+    /**
+     * The Zod validator used for this tool, if any.
+     * Present when tool was created with `validator` option.
+     */
+    readonly validator: ZodLike | undefined;
+}
+/**
+ * A defined context tool with dependency injection.
+ *
+ * Context tools extend ToolSchema and are callable with a context argument.
+ *
+ * @template T - The type of arguments the tool accepts.
+ * @template DepsT - The type of dependencies in the context.
+ */
+interface ContextTool<T extends Record<string, unknown> = Record<string, unknown>, DepsT = unknown> extends BaseContextTool<DepsT> {
+    /**
+     * Call the tool directly with context and arguments.
+     * This is equivalent to Python's `tool.__call__(ctx, *args, **kwargs)`.
+     *
+     * @param ctx - The context containing dependencies.
+     * @param args - The arguments to pass to the tool.
+     * @returns The tool result.
+     */
+    (ctx: Context<DepsT>, args: T): Promise<Jsonable>;
+}
+/**
+ * Union type for any tool (regular or context).
+ */
+type AnyTool = Tool | ContextTool;
+/**
+ * Union type for tools that can be used in context paths.
+ *
+ * Context paths accept BOTH regular tools AND context tools,
+ * matching Python's `ContextTools[DepsT] = Tool | ContextTool[DepsT]`.
+ *
+ * @template DepsT - The type of dependencies in the context.
+ */
+type AnyContextTool<DepsT = unknown> = BaseTool | BaseContextTool<DepsT>;
+/**
+ * Type alias for an array of regular tools.
+ * Matches Python's `Tools = Sequence[Tool | ProviderTool]`.
+ */
+type Tools = readonly (BaseTool | ProviderTool)[];
+/**
+ * Type alias for an array of tools usable in context paths.
+ * Accepts both regular tools AND context tools, plus provider tools.
+ * Matches Python's `ContextTools[DepsT] = Sequence[Tool | ContextTool[DepsT] | ProviderTool]`.
+ *
+ * @template DepsT - The type of dependencies in the context.
+ */
+type ContextTools<DepsT = unknown> = readonly (AnyContextTool<DepsT> | ProviderTool)[];
+type ToolFn<T extends Record<string, unknown> = Record<string, unknown>, R extends Jsonable = Jsonable> = (args: T) => Promise<R> | R;
+type ContextToolFn<T extends Record<string, unknown> = Record<string, unknown>, DepsT = unknown, R extends Jsonable = Jsonable> = (ctx: Context<DepsT>, args: T) => Promise<R> | R;
+type AnyToolFn = ToolFn | ContextToolFn;
+/**
+ * Type guard to check if a tool is a context tool.
+ *
+ * @param tool - The tool to check.
+ * @returns True if the tool is a context tool.
+ */
+declare function isContextTool<DepsT = unknown>(tool: AnyContextTool<DepsT>): tool is BaseContextTool<DepsT>;
+
+/**
+ * Tool definition functions for creating LLM-callable tools.
+ *
+ * Provides `defineTool()` and `defineContextTool()` for creating tools
+ * with type-safe argument inference.
+ *
+ * Two patterns are supported:
+ * 1. **Zod-native**: Use `validator` option with a Zod schema (no transformer needed)
+ * 2. **Transformer-based**: Use generic type parameter (requires transformer for schema injection)
+ */
+
+/**
+ * Check if a value is a Zod-like schema.
+ */
+declare function isZodLike(value: unknown): value is ZodLike;
+/**
+ * Arguments for defining a tool using a Zod schema.
+ *
+ * This pattern does NOT require the compile-time transformer.
+ * The schema is extracted from the Zod validator at runtime.
+ *
+ * @template Z - The Zod schema type.
+ */
+interface ZodToolArgs<Z extends ZodLike> {
+    /** The name of the tool. */
+    name: string;
+    /** A description of what the tool does. */
+    description: string;
+    /**
+     * Whether to use strict mode for the tool schema.
+     * When true, providers that support it will enforce strict schema validation.
+     */
+    strict?: boolean;
+    /**
+     * Zod schema for both schema generation AND runtime validation.
+     * Use `.describe()` on fields to add descriptions.
+     */
+    validator: Z;
+    /** The tool implementation function. */
+    tool: (args: InferZod<Z>) => Jsonable | Promise<Jsonable>;
+}
+/**
+ * Arguments for defining a context tool using a Zod schema.
+ *
+ * This pattern does NOT require the compile-time transformer.
+ *
+ * @template Z - The Zod schema type.
+ * @template DepsT - The type of dependencies in the context.
+ */
+interface ZodContextToolArgs<Z extends ZodLike, DepsT = unknown> {
+    /** The name of the tool. */
+    name: string;
+    /** A description of what the tool does. */
+    description: string;
+    /**
+     * Whether to use strict mode for the tool schema.
+     * When true, providers that support it will enforce strict schema validation.
+     */
+    strict?: boolean;
+    /**
+     * Zod schema for both schema generation AND runtime validation.
+     * Use `.describe()` on fields to add descriptions.
+     */
+    validator: Z;
+    /** The tool implementation function with context. */
+    tool: (ctx: Context<DepsT>, args: InferZod<Z>) => Jsonable | Promise<Jsonable>;
+}
+/**
+ * Arguments for defining a tool using the compile-time transformer.
+ *
+ * @template T - The type of arguments the tool accepts.
+ */
+interface ToolArgs<T extends Record<string, unknown>> {
+    /** The name of the tool. */
+    name: string;
+    /** A description of what the tool does. */
+    description: string;
+    /**
+     * Whether to use strict mode for the tool schema.
+     * When true, providers that support it will enforce strict schema validation.
+     */
+    strict?: boolean;
+    /** The tool implementation function. */
+    tool: (args: T) => Jsonable | Promise<Jsonable>;
+    /**
+     * Internal: JSON schema injected by the compile-time transformer.
+     * Users should not set this directly - it's populated automatically.
+     */
+    __schema?: ToolParameterSchema;
+}
+/**
+ * Arguments for defining a context tool using the compile-time transformer.
+ *
+ * @template T - The type of arguments the tool accepts.
+ * @template DepsT - The type of dependencies in the context.
+ */
+interface ContextToolArgs<T extends Record<string, unknown>, DepsT = unknown> {
+    /** The name of the tool. */
+    name: string;
+    /** A description of what the tool does. */
+    description: string;
+    /**
+     * Whether to use strict mode for the tool schema.
+     * When true, providers that support it will enforce strict schema validation.
+     */
+    strict?: boolean;
+    /** The tool implementation function with context. */
+    tool: (ctx: Context<DepsT>, args: T) => Jsonable | Promise<Jsonable>;
+    /**
+     * Internal: JSON schema injected by the compile-time transformer.
+     * Users should not set this directly - it's populated automatically.
+     */
+    __schema?: ToolParameterSchema;
+}
+/**
+ * Define a tool using a Zod schema (no transformer needed).
+ *
+ * @template Z - The Zod schema type.
+ * @param args - The tool definition arguments with validator.
+ * @returns A Tool instance with args inferred from the Zod schema.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const getWeather = defineTool({
+ *   name: 'get_weather',
+ *   description: 'Get weather for a city',
+ *   validator: z.object({
+ *     city: z.string().describe('The city name'),
+ *   }),
+ *   tool: ({ city }) => ({ temp: 72, city }),
+ * });
+ * ```
+ */
+declare function defineTool<Z extends ZodLike>(args: ZodToolArgs<Z>): Tool<InferZod<Z>>;
+/**
+ * Define a tool using the compile-time transformer.
+ *
+ * @template T - The type of arguments the tool accepts.
+ * @param args - The tool definition arguments.
+ * @returns A Tool instance.
+ *
+ * @example
+ * ```typescript
+ * interface WeatherArgs {
+ *   // JSDoc comments become field descriptions via transformer
+ *   city: string;
+ * }
+ *
+ * const getWeather = defineTool<WeatherArgs>({
+ *   name: 'get_weather',
+ *   description: 'Get weather for a city',
+ *   tool: ({ city }) => ({ temp: 72, city }),
+ * });
+ * ```
+ */
+declare function defineTool<T extends Record<string, unknown>>(args: ToolArgs<T>): Tool<T>;
+/**
+ * Define a context tool using a Zod schema (no transformer needed).
+ *
+ * @template Z - The Zod schema type.
+ * @template DepsT - The type of dependencies in the context.
+ * @param args - The tool definition arguments with validator.
+ * @returns A ContextTool instance with args inferred from the Zod schema.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const searchDatabase = defineContextTool({
+ *   name: 'search_database',
+ *   description: 'Search the database',
+ *   validator: z.object({
+ *     query: z.string().describe('The search query'),
+ *   }),
+ *   tool: (ctx, { query }) => ctx.deps.db.search(query),
+ * });
+ * ```
+ */
+declare function defineContextTool<Z extends ZodLike, DepsT = unknown>(args: ZodContextToolArgs<Z, DepsT>): ContextTool<InferZod<Z>, DepsT>;
+/**
+ * Define a context tool using the compile-time transformer.
+ *
+ * @template T - The type of arguments the tool accepts.
+ * @template DepsT - The type of dependencies in the context.
+ * @param args - The tool definition arguments.
+ * @returns A ContextTool instance.
+ *
+ * @example
+ * ```typescript
+ * interface MyDeps {
+ *   db: Database;
+ * }
+ *
+ * interface SearchArgs {
+ *   query: string;
+ * }
+ *
+ * const searchDatabase = defineContextTool<SearchArgs, MyDeps>({
+ *   name: 'search_database',
+ *   description: 'Search the database',
+ *   tool: (ctx, { query }) => ctx.deps.db.search(query),
+ * });
+ * ```
+ */
+declare function defineContextTool<T extends Record<string, unknown>, DepsT = unknown>(args: ContextToolArgs<T, DepsT>): ContextTool<T, DepsT>;
+
+/**
+ * Toolkit class for managing collections of tools.
+ *
+ * Provides a unified interface for executing tool calls against
+ * a collection of registered tools.
+ */
+
+/**
+ * Base interface that all toolkit types implement.
+ *
+ * This provides a unified interface for accessing tool schemas and looking
+ * up tools by name. Matches Python's `BaseToolkit[ToolSchemaT]` pattern.
+ *
+ * @template T - The type of tools stored in this toolkit.
+ */
+interface BaseToolkit<T extends ToolSchema = ToolSchema> {
+    /**
+     * Get all tools in the toolkit (including provider tools).
+     */
+    readonly tools: readonly (T | ProviderTool)[];
+    /**
+     * Get the schemas for all tools in the toolkit.
+     * Does NOT include provider tools (they have no schema).
+     */
+    readonly schemas: readonly ToolSchema[];
+    /**
+     * Get the provider tools in the toolkit.
+     */
+    readonly providerTools: readonly ProviderTool[];
+    /**
+     * Get a tool by name.
+     *
+     * @param name - The name of the tool.
+     * @returns The tool, or undefined if not found.
+     */
+    get(name: string): T | undefined;
+    /**
+     * Check if a tool with the given name exists.
+     *
+     * @param name - The name of the tool.
+     * @returns True if the tool exists.
+     */
+    has(name: string): boolean;
+}
+/**
+ * A toolkit for managing and executing regular tools.
+ *
+ * Implements BaseToolkit<BaseTool> for type-safe tool access.
+ *
+ * @example
+ * ```typescript
+ * const toolkit = new Toolkit([getWeather, searchWeb]);
+ *
+ * // Execute a tool call from the LLM
+ * const output = await toolkit.execute(toolCall);
+ * ```
+ */
+declare class Toolkit implements BaseToolkit<BaseTool> {
+    private readonly toolMap;
+    private readonly providerToolMap;
+    private readonly _tools;
+    /**
+     * Create a new Toolkit with the given tools.
+     *
+     * @param tools - The tools to include in the toolkit, or null/undefined for empty.
+     * @throws Error if multiple tools have the same name.
+     */
+    constructor(tools: readonly (BaseTool | ProviderTool)[] | null | undefined);
+    /**
+     * Get all tools in the toolkit (including provider tools).
+     */
+    get tools(): readonly (BaseTool | ProviderTool)[];
+    /**
+     * Get the schemas for all tools in the toolkit.
+     * Does NOT include provider tools (they have no schema).
+     */
+    get schemas(): readonly ToolSchema[];
+    /**
+     * Get the provider tools in the toolkit.
+     */
+    get providerTools(): readonly ProviderTool[];
+    /**
+     * Get a tool by name.
+     *
+     * @param name - The name of the tool.
+     * @returns The tool, or undefined if not found.
+     */
+    get(name: string): BaseTool | undefined;
+    /**
+     * Check if a tool with the given name exists.
+     *
+     * @param name - The name of the tool.
+     * @returns True if the tool exists.
+     */
+    has(name: string): boolean;
+    /**
+     * Execute a tool call.
+     *
+     * Finds the tool matching the call's name and executes it.
+     * Returns a ToolOutput with the result or error.
+     *
+     * @param toolCall - The tool call from the LLM.
+     * @returns A ToolOutput with the result or error.
+     */
+    execute(toolCall: ToolCall): Promise<ToolOutput<Jsonable>>;
+}
+/**
+ * A toolkit for managing and executing context tools.
+ *
+ * This toolkit supports BOTH regular tools (BaseTool) AND context tools
+ * (BaseContextTool), matching Python's `ContextToolkit[DepsT]` pattern.
+ * Regular tools are executed without context; context tools receive the
+ * context for dependency injection.
+ *
+ * Implements BaseToolkit<AnyContextTool<DepsT>> for type-safe tool access.
+ *
+ * @template DepsT - The type of dependencies in the context.
+ *
+ * @example
+ * ```typescript
+ * interface MyDeps { db: Database; }
+ *
+ * // Can mix regular and context tools
+ * const toolkit = new ContextToolkit<MyDeps>([
+ *   regularTool,      // BaseTool - no context needed
+ *   searchDatabase,   // BaseContextTool<MyDeps> - receives context
+ * ]);
+ *
+ * // Execute with context - polymorphic dispatch handles both types
+ * const ctx = createContext<MyDeps>({ db: myDatabase });
+ * const output = await toolkit.execute(ctx, toolCall);
+ * ```
+ */
+declare class ContextToolkit<DepsT = unknown> implements BaseToolkit<AnyContextTool<DepsT>> {
+    private readonly toolMap;
+    private readonly providerToolMap;
+    private readonly _tools;
+    /**
+     * Create a new ContextToolkit with the given tools.
+     *
+     * Accepts regular tools (BaseTool), context tools (BaseContextTool), and provider tools.
+     *
+     * @param tools - The tools to include in the toolkit, or null/undefined for empty.
+     * @throws Error if multiple tools have the same name.
+     */
+    constructor(tools: readonly (AnyContextTool<DepsT> | ProviderTool)[] | null | undefined);
+    /**
+     * Get all tools in the toolkit (including provider tools).
+     */
+    get tools(): readonly (AnyContextTool<DepsT> | ProviderTool)[];
+    /**
+     * Get the schemas for all tools in the toolkit.
+     * Does NOT include provider tools (they have no schema).
+     */
+    get schemas(): readonly ToolSchema[];
+    /**
+     * Get the provider tools in the toolkit.
+     */
+    get providerTools(): readonly ProviderTool[];
+    /**
+     * Get a tool by name.
+     *
+     * @param name - The name of the tool.
+     * @returns The tool, or undefined if not found.
+     */
+    get(name: string): AnyContextTool<DepsT> | undefined;
+    /**
+     * Check if a tool with the given name exists.
+     *
+     * @param name - The name of the tool.
+     * @returns True if the tool exists.
+     */
+    has(name: string): boolean;
+    /**
+     * Execute a tool call with context.
+     *
+     * Uses polymorphic dispatch to handle both regular tools and context tools:
+     * - Regular tools (BaseTool) are executed without context
+     * - Context tools (BaseContextTool) receive the context for dependency injection
+     *
+     * @param ctx - The context containing dependencies.
+     * @param toolCall - The tool call from the LLM.
+     * @returns A ToolOutput with the result or error.
+     */
+    execute(ctx: Context<DepsT>, toolCall: ToolCall): Promise<ToolOutput<Jsonable>>;
+    /**
+     * Execute multiple tool calls in parallel with context.
+     *
+     * @param ctx - The context containing dependencies.
+     * @param toolCalls - The tool calls to execute.
+     * @returns An array of ToolOutputs in the same order as the input.
+     */
+    executeAll(ctx: Context<DepsT>, toolCalls: readonly ToolCall[]): Promise<ToolOutput<Jsonable>[]>;
+}
+/**
+ * Create a toolkit from an array of tools.
+ *
+ * This is a convenience function for creating Toolkit instances.
+ *
+ * @param tools - The tools to include in the toolkit.
+ * @returns A new Toolkit instance.
+ */
+declare function createToolkit(tools: readonly (BaseTool | ProviderTool)[]): Toolkit;
+/**
+ * Create a context toolkit from an array of tools.
+ *
+ * This is a convenience function for creating ContextToolkit instances.
+ * Accepts regular tools (BaseTool), context tools (BaseContextTool), and provider tools.
+ *
+ * @template DepsT - The type of dependencies in the context.
+ * @param tools - The tools to include in the toolkit.
+ * @returns A new ContextToolkit instance.
+ */
+declare function createContextToolkit<DepsT = unknown>(tools: readonly (AnyContextTool<DepsT> | ProviderTool)[]): ContextToolkit<DepsT>;
+
+/**
+ * Web search tool for provider-native web search capabilities.
+ */
+
+/**
+ * Web search tool that allows the model to search the internet.
+ *
+ * This is a provider tool - the search is executed server-side by the provider,
+ * not by your code. The model decides when to search based on the prompt,
+ * and the provider returns search results with citations.
+ *
+ * Supported providers include Anthropic, Google, and OpenAI (when using the Responses API).
+ *
+ * @example
+ * ```typescript
+ * import { defineCall, WebSearchTool } from '@anthropic-ai/mirascope';
+ *
+ * const searchWeb = defineCall({
+ *   model: 'anthropic/claude-sonnet-4-5',
+ *   tools: [new WebSearchTool()],
+ * }, () => 'Search the web for: Who won the 2024 Super Bowl?');
+ *
+ * const response = await searchWeb();
+ * console.log(response.text()); // Response includes citations from web search
+ * ```
+ */
+declare class WebSearchTool extends ProviderTool {
+    constructor();
+}
+/**
+ * Type guard to check if a value is a WebSearchTool.
+ */
+declare function isWebSearchTool(value: unknown): value is WebSearchTool;
+
+/**
+ * Supported audio MIME types.
+ */
+type AudioMimeType = "audio/wav" | "audio/mp3" | "audio/aiff" | "audio/aac" | "audio/ogg" | "audio/flac";
+/**
+ * Audio data encoded as base64.
+ */
+type Base64AudioSource = {
+    readonly type: "base64_audio_source";
+    /** The audio data, as a base64 encoded string. */
+    readonly data: string;
+    /** The mime type of the audio (e.g. audio/mp3). */
+    readonly mimeType: AudioMimeType;
+};
+/**
+ * Audio content for a message.
+ *
+ * Audio can be included in user messages for multimodal models that support it.
+ */
+type Audio = {
+    readonly type: "audio";
+    readonly source: Base64AudioSource;
+};
+/**
+ * Factory methods for creating Audio instances.
+ */
+declare const Audio: {
+    /**
+     * Download audio from a URL and encode as base64.
+     *
+     * @throws Error if download fails or audio exceeds maxSize
+     */
+    download: (url: string, maxSize?: number) => Promise<Audio>;
+    /**
+     * Create Audio from raw bytes.
+     *
+     * @throws Error if data exceeds maxSize or type cannot be inferred
+     */
+    fromBytes: (data: Uint8Array, maxSize?: number) => Audio;
+};
+
+/**
+ * MIME types for text-based documents.
+ */
+type DocumentTextMimeType = "application/json" | "text/plain" | "application/x-javascript" | "text/javascript" | "application/x-python" | "text/x-python" | "text/html" | "text/css" | "text/xml" | "text/rtf";
+/**
+ * MIME types for binary documents (base64 encoded).
+ */
+type DocumentBase64MimeType = "application/pdf";
+/**
+ * Document data encoded as base64 (for binary formats like PDF).
+ */
+type Base64DocumentSource = {
+    readonly type: "base64_document_source";
+    /** The document data, as a base64 encoded string. */
+    readonly data: string;
+    /** The media type of the document (e.g. application/pdf). */
+    readonly mediaType: DocumentBase64MimeType;
+};
+/**
+ * Document data as plain text.
+ */
+type TextDocumentSource = {
+    readonly type: "text_document_source";
+    /** The document data, as plain text. */
+    readonly data: string;
+    /** The media type of the document (e.g. text/plain, text/csv). */
+    readonly mediaType: DocumentTextMimeType;
+};
+/**
+ * Document referenced by URL.
+ */
+type URLDocumentSource = {
+    readonly type: "url_document_source";
+    /** The url of the document (e.g. https://example.com/paper.pdf). */
+    readonly url: string;
+};
+/**
+ * Document content for a message.
+ *
+ * Documents can be included in user messages for models that support them.
+ * Supports text documents (JSON, plain text, code) and binary documents (PDF).
+ */
+type Document = {
+    readonly type: "document";
+    readonly source: Base64DocumentSource | TextDocumentSource | URLDocumentSource;
+};
+/**
+ * Factory methods for creating Document instances.
+ *
+ * Note: These are stubs that throw NotImplementedError.
+ * Full implementation is deferred to a later phase.
+ */
+declare const Document: {
+    /**
+     * Create a Document from a URL reference.
+     *
+     * @throws Error (not implemented)
+     */
+    fromUrl: (_url: string, _options?: {
+        download?: boolean;
+    }) => Document;
+    /**
+     * Create a Document from raw bytes.
+     *
+     * @throws Error (not implemented)
+     */
+    fromBytes: (_data: Uint8Array, _options?: {
+        mimeType?: DocumentTextMimeType | DocumentBase64MimeType;
+    }) => Document;
+};
+
+/**
+ * Supported image MIME types.
+ */
+type ImageMimeType = "image/png" | "image/jpeg" | "image/webp" | "image/gif" | "image/heic" | "image/heif";
+/**
+ * Image data encoded as base64.
+ */
+type Base64ImageSource = {
+    readonly type: "base64_image_source";
+    /** The image data, as a base64 encoded string. */
+    readonly data: string;
+    /** The mime type of the image (e.g. image/png). */
+    readonly mimeType: ImageMimeType;
+};
+/**
+ * Image referenced by URL.
+ */
+type URLImageSource = {
+    readonly type: "url_image_source";
+    /** The url of the image (e.g. https://example.com/image.png). */
+    readonly url: string;
+};
+/**
+ * Image content for a message.
+ *
+ * Images can be included in user messages for multimodal models.
+ * The source can be either base64-encoded data or a URL reference.
+ */
+type Image = {
+    readonly type: "image";
+    readonly source: Base64ImageSource | URLImageSource;
+};
+/**
+ * Factory methods for creating Image instances.
+ */
+declare const Image: {
+    /**
+     * Create an Image from a URL reference (no download).
+     */
+    fromUrl: (url: string) => Image;
+    /**
+     * Download an image from a URL and encode as base64.
+     *
+     * @throws Error if download fails or image exceeds maxSize
+     */
+    download: (url: string, maxSize?: number) => Promise<Image>;
+    /**
+     * Create an Image from raw bytes.
+     *
+     * @throws Error if data exceeds maxSize or type cannot be inferred
+     */
+    fromBytes: (data: Uint8Array, maxSize?: number) => Image;
+};
+
+/**
+ * Text content for a message.
+ *
+ * Represents plain text content in a message. This is the most common
+ * content type for both user and assistant messages.
+ */
+type Text = {
+    readonly type: "text";
+    /** The text content. */
+    readonly text: string;
+};
+/**
+ * Signals the start of a text content block in the stream.
+ */
+type TextStartChunk = {
+    readonly type: "text_start_chunk";
+    readonly contentType: "text";
+};
+/**
+ * Contains incremental text content.
+ */
+type TextChunk = {
+    readonly type: "text_chunk";
+    readonly contentType: "text";
+    /** The incremental text added in this chunk. */
+    readonly delta: string;
+};
+/**
+ * Signals the end of a text content block in the stream.
+ */
+type TextEndChunk = {
+    readonly type: "text_end_chunk";
+    readonly contentType: "text";
+};
+/** Create a TextStartChunk */
+declare function textStart(): TextStartChunk;
+/** Create a TextChunk */
+declare function textChunk(delta: string): TextChunk;
+/** Create a TextEndChunk */
+declare function textEnd(): TextEndChunk;
+
+/**
+ * Thought content from an assistant's extended thinking.
+ *
+ * Represents the reasoning or thinking process of an assistant model
+ * that supports extended thinking (e.g., Claude with thinking enabled).
+ */
+type Thought = {
+    readonly type: "thought";
+    /** The thoughts or reasoning of the assistant. */
+    readonly thought: string;
+};
+/**
+ * Signals the start of a thought content block in the stream.
+ */
+type ThoughtStartChunk = {
+    readonly type: "thought_start_chunk";
+    readonly contentType: "thought";
+};
+/**
+ * Contains incremental thought content.
+ */
+type ThoughtChunk = {
+    readonly type: "thought_chunk";
+    readonly contentType: "thought";
+    /** The incremental thought text added in this chunk. */
+    readonly delta: string;
+};
+/**
+ * Signals the end of a thought content block in the stream.
+ */
+type ThoughtEndChunk = {
+    readonly type: "thought_end_chunk";
+    readonly contentType: "thought";
+};
+/** Create a ThoughtStartChunk */
+declare function thoughtStart(): ThoughtStartChunk;
+/** Create a ThoughtChunk */
+declare function thoughtChunk(delta: string): ThoughtChunk;
+/** Create a ThoughtEndChunk */
+declare function thoughtEnd(): ThoughtEndChunk;
+
+/**
+ * All content types that can appear in messages.
+ */
+type ContentPart = Text | Image | Audio | Document | ToolOutput | ToolCall | Thought;
+/**
+ * Content types that can appear in user messages.
+ */
+type UserContentPart = Text | Image | Audio | Document | ToolOutput;
+/**
+ * Content types that can appear in assistant messages.
+ */
+type AssistantContentPart = Text | ToolCall | Thought;
+/**
+ * Chunks of assistant content that may be streamed as generated by the LLM.
+ */
+type AssistantContentChunk = TextStartChunk | TextChunk | TextEndChunk | ThoughtStartChunk | ThoughtChunk | ThoughtEndChunk | ToolCallStartChunk | ToolCallChunk | ToolCallEndChunk;
+
+/**
+ * The `Message` types and utility constructors.
+ */
+
+/**
+ * A system message that sets context and instructions for the conversation.
+ */
+type SystemMessage = {
+    /** The role of this message. Always "system". */
+    readonly role: "system";
+    /** The content of this SystemMessage. */
+    readonly content: Text;
+};
+/**
+ * A user message containing input from the user.
+ */
+type UserMessage = {
+    /** The role of this message. Always "user". */
+    readonly role: "user";
+    /** The content of the user message. */
+    readonly content: readonly UserContentPart[];
+    /** A name identifying the creator of this message. */
+    readonly name: string | null;
+};
+/**
+ * An assistant message containing the model's response.
+ */
+type AssistantMessage = {
+    /** The role of this message. Always "assistant". */
+    readonly role: "assistant";
+    /** The content of the assistant message. */
+    readonly content: readonly AssistantContentPart[];
+    /** A name identifying the creator of this message. */
+    readonly name: string | null;
+    /** The LLM provider that generated this assistant message, if available. */
+    readonly providerId: ProviderId | null;
+    /** The model identifier of the LLM that generated this assistant message, if available. */
+    readonly modelId: ModelId | null;
+    /** The provider-specific model identifier (e.g. "gpt-5:responses"), if available. */
+    readonly providerModelName: string | null;
+    /**
+     * The provider-specific raw representation of this assistant message, if available.
+     *
+     * If raw_content is truthy, then it may be used for provider-specific behavior when
+     * resuming an LLM interaction that included this assistant message. For example, we can
+     * reuse the provider-specific raw encoding rather than re-encoding the message from it's
+     * Mirascope content representation. This may also take advantage of server-side provider
+     * context, e.g. identifiers of reasoning context tokens that the provider generated.
+     *
+     * If present, the content should be encoded as JSON-serializable data, and in a format
+     * that matches representation the provider expects representing the Mirascope data.
+     *
+     * Raw content is not required, as the Mirascope content can also be used to generate
+     * a valid input to the provider (potentially without taking advantage of provider-specific
+     * reasoning caches, etc). In that case raw content should be left empty.
+     */
+    readonly rawMessage: Jsonable | null;
+};
+/**
+ * A message in an LLM interaction.
+ *
+ * Messages have a role (system, user, or assistant) and content that is a sequence
+ * of content parts. The content can include text, images, audio, documents, and
+ * tool interactions.
+ *
+ * For most use cases, prefer the convenience functions `system()`, `user()`, and
+ * `assistant()` instead of directly creating `Message` objects.
+ *
+ * @example
+ * ```typescript
+ * import { messages } from 'mirascope/llm';
+ *
+ * const msgs = [
+ *   messages.system("You are a helpful assistant."),
+ *   messages.user("Hello, how are you?"),
+ * ];
+ * ```
+ */
+type Message = SystemMessage | UserMessage | AssistantMessage;
+/**
+ * Type alias for content that can fit into a `UserMessage`.
+ */
+type UserContent = string | UserContentPart | readonly (string | UserContentPart)[];
+/**
+ * Type alias for content that can fit into an `AssistantMessage`.
+ */
+type AssistantContent = string | AssistantContentPart | readonly (string | AssistantContentPart)[];
+/**
+ * Type alias for content that can fit into a `SystemMessage`.
+ */
+type SystemContent = string | Text;
+/**
+ * Creates a system message.
+ *
+ * @param content - The content of the message, which must be a string or Text content.
+ * @returns A SystemMessage.
+ */
+declare function system(content: SystemContent): SystemMessage;
+/**
+ * Creates a user message.
+ *
+ * @param content - The content of the message, which can be a string or any UserContent,
+ *   or a sequence of such user content pieces.
+ * @param options - Optional parameters.
+ * @param options.name - Optional name to identify a specific user in multi-party conversations.
+ * @returns A UserMessage.
+ */
+declare function user(content: UserContent, options?: {
+    name?: string | null;
+}): UserMessage;
+/**
+ * Creates an assistant message.
+ *
+ * @param content - The content of the message, which can be a string or any AssistantContent,
+ *   or a sequence of assistant content pieces.
+ * @param options - Required and optional parameters.
+ * @param options.modelId - Optional id of the model that produced this message.
+ * @param options.providerId - Optional identifier of the provider that produced this message.
+ * @param options.providerModelName - Optional provider-specific model name.
+ * @param options.rawMessage - Optional Jsonable object with provider-specific raw data.
+ * @param options.name - Optional name to identify a specific assistant in multi-party conversations.
+ * @returns An AssistantMessage.
+ */
+declare function assistant(content: AssistantContent, options: {
+    modelId: ModelId | null;
+    providerId: ProviderId | null;
+    providerModelName?: string | null;
+    rawMessage?: Jsonable | null;
+    name?: string | null;
+}): AssistantMessage;
+
+/**
+ * Utility functions for message handling.
+ */
+
+/**
+ * Type guard that checks if the content is a sequence of Messages.
+ *
+ * @param content - Either user content or a sequence of messages.
+ * @returns True if content is a sequence of Messages, false otherwise.
+ * @throws Error if an empty array is provided.
+ */
+declare function isMessages(content: UserContent | readonly Message[]): content is readonly Message[];
+/**
+ * Promote a prompt result to a list of messages.
+ *
+ * If the result is already a list of Messages, returns it as-is.
+ * If the result is str/UserContentPart/Sequence of content parts, wraps it in a user message.
+ *
+ * @param content - Either user content or a sequence of messages.
+ * @returns A sequence of Messages.
+ */
+declare function promoteToMessages(content: UserContent | readonly Message[]): readonly Message[];
+
+/**
+ * The messages module for LLM interactions.
+ *
+ * This module defines the message types used in LLM interactions. Messages are represented
+ * as a unified `Message` type with different roles (system, user, assistant) and flexible
+ * content arrays that can include text, images, audio, documents, and tool interactions.
+ */
+
+type index$1_AssistantContent = AssistantContent;
+type index$1_AssistantMessage = AssistantMessage;
+type index$1_Message = Message;
+type index$1_SystemContent = SystemContent;
+type index$1_SystemMessage = SystemMessage;
+type index$1_UserContent = UserContent;
+type index$1_UserMessage = UserMessage;
+declare const index$1_assistant: typeof assistant;
+declare const index$1_isMessages: typeof isMessages;
+declare const index$1_promoteToMessages: typeof promoteToMessages;
+declare const index$1_system: typeof system;
+declare const index$1_user: typeof user;
+declare namespace index$1 {
+  export { type index$1_AssistantContent as AssistantContent, type index$1_AssistantMessage as AssistantMessage, type index$1_Message as Message, type index$1_SystemContent as SystemContent, type index$1_SystemMessage as SystemMessage, type index$1_UserContent as UserContent, type index$1_UserMessage as UserMessage, index$1_assistant as assistant, index$1_isMessages as isMessages, index$1_promoteToMessages as promoteToMessages, index$1_system as system, index$1_user as user };
+}
+
+/**
+ * Configuration for extended reasoning/thinking in LLM responses.
+ */
+/**
+ * Level of effort/reasoning to apply to thinking.
+ */
+type ThinkingLevel = "none" | "default" | "minimal" | "low" | "medium" | "high" | "max";
+/**
+ * Configuration for extended reasoning/thinking in LLM responses.
+ *
+ * Thinking is a process where the model spends additional tokens reasoning about
+ * the prompt before generating a response. Providing any `ThinkingConfig` will enable
+ * thinking (unless it is specifically disabled via level="minimal"). Depending on
+ * the provider and model, thinking may always be active regardless of user settings.
+ */
+interface ThinkingConfig {
+    /**
+     * Level of effort/reasoning to apply to thinking.
+     *
+     * - none: Disable thinking entirely. Minimizes cost and latency.
+     * - default: Use the provider's default
+     * - minimal: Use the provider's lowest setting for reasoning
+     * - medium: Use a moderate amount of reasoning tokens
+     * - high: Allow extensive resources for thinking
+     * - max: Uses as much thinking as allowed by the provider.
+     *
+     * Mirascope makes a best effort to apply the chosen thinking level, but exact behavior
+     * varies by provider and model. For example, some models may not support thinking,
+     * while other models may not allow disabling it.
+     */
+    level: ThinkingLevel;
+    /**
+     * Whether to include Thought content in the model output.
+     *
+     * Depending on the model and provider, enabling includeThoughts to true may
+     * request reasoning summaries (which are not the underlying reasoning tokens,
+     * but a readable summary produced by another model), or it may be the original
+     * reasoning tokens.
+     *
+     * When includeThoughts is false, no summaries will be requested, and thoughts
+     * will not be included in the output even if they were provided by the provider.
+     *
+     * Defaults to false.
+     */
+    includeThoughts?: boolean;
+    /**
+     * Re-encode Thought content as text for model consumption.
+     *
+     * If `true`, when an `AssistantMessage` contains `Thoughts` and is passed back
+     * to an LLM, those `Thoughts` will be encoded as `Text`, ensuring the assistant
+     * can read its prior reasoning. This contrasts with provider defaults which may
+     * ignore prior thoughts, particularly if tool calls are not involved.
+     *
+     * When `true`, Mirascope will re-encode messages rather than reusing raw provider
+     * response content, which may disable provider-specific optimizations like cached
+     * reasoning tokens.
+     *
+     * Defaults to `false` if unset.
+     */
+    encodeThoughtsAsText?: boolean;
+}
+
+/**
+ * Base parameters for LLM providers.
+ */
+
+/**
+ * Common parameters shared across LLM providers.
+ *
+ * Note: Each provider may handle these parameters differently or not support them at all.
+ * Please check provider-specific documentation for parameter support and behavior.
+ */
+interface Params {
+    /**
+     * Controls randomness in the output (0.0 to 1.0).
+     *
+     * Lower temperatures are good for prompts that require a less open-ended or
+     * creative response, while higher temperatures can lead to more diverse or
+     * creative results.
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate.
+     */
+    maxTokens?: number;
+    /**
+     * Nucleus sampling parameter (0.0 to 1.0).
+     *
+     * Tokens are selected from the most to least probable until the sum of their
+     * probabilities equals this value. Use a lower value for less random responses and a
+     * higher value for more random responses.
+     */
+    topP?: number;
+    /**
+     * Limits token selection to the k most probable tokens (typically 1 to 100).
+     *
+     * For each token selection step, the `topK` tokens with the
+     * highest probabilities are sampled. Then tokens are further filtered based
+     * on `topP` with the final token selected using temperature sampling. Use
+     * a lower number for less random responses and a higher number for more
+     * random responses.
+     */
+    topK?: number;
+    /**
+     * Random seed for reproducibility.
+     *
+     * When `seed` is fixed to a specific number, the model makes a best
+     * effort to provide the same response for repeated requests.
+     *
+     * Not supported by all providers, and does not guarantee strict reproducibility.
+     */
+    seed?: number;
+    /**
+     * Stop sequences to end generation.
+     *
+     * The model will stop generating text if one of these strings is encountered in the
+     * response.
+     */
+    stopSequences?: string[];
+    /**
+     * Configuration for extended reasoning/thinking.
+     *
+     * Pass a `ThinkingConfig` to configure thinking behavior. The `level` field controls
+     * whether thinking is enabled and how much reasoning to use. Level may be one of
+     * "minimal", "low", "medium", or "high". If level is unset, then thinking is enabled
+     * with a provider-specific default level.
+     *
+     * `ThinkingConfig` can also include `encodeThoughtsAsText`, which is an advanced
+     * feature for providing past thoughts back to the model as text content. This is
+     * primarily useful for making thoughts transferable when passing a conversation
+     * to a different model or provider than the one that generated the thinking.
+     */
+    thinking?: ThinkingConfig | null;
+}
+
+/**
+ * Google model information.
+ *
+ * This file is auto-generated by typescript/scripts/codegen/google.ts
+ * Do not edit manually - run `bun run codegen` to update.
+ */
+/**
+ * Array of all known Google model IDs.
+ * This is the source of truth - the type and Set are derived from it.
+ */
+declare const GOOGLE_KNOWN_MODELS_ARRAY: readonly ["google/gemini-2.0-flash", "google/gemini-2.0-flash-001", "google/gemini-2.0-flash-exp", "google/gemini-2.0-flash-exp-image-generation", "google/gemini-2.0-flash-lite", "google/gemini-2.0-flash-lite-001", "google/gemini-2.0-flash-lite-preview", "google/gemini-2.0-flash-lite-preview-02-05", "google/gemini-2.5-flash", "google/gemini-2.5-flash-image", "google/gemini-2.5-flash-image-preview", "google/gemini-2.5-flash-lite", "google/gemini-2.5-flash-lite-preview-09-2025", "google/gemini-2.5-flash-preview-09-2025", "google/gemini-2.5-pro", "google/gemini-3-flash-preview", "google/gemini-3-pro-image-preview", "google/gemini-3-pro-preview", "google/gemini-flash-latest", "google/gemini-flash-lite-latest", "google/gemini-pro-latest", "google/gemini-robotics-er-1.5-preview", "google/gemma-3-12b-it", "google/gemma-3-1b-it", "google/gemma-3-27b-it", "google/gemma-3-4b-it", "google/gemma-3n-e2b-it", "google/gemma-3n-e4b-it", "google/nano-banana-pro-preview"];
+/**
+ * Valid Google model IDs.
+ */
+type GoogleKnownModels = (typeof GOOGLE_KNOWN_MODELS_ARRAY)[number];
+
+/**
+ * Google registered LLM models.
+ */
+
+/**
+ * The Google model IDs registered with Mirascope.
+ */
+type GoogleModelId = GoogleKnownModels | (string & {});
+
+/**
+ * Finish reason indicating why the model stopped generating.
+ */
+/**
+ * Possible reasons why generation stopped.
+ */
+declare const FinishReason: {
+    /** Model ran out of tokens. */
+    readonly MAX_TOKENS: "max_tokens";
+    /** Model refused to generate. */
+    readonly REFUSAL: "refusal";
+    /** Context length exceeded. */
+    readonly CONTEXT_LENGTH_EXCEEDED: "context_length_exceeded";
+};
+/**
+ * Type representing a finish reason value.
+ */
+type FinishReason = (typeof FinishReason)[keyof typeof FinishReason];
+
+/**
+ * Token usage tracking for LLM responses.
+ */
+/**
+ * Token usage statistics for a response.
+ */
+interface Usage {
+    /**
+     * Total input tokens (includes cache tokens).
+     */
+    readonly inputTokens: number;
+    /**
+     * Total output tokens (includes reasoning tokens).
+     */
+    readonly outputTokens: number;
+    /**
+     * Tokens read from cache.
+     */
+    readonly cacheReadTokens: number;
+    /**
+     * Tokens written to cache.
+     */
+    readonly cacheWriteTokens: number;
+    /**
+     * Tokens used for thinking/reasoning.
+     */
+    readonly reasoningTokens: number;
+    /**
+     * Provider-specific raw usage object.
+     */
+    readonly raw: unknown;
+}
+/**
+ * Create a Usage object with default values.
+ */
+declare function createUsage(options?: Partial<Usage>): Usage;
+/**
+ * Calculate total tokens from usage.
+ */
+declare function totalTokens(usage: Usage): number;
+
+/**
+ * Shared base of Response implementations.
+ */
+
+/**
+ * Initialization options for creating a BaseResponse.
+ */
+interface BaseResponseInit {
+    /**
+     * The raw response from the LLM provider.
+     */
+    raw: unknown;
+    /**
+     * The provider that generated this response.
+     */
+    providerId: ProviderId;
+    /**
+     * The model ID that generated this response.
+     */
+    modelId: ModelId;
+    /**
+     * Provider-specific model name (may include additional info like API mode).
+     */
+    providerModelName: string;
+    /**
+     * The parameters used to generate this response.
+     */
+    params: Params;
+    /**
+     * The toolkit containing all tools available for this response.
+     * Can be a Toolkit or ContextToolkit.
+     */
+    toolkit: BaseToolkit;
+    /**
+     * The Format describing the structured response format, if any.
+     */
+    format?: Format | null;
+    /**
+     * The input messages (before the assistant response).
+     */
+    inputMessages: readonly Message[];
+    /**
+     * The assistant message containing the response content.
+     */
+    assistantMessage: AssistantMessage;
+    /**
+     * The reason generation stopped, if not normal completion.
+     */
+    finishReason: FinishReason | null;
+    /**
+     * Token usage statistics, if available.
+     */
+    usage: Usage | null;
+}
+/**
+ * Base response class with constructor logic.
+ *
+ * This class processes the assistant message content, organizing it by type
+ * (text, tool calls, thoughts) for easy access.
+ *
+ * @template F - The type of the formatted output when using structured outputs.
+ */
+declare class BaseResponse<F = unknown> extends RootResponse<F> {
+    readonly raw: unknown;
+    readonly providerId: ProviderId;
+    readonly modelId: ModelId;
+    readonly providerModelName: string;
+    readonly params: Params;
+    readonly messages: readonly Message[];
+    readonly content: readonly AssistantContentPart[];
+    readonly texts: readonly Text[];
+    readonly toolCalls: readonly ToolCall[];
+    readonly thoughts: readonly Thought[];
+    readonly finishReason: FinishReason | null;
+    readonly usage: Usage | null;
+    readonly format: Format | null;
+    readonly toolkit: BaseToolkit;
+    constructor(init: BaseResponseInit);
+}
+
+/**
+ * Response class for LLM calls.
+ */
+
+/**
+ * Initialization options for creating a Response.
+ *
+ * Accepts `tools` as either a Toolkit or a list of tools, which gets
+ * converted to a Toolkit before passing to BaseResponse.
+ */
+interface ResponseInit extends Omit<BaseResponseInit, "toolkit"> {
+    /**
+     * The tools available for this response.
+     * Can be a Toolkit instance or an array of tools.
+     */
+    tools?: Tools | Toolkit;
+}
+/**
+ * The response generated by an LLM.
+ *
+ * This is the primary response class for non-streaming LLM calls. Since TypeScript
+ * IO is always async, this single class handles all async response scenarios.
+ *
+ * @template F - The type of the formatted output when using structured outputs.
+ *
+ * @example
+ * ```typescript
+ * const response = await model.call([user("Hello!")]);
+ * console.log(response.text());
+ * ```
+ *
+ * @example With structured output
+ * ```typescript
+ * interface Book { title: string; author: string; }
+ * const response = await model.call<Book>('Recommend a book', { format: BookSchema });
+ * const book = response.parse(); // Type: Book | DeepPartial<Book> | null
+ * ```
+ */
+declare class Response<F = unknown> extends BaseResponse<F> {
+    /**
+     * Override base toolkit with correct type for execute() support.
+     */
+    readonly toolkit: Toolkit;
+    constructor(init: ResponseInit);
+    /**
+     * Execute all tool calls in this response using the registered tools.
+     *
+     * @returns An array of ToolOutput objects, one for each tool call.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.call('What is the weather?', [weatherTool]);
+     * if (response.toolCalls.length > 0) {
+     *   const outputs = await response.executeTools();
+     *   const followUp = await response.resume(outputs);
+     * }
+     * ```
+     */
+    executeTools(): Promise<ToolOutput<Jsonable>[]>;
+    /**
+     * Generate a new Response using this response's messages with additional user content.
+     *
+     * Uses this response's tools and format type. Also uses this response's provider,
+     * model, and params.
+     *
+     * @param content - The new user message content to append to the message history.
+     * @returns A new Response instance generated from the extended message history.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.call('Hello!');
+     * console.log(response.text());
+     *
+     * // Continue the conversation
+     * const followUp = await response.resume('Tell me more about that');
+     * console.log(followUp.text());
+     * ```
+     */
+    resume(content: UserContent): Promise<Response<F>>;
+}
+
+/**
+ * ContextResponse class for context-based LLM calls.
+ *
+ * Extends BaseResponse with context-aware functionality including:
+ * - executeTools(): Execute tool calls with context dependency injection
+ * - resume(): Continue the conversation with additional user content
+ */
+
+/**
+ * Initialization options for creating a ContextResponse.
+ *
+ * Accepts `tools` as either a ContextToolkit or a list of tools, which gets
+ * converted to a ContextToolkit before passing to BaseResponse.
+ *
+ * Supports both regular tools (BaseTool) and context tools (BaseContextTool),
+ * matching Python's `ContextTools[DepsT]` pattern.
+ *
+ * @template DepsT - The type of dependencies in the context.
+ */
+interface ContextResponseInit<DepsT = unknown> extends Omit<BaseResponseInit, "toolkit"> {
+    /**
+     * The tools available for this response.
+     * Can be a ContextToolkit instance or an array of tools.
+     * Accepts both regular tools and context tools.
+     */
+    tools?: ContextTools<DepsT> | ContextToolkit<DepsT>;
+}
+/**
+ * The response generated by an LLM from a context call.
+ *
+ * This class provides context-aware functionality on top of the standard response:
+ * - `executeTools()`: Execute all tool calls with context dependency injection
+ * - `resume()`: Continue the conversation with additional user content
+ *
+ * @template DepsT - The type of dependencies in the context.
+ * @template F - The type of the formatted output when using structured outputs.
+ *
+ * @example
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123' });
+ * const response = await myPrompt(model, ctx);
+ * console.log(response.text());
+ *
+ * // Continue the conversation
+ * const followUp = await response.resume(ctx, 'Tell me more');
+ * ```
+ */
+declare class ContextResponse<DepsT = unknown, F = unknown> extends BaseResponse<F> {
+    /**
+     * The context toolkit containing tools that can receive context.
+     */
+    readonly contextToolkit: ContextToolkit<DepsT>;
+    constructor(init: ContextResponseInit<DepsT>);
+    /**
+     * Execute all tool calls in this response using the registered context tools.
+     *
+     * @param ctx - The context containing dependencies to pass to tools.
+     * @returns An array of ToolOutput objects, one for each tool call.
+     *
+     * @example
+     * ```typescript
+     * const response = await myPrompt(model, ctx, [searchTool]);
+     * if (response.toolCalls.length > 0) {
+     *   const outputs = await response.executeTools(ctx);
+     *   const followUp = await response.resume(ctx, outputs);
+     * }
+     * ```
+     */
+    executeTools(ctx: Context<DepsT>): Promise<ToolOutput<Jsonable>[]>;
+    /**
+     * Generate a new ContextResponse using this response's messages with additional user content.
+     *
+     * Uses this response's tools and format type. Also uses this response's provider,
+     * model, and params.
+     *
+     * @param ctx - A Context with the required deps type.
+     * @param content - The new user message content to append to the message history.
+     * @returns A new ContextResponse instance generated from the extended message history.
+     *
+     * @example
+     * ```typescript
+     * const response = await myPrompt(model, ctx);
+     * console.log(response.text());
+     *
+     * // Continue the conversation
+     * const followUp = await response.resume(ctx, 'Tell me more about that');
+     * console.log(followUp.text());
+     * ```
+     */
+    resume(ctx: Context<DepsT>, content: UserContent): Promise<ContextResponse<DepsT, F>>;
+}
+
+/**
+ * Streaming metadata chunk types for provider-agnostic streaming responses.
+ *
+ * Content-specific chunks (Text, Thought, ToolCall) are defined in content/.
+ * This file only contains metadata chunks.
+ */
+
+/**
+ * Contains the finish reason when the stream completes.
+ */
+interface FinishReasonChunk {
+    readonly type: "finish_reason_chunk";
+    /** The reason the stream finished */
+    readonly finishReason: FinishReason;
+}
+/**
+ * Contains incremental token usage information.
+ */
+interface UsageDeltaChunk {
+    readonly type: "usage_delta_chunk";
+    /** Delta in input tokens */
+    readonly inputTokens: number;
+    /** Delta in output tokens */
+    readonly outputTokens: number;
+    /** Delta in cache read tokens */
+    readonly cacheReadTokens: number;
+    /** Delta in cache write tokens */
+    readonly cacheWriteTokens: number;
+    /** Delta in reasoning/thinking tokens */
+    readonly reasoningTokens: number;
+}
+/**
+ * Contains a raw stream event from the underlying provider.
+ */
+interface RawStreamEventChunk {
+    readonly type: "raw_stream_event_chunk";
+    /** The raw stream event from the underlying provider */
+    readonly rawStreamEvent: unknown;
+}
+/**
+ * Contains provider-specific raw message content.
+ */
+interface RawMessageChunk {
+    readonly type: "raw_message_chunk";
+    /** Provider-specific raw content */
+    readonly rawMessage: Jsonable;
+}
+/**
+ * All possible chunk types in a streaming response.
+ */
+type StreamResponseChunk = AssistantContentChunk | FinishReasonChunk | UsageDeltaChunk | RawStreamEventChunk | RawMessageChunk;
+/**
+ * Async iterator type for streaming chunks.
+ */
+type AsyncChunkIterator = AsyncIterator<StreamResponseChunk>;
+
+/**
+ * Stream classes for streaming assistant content parts.
+ *
+ * Each stream wraps a chunk iterator and provides:
+ * - Async iteration via [Symbol.asyncIterator]() yielding delta strings
+ * - collect() to consume remaining chunks and return the final content object
+ * - Partial accumulation properties to track content as it arrives
+ */
+
+/**
+ * Stream for text content.
+ *
+ * Wraps a TextChunk iterator and yields text delta strings.
+ * Accumulates text in partialText as chunks are consumed.
+ */
+declare class TextStream {
+    readonly type: "text_stream";
+    readonly contentType: "text";
+    /** The accumulated text content as chunks are received. */
+    partialText: string;
+    private _chunkIterator;
+    constructor(chunkIterator: AsyncIterator<TextChunk>);
+    /**
+     * Iterate over text deltas as they are received.
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<string>;
+    /**
+     * Collect all chunks and return the final Text content.
+     */
+    collect(): Promise<Text>;
+}
+/**
+ * Stream for thought/reasoning content.
+ *
+ * Wraps a ThoughtChunk iterator and yields thought delta strings.
+ * Accumulates thought in partialThought as chunks are consumed.
+ */
+declare class ThoughtStream {
+    readonly type: "thought_stream";
+    readonly contentType: "thought";
+    /** The accumulated thought content as chunks are received. */
+    partialThought: string;
+    private _chunkIterator;
+    constructor(chunkIterator: AsyncIterator<ThoughtChunk>);
+    /**
+     * Iterate over thought deltas as they are received.
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<string>;
+    /**
+     * Collect all chunks and return the final Thought content.
+     */
+    collect(): Promise<Thought>;
+}
+/**
+ * Stream for tool call content.
+ *
+ * Wraps a ToolCallChunk iterator and yields argument delta strings.
+ * Accumulates args in partialArgs as chunks are consumed.
+ */
+declare class ToolCallStream {
+    readonly type: "tool_call_stream";
+    readonly contentType: "tool_call";
+    /** A unique identifier for this tool call. */
+    readonly toolId: string;
+    /** The name of the tool being called. */
+    readonly toolName: string;
+    /** The accumulated tool arguments as chunks are received. */
+    partialArgs: string;
+    private _chunkIterator;
+    constructor(toolId: string, toolName: string, chunkIterator: AsyncIterator<ToolCallChunk>);
+    /**
+     * Iterate over tool call argument deltas as they are received.
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<string>;
+    /**
+     * Collect all chunks and return the final ToolCall content.
+     */
+    collect(): Promise<ToolCall>;
+}
+/**
+ * A stream for any assistant content type.
+ */
+type Stream = TextStream | ThoughtStream | ToolCallStream;
+
+/**
+ * BaseStreamResponse class for handling streaming LLM responses.
+ *
+ * Extends RootResponse to provide the standard response interface while adding
+ * streaming-specific methods:
+ * - chunkStream(): Raw chunks as async iterator (with caching for replay)
+ * - textStream(): Text deltas only
+ * - thoughtStream(): Thought deltas only
+ * - structuredStream(): Partial parsed objects for structured output streaming
+ *
+ * Accumulates content as chunks arrive, with final state accessible via
+ * the standard RootResponse interface (text(), content, finishReason, usage, etc.).
+ *
+ * This base class contains all streaming logic but no resume methods.
+ * StreamResponse and ContextStreamResponse extend this class and add their
+ * own resume methods with appropriate signatures.
+ */
+
+/**
+ * Arguments for constructing a BaseStreamResponse.
+ */
+interface BaseStreamResponseInit {
+    /** The provider ID (e.g., 'anthropic', 'openai') */
+    providerId: ProviderId;
+    /** The model ID (e.g., 'anthropic/claude-sonnet-4-20250514') */
+    modelId: ModelId;
+    /** The provider's model name from the response */
+    providerModelName: string;
+    /** Parameters used for the request */
+    params: Params;
+    /** The toolkit containing all tools available for this response */
+    toolkit: BaseToolkit;
+    /** The Format describing the structured response format, if any */
+    format?: Format | null;
+    /** Input messages sent in the request */
+    inputMessages: readonly Message[];
+    /** Async iterator of streaming chunks from the provider */
+    chunkIterator: AsyncIterator<StreamResponseChunk>;
+}
+/**
+ * Base streaming response that consumes chunks from an async iterator.
+ *
+ * Extends RootResponse to provide the standard response interface. Chunks are
+ * processed lazily and cached for replay. Content is accumulated as chunks
+ * arrive, with text/thought objects mutated in place for efficiency.
+ *
+ * This class contains all streaming logic but no resume methods. Subclasses
+ * (StreamResponse, ContextStreamResponse) add their own resume methods.
+ *
+ * @template F - The type of the formatted output when using structured outputs.
+ */
+declare class BaseStreamResponse<F = unknown> extends RootResponse<F> {
+    /** Raw stream events from provider */
+    get raw(): readonly unknown[];
+    readonly providerId: ProviderId;
+    readonly modelId: ModelId;
+    readonly providerModelName: string;
+    readonly params: Params;
+    readonly toolkit: BaseToolkit;
+    readonly format: Format | null;
+    /** Input messages sent in the request */
+    readonly inputMessages: readonly Message[];
+    get messages(): readonly Message[];
+    get content(): readonly AssistantContentPart[];
+    get texts(): readonly Text[];
+    get toolCalls(): readonly ToolCall[];
+    get thoughts(): readonly Thought[];
+    get finishReason(): FinishReason | null;
+    get usage(): Usage | null;
+    /** Cached chunks for replay */
+    private readonly _chunks;
+    /** Accumulated content parts */
+    private readonly _content;
+    /** Accumulated text parts */
+    private readonly _texts;
+    /** Accumulated thought parts */
+    private readonly _thoughts;
+    /** Accumulated tool calls */
+    private readonly _toolCalls;
+    /** Raw stream events from provider */
+    private readonly _rawStreamEvents;
+    /** The chunk iterator from the provider */
+    private _chunkIterator;
+    /** Current content block being built (Text or Thought) */
+    private _currentContent;
+    /** In-progress tool calls tracked by ID (for interleaved streaming) */
+    private readonly _currentToolCalls;
+    /** Whether the iterator has been fully consumed */
+    private _consumed;
+    /** Whether we're currently processing a FORMAT_TOOL call (transforming to text) */
+    private _processingFormatTool;
+    /** Finish reason once stream is complete */
+    private _finishReason;
+    /** Accumulated usage statistics */
+    private _usage;
+    /** Raw message from provider */
+    private _rawMessage;
+    constructor(args: BaseStreamResponseInit);
+    /**
+     * Get the cached chunks.
+     */
+    get chunks(): readonly AssistantContentChunk[];
+    /**
+     * Whether the stream has been fully consumed.
+     */
+    get consumed(): boolean;
+    /**
+     * Get the accumulated thought content.
+     * Joins all thought parts with the specified separator.
+     */
+    thought(separator?: string): string;
+    /**
+     * Build the assistant message from accumulated content.
+     */
+    get assistantMessage(): AssistantMessage;
+    /**
+     * Stream content chunks with caching for replay.
+     *
+     * First yields any cached chunks, then continues consuming from the iterator.
+     * All chunks are cached so subsequent calls can replay from the beginning.
+     */
+    chunkStream(): AsyncGenerator<AssistantContentChunk>;
+    /**
+     * Stream only text deltas.
+     *
+     * Yields the text string from each TextChunk, filtering out other chunk types.
+     */
+    textStream(): AsyncGenerator<string>;
+    /**
+     * Stream only thought deltas.
+     *
+     * Yields the thought string from each ThoughtChunk, filtering out other chunk types.
+     */
+    thoughtStream(): AsyncGenerator<string>;
+    /**
+     * Stream partial parsed objects as they arrive during structured output streaming.
+     *
+     * This method drives the stream forward, parsing the accumulated text content
+     * as partial JSON after each text chunk arrives. The yielded objects may have
+     * missing or incomplete fields early in the stream, gradually becoming complete.
+     *
+     * @yields DeepPartial<F> - Partial objects with fields populated as they arrive.
+     * @throws Error if format was not specified or uses OutputParser.
+     *
+     * @example
+     * ```typescript
+     * interface Book { title: string; author: string; }
+     *
+     * const stream = await model.stream<Book>('Recommend a book', {
+     *   format: BookSchema
+     * });
+     *
+     * for await (const partial of stream.structuredStream()) {
+     *   console.log(partial.title); // May be undefined initially
+     *   console.log(partial.author); // Populated as it arrives
+     * }
+     *
+     * // After stream completes, get the final validated result
+     * const book = stream.parse();
+     * ```
+     */
+    structuredStream(): AsyncGenerator<DeepPartial<F>>;
+    /**
+     * Consume the entire stream without processing chunks.
+     * Useful when you just want the final accumulated state.
+     */
+    consume(): Promise<void>;
+    /**
+     * Returns an async iterator that yields streams for each content part in the response.
+     *
+     * Each content part in the response will correspond to one stream, which will yield
+     * chunks of content as they come in from the underlying LLM.
+     *
+     * Fully iterating through this iterator will fully consume the underlying stream,
+     * updating the Response with all collected content.
+     *
+     * As content is consumed, it is cached on the StreamResponse. If a new iterator
+     * is constructed via calling `streams()`, it will start by replaying the cached
+     * content from the response, and (if there is still more content to consume from
+     * the LLM), it will proceed to consume it once it has iterated through all the
+     * cached chunks.
+     */
+    streams(): AsyncGenerator<Stream>;
+    /**
+     * Replace the chunk iterator with a wrapped version.
+     * Used internally by providers to wrap errors during iteration.
+     * @internal
+     */
+    wrapChunkIterator(wrapper: (iterator: AsyncIterator<StreamResponseChunk>) => AsyncIterator<StreamResponseChunk>): void;
+    /**
+     * Transform FORMAT_TOOL chunks to text chunks.
+     *
+     * When the format uses tool mode, the LLM generates tool calls to the
+     * FORMAT_TOOL. These chunks are transformed to text chunks so that the
+     * structured output appears as text content for parse() to consume.
+     *
+     * @param chunk - The original chunk from the provider.
+     * @returns The transformed chunk (tool_call → text) or the original chunk.
+     */
+    private _transformFormatToolChunk;
+    /**
+     * Process a single chunk, handling metadata and content accumulation.
+     * Returns the content chunk if it should be yielded, null otherwise.
+     */
+    private _processChunk;
+    /**
+     * Handle text chunks, accumulating content.
+     */
+    private _handleTextChunk;
+    /**
+     * Handle thought chunks, accumulating content.
+     */
+    private _handleThoughtChunk;
+    /**
+     * Handle tool call chunks, accumulating content.
+     *
+     * Unlike text/thought which are added immediately to content,
+     * tool calls are only added once the end chunk is received.
+     * Multiple tool calls can be in progress simultaneously (interleaved).
+     */
+    private _handleToolCallChunk;
+    /**
+     * Accumulate usage statistics from a usage delta chunk.
+     */
+    private _accumulateUsage;
+}
+
+/**
+ * StreamResponse class for handling streaming LLM responses.
+ *
+ * Extends BaseStreamResponse with resume methods for continuing conversations.
+ */
+
+/**
+ * Arguments for constructing a StreamResponse.
+ *
+ * Accepts `tools` as either a Toolkit or a list of tools, which gets
+ * converted to a Toolkit before passing to BaseStreamResponse.
+ */
+interface StreamResponseInit extends Omit<BaseStreamResponseInit, "toolkit"> {
+    /**
+     * The tools available for this response.
+     * Can be a Toolkit instance or an array of tools.
+     */
+    tools?: Tools | Toolkit;
+}
+/**
+ * Streaming response that consumes chunks from an async iterator.
+ *
+ * Extends BaseStreamResponse to provide the standard streaming interface,
+ * adding resume methods for continuing conversations.
+ *
+ * @template F - The type of the formatted output when using structured outputs.
+ *
+ * @example
+ * ```typescript
+ * const response = await model.stream('Hello!');
+ *
+ * for await (const text of response.textStream()) {
+ *   process.stdout.write(text);
+ * }
+ *
+ * // Continue the conversation
+ * const followUp = await response.resume('Tell me more');
+ * ```
+ *
+ * @example With structured output
+ * ```typescript
+ * interface Book { title: string; author: string; }
+ * const response = await model.stream<Book>('Recommend a book', { format: BookSchema });
+ * for await (const partial of response.structuredStream()) {
+ *   console.log(partial.title); // Typed as DeepPartial<Book>
+ * }
+ * ```
+ */
+declare class StreamResponse<F = unknown> extends BaseStreamResponse<F> {
+    /**
+     * Override base toolkit with correct type for execute() support.
+     */
+    readonly toolkit: Toolkit;
+    constructor(args: StreamResponseInit);
+    /**
+     * Execute all tool calls in this response using the registered tools.
+     *
+     * Note: The stream must be consumed before calling executeTools() to ensure
+     * all tool calls have been received.
+     *
+     * @returns An array of ToolOutput objects, one for each tool call.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.stream('What is the weather?', [weatherTool]);
+     *
+     * // Consume the stream first
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     *
+     * // Then execute tools
+     * if (response.toolCalls.length > 0) {
+     *   const outputs = await response.executeTools();
+     *   const followUp = await response.resume(outputs);
+     * }
+     * ```
+     */
+    executeTools(): Promise<ToolOutput<Jsonable>[]>;
+    /**
+     * Generate a new StreamResponse using this response's messages with additional user content.
+     *
+     * Uses this response's tools and format type. Also uses this response's provider,
+     * model, and params.
+     *
+     * Note: The stream must be consumed before calling resume() to ensure
+     * the assistant message is complete.
+     *
+     * @param content - The new user message content to append to the message history.
+     * @returns A new StreamResponse instance generated from the extended message history.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.stream('Hello!');
+     *
+     * // Consume the stream first
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     *
+     * // Then resume with streaming
+     * const followUp = await response.resume('Tell me more about that');
+     * for await (const text of followUp.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    resume(content: UserContent): Promise<StreamResponse<F>>;
+}
+
+/**
+ * ContextStreamResponse class for context-based streaming LLM calls.
+ *
+ * Extends BaseStreamResponse with context-aware functionality including:
+ * - executeTools(): Execute tool calls with context dependency injection
+ * - resume(): Continue the conversation with additional user content
+ */
+
+/**
+ * Arguments for constructing a ContextStreamResponse.
+ *
+ * Accepts `tools` as either a ContextToolkit or a list of tools, which gets
+ * converted to a ContextToolkit before passing to BaseStreamResponse.
+ *
+ * Supports both regular tools (BaseTool) and context tools (BaseContextTool),
+ * matching Python's `ContextTools[DepsT]` pattern.
+ *
+ * @template DepsT - The type of dependencies in the context.
+ */
+interface ContextStreamResponseInit<DepsT = unknown> extends Omit<BaseStreamResponseInit, "toolkit"> {
+    /**
+     * The tools available for this response.
+     * Can be a ContextToolkit instance or an array of tools.
+     * Accepts both regular tools and context tools.
+     */
+    tools?: ContextTools<DepsT> | ContextToolkit<DepsT>;
+}
+/**
+ * A streaming response from a context-based LLM call.
+ *
+ * This class provides context-aware functionality on top of the standard streaming response:
+ * - `executeTools()`: Execute all tool calls with context dependency injection
+ * - `resume()`: Continue the conversation with additional user content
+ *
+ * @template DepsT - The type of dependencies in the context.
+ * @template F - The type of the formatted output when using structured outputs.
+ *
+ * @example
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123' });
+ * const response = await myPrompt.stream(model, ctx);
+ *
+ * for await (const text of response.textStream()) {
+ *   process.stdout.write(text);
+ * }
+ *
+ * // Continue the conversation
+ * const followUp = await response.resume(ctx, 'Tell me more');
+ * ```
+ */
+declare class ContextStreamResponse<DepsT = unknown, F = unknown> extends BaseStreamResponse<F> {
+    /**
+     * The context toolkit containing tools that can receive context.
+     */
+    readonly contextToolkit: ContextToolkit<DepsT>;
+    constructor(args: ContextStreamResponseInit<DepsT>);
+    /**
+     * Execute all tool calls in this response using the registered context tools.
+     *
+     * Note: The stream must be consumed before calling executeTools() to ensure
+     * all tool calls have been received.
+     *
+     * @param ctx - The context containing dependencies to pass to tools.
+     * @returns An array of ToolOutput objects, one for each tool call.
+     *
+     * @example
+     * ```typescript
+     * const response = await myPrompt.stream(model, ctx, [searchTool]);
+     *
+     * // Consume the stream first
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     *
+     * // Then execute tools
+     * if (response.toolCalls.length > 0) {
+     *   const outputs = await response.executeTools(ctx);
+     *   const followUp = await response.resume(ctx, outputs);
+     * }
+     * ```
+     */
+    executeTools(ctx: Context<DepsT>): Promise<ToolOutput<Jsonable>[]>;
+    /**
+     * Generate a new ContextStreamResponse using this response's messages with additional user content.
+     *
+     * Uses this response's tools and format type. Also uses this response's provider,
+     * model, and params.
+     *
+     * Note: The stream must be consumed before calling resume() to ensure
+     * the assistant message is complete.
+     *
+     * @param ctx - A Context with the required deps type.
+     * @param content - The new user message content to append to the message history.
+     * @returns A new ContextStreamResponse instance generated from the extended message history.
+     *
+     * @example
+     * ```typescript
+     * const response = await myPrompt.stream(model, ctx);
+     *
+     * // Consume the stream first
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     *
+     * // Then resume with streaming
+     * const followUp = await response.resume(ctx, 'Tell me more about that');
+     * for await (const text of followUp.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    resume(ctx: Context<DepsT>, content: UserContent): Promise<ContextStreamResponse<DepsT, F>>;
+}
+
+/**
+ * OpenAI model information.
+ *
+ * This file is auto-generated by typescript/scripts/codegen/openai.ts
+ * Do not edit manually - run `bun run codegen` to update.
+ */
+/**
+ * Array of all known OpenAI model IDs.
+ * This is the source of truth - the type and Set are derived from it.
+ */
+declare const OPENAI_KNOWN_MODELS_ARRAY: readonly ["openai/chatgpt-4o-latest", "openai/chatgpt-4o-latest:completions", "openai/chatgpt-4o-latest:responses", "openai/codex-mini-latest", "openai/codex-mini-latest:responses", "openai/gpt-3.5-turbo", "openai/gpt-3.5-turbo:completions", "openai/gpt-3.5-turbo:responses", "openai/gpt-3.5-turbo-0125", "openai/gpt-3.5-turbo-0125:completions", "openai/gpt-3.5-turbo-0125:responses", "openai/gpt-3.5-turbo-1106", "openai/gpt-3.5-turbo-1106:completions", "openai/gpt-3.5-turbo-1106:responses", "openai/gpt-3.5-turbo-16k", "openai/gpt-3.5-turbo-16k:completions", "openai/gpt-4", "openai/gpt-4:completions", "openai/gpt-4:responses", "openai/gpt-4-0125-preview", "openai/gpt-4-0125-preview:completions", "openai/gpt-4-0125-preview:responses", "openai/gpt-4-0613", "openai/gpt-4-0613:completions", "openai/gpt-4-0613:responses", "openai/gpt-4-1106-preview", "openai/gpt-4-1106-preview:completions", "openai/gpt-4-1106-preview:responses", "openai/gpt-4-turbo", "openai/gpt-4-turbo:completions", "openai/gpt-4-turbo:responses", "openai/gpt-4-turbo-2024-04-09", "openai/gpt-4-turbo-2024-04-09:completions", "openai/gpt-4-turbo-2024-04-09:responses", "openai/gpt-4-turbo-preview", "openai/gpt-4-turbo-preview:completions", "openai/gpt-4-turbo-preview:responses", "openai/gpt-4.1", "openai/gpt-4.1:completions", "openai/gpt-4.1:responses", "openai/gpt-4.1-2025-04-14", "openai/gpt-4.1-2025-04-14:completions", "openai/gpt-4.1-2025-04-14:responses", "openai/gpt-4.1-mini", "openai/gpt-4.1-mini:completions", "openai/gpt-4.1-mini:responses", "openai/gpt-4.1-mini-2025-04-14", "openai/gpt-4.1-mini-2025-04-14:completions", "openai/gpt-4.1-mini-2025-04-14:responses", "openai/gpt-4.1-nano", "openai/gpt-4.1-nano:completions", "openai/gpt-4.1-nano:responses", "openai/gpt-4.1-nano-2025-04-14", "openai/gpt-4.1-nano-2025-04-14:completions", "openai/gpt-4.1-nano-2025-04-14:responses", "openai/gpt-4o", "openai/gpt-4o:completions", "openai/gpt-4o:responses", "openai/gpt-4o-2024-05-13", "openai/gpt-4o-2024-05-13:completions", "openai/gpt-4o-2024-05-13:responses", "openai/gpt-4o-2024-08-06", "openai/gpt-4o-2024-08-06:completions", "openai/gpt-4o-2024-08-06:responses", "openai/gpt-4o-2024-11-20", "openai/gpt-4o-2024-11-20:completions", "openai/gpt-4o-2024-11-20:responses", "openai/gpt-4o-mini", "openai/gpt-4o-mini:completions", "openai/gpt-4o-mini:responses", "openai/gpt-4o-mini-2024-07-18", "openai/gpt-4o-mini-2024-07-18:completions", "openai/gpt-4o-mini-2024-07-18:responses", "openai/gpt-4o-mini-search-preview", "openai/gpt-4o-mini-search-preview:completions", "openai/gpt-4o-mini-search-preview-2025-03-11", "openai/gpt-4o-mini-search-preview-2025-03-11:completions", "openai/gpt-4o-search-preview", "openai/gpt-4o-search-preview:completions", "openai/gpt-4o-search-preview-2025-03-11", "openai/gpt-4o-search-preview-2025-03-11:completions", "openai/gpt-5", "openai/gpt-5:completions", "openai/gpt-5:responses", "openai/gpt-5-2025-08-07", "openai/gpt-5-2025-08-07:completions", "openai/gpt-5-2025-08-07:responses", "openai/gpt-5-chat-latest", "openai/gpt-5-chat-latest:completions", "openai/gpt-5-chat-latest:responses", "openai/gpt-5-codex", "openai/gpt-5-codex:responses", "openai/gpt-5-mini", "openai/gpt-5-mini:completions", "openai/gpt-5-mini:responses", "openai/gpt-5-mini-2025-08-07", "openai/gpt-5-mini-2025-08-07:completions", "openai/gpt-5-mini-2025-08-07:responses", "openai/gpt-5-nano", "openai/gpt-5-nano:completions", "openai/gpt-5-nano:responses", "openai/gpt-5-nano-2025-08-07", "openai/gpt-5-nano-2025-08-07:completions", "openai/gpt-5-nano-2025-08-07:responses", "openai/gpt-5-pro", "openai/gpt-5-pro:responses", "openai/gpt-5-pro-2025-10-06", "openai/gpt-5-pro-2025-10-06:responses", "openai/gpt-5-search-api", "openai/gpt-5-search-api:completions", "openai/gpt-5-search-api-2025-10-14", "openai/gpt-5-search-api-2025-10-14:completions", "openai/gpt-5.1", "openai/gpt-5.1:responses", "openai/gpt-5.1-2025-11-13", "openai/gpt-5.1-2025-11-13:responses", "openai/gpt-5.1-chat-latest", "openai/gpt-5.1-chat-latest:completions", "openai/gpt-5.1-chat-latest:responses", "openai/gpt-5.1-codex", "openai/gpt-5.1-codex:responses", "openai/gpt-5.1-codex-max", "openai/gpt-5.1-codex-max:responses", "openai/gpt-5.1-codex-mini", "openai/gpt-5.1-codex-mini:responses", "openai/gpt-5.2", "openai/gpt-5.2:completions", "openai/gpt-5.2:responses", "openai/gpt-5.2-2025-12-11", "openai/gpt-5.2-2025-12-11:completions", "openai/gpt-5.2-2025-12-11:responses", "openai/gpt-5.2-chat-latest", "openai/gpt-5.2-chat-latest:completions", "openai/gpt-5.2-chat-latest:responses", "openai/gpt-5.2-pro", "openai/gpt-5.2-pro:responses", "openai/gpt-5.2-pro-2025-12-11", "openai/gpt-5.2-pro-2025-12-11:responses", "openai/o1", "openai/o1:completions", "openai/o1:responses", "openai/o1-2024-12-17", "openai/o1-2024-12-17:completions", "openai/o1-2024-12-17:responses", "openai/o1-pro", "openai/o1-pro:responses", "openai/o1-pro-2025-03-19", "openai/o1-pro-2025-03-19:responses", "openai/o3", "openai/o3:completions", "openai/o3:responses", "openai/o3-2025-04-16", "openai/o3-2025-04-16:completions", "openai/o3-2025-04-16:responses", "openai/o3-mini", "openai/o3-mini:completions", "openai/o3-mini:responses", "openai/o3-mini-2025-01-31", "openai/o3-mini-2025-01-31:completions", "openai/o3-mini-2025-01-31:responses", "openai/o3-pro", "openai/o3-pro:responses", "openai/o3-pro-2025-06-10", "openai/o3-pro-2025-06-10:responses", "openai/o4-mini", "openai/o4-mini:completions", "openai/o4-mini:responses", "openai/o4-mini-2025-04-16", "openai/o4-mini-2025-04-16:completions", "openai/o4-mini-2025-04-16:responses"];
+/**
+ * Valid OpenAI model IDs including API-specific variants.
+ */
+type OpenAIKnownModels = (typeof OPENAI_KNOWN_MODELS_ARRAY)[number];
+
+/**
+ * OpenAI model IDs and related utilities.
+ */
+
+/**
+ * The OpenAI model IDs registered with Mirascope.
+ */
+type OpenAIModelId = OpenAIKnownModels | (string & {});
+/**
+ * API mode for OpenAI requests.
+ */
+type ApiMode = "responses" | "completions";
+
+/**
+ * Union of all provider model IDs.
+ */
+
+/**
+ * Model identifier for any supported provider.
+ *
+ * This is a union of all provider-specific model IDs.
+ */
+type ModelId = AnthropicModelId | GoogleModelId | OpenAIModelId | (string & {});
+
+/**
+ * Identifiers for all registered providers.
+ */
+/**
+ * Array of known provider IDs for runtime checks.
+ */
+declare const KNOWN_PROVIDER_IDS: readonly ["anthropic", "google", "mirascope", "ollama", "openai", "together"];
+/**
+ * Known provider identifiers.
+ */
+type KnownProviderId = (typeof KNOWN_PROVIDER_IDS)[number];
+/**
+ * Provider identifier.
+ *
+ * Can be a known provider or any custom string for extensibility.
+ */
+type ProviderId = KnownProviderId | (string & {});
+
+/**
+ * The Model class - unified interface for LLM calls.
+ */
+
+/**
+ * The unified LLM interface that delegates to provider-specific clients.
+ *
+ * This class provides a consistent interface for interacting with language models
+ * from various providers. It handles the common operations like generating responses
+ * by delegating to the appropriate provider methods.
+ *
+ * @example
+ * ```typescript
+ * import { Model } from 'mirascope/llm';
+ *
+ * const model = new Model('anthropic/claude-sonnet-4-20250514');
+ * const response = await model.call('Hello!');
+ * console.log(response.text());
+ * ```
+ *
+ * @example With parameters
+ * ```typescript
+ * const model = new Model('anthropic/claude-sonnet-4-20250514', {
+ *   temperature: 0.7,
+ *   maxTokens: 1000,
+ * });
+ * const response = await model.call('Write a haiku about coding.');
+ * ```
+ */
+declare class Model {
+    /**
+     * The model ID being used (e.g., "anthropic/claude-sonnet-4-20250514").
+     */
+    readonly modelId: ModelId;
+    /**
+     * The default parameters for the model (temperature, maxTokens, etc.).
+     */
+    readonly params: Params;
+    /**
+     * Initialize the Model with a model ID and optional parameters.
+     *
+     * @param modelId - The model ID in "provider/model-name" format.
+     * @param params - Optional parameters for the model.
+     * @throws Error if the model ID format is invalid.
+     */
+    constructor(modelId: ModelId, params?: Params);
+    /**
+     * The provider being used (e.g., an AnthropicProvider).
+     *
+     * This property dynamically looks up the provider from the registry based on
+     * the current modelId. This allows provider overrides via registerProvider()
+     * to take effect even after the model instance is created.
+     *
+     * @throws NoRegisteredProviderError if no provider is available for the modelId.
+     */
+    get provider(): BaseProvider;
+    /**
+     * The string ID of the provider being used (e.g., "anthropic").
+     *
+     * @throws NoRegisteredProviderError if no provider is available for the modelId.
+     */
+    get providerId(): ProviderId;
+    /**
+     * Generate a Response by calling this model's LLM provider.
+     *
+     * @param content - Content to send to the LLM. Can be a string (converted to user
+     *   message), UserContent, a sequence of UserContent, or a sequence of Messages
+     *   for full control.
+     * @param options - Optional configuration for the call.
+     * @param options.tools - Optional tools to make available to the model.
+     * @param options.format - Optional format for structured output.
+     * @returns A Response object containing the LLM-generated content.
+     *
+     * @example Simple string input
+     * ```typescript
+     * const response = await model.call('What is the capital of France?');
+     * console.log(response.text());
+     * ```
+     *
+     * @example With message array
+     * ```typescript
+     * import { system, user } from 'mirascope/llm/messages';
+     *
+     * const response = await model.call([
+     *   system('You are a helpful assistant.'),
+     *   user('What is the capital of France?'),
+     * ]);
+     * ```
+     *
+     * @example With structured output format
+     * ```typescript
+     * import { defineFormat } from 'mirascope/llm';
+     *
+     * interface Book { title: string; author: string; }
+     * const bookFormat = defineFormat<Book>({ mode: 'tool' });
+     *
+     * const response = await model.call('Recommend a book', { format: bookFormat });
+     * const book = response.parse<Book>();
+     * ```
+     */
+    call(content: UserContent | readonly Message[], options?: {
+        tools?: Tools;
+        format?: Format | null;
+    }): Promise<Response>;
+    /**
+     * Generate a streaming Response by calling this model's LLM provider.
+     *
+     * @param content - Content to send to the LLM. Can be a string (converted to user
+     *   message), UserContent, a sequence of UserContent, or a sequence of Messages
+     *   for full control.
+     * @param options - Optional configuration for the stream.
+     * @param options.tools - Optional tools to make available to the model.
+     * @param options.format - Optional format for structured output.
+     * @returns A StreamResponse object for consuming the streamed content.
+     *
+     * @example Simple string input
+     * ```typescript
+     * const response = await model.stream('What is the capital of France?');
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     *
+     * @example With message array
+     * ```typescript
+     * import { system, user } from 'mirascope/llm/messages';
+     *
+     * const response = await model.stream([
+     *   system('You are a helpful assistant.'),
+     *   user('What is the capital of France?'),
+     * ]);
+     *
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     *
+     * // After consuming the stream, get the full text
+     * console.log(response.text());
+     * ```
+     *
+     * @example With structured streaming
+     * ```typescript
+     * import { defineFormat } from 'mirascope/llm';
+     *
+     * interface Book { title: string; author: string; }
+     * const bookFormat = defineFormat<Book>({ mode: 'tool' });
+     *
+     * const response = await model.stream('Recommend a book', { format: bookFormat });
+     * for await (const partial of response.structuredStream<Book>()) {
+     *   console.log('Partial:', partial);
+     * }
+     * const book = response.parse<Book>();
+     * ```
+     */
+    stream(content: UserContent | readonly Message[], options?: {
+        tools?: Tools;
+        format?: Format | null;
+    }): Promise<StreamResponse>;
+    /**
+     * Generate a ContextResponse by calling this model's LLM provider with context.
+     *
+     * This method accepts a context for dependency injection, enabling context-aware
+     * tools and prompts.
+     *
+     * @template DepsT - The type of dependencies in the context.
+     * @param ctx - The context containing dependencies for tools.
+     * @param content - Content to send to the LLM.
+     * @param options - Optional configuration for the call.
+     * @param options.tools - Optional tools to make available to the model.
+     * @param options.format - Optional format for structured output.
+     * @returns A ContextResponse object containing the LLM-generated content.
+     *
+     * @example
+     * ```typescript
+     * interface MyDeps { userId: string; }
+     *
+     * const ctx = createContext<MyDeps>({ userId: '123' });
+     * const response = await model.contextCall(ctx, 'Hello!');
+     * console.log(response.text());
+     * ```
+     */
+    contextCall<DepsT>(ctx: Context<DepsT>, content: UserContent | readonly Message[], options?: {
+        tools?: ContextTools<DepsT>;
+        format?: Format | null;
+    }): Promise<ContextResponse<DepsT>>;
+    /**
+     * Generate a streaming ContextStreamResponse by calling this model's LLM provider with context.
+     *
+     * This method accepts a context for dependency injection, enabling context-aware
+     * tools and prompts.
+     *
+     * @template DepsT - The type of dependencies in the context.
+     * @param ctx - The context containing dependencies for tools.
+     * @param content - Content to send to the LLM.
+     * @param options - Optional configuration for the stream.
+     * @param options.tools - Optional tools to make available to the model.
+     * @param options.format - Optional format for structured output.
+     * @returns A ContextStreamResponse object for consuming the streamed content.
+     *
+     * @example
+     * ```typescript
+     * interface MyDeps { userId: string; }
+     *
+     * const ctx = createContext<MyDeps>({ userId: '123' });
+     * const response = await model.contextStream(ctx, 'Hello!');
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    contextStream<DepsT>(ctx: Context<DepsT>, content: UserContent | readonly Message[], options?: {
+        tools?: ContextTools<DepsT>;
+        format?: Format | null;
+    }): Promise<ContextStreamResponse<DepsT>>;
+    /**
+     * Generate a new Response by extending a previous response's messages with additional user content.
+     *
+     * Uses the previous response's tools and output format, and this model's params.
+     *
+     * @param response - Previous response to extend.
+     * @param content - Additional user content to append.
+     * @returns A new Response object containing the extended conversation.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.call('Hello!');
+     * const followUp = await model.resume(response, 'Tell me more');
+     * console.log(followUp.text());
+     * ```
+     */
+    resume(response: RootResponse, content: UserContent): Promise<Response>;
+    /**
+     * Generate a new StreamResponse by extending a previous response's messages with additional user content.
+     *
+     * Uses the previous response's tools and output format, and this model's params.
+     *
+     * @param response - Previous response to extend.
+     * @param content - Additional user content to append.
+     * @returns A new StreamResponse object for consuming the streamed content.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.call('Hello!');
+     * const followUp = await model.resumeStream(response, 'Tell me more');
+     * for await (const text of followUp.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    resumeStream(response: RootResponse, content: UserContent): Promise<StreamResponse>;
+    /**
+     * Generate a new ContextResponse by extending a previous response's messages with additional user content.
+     *
+     * Uses the previous response's tools and output format, and this model's params.
+     *
+     * @template DepsT - The type of dependencies in the context.
+     * @param ctx - The context containing dependencies for tools.
+     * @param response - Previous response to extend.
+     * @param content - Additional user content to append.
+     * @returns A new ContextResponse object containing the extended conversation.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.contextCall(ctx, 'Hello!');
+     * const followUp = await model.contextResume(ctx, response, 'Tell me more');
+     * console.log(followUp.text());
+     * ```
+     */
+    contextResume<DepsT>(ctx: Context<DepsT>, response: RootResponse, content: UserContent): Promise<ContextResponse<DepsT>>;
+    /**
+     * Generate a new ContextStreamResponse by extending a previous response's messages with additional user content.
+     *
+     * Uses the previous response's tools and output format, and this model's params.
+     *
+     * @template DepsT - The type of dependencies in the context.
+     * @param ctx - The context containing dependencies for tools.
+     * @param response - Previous response to extend.
+     * @param content - Additional user content to append.
+     * @returns A new ContextStreamResponse object for consuming the streamed content.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.contextStream(ctx, 'Hello!');
+     * await response.consume();
+     * const followUp = await model.contextResumeStream(ctx, response, 'Tell me more');
+     * for await (const text of followUp.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    contextResumeStream<DepsT>(ctx: Context<DepsT>, response: RootResponse, content: UserContent): Promise<ContextStreamResponse<DepsT>>;
+}
+/**
+ * Helper for creating a Model instance.
+ *
+ * This is just an alias for the Model constructor, added for convenience.
+ *
+ * @param modelId - A model ID string (e.g., "anthropic/claude-sonnet-4-20250514").
+ * @param params - Optional parameters to configure the model.
+ * @returns A Model instance.
+ *
+ * @example
+ * ```typescript
+ * import { model } from 'mirascope/llm';
+ *
+ * const m = model('anthropic/claude-sonnet-4-20250514');
+ * const response = await m.call('Hello!');
+ * ```
+ */
+declare function model(modelId: ModelId, params?: Params): Model;
+
+/**
+ * Model context management for runtime model switching.
+ *
+ * This module provides a way to set a model context that overrides
+ * the default model in `defineCall` and `definePrompt`, similar to
+ * Python's `with llm.model(...):` context manager.
+ *
+ * ## Cross-Platform Implementation
+ *
+ * - **Node.js**: Uses native `AsyncLocalStorage` from `async_hooks` for proper
+ *   async context propagation. This handles concurrent async operations correctly.
+ *
+ * - **Browser**: Uses a stack-based fallback. This works correctly for:
+ *   - Synchronous code
+ *   - Sequential async/await chains
+ *   - Nested `withModel` calls (as long as they are sequential)
+ *
+ * ## Browser Limitations
+ *
+ * The browser fallback has a known limitation with **concurrent** async operations:
+ *
+ * ```typescript
+ * // WARNING: In browsers, this may have unexpected behavior:
+ * await Promise.all([
+ *   llm.withModel(modelA, async () => { await call(); }), // May see modelB!
+ *   llm.withModel(modelB, async () => { await call(); }), // May see modelA!
+ * ]);
+ * ```
+ *
+ * This is because the browser lacks a native async context mechanism. The stack
+ * can become interleaved when multiple async operations run concurrently.
+ *
+ * ## Future: TC39 AsyncContext Proposal
+ *
+ * The TC39 "Async Context" proposal (https://github.com/tc39/proposal-async-context)
+ * aims to bring `AsyncLocalStorage`-like functionality to all JavaScript environments.
+ * Once this proposal is standardized and widely supported, we can update the browser
+ * implementation to use native async context, eliminating the concurrent operation
+ * limitation.
+ *
+ * @see https://github.com/tc39/proposal-async-context
+ *
+ * @example
+ * ```typescript
+ * const call = llm.defineCall({
+ *   model: llm.model("openai/gpt-4o"),
+ *   template: () => "Hello"
+ * });
+ *
+ * // Without context - uses default model
+ * await call();
+ *
+ * // With context - overrides default
+ * await llm.withModel(llm.model("anthropic/claude-sonnet-4-0"), async () => {
+ *   await call(); // Uses Claude
+ * });
+ * ```
+ */
+
+/**
+ * Get the model currently set via context, if any.
+ *
+ * @returns The current context model, or undefined if none is set.
+ *
+ * @example
+ * ```typescript
+ * await llm.withModel(llm.model("anthropic/claude-sonnet-4-0"), async () => {
+ *   const model = llm.modelFromContext();
+ *   console.log(model?.modelId); // "anthropic/claude-sonnet-4-0"
+ * });
+ *
+ * const outsideModel = llm.modelFromContext(); // undefined
+ * ```
+ */
+declare function modelFromContext(): Model | undefined;
+/**
+ * Execute a function with a model set in context.
+ *
+ * All calls to `defineCall` and `definePrompt` within the callback
+ * will use the context model instead of their default model.
+ *
+ * @param model - The model to set in context (Model instance or model ID string).
+ * @param paramsOrFn - Either params object (if using string model ID) or the function to execute.
+ * @param fn - The function to execute (if params were provided).
+ * @returns The return value of the function.
+ *
+ * @example With Model instance
+ * ```typescript
+ * const response = await llm.withModel(llm.model("openai/gpt-4o"), async () => {
+ *   return await call();
+ * });
+ * ```
+ *
+ * @example With model ID string
+ * ```typescript
+ * const response = await llm.withModel("openai/gpt-4o", async () => {
+ *   return await call();
+ * });
+ * ```
+ *
+ * @example With model ID and params
+ * ```typescript
+ * const response = await llm.withModel("anthropic/claude-sonnet-4-0", { temperature: 0.9 }, async () => {
+ *   return await call();
+ * });
+ * ```
+ *
+ * @example Nested contexts
+ * ```typescript
+ * await llm.withModel("anthropic/claude-sonnet-4-0", async () => {
+ *   const model1 = llm.modelFromContext(); // Claude
+ *
+ *   await llm.withModel("openai/gpt-4o", async () => {
+ *     const model2 = llm.modelFromContext(); // GPT-4o
+ *   });
+ *
+ *   const model3 = llm.modelFromContext(); // Claude (restored)
+ * });
+ * ```
+ */
+declare function withModel<T>(model: Model, fn: () => T): T;
+declare function withModel<T>(modelId: ModelId, fn: () => T): T;
+declare function withModel<T>(modelId: ModelId, params: Params, fn: () => T): T;
+/**
+ * Get the model from context if available, otherwise use the provided model.
+ *
+ * This function implements the fallback pattern:
+ * 1. If a model is set in context, return it (context takes precedence)
+ * 2. Otherwise, if a Model instance is provided, return it
+ * 3. Otherwise, if a string model ID is provided, create a new Model
+ *
+ * @param modelOrId - A Model instance or model ID string.
+ * @param params - Optional parameters when creating a new Model from string ID.
+ * @returns The resolved Model instance.
+ *
+ * @example
+ * ```typescript
+ * // Outside context - returns the provided model
+ * const model1 = llm.useModel("openai/gpt-4o"); // Creates new Model
+ *
+ * // Inside context - returns context model
+ * await llm.withModel(llm.model("anthropic/claude-sonnet-4-0"), async () => {
+ *   const model2 = llm.useModel("openai/gpt-4o"); // Returns Claude model
+ * });
+ * ```
+ */
+declare function useModel(model: Model | ModelId, params?: Params): Model;
+
+/**
+ * Base interface for all LLM responses.
+ */
+
+/**
+ * Type alias for RootResponse with any format type.
+ * Useful for functions that accept any response type.
+ */
+type AnyResponse = RootResponse<unknown>;
+/**
+ * Base class for LLM responses.
+ *
+ * This abstract class defines the core interface that all response types must implement.
+ * It provides the common properties and methods shared across all response variants.
+ *
+ * @template F - The type of the formatted output when using structured outputs.
+ */
+declare abstract class RootResponse<F = unknown> {
+    /**
+     * The raw response from the LLM.
+     */
+    abstract readonly raw: unknown;
+    /**
+     * The provider that generated this response.
+     */
+    abstract readonly providerId: ProviderId;
+    /**
+     * The model ID that generated this response.
+     */
+    abstract readonly modelId: ModelId;
+    /**
+     * Provider-specific model name (may include additional info like API mode).
+     */
+    abstract readonly providerModelName: string;
+    /**
+     * The parameters used to generate this response.
+     */
+    abstract readonly params: Params;
+    /**
+     * The message history, including the most recent assistant message.
+     */
+    abstract readonly messages: readonly Message[];
+    /**
+     * The content generated by the LLM.
+     */
+    abstract readonly content: readonly AssistantContentPart[];
+    /**
+     * The text content in the generated response, if any.
+     */
+    abstract readonly texts: readonly Text[];
+    /**
+     * The tools the LLM wants called on its behalf, if any.
+     */
+    abstract readonly toolCalls: readonly ToolCall[];
+    /**
+     * The readable thoughts from the model's thinking process, if any.
+     *
+     * The thoughts may be direct output from the model thinking process, or may be a
+     * generated summary. (This depends on the provider; newer models tend to summarize.)
+     */
+    abstract readonly thoughts: readonly Thought[];
+    /**
+     * The reason why the LLM finished generating a response, if set.
+     *
+     * `finishReason` is only set if the response did not finish generating normally,
+     * e.g. `FinishReason.MAX_TOKENS` if the model ran out of tokens before completing.
+     * When the response generates normally, `response.finishReason` will be `null`.
+     */
+    abstract readonly finishReason: FinishReason | null;
+    /**
+     * Token usage statistics for this response, if available.
+     */
+    abstract readonly usage: Usage | null;
+    /**
+     * The Format describing the structured response format, if available.
+     *
+     * When a format is specified in the call, this contains the resolved Format
+     * with schema and validator information used for parsing.
+     */
+    abstract readonly format: Format | null;
+    /**
+     * Return all text content from this response as a single string.
+     *
+     * Joins the text from all `Text` parts in the response content using the
+     * specified separator.
+     *
+     * @param sep - The separator to use when joining multiple text parts.
+     *              Defaults to newline ("\n").
+     * @returns A string containing all text content joined by the separator.
+     *          Returns an empty string if the response contains no text parts.
+     *
+     * @example
+     * ```typescript
+     * response.text()        // Join with newlines (default): "Hello\nWorld"
+     * response.text(" ")     // Join with spaces: "Hello World"
+     * response.text("")      // Concatenate directly: "HelloWorld"
+     * ```
+     */
+    text(sep?: string): string;
+    /**
+     * Return a string representation of all response content.
+     *
+     * The response content will be represented in a way that emphasizes clarity and
+     * readability, but may not include all metadata (like thinking signatures or tool
+     * call ids), and thus cannot be used to reconstruct the response.
+     *
+     * @example
+     * ```
+     * **Thinking:**
+     *   The user is asking a math problem. I should use the calculator tool.
+     *
+     * **ToolCall (calculator):** {"operation": "mult", "a": 1337, "b": 4242}
+     *
+     * I am going to use the calculator and answer your question for you!
+     * ```
+     */
+    pretty(): string;
+    /**
+     * A Model with parameters matching this response.
+     *
+     * Creates a new Model instance with the same model ID and parameters that
+     * were used to generate this response. This is useful for resuming
+     * conversations or making follow-up calls with consistent settings.
+     *
+     * Uses dynamic import to avoid circular dependencies.
+     *
+     * @returns A Promise resolving to a Model instance configured with this response's model ID and params.
+     *
+     * @example
+     * ```typescript
+     * const response = await model.call('Hello!');
+     * const sameModel = await response.model;
+     * const followUp = await sameModel.call('Tell me more');
+     * ```
+     */
+    get model(): Promise<Model>;
+    /**
+     * Parse the response with partial parsing enabled (for streaming).
+     *
+     * Use this during streaming to parse incomplete JSON as it arrives.
+     * Returns a DeepPartial version where all fields are optional.
+     *
+     * @returns The partially parsed response with optional fields.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of streamResponse.chunkStream()) {
+     *   const partial = streamResponse.parse({ partial: true });
+     *   // partial.title may be undefined initially
+     * }
+     * ```
+     */
+    parse(options: {
+        partial: true;
+    }): DeepPartial<F>;
+    /**
+     * Parse the response according to the response format.
+     *
+     * If a format was specified in the call, parses the response content
+     * according to that format. For JSON-based formats, extracts and parses
+     * the JSON. For OutputParser formats, calls the custom parser.
+     *
+     * When a format is specified, returns the parsed value of type F.
+     * When no format is specified (F = unknown), returns null at runtime.
+     *
+     * @returns The parsed response.
+     * @throws ParseError if parsing fails.
+     *
+     * @example
+     * ```typescript
+     * interface Book { title: string; author: string; }
+     *
+     * const response = await model.call<Book>('Recommend a book', {
+     *   format: BookSchema
+     * });
+     *
+     * const book = response.parse(); // Type: Book
+     * console.log(book.title);
+     * ```
+     */
+    parse(options?: {
+        partial?: false;
+    }): F;
+}
+
+/**
+ * Output parser for custom format parsing.
+ *
+ * Provides OutputParser type and defineOutputParser function for creating
+ * custom parsers for non-JSON formats like XML, YAML, CSV, or any custom
+ * text structure.
+ */
+
+/**
+ * Type discriminator symbol for OutputParser.
+ * Used at runtime to distinguish OutputParsers from other format types.
+ */
+declare const OUTPUT_PARSER_TYPE: unique symbol;
+/**
+ * Represents a custom output parser for non-JSON formats.
+ *
+ * OutputParser wraps a parsing function and stores formatting instructions.
+ * Unlike structured outputs (JSON schema, tools, strict mode), OutputParser
+ * works with raw text responses and custom parsing logic.
+ *
+ * @template T - The type of the parsed output.
+ *
+ * @example
+ * ```typescript
+ * const xmlParser = defineOutputParser({
+ *   formattingInstructions: 'Return XML: <book><title>...</title></book>',
+ *   parser: (response) => {
+ *     const text = response.text();
+ *     // Parse XML and return Book
+ *     return { title: '...', author: '...' };
+ *   },
+ * });
+ *
+ * const response = await model.call('Recommend a book', { format: xmlParser });
+ * const book = response.parse(); // Returns parsed Book
+ * ```
+ */
+interface OutputParser<T = unknown> {
+    /**
+     * Type discriminator for runtime identification.
+     */
+    readonly __outputParserType: typeof OUTPUT_PARSER_TYPE;
+    /**
+     * The name of the output parser (derived from parser function name).
+     */
+    readonly name: string;
+    /**
+     * Instructions for the LLM on how to format its output.
+     * These are added to the system prompt.
+     */
+    readonly formattingInstructions: string;
+    /**
+     * Parse the response using the wrapped function.
+     *
+     * @param response - The response from the LLM call.
+     * @returns The parsed output of type T.
+     */
+    (response: AnyResponse): T;
+}
+/**
+ * Arguments for defining an output parser.
+ *
+ * @template T - The type of the parsed output.
+ */
+interface OutputParserArgs<T> {
+    /**
+     * Instructions for the LLM on how to format the output.
+     * These will be added to the system prompt.
+     */
+    formattingInstructions: string;
+    /**
+     * The parsing function that takes a Response and returns the parsed output.
+     *
+     * @param response - The response from the LLM call.
+     * @returns The parsed output of type T.
+     */
+    parser: (response: AnyResponse) => T;
+}
+/**
+ * Create an output parser for custom format parsing.
+ *
+ * Use this function to create custom parsers for non-JSON formats like
+ * XML, YAML, CSV, or any custom text structure. The parser function
+ * receives the full Response object and returns the parsed output.
+ *
+ * @template T - The type of the parsed output.
+ * @param args - The output parser arguments.
+ * @returns An OutputParser instance.
+ *
+ * @example XML parsing
+ * ```typescript
+ * interface Book {
+ *   title: string;
+ *   author: string;
+ * }
+ *
+ * const bookXmlParser = defineOutputParser<Book>({
+ *   formattingInstructions: `
+ *     Return the book information in this XML structure:
+ *     <book>
+ *       <title>Book Title</title>
+ *       <author>Author Name</author>
+ *     </book>
+ *   `,
+ *   parser: (response) => {
+ *     const text = response.text();
+ *     // Parse XML (example using regex, use proper parser in production)
+ *     const titleMatch = text.match(/<title>([^<]+)<\/title>/);
+ *     const authorMatch = text.match(/<author>([^<]+)<\/author>/);
+ *     return {
+ *       title: titleMatch?.[1] ?? '',
+ *       author: authorMatch?.[1] ?? '',
+ *     };
+ *   },
+ * });
+ *
+ * const response = await model.call('Recommend a fantasy book', {
+ *   format: bookXmlParser,
+ * });
+ * const book = response.parse(); // Type: Book
+ * ```
+ *
+ * @example CSV parsing
+ * ```typescript
+ * interface Book {
+ *   title: string;
+ *   author: string;
+ *   rating: number;
+ * }
+ *
+ * const booksCsvParser = defineOutputParser<Book[]>({
+ *   formattingInstructions: `
+ *     Return book information as CSV format with header:
+ *     title,author,rating
+ *     Book 1,Author 1,5
+ *     Book 2,Author 2,4
+ *   `,
+ *   parser: (response) => {
+ *     const text = response.text();
+ *     const lines = text.trim().split('\n').slice(1); // Skip header
+ *     return lines.map((line) => {
+ *       const [title, author, rating] = line.split(',').map((s) => s.trim());
+ *       return { title, author, rating: parseInt(rating, 10) };
+ *     });
+ *   },
+ * });
+ * ```
+ */
+declare function defineOutputParser<T>(args: OutputParserArgs<T>): OutputParser<T>;
+/**
+ * Check if an object is an OutputParser.
+ *
+ * This is a type guard function that narrows the type of `obj` to
+ * `OutputParser<unknown>` when it returns true.
+ *
+ * @param obj - The object to check.
+ * @returns True if the object is an OutputParser, false otherwise.
+ */
+declare function isOutputParser(obj: unknown): obj is OutputParser<unknown>;
+
+/**
+ * Format class and utilities for structured LLM outputs.
+ *
+ * Provides the Format interface and functions for creating and resolving
+ * structured output formats.
+ */
+
+/**
+ * Reserved tool name for formatted output tools.
+ * This is used internally to convert formatted output tool calls to textual output.
+ */
+declare const FORMAT_TOOL_NAME = "__mirascope_formatted_output_tool__";
+/**
+ * System prompt instructions for tool mode formatting.
+ */
+declare const TOOL_MODE_INSTRUCTIONS = "Always respond to the user's query using the __mirascope_formatted_output_tool__ tool for structured output.";
+/**
+ * System prompt instructions for JSON mode formatting.
+ * The {json_schema} placeholder will be replaced with the actual schema.
+ */
+declare const JSON_MODE_INSTRUCTIONS = "Respond only with valid JSON that matches this exact schema:\n{json_schema}";
+/**
+ * Type discriminator symbol for Format.
+ */
+declare const FORMAT_TYPE: unique symbol;
+/**
+ * Represents a resolved structured output format.
+ *
+ * A Format contains all metadata needed to describe a structured output type
+ * to the LLM, including the JSON schema, formatting mode, and optional validator.
+ *
+ * Format objects are created by `defineFormat` or `resolveFormat` and are used
+ * internally by providers to configure structured output requests.
+ *
+ * @template T - The type of the formatted output.
+ */
+interface Format<T = unknown> {
+    /**
+     * Type discriminator for runtime identification.
+     */
+    readonly __formatType: typeof FORMAT_TYPE;
+    /**
+     * The name of the format (derived from the type name).
+     */
+    readonly name: string;
+    /**
+     * A description of the format, if available.
+     */
+    readonly description: string | null;
+    /**
+     * JSON schema representation of the structured output format.
+     */
+    readonly schema: ToolParameterSchema;
+    /**
+     * The formatting mode determining how the LLM is configured.
+     */
+    readonly mode: FormattingMode;
+    /**
+     * Optional Zod schema for runtime validation.
+     */
+    readonly validator: ZodLike | null;
+    /**
+     * Optional OutputParser for custom parsing.
+     * When set, indicates this format uses custom parsing instead of JSON.
+     */
+    readonly outputParser: OutputParser<T> | null;
+    /**
+     * The formatting instructions to add to the system prompt.
+     */
+    readonly formattingInstructions: string | null;
+    /**
+     * Create a ToolSchema for this format.
+     * Used when mode is 'tool' to generate a tool for structured output.
+     */
+    createToolSchema(): ToolSchema;
+}
+/**
+ * Check if an object is a Format.
+ *
+ * @param obj - The object to check.
+ * @returns True if the object is a Format.
+ */
+declare function isFormat(obj: unknown): obj is Format<unknown>;
+/**
+ * Options for defineFormat when using TypeScript interfaces.
+ *
+ * The `__schema` field is injected by the compile-time transformer based on
+ * the generic type parameter T.
+ */
+interface DefineFormatOptions<T = unknown> {
+    /**
+     * The formatting mode to use.
+     */
+    mode: FormattingMode;
+    /**
+     * Optional Zod schema for runtime validation.
+     */
+    validator?: ZodLike;
+    /**
+     * Internal: JSON schema injected by compile-time transformer.
+     * Do not set this manually - it is populated automatically when using
+     * the Mirascope transformer with TypeScript interfaces.
+     */
+    __schema?: ToolParameterSchema;
+}
+/**
+ * Create a Format with explicit mode control.
+ *
+ * Use this to create structured output formats for LLM responses. The format
+ * can be derived from a Zod schema (via `validator`) or a TypeScript interface
+ * (via the compile-time transformer which injects `__schema`).
+ *
+ * @template T - The type of the formatted output.
+ * @param options - The format options including mode and optional validator.
+ * @returns A Format object.
+ *
+ * @example With Zod schema
+ * ```typescript
+ * const BookSchema = z.object({ title: z.string(), author: z.string() });
+ * const bookFormat = defineFormat<Book>({ mode: 'tool', validator: BookSchema });
+ * const response = await model.call('Recommend a book', { format: bookFormat });
+ * const book = response.parse(); // Typed as Book
+ * ```
+ *
+ * @example With TypeScript interface (requires transformer)
+ * ```typescript
+ * interface Book { title: string; author: string; }
+ *
+ * // Transformer injects __schema at compile time
+ * const bookFormat = defineFormat<Book>({ mode: 'json' });
+ * ```
+ */
+declare function defineFormat<T>(options: DefineFormatOptions<T>): Format<T>;
+/**
+ * Resolve any format input to internal Format representation.
+ *
+ * This function handles all possible format inputs and converts them to
+ * a Format object. It's used internally by providers to normalize format
+ * specifications.
+ *
+ * @template T - The type of the formatted output.
+ * @param formatArg - The format specification (can be Format, FormatSpec, ZodLike, OutputParser, or null).
+ * @param defaultMode - The default mode to use when not explicitly specified.
+ * @returns A Format object or null.
+ */
+declare function resolveFormat<T>(formatArg: Format<T> | FormatSpec<T> | ZodLike | OutputParser<T> | null | undefined, defaultMode: FormattingMode): Format<T> | null;
+
+/**
+ * Formatting types for structured LLM outputs.
+ *
+ * Provides types for defining structured output formats that LLMs
+ * should follow when generating responses.
+ */
+
+/**
+ * Formatting mode determines how the structured output is requested from the LLM.
+ *
+ * - `strict`: Use provider's strict structured output mode (requires provider support)
+ * - `json`: Use JSON mode with schema instructions in system prompt
+ * - `tool`: Use tool calling with a format tool to get structured output
+ * - `parser`: Use custom OutputParser for non-JSON formats
+ */
+type FormattingMode = "strict" | "json" | "tool" | "parser";
+/**
+ * User-facing format specification.
+ *
+ * Can be one of:
+ * - A TypeScript interface/type (transformer injects __schema)
+ * - A Zod schema (used for both schema and validation)
+ * - { schema: T, validator: ZodSchema } for explicit control
+ * - Format (from defineFormat)
+ * - OutputParser (from defineOutputParser)
+ *
+ * @template T - The type of the formatted output.
+ */
+interface FormatSpec<T = unknown> {
+    /**
+     * The schema marker for the TypeScript type.
+     * The compile-time transformer uses this to determine which type to extract schema from.
+     */
+    schema?: T;
+    /**
+     * Optional Zod schema for runtime validation.
+     * When provided, parsed output will be validated against this schema.
+     */
+    validator?: ZodLike;
+    /**
+     * Internal: JSON schema injected by the compile-time transformer.
+     * Users should not set this directly.
+     */
+    __schema?: ToolParameterSchema;
+}
+/**
+ * Any format input that can be provided to defineCall/definePrompt.
+ * Used for constraining format type parameters.
+ *
+ * @template F - The output type of the format. Defaults to unknown.
+ */
+type FormatInput<F = unknown> = Format<F> | FormatSpec<F> | OutputParser<F> | ZodLike | null | undefined;
+/**
+ * Union of all possible format input types (non-generic version).
+ * Used for type narrowing in resolveFormat.
+ */
+type AnyFormatInput = Format<unknown> | FormatSpec<unknown> | OutputParser<unknown> | ZodLike | null | undefined;
+/**
+ * Extract the format output type from a format input.
+ *
+ * This utility type enables automatic type inference when using formats
+ * with defineCall and definePrompt, eliminating the need to specify the
+ * format type parameter explicitly.
+ *
+ * @template F - The format input type.
+ * @returns The extracted output type, or `unknown` if not determinable.
+ *
+ * @example
+ * ```typescript
+ * // ExtractFormatType<Format<Book>> = Book
+ * // ExtractFormatType<OutputParser<Recipe>> = Recipe
+ * // ExtractFormatType<typeof BookSchema> = z.infer<typeof BookSchema>
+ * // ExtractFormatType<null> = unknown
+ * ```
+ */
+type ExtractFormatType<F> = F extends Format<infer F> ? F : F extends OutputParser<infer F> ? F : F extends FormatSpec<infer F> ? F : F extends {
+    _output: infer O;
+} ? O : F extends null | undefined ? unknown : unknown;
+
+/**
+ * Deep partial type for streaming structured outputs.
+ *
+ * Used when parsing incomplete JSON during structured streaming,
+ * where fields arrive incrementally.
+ */
+/**
+ * Deep partial type - all properties become optional recursively.
+ *
+ * This type is used for streaming structured outputs where fields
+ * arrive incrementally. During streaming, the parsed output may
+ * not have all fields populated yet.
+ *
+ * @template T - The original type to make deeply partial.
+ *
+ * @example
+ * ```typescript
+ * interface Book {
+ *   title: string;
+ *   author: string;
+ *   chapters: { name: string; pages: number }[];
+ * }
+ *
+ * // DeepPartial<Book> =
+ * // {
+ * //   title?: string | null;
+ * //   author?: string | null;
+ * //   chapters?: ({ name?: string | null; pages?: number | null } | null)[] | null;
+ * // }
+ *
+ * // During streaming:
+ * for await (const partial of response.structuredStream()) {
+ *   // partial.title may be undefined at first
+ *   if (partial.title) {
+ *     console.log('Got title:', partial.title);
+ *   }
+ * }
+ * ```
+ */
+type DeepPartial<T> = T extends (infer U)[] ? (DeepPartial<U> | null)[] | null : T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]> | null;
+} : T | null;
+
+/**
+ * Mirascope LLM exception hierarchy for unified error handling across providers.
+ */
+
+/**
+ * Base exception for all Mirascope LLM errors.
+ */
+declare class MirascopeError extends Error {
+    constructor(message: string);
+}
+/**
+ * Options for constructing a ProviderError.
+ */
+interface ProviderErrorOptions {
+    provider: ProviderId;
+    originalException?: Error | null;
+}
+/**
+ * Base class for errors that originate from a provider SDK.
+ *
+ * This wraps exceptions from provider libraries (OpenAI, Anthropic, etc.)
+ * and provides a unified interface for error handling.
+ */
+declare class ProviderError extends MirascopeError {
+    /**
+     * The provider that raised this error.
+     */
+    readonly provider: ProviderId;
+    /**
+     * The original exception from the provider SDK, if available.
+     */
+    readonly originalException: Error | null;
+    constructor(message: string, options: ProviderErrorOptions);
+}
+/**
+ * Options for constructing an APIError.
+ */
+interface APIErrorOptions extends ProviderErrorOptions {
+    statusCode?: number | null;
+}
+/**
+ * Base class for HTTP-level API errors.
+ */
+declare class APIError extends ProviderError {
+    /**
+     * The HTTP status code, if available.
+     */
+    readonly statusCode: number | null;
+    constructor(message: string, options: APIErrorOptions);
+}
+/**
+ * Raised for authentication failures (401, invalid API keys).
+ */
+declare class AuthenticationError extends APIError {
+    constructor(message: string, options: APIErrorOptions);
+}
+/**
+ * Raised for permission/authorization failures (403).
+ */
+declare class PermissionError extends APIError {
+    constructor(message: string, options: APIErrorOptions);
+}
+/**
+ * Raised for malformed requests (400, 422).
+ */
+declare class BadRequestError extends APIError {
+    constructor(message: string, options: APIErrorOptions);
+}
+/**
+ * Raised when requested resource is not found (404).
+ */
+declare class NotFoundError extends APIError {
+    constructor(message: string, options: APIErrorOptions);
+}
+/**
+ * Raised when rate limits are exceeded (429).
+ */
+declare class RateLimitError extends APIError {
+    constructor(message: string, options: APIErrorOptions);
+}
+/**
+ * Raised for server-side errors (500+).
+ */
+declare class ServerError extends APIError {
+    constructor(message: string, options: APIErrorOptions);
+}
+/**
+ * Raised when unable to connect to the API (network issues, timeouts).
+ */
+declare class ConnectionError extends ProviderError {
+    constructor(message: string, options: ProviderErrorOptions);
+}
+/**
+ * Raised when requests timeout or deadline exceeded.
+ */
+declare class TimeoutError extends ProviderError {
+    constructor(message: string, options: ProviderErrorOptions);
+}
+/**
+ * Raised when API response fails validation.
+ *
+ * This wraps the APIResponseValidationErrors that OpenAI and Anthropic both return.
+ */
+declare class ResponseValidationError extends ProviderError {
+    constructor(message: string, options: ProviderErrorOptions);
+}
+/**
+ * Base class for errors that occur during tool execution.
+ */
+declare class ToolError extends MirascopeError {
+}
+/**
+ * Raised if an uncaught exception is thrown while executing a tool.
+ */
+declare class ToolExecutionError extends ToolError {
+    /**
+     * The exception that was thrown while executing the tool.
+     */
+    readonly toolException: Error;
+    constructor(toolException: Error | string);
+}
+/**
+ * Raised if a tool call does not match any registered tool.
+ */
+declare class ToolNotFoundError extends ToolError {
+    /**
+     * The name of the tool that was not found.
+     */
+    readonly toolName: string;
+    constructor(toolName: string);
+}
+/**
+ * Raised when response.parse() fails to parse the response content.
+ *
+ * This wraps errors from JSON extraction, JSON parsing, Pydantic validation,
+ * or custom OutputParser functions.
+ */
+declare class ParseError extends MirascopeError {
+    /**
+     * The original exception that caused the parse failure.
+     */
+    readonly originalException: Error;
+    constructor(message: string, originalException: Error);
+    /**
+     * Generate a message suitable for retrying with the LLM.
+     *
+     * Returns a user-friendly message describing what went wrong,
+     * suitable for including in a retry prompt.
+     */
+    retryMessage(): string;
+}
+/**
+ * Raised if a Mirascope feature is unsupported by chosen provider.
+ *
+ * If compatibility is model-specific, then `modelId` should be specified.
+ * If the feature is not supported by the provider at all, then it may be `null`.
+ */
+declare class FeatureNotSupportedError extends MirascopeError {
+    /**
+     * The provider that does not support this feature.
+     */
+    readonly providerId: ProviderId;
+    /**
+     * The model that does not support this feature, if model-specific.
+     */
+    readonly modelId: ModelId | null;
+    /**
+     * The name of the unsupported feature.
+     */
+    readonly feature: string;
+    constructor(feature: string, providerId: ProviderId, modelId?: ModelId | null, message?: string | null);
+}
+/**
+ * Raised when no provider is registered for a given model_id.
+ */
+declare class NoRegisteredProviderError extends MirascopeError {
+    /**
+     * The model ID that has no registered provider.
+     */
+    readonly modelId: string;
+    constructor(modelId: string);
+}
+/**
+ * Raised when no API key is available for a provider.
+ *
+ * This error is raised during auto-registration when the required API key
+ * environment variable is not set. If a Mirascope fallback is available,
+ * the error message will suggest using MIRASCOPE_API_KEY as an alternative.
+ */
+declare class MissingAPIKeyError extends MirascopeError {
+    /**
+     * The provider that requires an API key.
+     */
+    readonly providerId: string;
+    /**
+     * The environment variable that should contain the API key.
+     */
+    readonly envVar: string;
+    constructor(providerId: string, envVar: string, hasMirascopeFallback?: boolean);
+}
+
+/**
+ * Base abstract interface for provider clients.
+ */
+
+/**
+ * A Mirascope error class constructor.
+ */
+type MirascopeErrorClass = (new (message: string, options: ProviderErrorOptions) => ProviderError) | (new (message: string, options: APIErrorOptions) => APIError);
+/**
+ * Mapping from provider SDK exception types to Mirascope error classes.
+ */
+type ProviderErrorMap = Array<[
+    new (...args: any[]) => Error,
+    MirascopeErrorClass
+]>;
+/**
+ * Base abstract provider for LLM interactions.
+ *
+ * This class defines the interface for provider implementations.
+ * Each provider (Anthropic, OpenAI, etc.) extends this class.
+ */
+declare abstract class BaseProvider {
+    /**
+     * Provider identifier (e.g., "anthropic", "openai").
+     */
+    abstract readonly id: ProviderId;
+    /**
+     * Mapping from provider SDK exceptions to Mirascope error types.
+     */
+    protected abstract readonly errorMap: ProviderErrorMap;
+    /**
+     * Generate a Response by calling this provider's LLM.
+     *
+     * This method wraps the provider-specific implementation with error handling,
+     * converting provider SDK exceptions to Mirascope error types.
+     */
+    call(args: {
+        modelId: string;
+        messages: readonly Message[];
+        tools?: Tools;
+        format?: Format | null;
+        params?: Params;
+    }): Promise<Response>;
+    /**
+     * Provider-specific implementation of call().
+     *
+     * Subclasses implement this method to handle the actual API call.
+     */
+    protected abstract _call(args: {
+        modelId: string;
+        messages: readonly Message[];
+        tools?: Tools;
+        format?: Format | null;
+        params?: Params;
+    }): Promise<Response>;
+    /**
+     * Generate a StreamResponse by calling this provider's LLM with streaming.
+     *
+     * This method wraps the provider-specific implementation with error handling,
+     * converting provider SDK exceptions to Mirascope error types. It also wraps
+     * the chunk iterator to catch errors during iteration (not just initial call).
+     */
+    stream(args: {
+        modelId: string;
+        messages: readonly Message[];
+        tools?: Tools;
+        format?: Format | null;
+        params?: Params;
+    }): Promise<StreamResponse>;
+    /**
+     * Wrap an async iterator to catch errors during iteration.
+     * Converts provider SDK exceptions to Mirascope error types.
+     */
+    private _wrapIteratorErrors;
+    /**
+     * Provider-specific implementation of stream().
+     *
+     * Subclasses implement this method to handle the actual streaming API call.
+     */
+    protected abstract _stream(args: {
+        modelId: string;
+        messages: readonly Message[];
+        tools?: Tools;
+        format?: Format | null;
+        params?: Params;
+    }): Promise<StreamResponse>;
+    /**
+     * Generate a ContextResponse by calling this provider's LLM with context.
+     *
+     * This method accepts a context for dependency injection, enabling context-aware
+     * tools and prompts.
+     *
+     * @template DepsT - The type of dependencies in the context.
+     */
+    contextCall<DepsT>(args: {
+        ctx: Context<DepsT>;
+        modelId: string;
+        messages: readonly Message[];
+        tools?: ContextTools<DepsT>;
+        format?: Format | null;
+        params?: Params;
+    }): Promise<ContextResponse<DepsT>>;
+    /**
+     * Provider-specific implementation of contextCall().
+     *
+     * Subclasses implement this method to handle the actual API call with context.
+     * Currently functionally equivalent to _call() since context-aware tools are
+     * not yet implemented. When context-aware tools are added, this method will
+     * handle passing context to tools during execution.
+     */
+    protected abstract _contextCall<DepsT>(args: {
+        ctx: Context<DepsT>;
+        modelId: string;
+        messages: readonly Message[];
+        tools?: ContextTools<DepsT>;
+        format?: Format | null;
+        params?: Params;
+    }): Promise<ContextResponse<DepsT>>;
+    /**
+     * Generate a ContextStreamResponse by calling this provider's LLM with context and streaming.
+     *
+     * This method accepts a context for dependency injection, enabling context-aware
+     * tools and prompts.
+     *
+     * @template DepsT - The type of dependencies in the context.
+     */
+    contextStream<DepsT>(args: {
+        ctx: Context<DepsT>;
+        modelId: string;
+        messages: readonly Message[];
+        tools?: ContextTools<DepsT>;
+        format?: Format | null;
+        params?: Params;
+    }): Promise<ContextStreamResponse<DepsT>>;
+    /**
+     * Provider-specific implementation of contextStream().
+     *
+     * Subclasses implement this method to handle the actual streaming API call with context.
+     * Currently functionally equivalent to _stream() since context-aware tools are
+     * not yet implemented. When context-aware tools are added, this method will
+     * handle passing context to tools during execution.
+     */
+    protected abstract _contextStream<DepsT>(args: {
+        ctx: Context<DepsT>;
+        modelId: string;
+        messages: readonly Message[];
+        tools?: ContextTools<DepsT>;
+        format?: Format | null;
+        params?: Params;
+    }): Promise<ContextStreamResponse<DepsT>>;
+    /**
+     * Generate a new Response by extending a previous response's messages with additional user content.
+     *
+     * Uses the previous response's tools and output format. The default implementation
+     * appends a user message and delegates to call().
+     *
+     * @param args.modelId - The model ID to use.
+     * @param args.response - The previous response to extend.
+     * @param args.content - The new user content to append.
+     * @param args.params - Optional parameters for the request.
+     * @returns A new Response containing the extended conversation.
+     */
+    resume(args: {
+        modelId: string;
+        response: RootResponse;
+        content: UserContent;
+        params?: Params;
+    }): Promise<Response>;
+    /**
+     * Generate a new StreamResponse by extending a previous response's messages with additional user content.
+     *
+     * Uses the previous response's tools and output format. The default implementation
+     * appends a user message and delegates to stream().
+     *
+     * @param args.modelId - The model ID to use.
+     * @param args.response - The previous response to extend.
+     * @param args.content - The new user content to append.
+     * @param args.params - Optional parameters for the request.
+     * @returns A new StreamResponse for consuming the extended conversation.
+     */
+    resumeStream(args: {
+        modelId: string;
+        response: RootResponse;
+        content: UserContent;
+        params?: Params;
+    }): Promise<StreamResponse>;
+    /**
+     * Generate a new ContextResponse by extending a previous response's messages with additional user content.
+     *
+     * Uses the previous response's tools and output format. The default implementation
+     * appends a user message and delegates to contextCall().
+     *
+     * @template DepsT - The type of dependencies in the context.
+     * @param args.ctx - The context containing dependencies for tools.
+     * @param args.modelId - The model ID to use.
+     * @param args.response - The previous response to extend.
+     * @param args.content - The new user content to append.
+     * @param args.params - Optional parameters for the request.
+     * @returns A new ContextResponse containing the extended conversation.
+     */
+    contextResume<DepsT>(args: {
+        ctx: Context<DepsT>;
+        modelId: string;
+        response: RootResponse;
+        content: UserContent;
+        params?: Params;
+    }): Promise<ContextResponse<DepsT>>;
+    /**
+     * Generate a new ContextStreamResponse by extending a previous response's messages with additional user content.
+     *
+     * Uses the previous response's tools and output format. The default implementation
+     * appends a user message and delegates to contextStream().
+     *
+     * @template DepsT - The type of dependencies in the context.
+     * @param args.ctx - The context containing dependencies for tools.
+     * @param args.modelId - The model ID to use.
+     * @param args.response - The previous response to extend.
+     * @param args.content - The new user content to append.
+     * @param args.params - Optional parameters for the request.
+     * @returns A new ContextStreamResponse for consuming the extended conversation.
+     */
+    contextResumeStream<DepsT>(args: {
+        ctx: Context<DepsT>;
+        modelId: string;
+        response: RootResponse;
+        content: UserContent;
+        params?: Params;
+    }): Promise<ContextStreamResponse<DepsT>>;
+    /**
+     * Wrap a provider SDK exception in the appropriate Mirascope error type.
+     */
+    protected wrapError(e: unknown): Error;
+    /**
+     * Extract HTTP status code from provider-specific exception.
+     *
+     * Different SDKs store status codes differently (e.g., .status_code vs .code).
+     * Each provider implements this to handle their SDK's convention.
+     *
+     * @param e - The exception to extract status code from.
+     * @returns The HTTP status code if available, undefined otherwise.
+     */
+    protected abstract getErrorStatus(e: Error): number | undefined;
+}
+/**
+ * Type alias for any provider instance.
+ * Equivalent to Python's `Provider = BaseProvider[Any]`.
+ */
+type Provider = BaseProvider;
+
+/**
+ * Provider registry for managing provider instances.
+ *
+ * Provides automatic provider resolution based on model ID prefixes.
+ */
+
+/**
+ * Reset the provider registry, clearing all registered providers.
+ * Primarily useful for testing.
+ */
+declare function resetProviderRegistry(): void;
+/**
+ * Register a provider with scope(s) in the global registry.
+ *
+ * Scopes use prefix matching on model IDs:
+ * - "anthropic/" matches "anthropic/*"
+ * - "anthropic/claude-sonnet-4" matches "anthropic/claude-sonnet-4*"
+ *
+ * When multiple scopes match a model_id, the longest match wins.
+ *
+ * @example
+ * ```typescript
+ * // Register with default scope
+ * registerProvider('anthropic', { apiKey: 'key' });
+ *
+ * // Register for specific models
+ * registerProvider('anthropic', { scope: 'anthropic/claude-sonnet-4' });
+ *
+ * // Register a custom instance
+ * const custom = new AnthropicProvider({ apiKey: 'team-key' });
+ * registerProvider(custom, { scope: 'anthropic/claude-sonnet-4' });
+ * ```
+ */
+declare function registerProvider(provider: ProviderId | BaseProvider, options?: {
+    scope?: string | string[];
+    apiKey?: string;
+    baseURL?: string;
+}): BaseProvider;
+/**
+ * Get the provider for a model ID based on the registry.
+ *
+ * Uses longest prefix matching to find the most specific provider for the model.
+ * If no explicit registration is found, checks for auto-registration defaults
+ * and automatically registers the provider on first use.
+ *
+ * @param modelId - The full model ID (e.g., "anthropic/claude-sonnet-4-20250514").
+ * @returns The provider instance registered for this model.
+ * @throws NoRegisteredProviderError if no provider scope matches the model ID.
+ * @throws MissingAPIKeyError if no provider has its API key set.
+ *
+ * @example
+ * ```typescript
+ * // Auto-registration on first use:
+ * const provider = getProviderForModel('anthropic/claude-sonnet-4-20250514');
+ * // Automatically loads and registers AnthropicProvider for "anthropic/"
+ * ```
+ */
+declare function getProviderForModel(modelId: string): BaseProvider;
+
+/**
+ * Prompt definition and creation utilities.
+ *
+ * This module provides a unified `definePrompt` function that automatically
+ * detects whether a prompt is context-aware based on the template type parameter.
+ * If T includes `ctx: Context<DepsT>`, a ContextPrompt is returned; otherwise
+ * a regular Prompt is returned.
+ */
+
+/**
+ * Extract DepsT from T if T has a `ctx: Context<DepsT>` property.
+ * Returns `never` if T doesn't have a context property.
+ */
+type ExtractDeps<T> = T extends {
+    ctx: Context<infer D>;
+} ? D : never;
+/**
+ * Extract the variables type from T by removing the `ctx` property.
+ */
+type ExtractVars<T> = Omit<T, "ctx">;
+/**
+ * A template function that generates message content from variables.
+ *
+ * @template T - The type of variables the template accepts.
+ */
+type MessageTemplate<T> = (vars: T) => UserContent | readonly Message[];
+/**
+ * Template function type - either takes no args or takes vars of type T.
+ */
+type TemplateFunc<T> = (() => UserContent | readonly Message[]) | ((vars: T) => UserContent | readonly Message[]);
+/**
+ * The combined context and variables object passed to context template functions.
+ *
+ * @template T - The type of variables the template accepts.
+ * @template DepsT - The type of dependencies in the context.
+ */
+type ContextMessageTemplate<T, DepsT> = {
+    ctx: Context<DepsT>;
+} & T;
+/**
+ * Context template function type - takes an object with ctx and vars.
+ *
+ * @template T - The type of variables the template accepts.
+ * @template DepsT - The type of dependencies in the context.
+ */
+type ContextTemplateFunc<T, DepsT> = (args: ContextMessageTemplate<T, DepsT>) => UserContent | readonly Message[];
+/**
+ * Arguments for defining a prompt.
+ *
+ * @template T - The type of variables the template accepts. Defaults to NoVars.
+ * @template F - The format input type. The output type F is derived via ExtractFormatType<F>.
+ */
+interface PromptArgs<T = NoVars, F extends AnyFormatInput = undefined> {
+    /** Optional tools to make available to the model. */
+    tools?: Tools;
+    /**
+     * Optional format specification for structured output.
+     * Can be a Zod schema, Format, FormatSpec, or OutputParser.
+     * The output type is automatically inferred from this format.
+     */
+    format?: F;
+    /** A function that generates message content (optionally from variables). */
+    template: TemplateFunc<T>;
+}
+/**
+ * Arguments for defining a context-aware prompt.
+ * Used when T includes `ctx: Context<DepsT>`.
+ *
+ * @template T - The full template parameter type including ctx.
+ * @template F - The format input type.
+ */
+interface ContextPromptArgs<T = NoVars, F extends AnyFormatInput = undefined> {
+    /** Optional tools to make available to the model. */
+    tools?: ExtractDeps<T> extends never ? Tools : ContextTools<ExtractDeps<T>>;
+    /**
+     * Optional format specification for structured output.
+     * Can be a Zod schema, Format, FormatSpec, or OutputParser.
+     */
+    format?: F;
+    /** A function that generates message content from context (and optionally variables). */
+    template: TemplateFunc<T>;
+}
+/**
+ * A prompt that can be called with a model to generate a response.
+ *
+ * Created by `definePrompt()`. The prompt is callable and also has a
+ * `messages()` method for getting the raw messages without calling the LLM.
+ *
+ * @template T - The type of variables the prompt accepts. Defaults to empty object.
+ * @template F - The format input type. The output type F is derived via ExtractFormatType<F>.
+ *
+ * @example With variables
+ * ```typescript
+ * const recommendBook = definePrompt<{ genre: string }>({
+ *   template: ({ genre }) => `Recommend a ${genre} book`,
+ * });
+ *
+ * const response = await recommendBook(model, { genre: 'fantasy' });
+ * const messages = recommendBook.messages({ genre: 'fantasy' });
+ * ```
+ *
+ * @example Without variables
+ * ```typescript
+ * const sayHello = definePrompt({
+ *   template: () => 'Hello!',
+ * });
+ * const response = await sayHello(model);
+ * ```
+ */
+interface Prompt<T = NoVars, F extends AnyFormatInput = undefined> {
+    /**
+     * Call the prompt with a model and variables to generate a response.
+     *
+     * @param model - The model to use, either a Model instance or model ID string.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the LLM response.
+     */
+    (model: Model | ModelId, ...args: keyof T extends never ? [] : [vars: T]): Promise<Response<ExtractFormatType<F>>>;
+    /**
+     * Call the prompt with a model and variables to generate a response.
+     * This is the method form of the callable interface.
+     *
+     * @param model - The model to use, either a Model instance or model ID string.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the LLM response.
+     */
+    call(model: Model | ModelId, ...args: keyof T extends never ? [] : [vars: T]): Promise<Response<ExtractFormatType<F>>>;
+    /**
+     * Stream the prompt with a model and variables to generate a streaming response.
+     *
+     * @param model - The model to use, either a Model instance or model ID string.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the streaming LLM response.
+     *
+     * @example
+     * ```typescript
+     * const response = await prompt.stream(model, { genre: 'fantasy' });
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    stream(model: Model | ModelId, ...args: keyof T extends never ? [] : [vars: T]): Promise<StreamResponse<ExtractFormatType<F>>>;
+    /**
+     * Get the messages for this prompt without calling the LLM.
+     *
+     * @param vars - The variables to pass to the template.
+     * @returns The messages that would be sent to the LLM.
+     */
+    messages(...args: keyof T extends never ? [] : [vars: T]): readonly Message[];
+    /**
+     * The tools available to this prompt.
+     */
+    readonly tools: Tools | undefined;
+    /**
+     * The format specification for structured output, if any.
+     */
+    readonly format: FormatInput<ExtractFormatType<F>>;
+    /**
+     * The underlying template function.
+     */
+    readonly template: TemplateFunc<T>;
+}
+/**
+ * A context-aware prompt that can be called with a model and context to generate a response.
+ *
+ * Created by `definePrompt()` when the template type includes `ctx: Context<DepsT>`.
+ * The prompt is callable and also has a `messages()` method for getting the raw messages.
+ *
+ * @template T - The type of variables the prompt accepts. Defaults to empty object.
+ * @template DepsT - The type of dependencies in the context.
+ * @template F - The format input type. The output type is derived via ExtractFormatType<F>.
+ *
+ * @example With variables
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const greetUser = definePrompt<{ ctx: Context<MyDeps>; greeting: string }>({
+ *   template: ({ ctx, greeting }) => `${greeting}, user ${ctx.deps.userId}!`,
+ * });
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123' });
+ * const response = await greetUser(model, ctx, { greeting: 'Hello' });
+ * const messages = greetUser.messages(ctx, { greeting: 'Hello' });
+ * ```
+ *
+ * @example Without variables
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const sayHello = definePrompt<{ ctx: Context<MyDeps> }>({
+ *   template: ({ ctx }) => `Hello, user ${ctx.deps.userId}!`,
+ * });
+ *
+ * const response = await sayHello(model, ctx);
+ * ```
+ */
+interface ContextPrompt<T = NoVars, DepsT = unknown, F extends AnyFormatInput = undefined> {
+    /**
+     * Call the prompt with a model, context, and variables to generate a response.
+     *
+     * @param model - The model to use, either a Model instance or model ID string.
+     * @param ctx - The context containing dependencies.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the LLM response.
+     */
+    (model: Model | ModelId, ctx: Context<DepsT>, ...args: keyof T extends never ? [] : [vars: T]): Promise<ContextResponse<DepsT, ExtractFormatType<F>>>;
+    /**
+     * Call the prompt with a model, context, and variables to generate a response.
+     * This is the method form of the callable interface.
+     *
+     * @param model - The model to use, either a Model instance or model ID string.
+     * @param ctx - The context containing dependencies.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the LLM response.
+     */
+    call(model: Model | ModelId, ctx: Context<DepsT>, ...args: keyof T extends never ? [] : [vars: T]): Promise<ContextResponse<DepsT, ExtractFormatType<F>>>;
+    /**
+     * Stream the prompt with a model, context, and variables to generate a streaming response.
+     *
+     * @param model - The model to use, either a Model instance or model ID string.
+     * @param ctx - The context containing dependencies.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the streaming LLM response.
+     *
+     * @example
+     * ```typescript
+     * const response = await prompt.stream(model, ctx, { greeting: 'Hello' });
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    stream(model: Model | ModelId, ctx: Context<DepsT>, ...args: keyof T extends never ? [] : [vars: T]): Promise<ContextStreamResponse<DepsT, ExtractFormatType<F>>>;
+    /**
+     * Get the messages for this prompt without calling the LLM.
+     *
+     * @param ctx - The context containing dependencies.
+     * @param vars - The variables to pass to the template.
+     * @returns The messages that would be sent to the LLM.
+     */
+    messages(ctx: Context<DepsT>, ...args: keyof T extends never ? [] : [vars: T]): readonly Message[];
+    /**
+     * The tools available to this prompt.
+     */
+    readonly tools: ContextTools<DepsT> | undefined;
+    /**
+     * The format specification for structured output, if any.
+     */
+    readonly format: Format<ExtractFormatType<F>> | FormatSpec<ExtractFormatType<F>> | ZodLike | OutputParser<ExtractFormatType<F>> | null | undefined;
+    /**
+     * The underlying template function.
+     */
+    readonly template: ContextTemplateFunc<T, DepsT>;
+}
+/**
+ * Unified prompt type that returns either Prompt or ContextPrompt
+ * based on whether T includes `ctx: Context<DepsT>`.
+ */
+type UnifiedPrompt<T, F extends AnyFormatInput = undefined> = ExtractDeps<T> extends never ? Prompt<T, F> : ContextPrompt<ExtractVars<T>, ExtractDeps<T>, F>;
+/**
+ * Define a prompt that automatically detects context from the template type.
+ *
+ * When T includes `ctx: Context<DepsT>`, returns a ContextPrompt.
+ * Otherwise returns a regular Prompt.
+ *
+ * @template T - The type of the template parameter (including ctx if context-aware).
+ * @template F - The format input type. The output type is derived via ExtractFormatType<F>.
+ * @param args - The prompt arguments including the template.
+ * @returns A callable prompt (context-aware if T includes ctx).
+ *
+ * @example Prompt without variables
+ * ```typescript
+ * const sayHello = definePrompt({
+ *   template: () => 'Hello!',
+ * });
+ * const response = await sayHello(model);
+ * ```
+ *
+ * @example Regular prompt with variables
+ * ```typescript
+ * const recommendBook = definePrompt<{ genre: string }>({
+ *   template: ({ genre }) => `Recommend a ${genre} book`,
+ * });
+ * const response = await recommendBook(model, { genre: 'fantasy' });
+ * ```
+ *
+ * @example Context-aware prompt
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const greetUser = definePrompt<{ ctx: Context<MyDeps>; greeting: string }>({
+ *   template: ({ ctx, greeting }) => `${greeting}, user ${ctx.deps.userId}!`,
+ * });
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123' });
+ * const response = await greetUser(model, ctx, { greeting: 'Hello' });
+ * ```
+ */
+declare function definePrompt<T extends Record<string, unknown> = NoVars, F extends AnyFormatInput = undefined>(args: PromptArgs<T, F> | ContextPromptArgs<T, F>): UnifiedPrompt<T, F>;
+
+/**
+ * Call definition and creation utilities.
+ *
+ * A Call is a Prompt with a bundled Model - it can be invoked directly
+ * without passing a model argument.
+ *
+ * This module provides a unified `defineCall` function that automatically
+ * detects whether a call is context-aware based on the template type parameter.
+ * If T includes `ctx: Context<DepsT>`, a ContextCall is returned; otherwise
+ * a regular Call is returned.
+ */
+
+/**
+ * Arguments for defining a call.
+ *
+ * @template T - The type of variables the template accepts. Defaults to NoVars.
+ * @template F - The format input type. The output type F is derived via ExtractFormatType<F>.
+ */
+interface CallArgs<T = NoVars, F extends AnyFormatInput = undefined> extends Params {
+    /** The model to use, either a Model instance or model ID string. */
+    model: Model | ModelId;
+    /** Optional tools to make available to the model. */
+    tools?: Tools;
+    /**
+     * Optional format specification for structured output.
+     * Can be a Zod schema, Format, FormatSpec, or OutputParser.
+     * The output type is automatically inferred from this format.
+     */
+    format?: F;
+    /** A function that generates message content (optionally from variables). */
+    template: TemplateFunc<T>;
+}
+/**
+ * Arguments for defining a context-aware call.
+ * Used when T includes `ctx: Context<DepsT>`.
+ *
+ * @template T - The full template parameter type including ctx.
+ * @template F - The format input type.
+ */
+interface ContextCallArgs<T = NoVars, F extends AnyFormatInput = undefined> extends Params {
+    /** The model to use, either a Model instance or model ID string. */
+    model: Model | ModelId;
+    /** Optional tools to make available to the model. */
+    tools?: ExtractDeps<T> extends never ? Tools : ContextTools<ExtractDeps<T>>;
+    /**
+     * Optional format specification for structured output.
+     * Can be a Zod schema, Format, FormatSpec, or OutputParser.
+     */
+    format?: F;
+    /** A function that generates message content from context (and optionally variables). */
+    template: TemplateFunc<T>;
+}
+/**
+ * A call that can be invoked directly to generate a response.
+ *
+ * Created by `defineCall()`. Unlike a `Prompt`, a `Call` has a model bundled in,
+ * so it can be invoked without passing a model argument.
+ *
+ * @template T - The type of variables the call accepts. Defaults to empty object.
+ * @template F - The format input type. The output type F is derived via ExtractFormatType<F>.
+ *
+ * @example With variables
+ * ```typescript
+ * const recommendBook = defineCall<{ genre: string }>({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   template: ({ genre }) => `Recommend a ${genre} book`,
+ * });
+ *
+ * const response = await recommendBook({ genre: 'fantasy' });
+ * ```
+ *
+ * @example Without variables
+ * ```typescript
+ * const sayHello = defineCall({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   template: () => 'Hello!',
+ * });
+ * const response = await sayHello();
+ * ```
+ */
+interface Call<T = NoVars, F extends AnyFormatInput = undefined> {
+    /**
+     * Call directly to generate a response (model is bundled).
+     *
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the LLM response.
+     */
+    (...args: keyof T extends never ? [] : [vars: T]): Promise<Response<ExtractFormatType<F>>>;
+    /**
+     * Call directly to generate a response (model is bundled).
+     * This is the method form of the callable interface.
+     *
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the LLM response.
+     */
+    call(...args: keyof T extends never ? [] : [vars: T]): Promise<Response<ExtractFormatType<F>>>;
+    /**
+     * Stream directly to generate a streaming response (model is bundled).
+     *
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the streaming LLM response.
+     *
+     * @example
+     * ```typescript
+     * const response = await call.stream({ genre: 'fantasy' });
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    stream(...args: keyof T extends never ? [] : [vars: T]): Promise<StreamResponse<ExtractFormatType<F>>>;
+    /**
+     * The model used for generating responses.
+     * Returns the context model if one is set via `withModel`, otherwise returns `defaultModel`.
+     */
+    readonly model: Model;
+    /**
+     * The default model configured when defining this call.
+     * Use `model` to get the effective model (which respects context).
+     */
+    readonly defaultModel: Model;
+    /**
+     * The tools available to this call.
+     */
+    readonly tools: Tools | undefined;
+    /**
+     * The format specification for structured output, if any.
+     */
+    readonly format: FormatInput<ExtractFormatType<F>>;
+    /**
+     * The underlying prompt.
+     */
+    readonly prompt: Prompt<T, F>;
+    /**
+     * The underlying template function.
+     */
+    readonly template: TemplateFunc<T>;
+}
+/**
+ * A context-aware call that can be invoked directly with a context to generate a response.
+ *
+ * Created by `defineCall()` when the template type includes `ctx: Context<DepsT>`.
+ * Unlike a `ContextPrompt`, a `ContextCall` has a model bundled in, so it can be
+ * invoked without passing a model argument.
+ *
+ * @template T - The type of variables the call accepts. Defaults to empty object.
+ * @template DepsT - The type of dependencies in the context.
+ * @template F - The format input type. The output type is derived via ExtractFormatType<F>.
+ *
+ * @example With variables
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const greetUser = defineCall<{ ctx: Context<MyDeps>; greeting: string }>({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   template: ({ ctx, greeting }) => `${greeting}, user ${ctx.deps.userId}!`,
+ * });
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123' });
+ * const response = await greetUser(ctx, { greeting: 'Hello' });
+ * ```
+ *
+ * @example Without variables
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const sayHello = defineCall<{ ctx: Context<MyDeps> }>({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   template: ({ ctx }) => `Hello, user ${ctx.deps.userId}!`,
+ * });
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123' });
+ * const response = await sayHello(ctx);
+ * ```
+ */
+interface ContextCall<T = NoVars, DepsT = unknown, F extends AnyFormatInput = undefined> {
+    /**
+     * Call directly with context to generate a response (model is bundled).
+     *
+     * @param ctx - The context containing dependencies.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the LLM response.
+     */
+    (ctx: Context<DepsT>, ...args: keyof T extends never ? [] : [vars: T]): Promise<ContextResponse<DepsT, ExtractFormatType<F>>>;
+    /**
+     * Call directly with context to generate a response (model is bundled).
+     * This is the method form of the callable interface.
+     *
+     * @param ctx - The context containing dependencies.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the LLM response.
+     */
+    call(ctx: Context<DepsT>, ...args: keyof T extends never ? [] : [vars: T]): Promise<ContextResponse<DepsT, ExtractFormatType<F>>>;
+    /**
+     * Stream directly with context to generate a streaming response (model is bundled).
+     *
+     * @param ctx - The context containing dependencies.
+     * @param vars - The variables to pass to the template.
+     * @returns A promise that resolves to the streaming LLM response.
+     *
+     * @example
+     * ```typescript
+     * const response = await call.stream(ctx, { greeting: 'Hello' });
+     * for await (const text of response.textStream()) {
+     *   process.stdout.write(text);
+     * }
+     * ```
+     */
+    stream(ctx: Context<DepsT>, ...args: keyof T extends never ? [] : [vars: T]): Promise<ContextStreamResponse<DepsT, ExtractFormatType<F>>>;
+    /**
+     * The model used for generating responses.
+     * Returns the context model if one is set via `withModel`, otherwise returns `defaultModel`.
+     */
+    readonly model: Model;
+    /**
+     * The default model configured when defining this call.
+     * Use `model` to get the effective model (which respects context).
+     */
+    readonly defaultModel: Model;
+    /**
+     * The tools available to this call.
+     */
+    readonly tools: ContextTools<DepsT> | undefined;
+    /**
+     * The format specification for structured output, if any.
+     */
+    readonly format: Format<ExtractFormatType<F>> | FormatSpec<ExtractFormatType<F>> | ZodLike | OutputParser<ExtractFormatType<F>> | null | undefined;
+    /**
+     * The underlying context prompt.
+     */
+    readonly prompt: ContextPrompt<T, DepsT, F>;
+    /**
+     * The underlying template function.
+     */
+    readonly template: ContextTemplateFunc<T, DepsT>;
+}
+/**
+ * Unified call type that returns either Call or ContextCall
+ * based on whether T includes `ctx: Context<DepsT>`.
+ */
+type UnifiedCall<T, F extends AnyFormatInput = undefined> = ExtractDeps<T> extends never ? Call<T, F> : ContextCall<ExtractVars<T>, ExtractDeps<T>, F>;
+/**
+ * A builder function returned when defineCall is called with only a type parameter.
+ * Allows specifying the variables type explicitly while inferring the format type.
+ *
+ * @template T - The type of variables the call accepts (may include ctx for context calls).
+ */
+interface CallBuilder<T extends Record<string, unknown>> {
+    <F extends AnyFormatInput = undefined>(args: CallArgs<T, F> | ContextCallArgs<T, F>): UnifiedCall<T, F>;
+}
+/**
+ * Define a call with explicit variables type, returning a builder that infers format.
+ *
+ * This overload enables specifying the variables type upfront while still allowing
+ * the format type to be inferred from the `format` property.
+ *
+ * @template T - The type of variables the template accepts (may include ctx for context calls).
+ * @returns A builder function that accepts call arguments and infers the format type.
+ *
+ * @example With explicit variables and inferred format
+ * ```typescript
+ * const recommendBook = defineCall<{ genre: string }>()({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   format: defineFormat<Book>({ mode: 'tool' }),
+ *   template: ({ genre }) => `Recommend a ${genre} book`,
+ * });
+ *
+ * const response = await recommendBook({ genre: 'fantasy' });
+ * const book = response.parse(); // Typed as Book
+ * ```
+ *
+ * @example Context-aware call with explicit type
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const greetUser = defineCall<{ ctx: Context<MyDeps>; greeting: string }>()({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   template: ({ ctx, greeting }) => `${greeting}, user ${ctx.deps.userId}!`,
+ * });
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123' });
+ * const response = await greetUser(ctx, { greeting: 'Hello' });
+ * ```
+ */
+declare function defineCall<T extends Record<string, unknown>>(): CallBuilder<T>;
+/**
+ * Define a call that automatically detects context from the template type.
+ *
+ * When T includes `ctx: Context<DepsT>`, returns a ContextCall.
+ * Otherwise returns a regular Call.
+ *
+ * Both the variables type and format type are inferred from the arguments.
+ * Type the template parameter to enable variables inference.
+ *
+ * @template T - The type of variables the template accepts (may include ctx for context calls).
+ * @template F - The format input type (inferred from format property).
+ * @param args - The call arguments including model, template, and optional parameters.
+ * @returns A callable that can be invoked directly with variables (and context if T includes ctx).
+ *
+ * @example Call without variables
+ * ```typescript
+ * const sayHello = defineCall({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   template: () => 'Hello!',
+ * });
+ * const response = await sayHello();
+ * ```
+ *
+ * @example Regular call with variables
+ * ```typescript
+ * const recommendBook = defineCall({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   format: defineFormat<Book>({ mode: 'tool' }),
+ *   template: ({ genre }: { genre: string }) => `Recommend a ${genre} book`,
+ * });
+ * const response = await recommendBook({ genre: 'fantasy' });
+ * ```
+ *
+ * @example Context-aware call
+ * ```typescript
+ * interface MyDeps { userId: string; }
+ *
+ * const greetUser = defineCall({
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   template: ({ ctx, greeting }: { ctx: Context<MyDeps>; greeting: string }) =>
+ *     `${greeting}, user ${ctx.deps.userId}!`,
+ * });
+ *
+ * const ctx = createContext<MyDeps>({ userId: '123' });
+ * const response = await greetUser(ctx, { greeting: 'Hello' });
+ * ```
+ */
+declare function defineCall<T extends Record<string, unknown> = NoVars, F extends AnyFormatInput = undefined>(args: CallArgs<T, F> | ContextCallArgs<T, F>): UnifiedCall<T, F>;
+
+type index_APIError = APIError;
+declare const index_APIError: typeof APIError;
+type index_AnthropicModelId = AnthropicModelId;
+type index_AnyContextTool<DepsT = unknown> = AnyContextTool<DepsT>;
+type index_AnyResponse = AnyResponse;
+type index_AnyTool = AnyTool;
+type index_AnyToolFn = AnyToolFn;
+type index_ApiMode = ApiMode;
+type index_AssistantContent = AssistantContent;
+type index_AssistantContentChunk = AssistantContentChunk;
+type index_AssistantContentPart = AssistantContentPart;
+type index_AssistantMessage = AssistantMessage;
+type index_AsyncChunkIterator = AsyncChunkIterator;
+declare const index_Audio: typeof Audio;
+type index_AudioMimeType = AudioMimeType;
+type index_AuthenticationError = AuthenticationError;
+declare const index_AuthenticationError: typeof AuthenticationError;
+type index_BadRequestError = BadRequestError;
+declare const index_BadRequestError: typeof BadRequestError;
+type index_Base64AudioSource = Base64AudioSource;
+type index_Base64DocumentSource = Base64DocumentSource;
+type index_Base64ImageSource = Base64ImageSource;
+type index_BaseContextTool<DepsT = unknown> = BaseContextTool<DepsT>;
+type index_BaseResponse<F = unknown> = BaseResponse<F>;
+declare const index_BaseResponse: typeof BaseResponse;
+type index_BaseResponseInit = BaseResponseInit;
+type index_BaseTool = BaseTool;
+declare const index_CONTEXT_MARKER: typeof CONTEXT_MARKER;
+declare const index_CONTEXT_TOOL_TYPE: typeof CONTEXT_TOOL_TYPE;
+type index_Call<T = NoVars, F extends AnyFormatInput = undefined> = Call<T, F>;
+type index_CallArgs<T = NoVars, F extends AnyFormatInput = undefined> = CallArgs<T, F>;
+type index_ConnectionError = ConnectionError;
+declare const index_ConnectionError: typeof ConnectionError;
+type index_ContentPart = ContentPart;
+type index_Context<DepsT> = Context<DepsT>;
+type index_ContextCall<T = NoVars, DepsT = unknown, F extends AnyFormatInput = undefined> = ContextCall<T, DepsT, F>;
+type index_ContextCallArgs<T = NoVars, F extends AnyFormatInput = undefined> = ContextCallArgs<T, F>;
+type index_ContextMessageTemplate<T, DepsT> = ContextMessageTemplate<T, DepsT>;
+type index_ContextPrompt<T = NoVars, DepsT = unknown, F extends AnyFormatInput = undefined> = ContextPrompt<T, DepsT, F>;
+type index_ContextPromptArgs<T = NoVars, F extends AnyFormatInput = undefined> = ContextPromptArgs<T, F>;
+type index_ContextResponse<DepsT = unknown, F = unknown> = ContextResponse<DepsT, F>;
+declare const index_ContextResponse: typeof ContextResponse;
+type index_ContextResponseInit<DepsT = unknown> = ContextResponseInit<DepsT>;
+type index_ContextStreamResponse<DepsT = unknown, F = unknown> = ContextStreamResponse<DepsT, F>;
+declare const index_ContextStreamResponse: typeof ContextStreamResponse;
+type index_ContextStreamResponseInit<DepsT = unknown> = ContextStreamResponseInit<DepsT>;
+type index_ContextTemplateFunc<T, DepsT> = ContextTemplateFunc<T, DepsT>;
+type index_ContextTool<T extends Record<string, unknown> = Record<string, unknown>, DepsT = unknown> = ContextTool<T, DepsT>;
+type index_ContextToolArgs<T extends Record<string, unknown>, DepsT = unknown> = ContextToolArgs<T, DepsT>;
+type index_ContextToolFn<T extends Record<string, unknown> = Record<string, unknown>, DepsT = unknown, R extends Jsonable = Jsonable> = ContextToolFn<T, DepsT, R>;
+type index_ContextToolkit<DepsT = unknown> = ContextToolkit<DepsT>;
+declare const index_ContextToolkit: typeof ContextToolkit;
+type index_ContextTools<DepsT = unknown> = ContextTools<DepsT>;
+type index_DeepPartial<T> = DeepPartial<T>;
+declare const index_Document: typeof Document;
+type index_DocumentBase64MimeType = DocumentBase64MimeType;
+type index_DocumentTextMimeType = DocumentTextMimeType;
+type index_ExtractDeps<T> = ExtractDeps<T>;
+type index_ExtractVars<T> = ExtractVars<T>;
+declare const index_FORMAT_TOOL_NAME: typeof FORMAT_TOOL_NAME;
+type index_FeatureNotSupportedError = FeatureNotSupportedError;
+declare const index_FeatureNotSupportedError: typeof FeatureNotSupportedError;
+type index_FinishReason = FinishReason;
+type index_FinishReasonChunk = FinishReasonChunk;
+type index_Format<T = unknown> = Format<T>;
+type index_FormatSpec<T = unknown> = FormatSpec<T>;
+type index_FormattingMode = FormattingMode;
+type index_GoogleModelId = GoogleModelId;
+declare const index_Image: typeof Image;
+type index_ImageMimeType = ImageMimeType;
+type index_InferZod<Z extends ZodLike> = InferZod<Z>;
+declare const index_JSON_MODE_INSTRUCTIONS: typeof JSON_MODE_INSTRUCTIONS;
+declare const index_JsonSchemaProperty: typeof JsonSchemaProperty;
+type index_Jsonable = Jsonable;
+declare const index_KNOWN_PROVIDER_IDS: typeof KNOWN_PROVIDER_IDS;
+type index_KnownProviderId = KnownProviderId;
+type index_Message = Message;
+type index_MessageTemplate<T> = MessageTemplate<T>;
+type index_MirascopeError = MirascopeError;
+declare const index_MirascopeError: typeof MirascopeError;
+type index_MissingAPIKeyError = MissingAPIKeyError;
+declare const index_MissingAPIKeyError: typeof MissingAPIKeyError;
+type index_Model = Model;
+declare const index_Model: typeof Model;
+type index_ModelId = ModelId;
+type index_NoRegisteredProviderError = NoRegisteredProviderError;
+declare const index_NoRegisteredProviderError: typeof NoRegisteredProviderError;
+type index_NotFoundError = NotFoundError;
+declare const index_NotFoundError: typeof NotFoundError;
+type index_OpenAIModelId = OpenAIModelId;
+type index_OutputParser<T = unknown> = OutputParser<T>;
+type index_OutputParserArgs<T> = OutputParserArgs<T>;
+type index_Params = Params;
+type index_ParseError = ParseError;
+declare const index_ParseError: typeof ParseError;
+type index_PermissionError = PermissionError;
+declare const index_PermissionError: typeof PermissionError;
+type index_Prompt<T = NoVars, F extends AnyFormatInput = undefined> = Prompt<T, F>;
+type index_PromptArgs<T = NoVars, F extends AnyFormatInput = undefined> = PromptArgs<T, F>;
+type index_Provider = Provider;
+type index_ProviderError = ProviderError;
+declare const index_ProviderError: typeof ProviderError;
+type index_ProviderId = ProviderId;
+type index_ProviderTool = ProviderTool;
+declare const index_ProviderTool: typeof ProviderTool;
+type index_RateLimitError = RateLimitError;
+declare const index_RateLimitError: typeof RateLimitError;
+type index_RawMessageChunk = RawMessageChunk;
+type index_RawStreamEventChunk = RawStreamEventChunk;
+type index_Response<F = unknown> = Response<F>;
+declare const index_Response: typeof Response;
+type index_ResponseInit = ResponseInit;
+type index_ResponseValidationError = ResponseValidationError;
+declare const index_ResponseValidationError: typeof ResponseValidationError;
+type index_RootResponse<F = unknown> = RootResponse<F>;
+declare const index_RootResponse: typeof RootResponse;
+type index_ServerError = ServerError;
+declare const index_ServerError: typeof ServerError;
+type index_StreamResponse<F = unknown> = StreamResponse<F>;
+declare const index_StreamResponse: typeof StreamResponse;
+type index_StreamResponseChunk = StreamResponseChunk;
+type index_StreamResponseInit = StreamResponseInit;
+type index_SystemContent = SystemContent;
+type index_SystemMessage = SystemMessage;
+declare const index_TOOL_MODE_INSTRUCTIONS: typeof TOOL_MODE_INSTRUCTIONS;
+declare const index_TOOL_TYPE: typeof TOOL_TYPE;
+type index_TemplateFunc<T> = TemplateFunc<T>;
+type index_Text = Text;
+type index_TextChunk = TextChunk;
+type index_TextDocumentSource = TextDocumentSource;
+type index_TextEndChunk = TextEndChunk;
+type index_TextStartChunk = TextStartChunk;
+type index_ThinkingConfig = ThinkingConfig;
+type index_ThinkingLevel = ThinkingLevel;
+type index_Thought = Thought;
+type index_ThoughtChunk = ThoughtChunk;
+type index_ThoughtEndChunk = ThoughtEndChunk;
+type index_ThoughtStartChunk = ThoughtStartChunk;
+type index_TimeoutError = TimeoutError;
+declare const index_TimeoutError: typeof TimeoutError;
+type index_Tool<T extends Record<string, unknown> = Record<string, unknown>> = Tool<T>;
+type index_ToolArgs<T extends Record<string, unknown>> = ToolArgs<T>;
+type index_ToolCall = ToolCall;
+type index_ToolCallChunk = ToolCallChunk;
+type index_ToolCallEndChunk = ToolCallEndChunk;
+type index_ToolCallStartChunk = ToolCallStartChunk;
+type index_ToolError = ToolError;
+declare const index_ToolError: typeof ToolError;
+type index_ToolExecutionError = ToolExecutionError;
+declare const index_ToolExecutionError: typeof ToolExecutionError;
+type index_ToolFn<T extends Record<string, unknown> = Record<string, unknown>, R extends Jsonable = Jsonable> = ToolFn<T, R>;
+type index_ToolNotFoundError = ToolNotFoundError;
+declare const index_ToolNotFoundError: typeof ToolNotFoundError;
+declare const index_ToolOutput: typeof ToolOutput;
+declare const index_ToolParameterSchema: typeof ToolParameterSchema;
+declare const index_ToolSchema: typeof ToolSchema;
+type index_Toolkit = Toolkit;
+declare const index_Toolkit: typeof Toolkit;
+type index_Tools = Tools;
+type index_URLDocumentSource = URLDocumentSource;
+type index_URLImageSource = URLImageSource;
+type index_UnifiedCall<T, F extends AnyFormatInput = undefined> = UnifiedCall<T, F>;
+type index_UnifiedPrompt<T, F extends AnyFormatInput = undefined> = UnifiedPrompt<T, F>;
+type index_Usage = Usage;
+type index_UsageDeltaChunk = UsageDeltaChunk;
+type index_UserContent = UserContent;
+type index_UserContentPart = UserContentPart;
+type index_UserMessage = UserMessage;
+type index_WebSearchTool = WebSearchTool;
+declare const index_WebSearchTool: typeof WebSearchTool;
+type index_ZodContextToolArgs<Z extends ZodLike, DepsT = unknown> = ZodContextToolArgs<Z, DepsT>;
+type index_ZodLike = ZodLike;
+type index_ZodToolArgs<Z extends ZodLike> = ZodToolArgs<Z>;
+declare const index_createContext: typeof createContext;
+declare const index_createContextToolkit: typeof createContextToolkit;
+declare const index_createToolkit: typeof createToolkit;
+declare const index_createUsage: typeof createUsage;
+declare const index_defineCall: typeof defineCall;
+declare const index_defineContextTool: typeof defineContextTool;
+declare const index_defineFormat: typeof defineFormat;
+declare const index_defineOutputParser: typeof defineOutputParser;
+declare const index_definePrompt: typeof definePrompt;
+declare const index_defineTool: typeof defineTool;
+declare const index_getProviderForModel: typeof getProviderForModel;
+declare const index_isContext: typeof isContext;
+declare const index_isContextTool: typeof isContextTool;
+declare const index_isFormat: typeof isFormat;
+declare const index_isOutputParser: typeof isOutputParser;
+declare const index_isProviderTool: typeof isProviderTool;
+declare const index_isWebSearchTool: typeof isWebSearchTool;
+declare const index_isZodLike: typeof isZodLike;
+declare const index_model: typeof model;
+declare const index_modelFromContext: typeof modelFromContext;
+declare const index_registerProvider: typeof registerProvider;
+declare const index_resetProviderRegistry: typeof resetProviderRegistry;
+declare const index_resolveFormat: typeof resolveFormat;
+declare const index_textChunk: typeof textChunk;
+declare const index_textEnd: typeof textEnd;
+declare const index_textStart: typeof textStart;
+declare const index_thoughtChunk: typeof thoughtChunk;
+declare const index_thoughtEnd: typeof thoughtEnd;
+declare const index_thoughtStart: typeof thoughtStart;
+declare const index_toolCallChunk: typeof toolCallChunk;
+declare const index_toolCallEnd: typeof toolCallEnd;
+declare const index_toolCallStart: typeof toolCallStart;
+declare const index_totalTokens: typeof totalTokens;
+declare const index_useModel: typeof useModel;
+declare const index_withModel: typeof withModel;
+declare namespace index {
+  export { index_APIError as APIError, type index_AnthropicModelId as AnthropicModelId, type index_AnyContextTool as AnyContextTool, type index_AnyResponse as AnyResponse, type index_AnyTool as AnyTool, type index_AnyToolFn as AnyToolFn, type index_ApiMode as ApiMode, type index_AssistantContent as AssistantContent, type index_AssistantContentChunk as AssistantContentChunk, type index_AssistantContentPart as AssistantContentPart, type index_AssistantMessage as AssistantMessage, type index_AsyncChunkIterator as AsyncChunkIterator, index_Audio as Audio, type index_AudioMimeType as AudioMimeType, index_AuthenticationError as AuthenticationError, index_BadRequestError as BadRequestError, type index_Base64AudioSource as Base64AudioSource, type index_Base64DocumentSource as Base64DocumentSource, type index_Base64ImageSource as Base64ImageSource, type index_BaseContextTool as BaseContextTool, index_BaseResponse as BaseResponse, type index_BaseResponseInit as BaseResponseInit, type index_BaseTool as BaseTool, index_CONTEXT_MARKER as CONTEXT_MARKER, index_CONTEXT_TOOL_TYPE as CONTEXT_TOOL_TYPE, type index_Call as Call, type index_CallArgs as CallArgs, index_ConnectionError as ConnectionError, type index_ContentPart as ContentPart, type index_Context as Context, type index_ContextCall as ContextCall, type index_ContextCallArgs as ContextCallArgs, type index_ContextMessageTemplate as ContextMessageTemplate, type index_ContextPrompt as ContextPrompt, type index_ContextPromptArgs as ContextPromptArgs, index_ContextResponse as ContextResponse, type index_ContextResponseInit as ContextResponseInit, index_ContextStreamResponse as ContextStreamResponse, type index_ContextStreamResponseInit as ContextStreamResponseInit, type index_ContextTemplateFunc as ContextTemplateFunc, type index_ContextTool as ContextTool, type index_ContextToolArgs as ContextToolArgs, type index_ContextToolFn as ContextToolFn, index_ContextToolkit as ContextToolkit, type index_ContextTools as ContextTools, type index_DeepPartial as DeepPartial, index_Document as Document, type index_DocumentBase64MimeType as DocumentBase64MimeType, type index_DocumentTextMimeType as DocumentTextMimeType, type index_ExtractDeps as ExtractDeps, type index_ExtractVars as ExtractVars, index_FORMAT_TOOL_NAME as FORMAT_TOOL_NAME, index_FeatureNotSupportedError as FeatureNotSupportedError, type index_FinishReason as FinishReason, type index_FinishReasonChunk as FinishReasonChunk, FinishReason as FinishReasonType, type index_Format as Format, type index_FormatSpec as FormatSpec, type index_FormattingMode as FormattingMode, type index_GoogleModelId as GoogleModelId, index_Image as Image, type index_ImageMimeType as ImageMimeType, type index_InferZod as InferZod, index_JSON_MODE_INSTRUCTIONS as JSON_MODE_INSTRUCTIONS, index_JsonSchemaProperty as JsonSchemaProperty, type index_Jsonable as Jsonable, index_KNOWN_PROVIDER_IDS as KNOWN_PROVIDER_IDS, type index_KnownProviderId as KnownProviderId, type index_Message as Message, type index_MessageTemplate as MessageTemplate, index_MirascopeError as MirascopeError, index_MissingAPIKeyError as MissingAPIKeyError, index_Model as Model, type index_ModelId as ModelId, index_NoRegisteredProviderError as NoRegisteredProviderError, index_NotFoundError as NotFoundError, type index_OpenAIModelId as OpenAIModelId, type index_OutputParser as OutputParser, type index_OutputParserArgs as OutputParserArgs, type index_Params as Params, index_ParseError as ParseError, index_PermissionError as PermissionError, type index_Prompt as Prompt, type index_PromptArgs as PromptArgs, type index_Provider as Provider, index_ProviderError as ProviderError, type index_ProviderId as ProviderId, index_ProviderTool as ProviderTool, index_RateLimitError as RateLimitError, type index_RawMessageChunk as RawMessageChunk, type index_RawStreamEventChunk as RawStreamEventChunk, index_Response as Response, type index_ResponseInit as ResponseInit, index_ResponseValidationError as ResponseValidationError, index_RootResponse as RootResponse, index_ServerError as ServerError, index_StreamResponse as StreamResponse, type index_StreamResponseChunk as StreamResponseChunk, type index_StreamResponseInit as StreamResponseInit, type index_SystemContent as SystemContent, type index_SystemMessage as SystemMessage, index_TOOL_MODE_INSTRUCTIONS as TOOL_MODE_INSTRUCTIONS, index_TOOL_TYPE as TOOL_TYPE, type index_TemplateFunc as TemplateFunc, type index_Text as Text, type index_TextChunk as TextChunk, type index_TextDocumentSource as TextDocumentSource, type index_TextEndChunk as TextEndChunk, type index_TextStartChunk as TextStartChunk, type index_ThinkingConfig as ThinkingConfig, type index_ThinkingLevel as ThinkingLevel, type index_Thought as Thought, type index_ThoughtChunk as ThoughtChunk, type index_ThoughtEndChunk as ThoughtEndChunk, type index_ThoughtStartChunk as ThoughtStartChunk, index_TimeoutError as TimeoutError, type index_Tool as Tool, type index_ToolArgs as ToolArgs, type index_ToolCall as ToolCall, type index_ToolCallChunk as ToolCallChunk, type index_ToolCallEndChunk as ToolCallEndChunk, type index_ToolCallStartChunk as ToolCallStartChunk, index_ToolError as ToolError, index_ToolExecutionError as ToolExecutionError, type index_ToolFn as ToolFn, index_ToolNotFoundError as ToolNotFoundError, index_ToolOutput as ToolOutput, index_ToolParameterSchema as ToolParameterSchema, index_ToolSchema as ToolSchema, index_Toolkit as Toolkit, type index_Tools as Tools, type index_URLDocumentSource as URLDocumentSource, type index_URLImageSource as URLImageSource, type index_UnifiedCall as UnifiedCall, type index_UnifiedPrompt as UnifiedPrompt, type index_Usage as Usage, type index_UsageDeltaChunk as UsageDeltaChunk, type index_UserContent as UserContent, type index_UserContentPart as UserContentPart, type index_UserMessage as UserMessage, index_WebSearchTool as WebSearchTool, type index_ZodContextToolArgs as ZodContextToolArgs, type index_ZodLike as ZodLike, type index_ZodToolArgs as ZodToolArgs, index_createContext as createContext, index_createContextToolkit as createContextToolkit, index_createToolkit as createToolkit, index_createUsage as createUsage, index_defineCall as defineCall, index_defineContextTool as defineContextTool, index_defineFormat as defineFormat, index_defineOutputParser as defineOutputParser, index_definePrompt as definePrompt, index_defineTool as defineTool, index_getProviderForModel as getProviderForModel, index_isContext as isContext, index_isContextTool as isContextTool, index_isFormat as isFormat, index_isOutputParser as isOutputParser, index_isProviderTool as isProviderTool, index_isWebSearchTool as isWebSearchTool, index_isZodLike as isZodLike, index$1 as messages, index_model as model, index_modelFromContext as modelFromContext, index_registerProvider as registerProvider, index_resetProviderRegistry as resetProviderRegistry, index_resolveFormat as resolveFormat, index_textChunk as textChunk, index_textEnd as textEnd, index_textStart as textStart, index_thoughtChunk as thoughtChunk, index_thoughtEnd as thoughtEnd, index_thoughtStart as thoughtStart, index_toolCallChunk as toolCallChunk, index_toolCallEnd as toolCallEnd, index_toolCallStart as toolCallStart, index_totalTokens as totalTokens, index_useModel as useModel, index_withModel as withModel };
+}
+
+export { index as llm };