import type { ProviderOptions } from '@ai-sdk/provider-utils';
import type { JSONSchema7 } from 'json-schema';
import type { z } from 'zod';
import type { Eval } from './eval';
import type { McpClient } from './mcp-client';
import { Memory } from './memory';
import { Telemetry } from './telemetry';
import type { VectorStore } from './vector-store';
import { type AgentRuntimeConfig } from '../runtime/loop/agent-runtime';
import type { ScopedMemoryTaskEvent } from '../runtime/memory/scoped-memory-task-runner';
import type { FetchFn } from '../runtime/model/model-factory';
import type { RuntimeSkill, RuntimeSkillSource } from '../skills';
import type { AgentEventHandler, AgentMiddleware, BuiltAgent, BuiltEval, BuiltFileStore, BuiltGuardrail, BuiltMemory, BuiltProviderTool, BuiltTool, BuiltTelemetry, CheckpointStore, ExecutionOptions, GenerateResult, MemoryConfig, ModelConfig, Provider, PromptCachingConfig, ReasoningLevel, RunOptions, StreamResult, ThinkingConfig, ThinkingConfigFor, ResumeOptions, McpConnectionFailedEvent } from '../types';
import type { AgentEvent } from '../types/runtime/event';
import type { AgentBuilder } from '../types/sdk/agent-builder';
import type { AgentMessage } from '../types/sdk/message';
import type { Workspace } from '../workspace/workspace';
type ToolParameter = BuiltTool | {
    build(): BuiltTool;
};
interface DeferredToolOptions {
    search?: {
        topK?: number;
    };
}
export interface AgentSnapshot {
    name: string;
    model: {
        provider: string | null;
        name: string | null;
    };
    instructions: string | null;
    tools: ReadonlyArray<{
        name: string;
        description: string | undefined;
    }>;
    hasMemory: boolean;
    hasObservationalMemory: boolean;
    hasEpisodicMemory: boolean;
    thinking: ThinkingConfig | null;
    reasoning: ReasoningLevel | null;
    promptCaching: PromptCachingConfig | null;
    toolCallConcurrency: number | null;
}
export declare class Agent implements BuiltAgent, AgentBuilder {
    readonly name: string;
    private modelConfig?;
    private modelFetchValue?;
    private instructionProviderOpts?;
    private instructionsText?;
    private tools;
    private deferredTools;
    private deferredToolSearchTopK;
    private providerTools;
    private skillSource?;
    private hasRuntimeSkillTool;
    private memoryConfig?;
    private fileStoreValue?;
    private onMemoryTaskEvent?;
    private inputGuardrails;
    private outputGuardrails;
    private agentEvals;
    private outputSchema?;
    private checkpointStore?;
    private thinkingConfig?;
    private reasoningLevel?;
    private promptCachingConfig?;
    private concurrencyValue?;
    private telemetryBuilder?;
    private telemetryConfig?;
    private middlewares;
    private mcpClients;
    private externalMcpConnectionFailures;
    private defaultExecutionOptions?;
    private buildPromise;
    private agentHandlers;
    private activeRuntimes;
    private workspaceInstance?;
    constructor(name: string);
    hasCheckpointStorage(): boolean;
    hasMemory(): boolean;
    model(providerOrIdOrConfig: string | ModelConfig, modelName?: string): this;
    modelFetch(fetch: FetchFn): this;
    instructions(text: string, options?: {
        providerOptions?: ProviderOptions;
    }): this;
    tool(t: ToolParameter | ToolParameter[]): this;
    vectorStore(store: VectorStore, options?: {
        name?: string;
        description?: string;
        filterableKeys?: Record<string, string>;
    }): this;
    deferredTool(t: ToolParameter | ToolParameter[], options?: DeferredToolOptions): this;
    skills(sourceOrSkills: RuntimeSkillSource | RuntimeSkill[]): this;
    providerTool(builtProviderTool: BuiltProviderTool): this;
    get declaredTools(): BuiltTool[];
    memory(m: MemoryConfig | Memory | BuiltMemory): this;
    memoryTaskObserver(observer: (event: ScopedMemoryTaskEvent) => void): this;
    fileStore(store: BuiltFileStore): this;
    middleware(m: AgentMiddleware): this;
    inputGuardrail(g: BuiltGuardrail | {
        build(): BuiltGuardrail;
    }): this;
    outputGuardrail(g: BuiltGuardrail | {
        build(): BuiltGuardrail;
    }): this;
    eval(e: Eval | BuiltEval | {
        ensureBuilt(): BuiltEval;
    }): this;
    checkpoint(storage: 'memory' | CheckpointStore): this;
    structuredOutput(schema: z.ZodType | JSONSchema7): this;
    thinking<P extends Provider>(_provider: P, config?: ThinkingConfigFor<P>): this;
    reasoning(level?: ReasoningLevel): this;
    promptCaching(config?: PromptCachingConfig): this;
    telemetry(t: Telemetry | BuiltTelemetry): this;
    protected get declaredTelemetry(): Telemetry | undefined;
    toolCallConcurrency(n: number): this;
    workspace(ws: Workspace): this;
    mcp(client: McpClient): this;
    mcpConnectionFailures(events: McpConnectionFailedEvent[]): this;
    getMcpConnectionFailures(): McpConnectionFailedEvent[];
    configuration(options: ExecutionOptions): this;
    get evaluations(): BuiltEval[];
    on(event: AgentEvent, handler: AgentEventHandler): void;
    off(event: AgentEvent, handler: AgentEventHandler): void;
    get snapshot(): AgentSnapshot;
    abort(): void;
    close(): Promise<void>;
    generate(input: AgentMessage[] | string, options?: RunOptions & ExecutionOptions): Promise<GenerateResult>;
    stream(input: AgentMessage[] | string, options?: RunOptions & ExecutionOptions): Promise<StreamResult>;
    resume(method: 'generate', data: unknown, options: ResumeOptions & ExecutionOptions): Promise<GenerateResult>;
    resume(method: 'stream', data: unknown, options: ResumeOptions & ExecutionOptions): Promise<StreamResult>;
    crashResume(options: {
        runId: string;
        contextNotes?: string[];
    } & ExecutionOptions): Promise<StreamResult>;
    approve(method: 'generate', options: ResumeOptions & ExecutionOptions): Promise<GenerateResult>;
    approve(method: 'stream', options: ResumeOptions & ExecutionOptions): Promise<StreamResult>;
    deny(method: 'generate', options: ResumeOptions & ExecutionOptions): Promise<GenerateResult>;
    deny(method: 'stream', options: ResumeOptions & ExecutionOptions): Promise<StreamResult>;
    private mergeWithDefaults;
    private ensureBuilt;
    private createRuntime;
    private trackStreamRuntime;
    private cleanupRuntime;
    private toMessages;
    protected build(): Promise<AgentRuntimeConfig>;
    private completeInlineDelegateTools;
    private createInlineSubAgentRunner;
    private assertToolRegistrationAllowed;
    private assertToolNameAvailable;
    private assertReservedSdkBuiltInToolName;
    private removeRuntimeSkillTools;
}
export declare function buildInlineSubAgentBlockedToolNames(hostBlockedTools?: string[]): Set<string>;
export declare function filterInlineSubAgentTools<T extends {
    readonly name: string;
}>(tools: T[], hostBlockedTools?: string[]): T[];
export {};