import type { ProviderOptions } from '@ai-sdk/provider-utils';
import type { JSONSchema7 } from 'json-schema';
import type { z } from 'zod';
import { type ModelCost } from '../../sdk/catalog';
import type { BuiltFileStore, BuiltMemory, BuiltProviderTool, BuiltTelemetry, BuiltTool, CheckpointStore, EpisodicMemoryConfig, GenerateResult, McpConnectionFailedEvent, ObservationalMemoryConfig, ObservationLogMemoryConfig, RunOptions, ReasoningLevel, SerializableAgentState, StreamResult, ThinkingConfig, TitleGenerationConfig } from '../../types';
import type { ExecutionOptions, ModelConfig, PromptCachingConfig, ResumeOptions } from '../../types/sdk/agent';
import type { AgentMessage } from '../../types/sdk/message';
import { type WorkspaceFilesystem } from '../../workspace';
import type { ScopedMemoryTaskEvent } from '../memory/scoped-memory-task-runner';
import type { FetchFn } from '../model/model-factory';
import { AgentEventBus } from '../state/event-bus';
import { RunStateManager } from '../state/run-state';
export interface AgentRuntimeConfig {
    name: string;
    model: ModelConfig;
    modelFetch?: FetchFn;
    instructions: string;
    instructionProviderOptions?: ProviderOptions;
    tools?: BuiltTool[];
    deferredTools?: BuiltTool[];
    workspaceFilesystem?: WorkspaceFilesystem;
    toolSearch?: {
        topK?: number;
    };
    providerTools?: BuiltProviderTool[];
    memory?: BuiltMemory;
    fileStore?: BuiltFileStore;
    observationLog?: ObservationLogMemoryConfig;
    observationalMemory?: ObservationalMemoryConfig;
    episodicMemory?: EpisodicMemoryConfig;
    structuredOutput?: z.ZodType | JSONSchema7;
    checkpointStorage?: 'memory' | CheckpointStore;
    thinking?: ThinkingConfig;
    reasoning?: ReasoningLevel;
    promptCaching?: PromptCachingConfig;
    eventBus?: AgentEventBus;
    toolCallConcurrency?: number;
    titleGeneration?: TitleGenerationConfig;
    telemetry?: BuiltTelemetry;
    runId?: string;
    modelCost?: ModelCost;
    runState?: RunStateManager;
    onMemoryTaskEvent?: (event: ScopedMemoryTaskEvent) => void;
    mcpConnectionFailures?: McpConnectionFailedEvent[];
}
export declare class AgentRuntime {
    private config;
    private runState;
    private eventBus;
    private currentState;
    private modelCost;
    private backgroundTasks;
    private deferredToolManager;
    private runId;
    private telemetry;
    private memory;
    private context;
    private toolExecutor;
    constructor(config: AgentRuntimeConfig);
    setTelemetry(telemetry: BuiltTelemetry | undefined): void;
    dispose(): Promise<void>;
    getState(): SerializableAgentState;
    abort(): 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>;
    private buildMessageList;
    private initRun;
    private finalizeGenerate;
    private buildAiSdkOptions;
    private assertNotAborted;
    private createRunServices;
    private maybeGenerateTitle;
    private runAgentLoop;
    private startStream;
    private persistSuspension;
    private persistStepCheckpoint;
    private cleanupRun;
    private emitTurnEnd;
    private updateState;
    private get modelIdString();
    private ensureModelCost;
    private applyCost;
    getConfiguredTelemetry(): BuiltTelemetry | undefined;
}