import { A as AgentestConfigInput, a as AgentestConfig, S as Scenario, b as ScenarioOptions, C as CustomHandlerContext, L as LLMProvider, Q as QuantitativeMetric, c as ScoreInput, d as QuantResult, e as ConversationMetric, f as ConversationScoreInput, g as QualitativeMetric, h as QualResult, i as ConversationEvaluation, R as Reporter, P as ProgressEvent, j as ScenarioResult, k as RunResult, l as ComparisonScenarioResult, m as ComparisonRunResult } from './runner-BA28_sSe.cjs';
export { n as AgentestError, o as ComparisonAgentResult, p as ConversationRecord, q as CustomAgentHandler, D as DEFAULT_MODEL, r as DiscoveryResult, E as ErrorDetection, s as Evaluator, F as FailureTurn, t as ForbiddenToolAssertion, G as GenerateObjectOptions, u as GenerateTextOptions, K as KnowledgeItem, M as MetricName, v as MockResolver, w as PerTurnTrajectoryResult, x as ProviderName, y as ProviderOptions, z as Runner, B as ScriptedTurn, H as SimulationResult, I as Simulator, T as ToolCallAssertion, J as ToolCallRecord, N as ToolMockFn, O as TrajectoryAssertions, U as TrajectoryMatcher, V as TrajectoryResult, W as TurnEvaluation, X as TurnRecord, Y as UniqueError, Z as createProvider, _ as discoverAndLoad, $ as discoverScenarioFiles, a0 as loadScenarioFile, a1 as sequence, a2 as validateScenarioOptions } from './runner-BA28_sSe.cjs';
import 'zod';
import 'ai';

declare function defineConfig(input: AgentestConfigInput): AgentestConfig;

declare function scenario(name: string, options: ScenarioOptions): Scenario;
declare function getRegisteredScenarios(): Scenario[];
declare function clearScenarioRegistry(): void;

interface ChatMessage {
    role: 'system' | 'user' | 'assistant' | 'tool';
    content: string | null;
    tool_call_id?: string;
    tool_calls?: ToolCall[];
}
interface ToolCall {
    id: string;
    type: 'function';
    function: {
        name: string;
        arguments: string;
    };
}
interface AgentResponse {
    message: ChatMessage;
    toolCalls: ToolCall[];
    hasToolCalls: boolean;
}
declare class AgentClient {
    private mode;
    private endpoint?;
    private headers;
    private bodyDefaults;
    private requestTimeoutMs;
    private customHandler?;
    private streaming;
    private handlerContext?;
    constructor(config: AgentestConfig);
    setHandlerContext(ctx: CustomHandlerContext): void;
    private validateEndpoint;
    send(messages: ChatMessage[]): Promise<AgentResponse>;
    private sendCustom;
    private sendChatCompletions;
    private readStreamingResponse;
    private readBoundedBody;
    private mergeMessages;
}

interface SimulatedUserMessage {
    message: string;
    shouldStop: boolean;
}
declare class SimulatedUser {
    private llm;
    private systemPrompt;
    constructor(llm: LLMProvider, scenario: ScenarioOptions);
    generateMessage(conversationHistory: Array<{
        role: 'user' | 'assistant';
        content: string;
    }>): Promise<SimulatedUserMessage>;
}

declare class HelpfulnessMetric extends QuantitativeMetric {
    readonly name = "helpfulness";
    score(input: ScoreInput): Promise<QuantResult>;
}

declare class CoherenceMetric extends QuantitativeMetric {
    readonly name = "coherence";
    score(input: ScoreInput): Promise<QuantResult>;
}

declare class RelevanceMetric extends QuantitativeMetric {
    readonly name = "relevance";
    score(input: ScoreInput): Promise<QuantResult>;
}

declare class FaithfulnessMetric extends QuantitativeMetric {
    readonly name = "faithfulness";
    score(input: ScoreInput): Promise<QuantResult>;
}

declare class VerbosityMetric extends QuantitativeMetric {
    readonly name = "verbosity";
    score(input: ScoreInput): Promise<QuantResult>;
}

declare class GoalCompletionMetric extends ConversationMetric {
    readonly name = "goal_completion";
    score(input: ConversationScoreInput): Promise<QuantResult>;
}

declare class AgentBehaviorFailureMetric extends QualitativeMetric {
    readonly name = "agent_behavior_failure";
    evaluate(input: ScoreInput): Promise<QualResult>;
}

declare class ToolCallBehaviorFailureMetric extends QualitativeMetric {
    readonly name = "tool_call_behavior_failure";
    evaluate(input: ScoreInput): Promise<QualResult>;
}

declare function renderPrompt(template: string, vars: Record<string, string>): string;
declare function wrapContent(label: string, content: string): string;
declare function formatHistory(turns: Array<{
    userMessage: string;
    agentMessage: string;
}>): string;
declare function formatToolCalls(toolCalls: Array<{
    name: string;
    args: Record<string, unknown>;
    result: unknown;
}>): string;
declare function formatToolCallSignatures(toolCalls: Array<{
    name: string;
    args: Record<string, unknown>;
}>): string;
declare function formatToolResults(toolCalls: Array<{
    name: string;
    result: unknown;
}>): string;
declare function formatKnowledge(knowledge: Array<{
    content: string;
}> | undefined): string;

interface ThresholdViolation {
    metric: string;
    avg: number;
    threshold: number;
}
/**
 * Computes which thresholds are violated given a set of evaluations.
 */
declare function computeThresholdViolations(evaluations: Iterable<ConversationEvaluation>, thresholds: Record<string, number>): ThresholdViolation[];
/**
 * Computes average scores across turn evaluations for all numeric metrics.
 * Does NOT include goal_completion — use computeMetricAverages() for that.
 */
declare function computeTurnAverages(turnEvaluations: Array<{
    metrics: Record<string, {
        value: string | number;
        reason: string;
    }>;
}>): Record<string, number>;
/**
 * Computes average scores across all conversations in a scenario,
 * including goal_completion from per-conversation evaluations.
 */
declare function computeMetricAverages(evaluations: Iterable<ConversationEvaluation>): Record<string, number>;

declare class ConsoleReporter implements Reporter {
    private spinnerInterval;
    private spinnerFrame;
    private currentStatus;
    private isTTY;
    private thresholds;
    private verbose;
    constructor(thresholds?: Record<string, number>, verbose?: boolean);
    onRunStart(scenarios: Scenario[], agents?: string[]): void;
    onProgress(event: ProgressEvent): void;
    onScenarioEnd(result: ScenarioResult): void;
    onRunEnd(result: RunResult): void;
    onComparisonScenarioEnd(comparison: ComparisonScenarioResult): void;
    onComparisonRunEnd(result: ComparisonRunResult): void;
    private printScenarioDetails;
    private printMetricComparison;
    private startSpinner;
    private renderSpinner;
    private stopSpinner;
    private printTranscript;
}

interface JsonReporterOptions {
    outputDir?: string;
    filename?: string;
}
declare class JsonReporter implements Reporter {
    private outputDir;
    private filename;
    constructor(options?: JsonReporterOptions);
    onRunEnd(result: RunResult): Promise<void>;
    onComparisonRunEnd(result: ComparisonRunResult): Promise<void>;
    private writeOutput;
    private serialize;
    private serializeComparison;
    private serializeScenario;
}

declare class GitHubActionsReporter implements Reporter {
    private summaryFile;
    private thresholds;
    constructor(thresholds?: Record<string, number>);
    onScenarioEnd(result: ScenarioResult): void;
    onRunEnd(result: RunResult): void;
    onComparisonScenarioEnd(comparison: ComparisonScenarioResult): void;
    onComparisonRunEnd(result: ComparisonRunResult): void;
    private emitAnnotationsForScenario;
    private emitRunAnnotations;
    private annotate;
    private severityToLevel;
    private writeSummary;
    private buildStandardSummary;
    private buildComparisonSummary;
    private collectMetricNames;
    private getThresholdViolations;
    private getFailureReason;
}

export { AgentBehaviorFailureMetric, AgentClient, type AgentResponse, AgentestConfig, AgentestConfigInput, type ChatMessage, CoherenceMetric, ComparisonRunResult, ComparisonScenarioResult, ConsoleReporter, ConversationEvaluation, ConversationMetric, ConversationScoreInput, CustomHandlerContext, FaithfulnessMetric, GitHubActionsReporter, GoalCompletionMetric, HelpfulnessMetric, JsonReporter, LLMProvider, ProgressEvent, QualResult, QualitativeMetric, QuantResult, QuantitativeMetric, RelevanceMetric, Reporter, RunResult, Scenario, ScenarioOptions, ScenarioResult, ScoreInput, SimulatedUser, type ThresholdViolation, type ToolCall, ToolCallBehaviorFailureMetric, VerbosityMetric, clearScenarioRegistry, computeMetricAverages, computeThresholdViolations, computeTurnAverages, defineConfig, formatHistory, formatKnowledge, formatToolCallSignatures, formatToolCalls, formatToolResults, getRegisteredScenarios, renderPrompt, scenario, wrapContent };