import type { Agent, StreamFn } from "@caupulican/pi-agent-core";
import { type TextToolProtocolVariant } from "@caupulican/pi-ai/text-tool-protocol";
import type { Api, AssistantMessage, Model, TextToolProtocolParseEvent, Usage } from "@caupulican/pi-ai/types";
import type { ToolArgumentValidationTelemetryEvent } from "@caupulican/pi-ai/validation";
import type { ModelRegistry } from "./model-registry.ts";
import { type ModelToolProtocolResolution } from "./model-tool-protocol.ts";
import type { ModelAdaptationRule, ModelAdaptationStore, ModelToolProbeVerdict, NativeToolProbeGrade } from "./models/adaptation-store.ts";
import type { RequestAuth } from "./request-auth.ts";
import type { SettingsManager } from "./settings-manager.ts";
import type { ToolRecoveryLoggerStats } from "./tool-recovery-logger.ts";
export type ToolProbeVerdict = "native" | "text-protocol" | "none";
export interface ToolProbeResult {
    model: string;
    verdict: ToolProbeVerdict;
    variant?: TextToolProtocolVariant;
    nativeGrade?: NativeToolProbeGrade;
    diagnostic?: string;
}
export interface ToolProbeReport {
    results: ToolProbeResult[];
    table: string;
}
export interface ToolProtocolControllerDeps {
    agent: Agent;
    agentDir: string;
    settingsManager: SettingsManager;
    getModelRegistry(): ModelRegistry;
    adaptationStore: ModelAdaptationStore;
    isRawStreamSimple(fn: StreamFn): boolean;
    getRequiredRequestAuth(model: Model<Api>): Promise<RequestAuth>;
    addSpawnedUsage(usage: Usage, opts: {
        label?: string;
        reportId: string;
    }): string | undefined;
    emitWarning(message: string): void;
    sendCorrectiveSteer(message: string): Promise<void>;
    findLastAssistantMessage(): AssistantMessage | undefined;
    isDisposed(): boolean;
    probeForAuto(model: Model<Api>): Promise<ToolProbeResult>;
}
/** Owns model tool-protocol selection, probing, circuit breaking, and repair teaching. */
export declare class ToolProtocolController {
    private readonly repairModeSessionCounts;
    private readonly parseFailures;
    private parseObservedThisTurn;
    private correctiveSteerCount;
    private probeUsageReportSeq;
    private readonly autoProbedModels;
    private validationOutcomeThisTurn;
    private readonly deps;
    constructor(deps: ToolProtocolControllerDeps);
    applyRepairLayerSettings(): void;
    resetTurnState(): void;
    getAdaptationRulesForPrompt(): ModelAdaptationRule[];
    resolveModelToolProtocol(model: Model<Api>): ModelToolProtocolResolution;
    ensureActiveModelProtocol(): Promise<void>;
    getToolProbeVerdict(model: Model<Api>): ModelToolProbeVerdict | undefined;
    probeToolCalling(target?: string): Promise<ToolProbeReport>;
    probeToolCallingForModel(model: Model<Api>): Promise<ToolProbeResult>;
    handleTextProtocolParse(event: TextToolProtocolParseEvent): void;
    handleValidationOutcome(event: ToolArgumentValidationTelemetryEvent): void;
    recordParseOutcomeFromLastAssistant(): void;
    tagAdaptationRuleTeaching(event: ToolArgumentValidationTelemetryEvent): ToolArgumentValidationTelemetryEvent;
    handleAdaptationTelemetry(event: ToolArgumentValidationTelemetryEvent): void;
    maybeAutoProbe(model: Model<Api>): void;
    formatRepairHealth(stats?: ToolRecoveryLoggerStats): string;
    removeRepairRule(model: string, mode: string): boolean;
    resetProtocolCalibration(model: string): boolean;
    getRepairSettings(): import("./tool-repair-settings.ts").ResolvedToolRepairSettings;
    private modelKey;
    private modelRef;
    private streamForProbe;
    private nextProbeUsageReportId;
    private resolveProbeStreamCountingUsage;
    private textProtocolCalibrationContext;
    private messageHasToolCallWithStringArgument;
    private nativeToolProbeSystemPrompt;
    private runNativeToolProbeTrial;
    private runNativeReadTaskProbeTrial;
    private runNativeEchoToolProbeTrial;
    private gradeNativeToolCallingForModel;
    private runTextProtocolTrial;
    private calibrateTextToolProtocolForModel;
    private formatToolProbeReport;
    private storeToolProbe;
    private resolveToolProbeModels;
    private maybeInjectCorrectiveSteer;
    private looksLikeTextProtocolAttempt;
    private repairSessionCount;
    private hasFreshToolProbeVerdict;
}
//# sourceMappingURL=tool-protocol-controller.d.ts.map