/**
 * Agent Runtime - Core execution engine
 *
 * Handles agent execution with:
 * - Multi-step reasoning (agent loop)
 * - Tool calling and execution
 * - Streaming responses
 * - Memory management
 * - Middleware execution
 *
 * @module ai/agent/runtime
 */
import { type AgentConfig, type AgentGenerateToolReplacements, type AgentResponse, type Message, type ToolCall } from "../types.js";
import { type Memory } from "../memory/index.js";
export { closeSSEStream, generateMessageId, sendSSE } from "./sse-utils.js";
export { RunAlreadyExistsError, RunCancelledError, RunNotActiveError, RunResumeSessionManager, WaitConflictError, WaitNotPendingError, } from "./resume-session.js";
export type { RunResumeSessionManagerOptions, RunSessionStatus, SubmitResumeValueOutcome, } from "./resume-session.js";
export { executeConfiguredTool, getAvailableTools, isDynamicTool, parseToolArgs, resolveConfiguredTool, } from "./tool-helpers.js";
export type { ParsedToolArgs, ToolConfigEntry } from "./tool-helpers.js";
export { getProviderToolProfile, type ProviderToolCompatOptions, type ProviderToolCompatProvider, type ProviderToolProfile, sanitizeProviderToolSchema, selectProviderCompatibleToolNames, selectProviderCompatibleTools, } from "./provider-tool-compat.js";
export { accumulateUsage, getMaxSteps, normalizeInput } from "./input-utils.js";
export { createStreamState, processStream } from "./chat-stream-handler.js";
export type { ChatStreamCallbacks, ChatStreamState, StreamingToolCall, } from "./chat-stream-handler.js";
export { DEFAULT_MAX_STEPS, DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, MAX_STREAM_BUFFER_SIZE, } from "./constants.js";
export { captureStreamedToolCallInput, collectFinalStreamToolResults, collectGeneratedToolResults, collectPersistedToolResults, isRecoverablePlaceholderToolCall, isStreamedToolCallIncomplete, materializeStreamedToolCall, shouldContinueAfterStreamStep, type StreamedToolCallMaterialization, } from "./tool-result-continuation.js";
export { enforceSkillPolicy, type SkillPolicyResult } from "./skill-policy-enforcement.js";
export declare function cloneRuntimeStateMutableData<T>(value: T, proxyDetectionAvailable?: boolean, providerOptionKey?: string): T;
/** Implement agent runtime. */
export declare class AgentRuntime {
    private id;
    private config;
    private memory;
    private status;
    constructor(id: string, config: AgentConfig);
    /**
     * Persist this turn's input, then resolve the messages to run on. Configured
     * memory returns the full persisted conversation (this turn + history); the
     * stateless default persists nothing and returns empty, so we fall back to
     * this turn's input. That fallback is what keeps concurrent stream()/
     * generate() calls on a shared instance isolated instead of interleaving into
     * one conversation.
     */
    private prepareTurnMessages;
    private resolveModelTransport;
    private resolveRuntimeState;
    private notifyToolResult;
    private createGenerateReplacementTools;
    /**
     * Resolve the schema that constrains this request.
     *
     * A per-call schema replaces the configured one; without either, the agent
     * is unconstrained.
     */
    private resolveOutputSchema;
    /**
     * Generate a response (non-streaming)
     */
    generate(input: string | Message[], context?: Record<string, unknown>, modelOverride?: string, maxOutputTokensOverride?: number, abortSignal?: AbortSignal, options?: {
        toolReplacements?: AgentGenerateToolReplacements;
        retainSkillLoaderTools?: boolean;
        outputSchema?: unknown;
    }): Promise<AgentResponse>;
    /**
     * Stream a response
     * Returns a ReadableStream in the veryfront stream event format.
     */
    stream(messages: Message[], context?: Record<string, unknown>, callbacks?: {
        onToolCall?: (toolCall: ToolCall) => void;
        onChunk?: (chunk: string) => void;
        onFinish?: (response: AgentResponse) => void;
    }, modelOverride?: string, maxOutputTokensOverride?: number, abortSignal?: AbortSignal, options?: {
        outputSchema?: unknown;
    }): Promise<ReadableStream<Uint8Array>>;
    /**
     * Execute agent loop (with tool calling)
     */
    private executeAgentLoop;
    /**
     * Execute agent loop with streaming
     * Emits veryfront stream events (message-start/message-finish + step-start/step-end)
     * while consuming model-runtime `streamText()` parts internally.
     */
    private executeAgentLoopStreaming;
    /**
     * Record a tool error and send SSE event.
     */
    private recordToolError;
    /**
     * Resolve system prompt (handle string or function)
     */
    private resolveSystemPrompt;
    /**
     * Compute max steps considering edge config and platform limits.
     */
    private computeMaxSteps;
    private resolveTemperature;
    private resolveMaxOutputTokens;
    /**
     * Get memory instance (for advanced use cases)
     */
    getMemory(): Memory<Message>;
    /**
     * Get memory stats
     */
    getMemoryStats(): Promise<{
        totalMessages: number;
        estimatedTokens: number;
        type: string;
    }>;
    /**
     * Clear agent memory
     */
    clearMemory(): Promise<void>;
}
//# sourceMappingURL=index.d.ts.map