import type { PipelineCommandConfig, PipelineExtractionConfig, PipelineSynthesisConfig } from "./types";
export declare const ROUTING_ACCOUNT_KINDS: readonly ["subscription_session", "api"];
export declare const ROUTING_TARGET_KINDS: readonly ["subscription_session", "api", "local", "gateway"];
export declare const ROUTING_EXECUTOR_KINDS: readonly ["acpx", "claude-code", "codex", "opencode", "anthropic", "openrouter", "ollama", "llama-cpp", "openai-compatible", "command"];
export declare const ROUTING_POLICY_MODES: readonly ["strict", "automatic", "hybrid"];
export declare const ROUTING_PRIVACY_TIERS: readonly ["remote_ok", "restricted_remote", "local_only"];
export declare const ROUTING_REASONING_DEPTHS: readonly ["low", "medium", "high"];
export declare const ROUTING_COST_TIERS: readonly ["low", "medium", "high"];
export declare const ROUTING_OPERATION_KINDS: readonly ["default", "interactive", "tool_planning", "code_reasoning", "memory_extraction", "session_synthesis", "aggregate_recall", "widget_generation", "repair", "os_agent"];
export type RoutingAccountKind = (typeof ROUTING_ACCOUNT_KINDS)[number];
export type RoutingTargetKind = (typeof ROUTING_TARGET_KINDS)[number];
export type RoutingExecutorKind = (typeof ROUTING_EXECUTOR_KINDS)[number] | (string & {});
export type RoutingPolicyMode = (typeof ROUTING_POLICY_MODES)[number];
export type RoutingPrivacyTier = (typeof ROUTING_PRIVACY_TIERS)[number];
export type RoutingReasoningDepth = (typeof ROUTING_REASONING_DEPTHS)[number];
export type RoutingCostTier = (typeof ROUTING_COST_TIERS)[number];
export type RoutingOperationKind = (typeof ROUTING_OPERATION_KINDS)[number];
/**
 * Task classes the classifier can emit that are NOT declared in config.taskClasses.
 * Configs may legitimately key policy.taskTargets / agent.preferredTargets /
 * agent.pinnedTargets by these, so reference validation must treat them as valid.
 */
export declare const ROUTING_CLASSIFIER_TASK_CLASSES: {
    readonly codeReasoning: "hard_coding";
    readonly localSensitive: "local_sensitive";
};
export type RoutingTargetRef = string & {
    readonly __brand: "RoutingTargetRef";
};
export type RoutingPolicyId = string & {
    readonly __brand: "RoutingPolicyId";
};
export type RoutingAgentId = string & {
    readonly __brand: "RoutingAgentId";
};
export interface RouterError {
    readonly code: "invalid-config" | "invalid-target-ref" | "policy-not-found" | "no-candidates" | "target-not-found" | "execution-failed";
    readonly message: string;
    readonly details?: Readonly<Record<string, unknown>>;
}
export interface RoutingValidationIssue {
    readonly severity: "error" | "warning";
    /** Dotted path to the reference site, e.g. "workloads.memoryExtraction.target". */
    readonly field: string;
    /** The broken reference value. */
    readonly ref: string;
    readonly message: string;
}
export type RouterResult<T> = {
    readonly ok: true;
    readonly value: T;
} | {
    readonly ok: false;
    readonly error: RouterError;
};
export interface RoutingAccountConfig {
    readonly kind: RoutingAccountKind;
    readonly providerFamily: string;
    readonly label?: string;
    readonly credentialRef?: string;
    readonly sessionRef?: string;
    readonly usageTier?: string;
}
export interface RoutingModelConfig {
    readonly model: string;
    readonly label?: string;
    readonly reasoning?: RoutingReasoningDepth;
    readonly contextWindow?: number;
    readonly toolUse?: boolean;
    readonly streaming?: boolean;
    readonly multimodal?: boolean;
    readonly costTier?: RoutingCostTier;
    readonly averageLatencyMs?: number;
}
export interface RoutingOpenRouterReasoningConfig {
    readonly enabled?: boolean;
    readonly maxTokens?: number;
}
export interface RoutingOpenRouterConfig {
    readonly reasoning?: RoutingOpenRouterReasoningConfig;
}
export type RoutingAcpxPermissionMode = "inherit" | "deny-all" | "approve-reads" | "approve-all";
export type RoutingAcpxHooksMode = "inherit" | "disabled" | "enabled";
export type RoutingAcpxTerminalMode = "inherit" | "disabled" | "enabled";
export type RoutingAcpxSessionMode = "exec" | "session";
export type RoutingAcpxOutputFormat = "quiet" | "json";
export type AcpxModelSelection = "acp" | "agent";
export declare function resolveAcpxModelSelection(agent: string, configured?: AcpxModelSelection): AcpxModelSelection;
export interface RoutingAcpxConfig {
    readonly agent: string;
    readonly modelSelection?: AcpxModelSelection;
    readonly version?: string;
    readonly bin?: string;
    readonly package?: string;
    readonly cwd?: string;
    readonly session?: string;
    readonly mode?: RoutingAcpxSessionMode;
    readonly permissions?: RoutingAcpxPermissionMode;
    readonly hooks?: RoutingAcpxHooksMode;
    readonly terminal?: RoutingAcpxTerminalMode;
    readonly allowedTools?: readonly string[];
    readonly format?: RoutingAcpxOutputFormat;
    readonly captureEvents?: boolean;
    readonly maxCapturedEvents?: number;
    readonly emptyResponseRetries?: number;
    readonly timeoutMs?: number;
    readonly extraArgs?: readonly string[];
}
export interface RoutingTargetConfig {
    readonly kind: RoutingTargetKind;
    readonly executor: RoutingExecutorKind;
    readonly account?: string;
    readonly endpoint?: string;
    readonly command?: PipelineCommandConfig;
    readonly acpx?: RoutingAcpxConfig;
    readonly openrouter?: RoutingOpenRouterConfig;
    readonly privacy?: RoutingPrivacyTier;
    readonly models: Readonly<Record<string, RoutingModelConfig>>;
}
export interface RoutingPolicyConfig {
    readonly mode: RoutingPolicyMode;
    readonly allow?: readonly string[];
    readonly deny?: readonly string[];
    readonly defaultTargets?: readonly string[];
    readonly taskTargets?: Readonly<Record<string, readonly string[]>>;
    readonly fallbackTargets?: readonly string[];
    readonly maxLatencyMs?: number;
    readonly costCeiling?: RoutingCostTier;
}
export interface RoutingTaskClassConfig {
    readonly reasoning?: RoutingReasoningDepth;
    readonly toolsRequired?: boolean;
    readonly streamingPreferred?: boolean;
    readonly multimodalRequired?: boolean;
    readonly privacy?: RoutingPrivacyTier;
    readonly maxLatencyMs?: number;
    readonly costCeiling?: RoutingCostTier;
    readonly expectedInputTokens?: number;
    readonly expectedOutputTokens?: number;
    readonly preferredTargets?: readonly string[];
    readonly keywords?: readonly string[];
}
export interface AgentRoutingConfig {
    readonly defaultPolicy?: string;
    readonly roster?: readonly string[];
    readonly preferredTargets?: Readonly<Record<string, readonly string[]>>;
    readonly pinnedTargets?: Readonly<Record<string, string>>;
}
export interface RoutingWorkloadBinding {
    readonly policy?: string;
    readonly taskClass?: string;
    readonly target?: string;
}
export interface RoutingConfig {
    readonly source: "explicit" | "legacy-implicit";
    readonly enabled: boolean;
    readonly defaultPolicy?: string;
    readonly accounts: Readonly<Record<string, RoutingAccountConfig>>;
    readonly targets: Readonly<Record<string, RoutingTargetConfig>>;
    readonly policies: Readonly<Record<string, RoutingPolicyConfig>>;
    readonly taskClasses: Readonly<Record<string, RoutingTaskClassConfig>>;
    readonly agents: Readonly<Record<string, AgentRoutingConfig>>;
    readonly workloads?: {
        readonly default?: RoutingWorkloadBinding;
        readonly interactive?: RoutingWorkloadBinding;
        readonly memoryExtraction?: RoutingWorkloadBinding;
        readonly aggregateRecall?: RoutingWorkloadBinding;
        readonly widgetGeneration?: RoutingWorkloadBinding;
        readonly repair?: RoutingWorkloadBinding;
    };
}
export interface RoutingRuntimeState {
    readonly available: boolean;
    readonly health: "healthy" | "degraded" | "blocked";
    readonly circuitOpen: boolean;
    readonly accountState: "ready" | "missing" | "expired" | "rate_limited" | "unknown";
    readonly unavailableReason?: string;
}
export interface RoutingRuntimeSnapshot {
    readonly targets: Readonly<Record<string, RoutingRuntimeState>>;
}
export interface RouteRequest {
    readonly agentId?: string;
    readonly operation: RoutingOperationKind;
    readonly taskClass?: string;
    readonly explicitPolicy?: string;
    readonly explicitTargets?: readonly string[];
    readonly requireTools?: boolean;
    readonly requireStreaming?: boolean;
    readonly requireMultimodal?: boolean;
    readonly expectedInputTokens?: number;
    readonly expectedOutputTokens?: number;
    readonly privacy?: RoutingPrivacyTier;
    readonly latencyBudgetMs?: number;
    readonly costCeiling?: RoutingCostTier;
    readonly promptPreview?: string;
}
export interface RouteClassification {
    readonly taskClass: string;
    readonly reasoning: RoutingReasoningDepth;
    readonly source: "request" | "workload" | "classifier" | "default";
    readonly signals: readonly string[];
}
export interface RouteCandidateTrace {
    readonly targetRef: string;
    readonly allowed: boolean;
    readonly score: number | null;
    readonly reasons: readonly string[];
    readonly blockedBy: readonly string[];
    readonly runtime: RoutingRuntimeState;
}
export interface RouteTrace {
    readonly policyId: string;
    readonly mode: RoutingPolicyMode;
    readonly classification: RouteClassification;
    readonly orderedTargets: readonly string[];
    readonly candidates: readonly RouteCandidateTrace[];
}
export interface RouteDecision {
    readonly policyId: string;
    readonly mode: RoutingPolicyMode;
    readonly taskClass: string;
    readonly targetRef: string;
    readonly targetId: string;
    readonly modelId: string;
    readonly fallbackTargetRefs: readonly string[];
    readonly trace: RouteTrace;
}
export declare function isLocalInferenceEndpoint(endpoint: string | undefined): boolean;
export declare function makeRoutingTargetRef(targetId: string, modelId: string): RoutingTargetRef;
export declare function parseRoutingTargetRef(value: string): RouterResult<{
    readonly targetId: string;
    readonly modelId: string;
}>;
export declare function compileLegacyRoutingConfig(opts: {
    readonly extraction: Pick<PipelineExtractionConfig, "provider" | "model" | "endpoint" | "command" | "fallbackProvider">;
    /** Accepted only for legacy callers; it never creates a route. */
    readonly synthesis?: Pick<PipelineSynthesisConfig, "enabled" | "provider" | "model" | "endpoint">;
}): RoutingConfig;
/**
 * Validate that every cross-reference inside a routing config resolves.
 *
 * Error-severity issues make routing structurally non-functional and refuse
 * config load. Only a broken `defaultPolicy` qualifies: it is treated as a
 * structural anchor even though workload/agent policies can shadow it, because
 * a stale defaultPolicy almost always signals a rename the user forgot to
 * propagate (the #1005 case). This mirrors the pre-existing parse-time check.
 *
 * Warning-severity issues degrade routing for the affected path without
 * blocking load: dangling target refs are filtered out at route time, while a
 * stale policy reference (e.g. an agent defaultPolicy) surfaces as a per-route
 * policy-not-found error rather than silently misrouting.
 */
export declare function validateRoutingReferences(config: RoutingConfig): readonly RoutingValidationIssue[];
export declare function parseRoutingConfig(raw: unknown, legacyConfig?: RoutingConfig): RouterResult<RoutingConfig>;
export declare function allTargetRefs(config: RoutingConfig): readonly string[];
export declare function resolveRoutingDecision(config: RoutingConfig, request: RouteRequest, runtimeSnapshot: RoutingRuntimeSnapshot): RouterResult<RouteDecision>;
//# sourceMappingURL=routing.d.ts.map