@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/inference/index.d.ts

@@ -0,0 +1,62 @@
+import { ToolSet } from 'ai';
+import { T as Tool } from '../tool-BHbyUAy3.js';
+import { T as ToolHost } from '../types-CHiPh8U2.js';
+import { M as MiddlewareRunner } from '../runner-e2YRcUoX.js';
+export { S as StreamChunk } from '../runner-e2YRcUoX.js';
+import { d as TurnTrackerContext } from '../tool-DLXAR9Ce.js';
+import { T as ToolExecutionMode, I as InferenceStreamInput, A as AnyInferenceResult } from '../types-KKDrdU9Y.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-KKDrdU9Y.js';
+import 'zod';
+import '@ai-sdk/provider-utils';
+import '../events-CE72w8W4.js';
+import '../messages-BYWGn8TY.js';
+import '../types-BfNpU8NS.js';
+import '../types-CQL-SvTn.js';
+import '../types-CQaXbRsS.js';
+import '../llm-error-D93FNNLY.js';
+
+/**
+ * Build a Vercel AI SDK `ToolSet` from `Tool.Info` definitions.
+ */
+declare function buildToolSet(options: {
+    tools: Record<string, Tool.Info>;
+    cwd: string;
+    sessionID: string;
+    messageID: string;
+    abort: AbortSignal;
+    turnTracker?: TurnTrackerContext;
+    host?: ToolHost;
+    middleware?: MiddlewareRunner;
+    executionMode?: ToolExecutionMode;
+}): Promise<ToolSet>;
+
+/**
+ * Create a model inference stream with optional retry support.
+ */
+declare function stream(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+/**
+ * Create a stream without retry.
+ */
+declare function streamOnce(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+/**
+ * Create a single-step stream.
+ */
+declare function streamStep(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+
+declare const Inference: {
+    readonly buildToolSet: typeof buildToolSet;
+    readonly stream: typeof stream;
+    readonly streamOnce: typeof streamOnce;
+    readonly streamStep: typeof streamStep;
+};
+/**
+ * @deprecated Use `Inference`.
+ */
+declare const LLM: {
+    readonly buildToolSet: typeof buildToolSet;
+    readonly stream: typeof stream;
+    readonly streamOnce: typeof streamOnce;
+    readonly streamStep: typeof streamStep;
+};
+
+export { AnyInferenceResult, Inference, InferenceStreamInput, LLM, ToolExecutionMode, buildToolSet, stream, streamOnce, streamStep };

package/dist/inference/index.js

@@ -0,0 +1,27 @@
+import {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  Inference,
+  LLM,
+  OUTPUT_TOKEN_MAX,
+  buildToolSet,
+  stream,
+  streamOnce,
+  streamStep
+} from "../chunk-N6HWIEEA.js";
+import "../chunk-7VKQ4WPB.js";
+import "../chunk-VEKUXUVF.js";
+import "../chunk-SQU2AJHO.js";
+import "../chunk-N7P4PN3O.js";
+import "../chunk-RZITT45F.js";
+import "../chunk-RFEKJKTO.js";
+import "../chunk-DWYX7ASF.js";
+export {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  Inference,
+  LLM,
+  OUTPUT_TOKEN_MAX,
+  buildToolSet,
+  stream,
+  streamOnce,
+  streamStep
+};

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,8 +1,249 @@
-export { h as AgentMiddleware, i as AgentModelHooks, B as BlockedModelCall, M as MiddlewareRunner, m as ModelCallContext, f as ModelCallInput, n as ModelCallOutput, T as ToolCallDecision } from '../runner-G1wxEgac.js';
-export { c as ApprovalMiddlewareConfig, O as OtelMiddlewareConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware } from '../index-ipP3_ztp.js';
-import 'ai';
+import { A as AgentMiddleware } from '../runner-e2YRcUoX.js';
+export { f as AgentModelHooks, B as BlockedModelCall, M as MiddlewareRunner, h as ModelCallContext, e as ModelCallInput, i as ModelCallOutput, j as PluginCommand, k as PluginContext, l as PluginInit, T as ToolCallDecision } from '../runner-e2YRcUoX.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-pFAnJc5Y.js';
+import '../types-BfNpU8NS.js';
+import '../types-CQL-SvTn.js';
+import '../tool-DLXAR9Ce.js';
+import '../types-CHiPh8U2.js';
+import '../tool-BHbyUAy3.js';
 import 'zod';
-import '../tool-DYp6-cC3.js';
 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

@@ -2,11 +2,15 @@ import {
   MiddlewareRunner,
   approvalMiddleware,
   createTelemetryConfig,
-  otelMiddleware
-} from "../chunk-O2ZCFQL6.js";
+  otelMiddleware,
+  promptCacheMiddleware
+} from "../chunk-YSLSEQ6B.js";
+import "../chunk-BFM2YHNM.js";
+import "../chunk-DWYX7ASF.js";
 export {
   MiddlewareRunner,
   approvalMiddleware,
   createTelemetryConfig,
-  otelMiddleware
+  otelMiddleware,
+  promptCacheMiddleware
 };

package/dist/models/index.d.ts

@@ -1,7 +1,17 @@
-export { g as getModelId, a as getProviderId } from '../identifiers-BLUxFqV_.js';
 import { LanguageModel } from 'ai';
+import { C as CapabilitySource, S as SourcePriority, b as SourceResult, P as ProviderCompatibility, R as ResolverOptions, a as ModelEntry, M as ModelCapabilities } from '../types-QA4WhEfz.js';
+export { D as DEFAULT_RESOLVER_OPTIONS, I as InputModality, O as OutputModality } from '../types-QA4WhEfz.js';
 
-type AdapterKind = "openai" | "anthropic" | "google" | "openai-compatible";
+/**
+ * Extract a model ID string from a LanguageModel instance.
+ */
+declare function getModelId(model: LanguageModel): string;
+/**
+ * Extract a provider identifier from a LanguageModel instance.
+ */
+declare function getProviderId(model: LanguageModel): string | undefined;
+
+type AdapterKind = "openai" | "anthropic" | "google" | "openai-compatible" | "openrouter" | "azure" | "bedrock" | "vertex" | "xai" | "mistral" | "groq";
 type AdapterSettings = {
     apiKey?: string;
     baseUrl?: string;
@@ -30,4 +40,217 @@ type Resolver = (key: string) => Promise<LanguageModel>;
 type SyncResolver = (key: string) => LanguageModel;
 declare function createResolver(directory: Directory): Resolver;
 
-export { type AdapterSettings, type Directory, type EngineSpec, type ModelSpec, type Resolver, type SyncResolver, createResolver };
+/**
+ * Profile-Based Capability Detection for @cuylabs/agent-core
+ *
+ * Static pattern matching for model capabilities when no external data is available.
+ * 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
+ */
+declare function inferProvider(modelId: string): string | undefined;
+/**
+ * Pattern-based capability source
+ * Always available, uses heuristics to detect capabilities
+ */
+declare class PatternCapabilitySource implements CapabilitySource {
+    readonly priority = SourcePriority.PatternMatch;
+    readonly name = "Pattern Matching";
+    lookup(modelId: string, providerHint?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Quick check if a model ID likely supports reasoning
+ */
+declare function likelySupportsReasoning(modelId: string): boolean;
+/**
+ * Get provider compatibility for a model
+ */
+declare function getProviderCompatibility(modelId: string, provider?: string): ProviderCompatibility | undefined;
+
+type CapabilityOverrides = ResolverOptions["modelOverrides"];
+type OverrideLookup = {
+    override?: Partial<ModelCapabilities>;
+    matchedKey?: string;
+};
+declare function findCapabilityOverride(overrides: CapabilityOverrides, modelId: string, provider?: string): OverrideLookup;
+declare function applyCapabilityOverride(entry: ModelEntry, override?: Partial<ModelCapabilities>): ModelEntry;
+
+declare class CapabilityCache {
+    private adapter;
+    private memoryCache;
+    private ttlMs;
+    private loaded;
+    constructor(options?: Partial<ResolverOptions>);
+    private load;
+    get(modelId: string, provider?: string): Promise<ModelEntry | undefined>;
+    set(entry: ModelEntry): Promise<void>;
+    setMany(entries: ModelEntry[]): Promise<void>;
+    persist(): Promise<void>;
+    clear(): Promise<void>;
+    stats(): {
+        size: number;
+        loaded: boolean;
+    };
+    getAll(): Promise<ModelEntry[]>;
+    getAllByProvider(): Promise<Record<string, ModelEntry[]>>;
+}
+declare class CacheCapabilitySource implements CapabilitySource {
+    private cache;
+    readonly priority = SourcePriority.LocalCache;
+    readonly name = "Local Cache";
+    constructor(cache: CapabilityCache);
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+}
+
+interface NetworkStatus {
+    online: boolean;
+    lastSuccess?: number;
+    lastError?: string;
+    failureCount: number;
+}
+
+declare function getNetworkStatus(): NetworkStatus;
+
+declare class RemoteCapabilityFetcher {
+    private apiUrl;
+    private timeoutMs;
+    private cache;
+    private lastFetchTime;
+    private minFetchInterval;
+    constructor(cache: CapabilityCache, options?: Partial<ResolverOptions>);
+    fetchAll(): Promise<ModelEntry[]>;
+    ping(): Promise<boolean>;
+}
+
+declare class RemoteCapabilitySource implements CapabilitySource {
+    readonly priority = SourcePriority.RemoteAPI;
+    readonly name = "Remote API (models.dev)";
+    private fetcher;
+    private cache;
+    private fetchPromise;
+    private enabled;
+    constructor(cache: CapabilityCache, options?: Partial<ResolverOptions>);
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+    refresh(): Promise<void>;
+}
+
+/**
+ * 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.
+ */
+
+/**
+ * Extract model ID from LanguageModel
+ */
+declare function extractModelId(model: LanguageModel): string;
+/**
+ * Extract provider from LanguageModel
+ */
+declare function extractProvider(model: LanguageModel): string | undefined;
+/**
+ * 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, type SyncResolver, applyCapabilityOverride, configureResolver, createResolver, extractModelId, extractProvider, findCapabilityOverride, getDefaultResolver, getModelId, getNetworkStatus, getProviderCompatibility, getProviderId, inferContextWindow, inferProvider, likelySupportsReasoning };

package/dist/models/index.js

@@ -1,12 +1,50 @@
 import {
-  createResolver
-} from "../chunk-6TDTQJ4P.js";
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
+  createResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
+  getNetworkStatus,
+  getProviderCompatibility,
+  inferContextWindow,
+  inferProvider,
+  likelySupportsReasoning
+} from "../chunk-RFEKJKTO.js";
 import {
   getModelId,
   getProviderId
 } from "../chunk-DWYX7ASF.js";
 export {
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
   createResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
   getModelId,
-  getProviderId
+  getNetworkStatus,
+  getProviderCompatibility,
+  getProviderId,
+  inferContextWindow,
+  inferProvider,
+  likelySupportsReasoning
 };