@cuylabs/agent-core 0.7.0 → 0.9.0

package/dist/inference/errors/index.d.ts

@@ -0,0 +1,11 @@
+import { E as ErrorCategory, R as ResponseHeaders } from '../../llm-error-D93FNNLY.js';
+export { L as LLMError, a as LLMErrorOptions } from '../../llm-error-D93FNNLY.js';
+
+declare function isRetryableCategory(category: ErrorCategory): boolean;
+declare function parseRetryDelay(headers: ResponseHeaders): number | undefined;
+
+declare function isRetryable(error: unknown): boolean;
+declare function getRetryDelay(error: unknown): number | undefined;
+declare function getErrorCategory(error: unknown): ErrorCategory;
+
+export { ErrorCategory, ResponseHeaders, getErrorCategory, getRetryDelay, isRetryable, isRetryableCategory, parseRetryDelay };

package/dist/inference/errors/index.js

@@ -0,0 +1,16 @@
+import {
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+} from "../../chunk-4QFNWPIF.js";
+export {
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+};

package/dist/inference/index.d.ts

@@ -1,16 +1,20 @@
 import { ToolSet } from 'ai';
-import { T as Tool } from '../tool-Db1Ue-1U.js';
+import { T as Tool } from '../tool-CZWN3KbO.js';
 import { T as ToolHost } from '../types-CHiPh8U2.js';
-import { M as MiddlewareRunner } from '../runner-DSKaEz3z.js';
-export { S as StreamChunk } from '../runner-DSKaEz3z.js';
-import { d as TurnTrackerContext } from '../tool-HUtkiVBx.js';
-import { T as ToolExecutionMode, I as InferenceStreamInput, A as AnyInferenceResult } from '../types-FRpzzg_9.js';
-export { a as AnyStreamResult, C as CustomStreamProvider, b as CustomStreamResult, D as DEFAULT_MAX_OUTPUT_TOKENS, c as InferenceCustomResult, d as InferenceStepInfo, e as InferenceStreamResult, L as LLMStreamInput, f as LLMStreamResult, O as OUTPUT_TOKEN_MAX, S as StepInfo } from '../types-FRpzzg_9.js';
+import { M as MiddlewareRunner } from '../runner-CI-XeR16.js';
+import { d as TurnTrackerContext } from '../tool-DkhSCV2Y.js';
+import { T as ToolExecutionMode, I as InferenceStreamInput, A as AnyInferenceResult } from '../types-BlOKk-Bb.js';
+export { a as AnyStreamResult, C as CustomStreamProvider, b as CustomStreamResult, D as DEFAULT_MAX_OUTPUT_TOKENS, c as DEFAULT_RETRY_CONFIG, d as InferenceCustomResult, e as InferenceStepInfo, f as InferenceStreamResult, L as LLMStreamInput, g as LLMStreamResult, O as OUTPUT_TOKEN_MAX, R as RetryConfig, h as RetryHandlerOptions, i as RetryState, S as StepInfo, j as calculateDelay, k as createRetryHandler, l as createRetryState, s as shouldRetry, m as sleep, w as withRetry } from '../types-BlOKk-Bb.js';
+export { E as ErrorCategory, L as LLMError, a as LLMErrorOptions, R as ResponseHeaders } from '../llm-error-D93FNNLY.js';
+export { getErrorCategory, getRetryDelay, isRetryable, isRetryableCategory, parseRetryDelay } from './errors/index.js';
+export { S as StreamChunk } from '../types-DTSkxakL.js';
 import 'zod';
-import '@ai-sdk/provider-utils';
+import '../events-CE72w8W4.js';
 import '../messages-BYWGn8TY.js';
-import '../types-9jGQUjqW.js';
+import '../types-CQL-SvTn.js';
 import '../types-CQaXbRsS.js';
+import '@ai-sdk/provider-utils';
+import '../types-BfNpU8NS.js';
 
 /**
  * Build a Vercel AI SDK `ToolSet` from `Tool.Info` definitions.

package/dist/inference/index.js

@@ -1,25 +1,53 @@
 import {
   DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_RETRY_CONFIG,
   Inference,
   LLM,
   OUTPUT_TOKEN_MAX,
   buildToolSet,
+  calculateDelay,
+  createRetryHandler,
+  createRetryState,
+  shouldRetry,
+  sleep,
   stream,
   streamOnce,
-  streamStep
-} from "../chunk-5K7AQVOU.js";
-import "../chunk-ZPMACVZK.js";
-import "../chunk-IEFIQENH.js";
-import "../chunk-N7P4PN3O.js";
+  streamStep,
+  withRetry
+} from "../chunk-WKHDSSXG.js";
+import "../chunk-H3FUYU52.js";
 import "../chunk-VEKUXUVF.js";
-import "../chunk-QGOGIP7T.js";
+import {
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+} from "../chunk-4QFNWPIF.js";
+import "../chunk-N7P4PN3O.js";
+import "../chunk-UDCZ673N.js";
+import "../chunk-I6PKJ7XQ.js";
 export {
   DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_RETRY_CONFIG,
   Inference,
   LLM,
+  LLMError,
   OUTPUT_TOKEN_MAX,
   buildToolSet,
+  calculateDelay,
+  createRetryHandler,
+  createRetryState,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay,
+  shouldRetry,
+  sleep,
   stream,
   streamOnce,
-  streamStep
+  streamStep,
+  withRetry
 };

package/dist/llm-error-D93FNNLY.d.ts

@@ -0,0 +1,32 @@
+type ErrorCategory = "rate_limit" | "overloaded" | "auth" | "invalid_request" | "context_overflow" | "content_filter" | "network" | "timeout" | "cancelled" | "unknown";
+interface ResponseHeaders {
+    "retry-after"?: string;
+    "retry-after-ms"?: string;
+    "x-ratelimit-remaining"?: string;
+    "x-ratelimit-reset"?: string;
+    [key: string]: string | undefined;
+}
+interface LLMErrorOptions {
+    message: string;
+    category?: ErrorCategory;
+    status?: number;
+    headers?: ResponseHeaders;
+    cause?: Error;
+    provider?: string;
+    model?: string;
+}
+
+declare class LLMError extends Error {
+    readonly category: ErrorCategory;
+    readonly status?: number;
+    readonly headers?: ResponseHeaders;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly isRetryable: boolean;
+    readonly retryDelayMs?: number;
+    constructor(options: LLMErrorOptions);
+    static from(error: unknown, context?: Partial<LLMErrorOptions>): LLMError;
+    get description(): string;
+}
+
+export { type ErrorCategory as E, LLMError as L, type ResponseHeaders as R, type LLMErrorOptions as a };

package/dist/middleware/index.d.ts

@@ -1,11 +1,250 @@
-export { h as AgentMiddleware, i as AgentModelHooks, B as BlockedModelCall, M as MiddlewareRunner, m as ModelCallContext, e as ModelCallInput, n as ModelCallOutput, T as ToolCallDecision } from '../runner-DSKaEz3z.js';
-export { c as ApprovalMiddlewareConfig, C as CacheTTL, O as OtelMiddlewareConfig, P as PromptCacheConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware, p as promptCacheMiddleware } from '../index-CfBGYrpd.js';
-import 'ai';
+import { A as AgentMiddleware } from '../types-DTSkxakL.js';
+export { g as AgentModelHooks, B as BlockedModelCall, a as ModelCallContext, M as ModelCallInput, b as ModelCallOutput, T as ToolCallDecision } from '../types-DTSkxakL.js';
+export { M as MiddlewareRunner } from '../runner-CI-XeR16.js';
+import { a as ApprovalConfig, R as RiskLevel } from '../types-CWm-7rvB.js';
+import { TelemetrySettings } from 'ai';
 import '@ai-sdk/provider-utils';
+import '../events-CE72w8W4.js';
 import '../messages-BYWGn8TY.js';
-import '../tool-Db1Ue-1U.js';
-import 'zod';
-import '../tool-HUtkiVBx.js';
+import '../types-BfNpU8NS.js';
+import '../types-CQL-SvTn.js';
+import '../tool-DkhSCV2Y.js';
 import '../types-CHiPh8U2.js';
-import '../types-9jGQUjqW.js';
+import '../tool-CZWN3KbO.js';
+import 'zod';
 import '../types-CQaXbRsS.js';
+
+/**
+ * Approval Middleware
+ *
+ * Wraps the existing approval system as an AgentMiddleware.
+ * This is how approval finally gets wired into the tool execution
+ * pipeline — no more dead code.
+ *
+ * @example
+ * ```typescript
+ * import { createAgent, approvalMiddleware } from "@cuylabs/agent-core";
+ *
+ * const agent = createAgent({
+ *   model: anthropic("claude-sonnet-4-20250514"),
+ *   tools: [read, write, bash],
+ *   middleware: [
+ *     approvalMiddleware({
+ *       rules: [
+ *         { pattern: "src/*", tool: "read_file", action: "allow" },
+ *       ],
+ *       onRequest: async (req) => {
+ *         // Prompt user in your UI
+ *         return await askUser(req);
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+
+/**
+ * Configuration for the approval middleware.
+ *
+ * Extends the existing ApprovalConfig with middleware-specific options.
+ */
+interface ApprovalMiddlewareConfig extends ApprovalConfig {
+    /**
+     * Custom risk classification for tools.
+     *
+     * Overrides the built-in risk map. Tools not listed here
+     * fall back to the default classification.
+     *
+     * @example
+     * ```typescript
+     * customRisks: {
+     *   "my_deploy_tool": "dangerous",
+     *   "my_lint_tool": "safe",
+     * }
+     * ```
+     */
+    customRisks?: Record<string, RiskLevel>;
+}
+/**
+ * Create an approval middleware from an ApprovalConfig.
+ *
+ * This bridges the existing `createApprovalHandler` into the middleware
+ * system. The `beforeToolCall` hook checks rules, classifies risk,
+ * and calls the approval handler when needed.
+ *
+ * @param config - Approval configuration (rules, handler, timeout, etc.)
+ * @returns An AgentMiddleware that gates tool execution
+ */
+declare function approvalMiddleware(config?: ApprovalMiddlewareConfig): AgentMiddleware;
+
+/**
+ * Configuration for the OpenTelemetry middleware.
+ */
+interface OtelMiddlewareConfig {
+    /**
+     * Whether to record tool call arguments as span attributes.
+     * Defaults to `true`.
+     */
+    recordInputs?: boolean;
+    /**
+     * Whether to record tool results as span attributes.
+     * Defaults to `true`.
+     */
+    recordOutputs?: boolean;
+    /**
+     * Agent name — used in the root span name and attributes.
+     * Falls back to `"agent"`.
+     */
+    agentName?: string;
+    /** Agent description — recorded as `gen_ai.agent.description`. */
+    agentDescription?: string;
+    /**
+     * Whether to emit `execute_tool` spans for tool calls.
+     * Defaults to `true`.
+     */
+    emitToolSpans?: boolean;
+    /**
+     * TTL in milliseconds for orphaned spans.
+     * Defaults to 5 minutes.
+     */
+    spanTimeoutMs?: number;
+}
+/**
+ * Configuration for `createTelemetryConfig()`.
+ */
+interface TelemetryConfig {
+    /** Agent name — used in span names and `gen_ai.agent.name`. */
+    agentName: string;
+    /** Agent description — recorded as `gen_ai.agent.description`. */
+    agentDescription?: string;
+    /** Record tool arguments and LLM prompts in spans. Defaults to `true`. */
+    recordInputs?: boolean;
+    /** Record tool results and LLM responses in spans. Defaults to `true`. */
+    recordOutputs?: boolean;
+    /** Emit `execute_tool` spans from our middleware. Defaults to `true`. */
+    emitToolSpans?: boolean;
+    /** TTL in ms for orphaned spans. Defaults to 5 minutes. */
+    spanTimeoutMs?: number;
+    /**
+     * An OTel `SpanProcessor` to auto-create and register a `NodeTracerProvider`.
+     */
+    spanProcessor?: unknown;
+    /**
+     * OTel service name for the `NodeTracerProvider` resource.
+     * Defaults to `agentName`.
+     */
+    serviceName?: string;
+}
+/**
+ * Result of `createTelemetryConfig()`.
+ */
+interface TelemetryConfigResult {
+    /** Agent-core middleware. */
+    middleware: AgentMiddleware;
+    /** AI SDK telemetry settings. */
+    telemetry: TelemetrySettings;
+    /**
+     * Flush and shut down the auto-created tracer provider.
+     * No-op when no provider was auto-created.
+     */
+    shutdown: () => Promise<void>;
+}
+
+declare function otelMiddleware(config?: OtelMiddlewareConfig): AgentMiddleware;
+
+declare function createTelemetryConfig(config: TelemetryConfig): TelemetryConfigResult;
+
+/**
+ * Prompt Cache Middleware — Type definitions.
+ *
+ * The middleware auto-detects the model provider and applies the right
+ * caching strategy. Currently supports Anthropic's `cache_control`
+ * with ephemeral breakpoints. Other providers pass through unchanged
+ * until their caching strategy is implemented.
+ */
+/**
+ * Supported cache TTL values.
+ *
+ * - `"5m"` — 5-minute cache (default, ~90% input cost reduction on Anthropic)
+ * - `"1h"` — 1-hour cache (higher write cost, longer retention)
+ */
+type CacheTTL = "5m" | "1h";
+/**
+ * Configuration for the prompt cache middleware.
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect provider, 5-minute TTL
+ * promptCacheMiddleware()
+ *
+ * // Custom TTL
+ * promptCacheMiddleware({ ttl: "1h" })
+ *
+ * // Custom breakpoint strategy (Anthropic)
+ * promptCacheMiddleware({ messageBreakpoints: 2 })
+ * ```
+ */
+interface PromptCacheConfig {
+    /**
+     * Cache TTL. Defaults to `"5m"`.
+     *
+     * - `"5m"` — 5 minutes.
+     * - `"1h"` — 1 hour.
+     */
+    ttl?: CacheTTL;
+    /**
+     * Number of cache breakpoints to place on conversation messages.
+     *
+     * For Anthropic: max 4 breakpoints total (system always gets 1).
+     * This controls additional breakpoints on conversation messages.
+     *
+     * Defaults to `1` (system + 1 message boundary = 2 breakpoints).
+     * Set to `0` to only cache the system prompt.
+     */
+    messageBreakpoints?: number;
+}
+
+/**
+ * Prompt Cache Middleware — provider-dispatched prompt caching.
+ *
+ * Auto-detects the model provider and applies the right caching strategy:
+ *
+ * - **Anthropic**: Sets `cache_control: { type: "ephemeral" }` breakpoints
+ *   on system prompt and stable conversation messages. Up to 4 breakpoints.
+ *
+ * - **Other providers**: Pass through unchanged (strategies can be added).
+ *
+ * @example
+ * ```typescript
+ * import { promptCacheMiddleware } from "@cuylabs/agent-core/middleware";
+ *
+ * const agent = createAgent({
+ *   model: anthropic("claude-sonnet-4-20250514"),
+ *   middleware: [promptCacheMiddleware()],
+ * });
+ * ```
+ */
+
+/**
+ * Create a prompt cache middleware that auto-detects the model provider
+ * and applies the right caching strategy.
+ *
+ * Currently supported:
+ * - **Anthropic** — `cache_control` breakpoints on system + messages
+ *
+ * Unsupported providers pass through unchanged.
+ *
+ * @param config - Optional TTL and breakpoint settings
+ *
+ * @example
+ * ```typescript
+ * // Works with any supported provider — auto-detects
+ * const agent = createAgent({
+ *   model: anthropic("claude-sonnet-4-20250514"),
+ *   middleware: [promptCacheMiddleware()],
+ * });
+ * ```
+ */
+declare function promptCacheMiddleware(config?: PromptCacheConfig): AgentMiddleware;
+
+export { AgentMiddleware, type ApprovalMiddlewareConfig, type CacheTTL, type OtelMiddlewareConfig, type PromptCacheConfig, type TelemetryConfig, type TelemetryConfigResult, approvalMiddleware, createTelemetryConfig, otelMiddleware, promptCacheMiddleware };

package/dist/middleware/index.js

@@ -4,7 +4,9 @@ import {
   createTelemetryConfig,
   otelMiddleware,
   promptCacheMiddleware
-} from "../chunk-CDTV2UYU.js";
+} from "../chunk-MAZ5DY5B.js";
+import "../chunk-5ARZJWD2.js";
+import "../chunk-I6PKJ7XQ.js";
 export {
   MiddlewareRunner,
   approvalMiddleware,

package/dist/models/index.d.ts

@@ -1,6 +1,8 @@
 import { LanguageModel } from 'ai';
-import { C as CapabilitySource, S as SourcePriority, d as SourceResult, P as ProviderCompatibility, c as ResolverOptions, b as ModelEntry, M as ModelCapabilities, N as NetworkStatus } from '../capability-resolver-CgRGsWVX.js';
-export { D as DEFAULT_RESOLVER_OPTIONS, I as InputModality, a as ModelCapabilityResolver, O as OutputModality, R as ResolutionResult, e as configureResolver, f as extractModelId, g as extractProvider, h as getDefaultResolver } from '../capability-resolver-CgRGsWVX.js';
+import { C as CapabilitySource, S as SourcePriority, b as SourceResult, P as ProviderCompatibility, R as ResolverOptions, a as ModelEntry, M as ModelCapabilities } from '../index-BCqEGzBj.js';
+export { D as DEFAULT_RESOLVER_OPTIONS, I as InputModality, O as OutputModality, c as buildAnthropicOptions, d as buildBedrockOptions, e as buildGoogleOptions, f as buildGroqOptions, g as buildOpenAIOptions, h as buildOpenRouterOptions, i as buildReasoningOptions, j as buildReasoningOptionsSync, k as buildXAIOptions, l as getProviderOptionsKey, m as getReasoningConfig, n as getReasoningConfigSync, s as supportsReasoning, o as supportsReasoningSync } from '../index-BCqEGzBj.js';
+export { E as EXTENDED_LEVELS, F as FIXED_LEVELS, a as ReasoningConfig, R as ReasoningLevel, S as STANDARD_LEVELS, s as shouldIncludeReasoningSummary } from '../types-CQaXbRsS.js';
+import '@ai-sdk/provider-utils';
 
 /**
  * Extract a model ID string from a LanguageModel instance.
@@ -10,8 +12,21 @@ declare function getModelId(model: LanguageModel): string;
  * Extract a provider identifier from a LanguageModel instance.
  */
 declare function getProviderId(model: LanguageModel): string | undefined;
+/**
+ * Extract model ID from a LanguageModel.
+ *
+ * Canonical helper — use this instead of `getModelId` in consumer code.
+ */
+declare const extractModelId: (model: LanguageModel) => string;
+/**
+ * Extract provider from a LanguageModel.
+ *
+ * Tries the model's `.provider` property first, then falls back
+ * to pattern-matching the model ID via `inferProvider`.
+ */
+declare function extractProvider(model: LanguageModel): string | undefined;
 
-type AdapterKind = "openai" | "anthropic" | "google" | "openai-compatible";
+type AdapterKind = "openai" | "anthropic" | "google" | "openai-compatible" | "openrouter" | "azure" | "bedrock" | "vertex" | "xai" | "mistral" | "groq";
 type AdapterSettings = {
     apiKey?: string;
     baseUrl?: string;
@@ -33,11 +48,6 @@ type Directory = {
     entries?: Record<string, ModelSpec>;
 };
 type Resolver = (key: string) => Promise<LanguageModel>;
-/**
- * @deprecated Use `Resolver` (async) instead. Kept for backwards compatibility
- * with custom `build` functions that return synchronously.
- */
-type SyncResolver = (key: string) => LanguageModel;
 declare function createResolver(directory: Directory): Resolver;
 
 /**
@@ -47,6 +57,13 @@ declare function createResolver(directory: Directory): Resolver;
  * This is the fallback layer — always works offline.
  */
 
+/**
+ * Infer context window size (in tokens) from a model ID.
+ *
+ * Uses local pattern matching — no network calls, always fast.
+ * Returns `undefined` if the model isn't recognized.
+ */
+declare function inferContextWindow(modelId: string): number | undefined;
 /**
  * Infer provider from model ID
  */
@@ -106,6 +123,13 @@ declare class CacheCapabilitySource implements CapabilitySource {
     isAvailable(): Promise<boolean>;
 }
 
+interface NetworkStatus {
+    online: boolean;
+    lastSuccess?: number;
+    lastError?: string;
+    failureCount: number;
+}
+
 declare function getNetworkStatus(): NetworkStatus;
 
 declare class RemoteCapabilityFetcher {
@@ -132,4 +156,103 @@ declare class RemoteCapabilitySource implements CapabilitySource {
     refresh(): Promise<void>;
 }
 
-export { type AdapterSettings, CacheCapabilitySource, CapabilityCache, type CapabilityOverrides, CapabilitySource, type Directory, type EngineSpec, ModelCapabilities, ModelEntry, type ModelSpec, NetworkStatus, PatternCapabilitySource, ProviderCompatibility, RemoteCapabilityFetcher, RemoteCapabilitySource, type Resolver, ResolverOptions, SourcePriority, SourceResult, type SyncResolver, applyCapabilityOverride, createResolver, findCapabilityOverride, getModelId, getNetworkStatus, getProviderCompatibility, getProviderId, inferProvider, likelySupportsReasoning };
+/**
+ * Model Capability Resolver for @cuylabs/agent-core
+ *
+ * Main orchestrator that combines multiple capability sources:
+ * 1. User overrides (highest priority)
+ * 2. Local cache (fast, persisted)
+ * 3. Pattern matching (always available)
+ * 4. Remote API (optional, network-dependent)
+ *
+ * Designed for the Vercel AI SDK v6 ecosystem.
+ */
+
+/**
+ * Resolution result with source information
+ */
+interface ResolutionResult {
+    /** The resolved model entry */
+    entry: ModelEntry;
+    /** Which source provided the primary result */
+    source: SourcePriority;
+    /** Whether this is a confident match */
+    confident: boolean;
+    /** Resolution timing in ms */
+    resolveTimeMs: number;
+}
+/**
+ * Model Capability Resolver
+ *
+ * Provides a unified API for querying model capabilities with
+ * automatic fallback through multiple sources.
+ */
+declare class ModelCapabilityResolver {
+    private options;
+    private cache;
+    private sources;
+    private initialized;
+    private initPromise;
+    constructor(options?: Partial<ResolverOptions>);
+    /**
+     * Initialize the resolver (load cache, optionally fetch remote)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Resolve capabilities for a model
+     */
+    resolve(model: LanguageModel): Promise<ResolutionResult>;
+    /**
+     * Quick check if a model supports reasoning
+     * Uses cache/patterns only for speed
+     */
+    supportsReasoning(model: LanguageModel): Promise<boolean>;
+    /**
+     * Get capabilities for a model
+     */
+    getCapabilities(model: LanguageModel): Promise<ModelCapabilities>;
+    /**
+     * Get provider compatibility settings
+     */
+    getCompatibility(model: LanguageModel): Promise<ProviderCompatibility | undefined>;
+    /**
+     * Force refresh from remote API
+     */
+    refreshRemote(): Promise<void>;
+    /**
+     * Get current network status
+     */
+    getNetworkStatus(): NetworkStatus;
+    /**
+     * Get resolver statistics
+     */
+    getStats(): {
+        cacheSize: number;
+        cacheLoaded: boolean;
+        remoteFetchEnabled: boolean;
+        networkOnline: boolean;
+    };
+    /**
+     * Clear all cached data
+     */
+    clearCache(): Promise<void>;
+    /**
+     * List all available models
+     * Fetches from remote if cache is empty and remote is enabled
+     */
+    listModels(): Promise<ModelEntry[]>;
+    /**
+     * List all available models grouped by provider
+     */
+    listModelsByProvider(): Promise<Record<string, ModelEntry[]>>;
+}
+/**
+ * Get the default resolver instance
+ */
+declare function getDefaultResolver(): ModelCapabilityResolver;
+/**
+ * Configure the default resolver with custom options
+ */
+declare function configureResolver(options: Partial<ResolverOptions>): void;
+
+export { type AdapterSettings, CacheCapabilitySource, CapabilityCache, type CapabilityOverrides, CapabilitySource, type Directory, type EngineSpec, ModelCapabilities, ModelCapabilityResolver, ModelEntry, type ModelSpec, type NetworkStatus, PatternCapabilitySource, ProviderCompatibility, RemoteCapabilityFetcher, RemoteCapabilitySource, type ResolutionResult, type Resolver, ResolverOptions, SourcePriority, SourceResult, applyCapabilityOverride, configureResolver, createResolver, extractModelId, extractProvider, findCapabilityOverride, getDefaultResolver, getModelId, getNetworkStatus, getProviderCompatibility, getProviderId, inferContextWindow, inferProvider, likelySupportsReasoning };