import { A as AiModelsCatalogClient } from './AiModelsCatalogClient-DBSadPkS.js';
import { R as ResolutionStrategy, m as OpenRouterRoutingConfig, f as ModelResolutionSuccess, g as ModelResolverOptions, c as ModelResolutionInput, d as ModelResolutionNotFound } from './types-B7BnnrsK.js';
import { PreferOpenRouterInput, ProfileCatalogLane } from '@x12i/ai-profiles';
import { C as CostCalculator } from './CostCalculator-rEueUyh0.js';

/** Minimum input after host config merge. */
type InvokeModelResolutionInput = {
    /** Provider hint: openrouter | openai | anthropic | … May be omitted. */
    provider?: string;
    /** Model id or profile/choice key. Required. */
    model: string;
};
type PreferOpenRouterOptions = {
    /** Explicit override; when omitted reads PREFER_OPENROUTER env via ai-profiles. */
    preferOpenRouter?: PreferOpenRouterInput;
};
type InvokeModelResolutionOptions = {
    /** @default true — when false, skip catalog.resolveModel (passthrough). */
    resolveModels?: boolean;
    /** Shared catalog client; when omitted, create/use a process singleton. */
    catalog?: AiModelsCatalogClient;
    /** Pre-loaded routing env; when omitted, loadOpenRouterRoutingEnv(). */
    routingEnv?: OpenRouterRoutingConfig;
    /** OpenRouter preference. @default true when PREFER_OPENROUTER env unset. */
    preferOpenRouter?: boolean | PreferOpenRouterOptions;
    /**
     * When set, enables applyOpenRouterInvokeRouting.
     * When omitted, reads OPENROUTER_API_KEY from env.
     * No-op when key absent/empty.
     */
    openRouterApiKey?: string;
    /**
     * Fallback provider when resolution leaves provider unset.
     */
    defaultProvider?: string;
    /** Passed to catalog.resolveModel as catalogLane. @default "text" */
    catalogLane?: ProfileCatalogLane;
    /**
     * When true, reject inputs where isKnownProfileInput(model) before resolveModel.
     * @default false
     */
    modelsOnly?: boolean;
    /** Use bundled catalogs only (offline/tests). */
    bundledOnly?: boolean;
};
/** Router config fields produced by orchestrator (subset of router invoke config). */
type InvokeRouterConfigSlice = {
    provider: string;
    model: string;
    allowOpenRouterProxy?: boolean;
    providerProxy?: string;
};
type InvokeModelResolutionDiagnostics = {
    /** Caller input preserved. */
    originalProvider?: string;
    originalModel: string;
    /** Canonical catalog model id from resolveModel (vendor/slug). */
    modelId: string;
    routedViaOpenRouter: boolean;
    confidence: number;
    resolvedVia: ResolutionStrategy[];
    /** Set when resolution used ai-profiles profile/choice. */
    profile?: string;
    choice?: string;
    /**
     * For logging: original profile/choice key when input differed from resolved model.
     */
    profileKey?: string;
    invokedModelId: string;
};
type InvokeModelResolutionResult = {
    /** Ready to merge into host config before router.invoke. */
    router: InvokeRouterConfigSlice;
    /** Full success payload from catalog.resolveModel. */
    resolution: ModelResolutionSuccess;
    diagnostics: InvokeModelResolutionDiagnostics;
};

/**
 * End-to-end invoke model resolution: catalog + profiles + vendor mapping + OR routing.
 */
declare function resolveInvokeModel(input: InvokeModelResolutionInput, options?: InvokeModelResolutionOptions): Promise<InvokeModelResolutionResult>;

declare function buildInvokeModelResolverOptions(options?: Pick<InvokeModelResolutionOptions, "routingEnv" | "preferOpenRouter" | "catalogLane">): ModelResolverOptions;

/**
 * Map catalog resolution to router `{ provider, model }`.
 */
declare function mapResolutionToRouterConfig(resolution: ModelResolutionSuccess, input: InvokeModelResolutionInput, defaultProvider?: string): InvokeRouterConfigSlice;

type ApplyOpenRouterInvokeRoutingOptions = {
    routingEnv?: OpenRouterRoutingConfig;
    preferOpenRouter?: boolean | PreferOpenRouterOptions;
    openRouterApiKey?: string;
    resolution?: Pick<ModelResolutionSuccess, "routedViaOpenRouter">;
};
/**
 * Set router proxy flags when OpenRouter transport is effective and API key is present.
 */
declare function applyOpenRouterInvokeRouting(routerSlice: InvokeRouterConfigSlice, options?: ApplyOpenRouterInvokeRoutingOptions): InvokeRouterConfigSlice;

type AiToolsErrorCode = "INVALID_INVOKE_INPUT" | "MODEL_PROFILE_INPUT_REJECTED" | "PROFILE_RESOLVE_KEY_REQUIRED" | "MODEL_NOT_FOUND" | "SYNC_FETCH_FAILED" | "SYNC_UPSERT_FAILED" | "COST_CALCULATION_FAILED" | "COST_UNKNOWN_MODEL" | "INVALID_USAGE_INPUT" | "OPENROUTER_AUTH_FAILED" | "OPENROUTER_MODELS_FETCH_FAILED" | "CACHE_READ_ERROR";
declare class AiToolsError extends Error {
    readonly code: AiToolsErrorCode;
    readonly cause?: unknown | undefined;
    constructor(code: AiToolsErrorCode, message: string, cause?: unknown | undefined);
}
declare class ModelNotFoundError extends AiToolsError {
    constructor(modelId: string);
}
declare class ModelProfileInputRejectedError extends AiToolsError {
    readonly model: string;
    constructor(model: string);
}
declare class ModelResolutionError extends AiToolsError {
    readonly input: ModelResolutionInput;
    readonly result: ModelResolutionNotFound;
    constructor(input: ModelResolutionInput, result: ModelResolutionNotFound);
}
declare class SyncError extends AiToolsError {
    constructor(code: Extract<AiToolsErrorCode, "SYNC_FETCH_FAILED" | "SYNC_UPSERT_FAILED" | "OPENROUTER_AUTH_FAILED" | "OPENROUTER_MODELS_FETCH_FAILED">, message: string, cause?: unknown);
}
declare class CostCalculationError extends AiToolsError {
    constructor(message: string, cause?: unknown);
}
declare class ProfileResolveKeyRequiredError extends AiToolsError {
    readonly input: string;
    constructor(input: string, options?: {
        reason?: "bare_profile" | "not_profile_intent";
    });
}
declare class UnknownModelCostError extends AiToolsError {
    readonly model: string;
    readonly provider: string;
    constructor(model: string, provider: string);
}

declare const MODEL_PROFILE_UNROUTABLE = "MODEL_PROFILE_UNROUTABLE";
declare class ModelProfileUnroutableError extends Error {
    readonly profileKey: string;
    readonly provider: string | undefined;
    readonly code = "MODEL_PROFILE_UNROUTABLE";
    constructor(profileKey: string, provider: string | undefined, cause?: unknown);
}
declare function enrichModelResolutionError(input: InvokeModelResolutionInput, resolution: ModelResolutionNotFound): ModelResolutionError | ModelProfileUnroutableError;

/**
 * Resolve OpenRouter preference for invoke-time routing.
 * Delegates to `@x12i/ai-profiles` {@link resolvePreferOpenRouter}.
 */
declare function resolvePreferOpenRouterPreference(options?: boolean | PreferOpenRouterOptions): boolean;
/**
 * Resolve OpenRouter API key from explicit option or OPENROUTER_API_KEY env.
 */
declare function resolveOpenRouterApiKey(explicit?: string, env?: Record<string, string | undefined>): string | undefined;

type AiToolsInvokeClient = {
    catalog: AiModelsCatalogClient;
    calculator: CostCalculator;
    routingEnv: OpenRouterRoutingConfig;
};
type CreateAiToolsInvokeClientOptions = {
    cacheTtlMs?: number;
    bundledOnly?: boolean;
    costIncludeBreakdown?: boolean;
    cacheKey?: string;
};
declare function createAiToolsInvokeClient(options?: CreateAiToolsInvokeClientOptions): AiToolsInvokeClient;
/** Reset process singleton (tests). */
declare function resetAiToolsInvokeClientForTests(): void;
/**
 * Process singleton with config-key invalidation.
 * Returns null when catalog bootstrap fails.
 */
declare function getAiToolsInvokeClient(options?: CreateAiToolsInvokeClientOptions, logger?: {
    warn?: (msg: string, err?: unknown) => void;
}): Promise<AiToolsInvokeClient | null>;

export { AiToolsError as A, CostCalculationError as C, type InvokeModelResolutionDiagnostics as I, MODEL_PROFILE_UNROUTABLE as M, type PreferOpenRouterOptions as P, SyncError as S, UnknownModelCostError as U, type AiToolsErrorCode as a, type AiToolsInvokeClient as b, type ApplyOpenRouterInvokeRoutingOptions as c, type CreateAiToolsInvokeClientOptions as d, type InvokeModelResolutionInput as e, type InvokeModelResolutionOptions as f, type InvokeModelResolutionResult as g, type InvokeRouterConfigSlice as h, ModelNotFoundError as i, ModelProfileInputRejectedError as j, ModelProfileUnroutableError as k, ModelResolutionError as l, ProfileResolveKeyRequiredError as m, applyOpenRouterInvokeRouting as n, buildInvokeModelResolverOptions as o, createAiToolsInvokeClient as p, enrichModelResolutionError as q, getAiToolsInvokeClient as r, mapResolutionToRouterConfig as s, resetAiToolsInvokeClientForTests as t, resolveInvokeModel as u, resolveOpenRouterApiKey as v, resolvePreferOpenRouterPreference as w };