import { type LanguageModel, type LanguageModelUsage, type ModelMessage, type ProviderMetadata, type TimeoutConfiguration, type Tool, ToolLoopAgent, type ToolLoopAgentSettings, type ToolSet } from 'ai';
import type { z } from 'zod';
import { type EnvInfo } from './env-block.ts';
import { type PromptBlock } from './prompt-blocks.ts';
export declare const SUBMIT_TOOL_NAME = "submit";
export declare function composeSystemPrompt(blocks: readonly PromptBlock[]): string;
export declare function composeSystemPrompt(style: string, rolePrefix: string, env: string | EnvInfo): string;
export type SubagentStreamEvent = {
    type: 'text-delta';
    text: string;
} | {
    type: 'tool-call';
    toolName: string;
    input: unknown;
};
export type SubagentStreamSink = (event: SubagentStreamEvent) => void;
export declare const STREAM_INACTIVITY_MS = 120000;
export declare const STREAM_GRACE_MS = 30000;
export declare const MAX_STREAM_STALL_RETRIES = 1;
export type StreamTimer = {
    expired: Promise<void>;
    cancel: () => void;
};
export type StreamTimerFactory = (ms: number) => StreamTimer;
export type StreamWatchdogConfig = {
    inactivityMs?: number;
    graceMs?: number;
    timer?: StreamTimerFactory;
};
export type StreamWatchdog = {
    inactivityMs: number;
    graceMs: number;
    timer: StreamTimerFactory;
};
export type StreamWatchdogOutcome = 'drained' | 'stalled-active' | 'stalled-grace';
export declare class StreamStallError extends Error {
    readonly name = "StreamStallError";
}
export type SubagentConfig<TOOLS extends ToolSet> = {
    model: LanguageModel;
    tools: TOOLS;
    systemPrompt: string;
    submit: Tool;
    maxSteps?: number;
    timeout?: TimeoutConfiguration;
    prepareStep?: ToolLoopAgentSettings<never, TOOLS>['prepareStep'];
    providerOptions?: ToolLoopAgentSettings<never, TOOLS>['providerOptions'];
    onStepFinish?: ToolLoopAgentSettings<never, TOOLS>['onStepFinish'];
    onRetry?: RetryOptions['onRetry'];
    onStream?: SubagentStreamSink;
    streamWatchdog?: StreamWatchdogConfig;
    signal?: AbortSignal;
};
export declare function createSubagent<TOOLS extends ToolSet>(config: SubagentConfig<TOOLS>, defaultMaxSteps: number): ToolLoopAgent<never, TOOLS>;
export declare function consumeStreamWithWatchdog<PART>(stream: AsyncIterable<PART>, handlers: {
    onPart: (part: PART) => void;
    isFinish: (part: PART) => boolean;
    abort: () => void;
}, watchdog: StreamWatchdog): Promise<StreamWatchdogOutcome>;
export declare class StepTimeoutError extends Error {
    readonly name = "StepTimeoutError";
}
export declare function callWithStepTimeout<T>(call: () => Promise<T>, timeout: TimeoutConfiguration | undefined, retry?: RetryOptions): Promise<T>;
export declare function withTimeout<T extends object>(options: T, timeout: TimeoutConfiguration | undefined): T | (T & {
    timeout: TimeoutConfiguration;
});
export declare const DEFAULT_LLM_MAX_RETRIES = 10;
export declare function defaultRetryDelayMs(attemptIndex: number): number;
export type RetryInfo = {
    attempt: number;
    maxAttempts: number;
    delayMs: number;
    reason: string;
};
export type RetryOptions = {
    maxRetries?: number;
    delayMs?: (attemptIndex: number) => number;
    sleep?: (ms: number) => Promise<void>;
    isRetryable?: (err: unknown) => boolean;
    onRetry?: (info: RetryInfo) => void;
    signal?: AbortSignal;
};
export declare function callWithRetry<T>(call: () => Promise<T>, opts?: RetryOptions): Promise<T>;
export declare function isRetryableProviderError(err: unknown): boolean;
export declare function parseRetryAfterMs(err: unknown): number | undefined;
type StepsResult = {
    steps: ReadonlyArray<{
        toolCalls: ReadonlyArray<{
            toolName: string;
            input: unknown;
        }>;
    }>;
};
export type SubmittedOutput<OUTPUT> = {
    ok: true;
    value: OUTPUT;
} | {
    ok: false;
    reason: 'no-submission';
} | {
    ok: false;
    reason: 'invalid';
    issues: readonly z.core.$ZodIssue[];
};
export declare function submittedOutput<OUTPUT>(result: StepsResult, outputSchema: z.ZodType<OUTPUT>): SubmittedOutput<OUTPUT>;
export declare function formatSubmitIssues(issues: readonly z.core.$ZodIssue[]): string;
export type SchemaRetryOptions = {
    maxRetries?: number;
    onUsage?: (usage: LanguageModelUsage, modelId: string | undefined, providerMetadata?: ProviderMetadata, meta?: {
        latencyMs?: number;
        retries?: number;
    }) => void;
};
export declare function runWithSchemaRetry<TOOLS extends ToolSet, OUTPUT>(agent: ToolLoopAgent<never, TOOLS>, schema: z.ZodType<OUTPUT>, prompt: string, options?: SchemaRetryOptions): Promise<SubmittedOutput<OUTPUT>>;
type GenerateResult<TOOLS extends ToolSet> = Awaited<ReturnType<ToolLoopAgent<never, TOOLS>['generate']>>;
export type SubagentHandle<TOOLS extends ToolSet> = {
    agent: ToolLoopAgent<never, TOOLS>;
    messages: ModelMessage[];
};
export type SubagentRun<TOOLS extends ToolSet> = {
    result: GenerateResult<TOOLS>;
    handle: SubagentHandle<TOOLS>;
};
export type SubagentRunOptions = {
    signal?: AbortSignal;
};
export declare function runSubagent<TOOLS extends ToolSet>(agent: ToolLoopAgent<never, TOOLS>, prompt: string, options?: SubagentRunOptions): Promise<SubagentRun<TOOLS>>;
export declare function continueSubagent<TOOLS extends ToolSet>(handle: SubagentHandle<TOOLS>, followUpPrompt: string, options?: SubagentRunOptions): Promise<SubagentRun<TOOLS>>;
export declare function correctiveMessage(failure: {
    reason: 'no-submission';
} | {
    reason: 'invalid';
    issues: readonly z.core.$ZodIssue[];
}): string;
export {};