@cuylabs/agent-core 0.4.0 → 0.5.0

package/dist/chunk-QWFMX226.js

@@ -0,0 +1,879 @@
+import {
+  getModelId,
+  getProviderId
+} from "./chunk-DWYX7ASF.js";
+
+// src/capabilities/types.ts
+var SourcePriority = /* @__PURE__ */ ((SourcePriority3) => {
+  SourcePriority3[SourcePriority3["UserConfig"] = 0] = "UserConfig";
+  SourcePriority3[SourcePriority3["LocalCache"] = 1] = "LocalCache";
+  SourcePriority3[SourcePriority3["BundledData"] = 2] = "BundledData";
+  SourcePriority3[SourcePriority3["PatternMatch"] = 3] = "PatternMatch";
+  SourcePriority3[SourcePriority3["RemoteAPI"] = 4] = "RemoteAPI";
+  return SourcePriority3;
+})(SourcePriority || {});
+var DEFAULT_RESOLVER_OPTIONS = {
+  enableRemoteFetch: false,
+  remoteApiUrl: "https://models.dev",
+  cachePath: ".agent-core/cache",
+  cacheTtlMs: 60 * 60 * 1e3,
+  // 1 hour
+  networkTimeoutMs: 10 * 1e3,
+  // 10 seconds
+  modelOverrides: {}
+};
+
+// src/capabilities/patterns.ts
+var REASONING_PATTERNS = [
+  // OpenAI o-series
+  {
+    pattern: /^o[134]-?(mini|pro|preview)?$/i,
+    provider: "openai",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { supportsReasoningEffort: true, thinkingFormat: "openai" },
+    confidence: 0.95
+  },
+  // OpenAI GPT-5.x
+  {
+    pattern: /gpt-?5(\.\d)?/i,
+    provider: "openai",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { supportsReasoningEffort: true, thinkingFormat: "openai" },
+    confidence: 0.9
+  },
+  // DeepSeek R1 variants
+  {
+    pattern: /deepseek[_-]?r1|r1[_-]distill/i,
+    capabilities: { reasoning: true, toolCalling: false },
+    confidence: 0.95
+  },
+  // Anthropic Claude with thinking
+  {
+    pattern: /claude.*thinking|thinking.*claude/i,
+    provider: "anthropic",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "anthropic" },
+    confidence: 0.9
+  },
+  // Claude 4.x series (reasoning capable)
+  {
+    pattern: /claude[_-]?(opus|sonnet)[_-]?4/i,
+    provider: "anthropic",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "anthropic" },
+    confidence: 0.85
+  },
+  // Gemini thinking models
+  {
+    pattern: /gemini.*thinking|gemini[_-]?2\.5[_-]?pro/i,
+    provider: "google",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "google" },
+    confidence: 0.85
+  },
+  // Gemini 3.x (future-proofing)
+  {
+    pattern: /gemini[_-]?3/i,
+    provider: "google",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "google" },
+    confidence: 0.8
+  },
+  // Grok reasoning models
+  {
+    pattern: /grok[_-]?\d[_-]?(mini|reasoning)/i,
+    provider: "xai",
+    capabilities: { reasoning: true, toolCalling: true },
+    confidence: 0.85
+  },
+  // Qwen thinking models
+  {
+    pattern: /qwen.*thinking|qwen3/i,
+    capabilities: { reasoning: true, toolCalling: true },
+    confidence: 0.8
+  },
+  // Generic reasoning/thinking in name
+  {
+    pattern: /reasoning|thinking/i,
+    capabilities: { reasoning: true },
+    confidence: 0.7
+  }
+];
+var PROVIDER_PATTERNS = [
+  { pattern: /^(gpt|o[134]|chatgpt|davinci)/i, provider: "openai" },
+  { pattern: /^claude/i, provider: "anthropic" },
+  { pattern: /^gemini|^palm/i, provider: "google" },
+  { pattern: /^grok/i, provider: "xai" },
+  { pattern: /^deepseek/i, provider: "deepseek" },
+  { pattern: /^mistral|^mixtral|codestral/i, provider: "mistral" },
+  { pattern: /^llama/i, provider: "meta" },
+  { pattern: /^qwen/i, provider: "alibaba" },
+  { pattern: /^command/i, provider: "cohere" }
+];
+function inferProvider(modelId) {
+  const normalized = modelId.toLowerCase();
+  for (const { pattern, provider } of PROVIDER_PATTERNS) {
+    if (pattern.test(normalized)) {
+      return provider;
+    }
+  }
+  if (modelId.includes("/")) {
+    return modelId.split("/")[0];
+  }
+  return void 0;
+}
+function matchPatterns(modelId, providerHint) {
+  const normalized = modelId.toLowerCase();
+  for (const rule of REASONING_PATTERNS) {
+    if (rule.provider && providerHint && rule.provider !== providerHint) {
+      continue;
+    }
+    const matches = typeof rule.pattern === "string" ? normalized.includes(rule.pattern.toLowerCase()) : rule.pattern.test(normalized);
+    if (matches) {
+      return { rule, confidence: rule.confidence };
+    }
+  }
+  return void 0;
+}
+function createDefaultCapabilities() {
+  return {
+    reasoning: false,
+    toolCalling: true,
+    temperature: true,
+    attachments: false,
+    streaming: true,
+    inputModalities: ["text"],
+    outputModalities: ["text"]
+  };
+}
+var PatternCapabilitySource = class {
+  priority = 3 /* PatternMatch */;
+  name = "Pattern Matching";
+  async lookup(modelId, providerHint) {
+    const provider = providerHint || inferProvider(modelId);
+    const match = matchPatterns(modelId, provider);
+    const baseCapabilities = createDefaultCapabilities();
+    if (match) {
+      const entry = {
+        id: modelId,
+        name: modelId,
+        provider: match.rule.provider || provider || "unknown",
+        capabilities: {
+          ...baseCapabilities,
+          ...match.rule.capabilities
+        },
+        compatibility: match.rule.compatibility
+      };
+      return {
+        entry,
+        source: this.priority,
+        confident: match.confidence > 0.8
+      };
+    }
+    return {
+      entry: {
+        id: modelId,
+        name: modelId,
+        provider: provider || "unknown",
+        capabilities: baseCapabilities
+      },
+      source: this.priority,
+      confident: false
+    };
+  }
+  async isAvailable() {
+    return true;
+  }
+};
+function likelySupportsReasoning(modelId) {
+  const match = matchPatterns(modelId);
+  return match !== void 0 && match.rule.capabilities.reasoning === true;
+}
+function getProviderCompatibility(modelId, provider) {
+  const match = matchPatterns(modelId, provider);
+  return match?.rule.compatibility;
+}
+
+// src/capabilities/overrides.ts
+function normalizeKey(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function findCapabilityOverride(overrides, modelId, provider) {
+  if (!overrides) return {};
+  const normalizedModel = normalizeKey(modelId);
+  const normalizedProvider = normalizeKey(provider);
+  if (!normalizedModel) return {};
+  if (normalizedProvider) {
+    const scopedKey = `${normalizedProvider}/${normalizedModel}`;
+    const scopedOverride = overrides[scopedKey];
+    if (scopedOverride) {
+      return { override: scopedOverride, matchedKey: scopedKey };
+    }
+  }
+  const modelOverride = overrides[normalizedModel];
+  if (modelOverride) {
+    return { override: modelOverride, matchedKey: normalizedModel };
+  }
+  return {};
+}
+function applyCapabilityOverride(entry, override) {
+  if (!override) return entry;
+  return {
+    ...entry,
+    capabilities: {
+      ...entry.capabilities,
+      ...override
+    }
+  };
+}
+
+// src/capabilities/cache/adapters.ts
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function hasLocalStorage() {
+  try {
+    return typeof localStorage !== "undefined" && localStorage !== null;
+  } catch {
+    return false;
+  }
+}
+var FileSystemAdapter = class {
+  cachePath;
+  fs;
+  path;
+  constructor(cachePath) {
+    this.cachePath = cachePath;
+  }
+  async ensureModules() {
+    if (!this.fs) {
+      this.fs = await import("fs/promises");
+      this.path = await import("path");
+    }
+  }
+  getFilePath() {
+    return this.path.join(this.cachePath, "model-capabilities.json");
+  }
+  async read() {
+    await this.ensureModules();
+    try {
+      const content = await this.fs.readFile(this.getFilePath(), "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return void 0;
+    }
+  }
+  async write(data) {
+    await this.ensureModules();
+    const filePath = this.getFilePath();
+    await this.fs.mkdir(this.path.dirname(filePath), { recursive: true });
+    await this.fs.writeFile(filePath, JSON.stringify(data, null, 2));
+  }
+  async clear() {
+    await this.ensureModules();
+    try {
+      await this.fs.unlink(this.getFilePath());
+    } catch {
+    }
+  }
+};
+var LocalStorageAdapter = class {
+  key = "agent-core:model-capabilities";
+  async read() {
+    try {
+      const content = localStorage.getItem(this.key);
+      if (!content) return void 0;
+      return JSON.parse(content);
+    } catch {
+      return void 0;
+    }
+  }
+  async write(data) {
+    try {
+      localStorage.setItem(this.key, JSON.stringify(data));
+    } catch (error) {
+      console.warn("[agent-core] Failed to write to localStorage:", error);
+    }
+  }
+  async clear() {
+    try {
+      localStorage.removeItem(this.key);
+    } catch {
+    }
+  }
+};
+var MemoryAdapter = class {
+  data;
+  async read() {
+    return this.data;
+  }
+  async write(data) {
+    this.data = data;
+  }
+  async clear() {
+    this.data = void 0;
+  }
+};
+function createCapabilityCacheAdapter(cachePath) {
+  if (isNodeEnvironment()) {
+    return new FileSystemAdapter(cachePath);
+  }
+  if (hasLocalStorage()) {
+    return new LocalStorageAdapter();
+  }
+  return new MemoryAdapter();
+}
+
+// src/capabilities/cache/types.ts
+var CACHE_VERSION = 1;
+function cacheKey(modelId, provider) {
+  return provider ? `${provider}:${modelId}` : modelId;
+}
+function isExpired(data) {
+  return Date.now() > new Date(data.expiresAt).getTime();
+}
+
+// src/capabilities/cache/manager.ts
+var CapabilityCache = class {
+  adapter;
+  memoryCache = /* @__PURE__ */ new Map();
+  ttlMs;
+  loaded = false;
+  constructor(options = {}) {
+    const opts = { ...DEFAULT_RESOLVER_OPTIONS, ...options };
+    this.ttlMs = opts.cacheTtlMs;
+    this.adapter = createCapabilityCacheAdapter(opts.cachePath);
+  }
+  async load() {
+    if (this.loaded) return;
+    try {
+      const data = await this.adapter.read();
+      if (data && data.version === CACHE_VERSION && !isExpired(data)) {
+        for (const [key, entry] of Object.entries(data.models)) {
+          this.memoryCache.set(key, entry);
+        }
+      }
+    } catch (error) {
+      console.warn("[agent-core] Failed to load capability cache:", error);
+    }
+    this.loaded = true;
+  }
+  async get(modelId, provider) {
+    await this.load();
+    return this.memoryCache.get(cacheKey(modelId, provider));
+  }
+  async set(entry) {
+    await this.load();
+    this.memoryCache.set(cacheKey(entry.id, entry.provider), entry);
+  }
+  async setMany(entries) {
+    await this.load();
+    for (const entry of entries) {
+      this.memoryCache.set(cacheKey(entry.id, entry.provider), entry);
+    }
+  }
+  async persist() {
+    const models = {};
+    for (const [key, entry] of this.memoryCache.entries()) {
+      models[key] = entry;
+    }
+    await this.adapter.write({
+      version: CACHE_VERSION,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: new Date(Date.now() + this.ttlMs).toISOString(),
+      models
+    });
+  }
+  async clear() {
+    this.memoryCache.clear();
+    await this.adapter.clear();
+    this.loaded = false;
+  }
+  stats() {
+    return {
+      size: this.memoryCache.size,
+      loaded: this.loaded
+    };
+  }
+  async getAll() {
+    await this.load();
+    return Array.from(this.memoryCache.values());
+  }
+  async getAllByProvider() {
+    await this.load();
+    const byProvider = {};
+    for (const entry of this.memoryCache.values()) {
+      const provider = entry.provider ?? "unknown";
+      byProvider[provider] ??= [];
+      byProvider[provider].push(entry);
+    }
+    return byProvider;
+  }
+};
+var CacheCapabilitySource = class {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  priority = 1 /* LocalCache */;
+  name = "Local Cache";
+  async lookup(modelId, provider) {
+    const entry = await this.cache.get(modelId, provider);
+    if (entry) {
+      return {
+        entry,
+        source: this.priority,
+        confident: true
+      };
+    }
+    return {
+      source: this.priority,
+      confident: false
+    };
+  }
+  async isAvailable() {
+    return this.cache.stats().size > 0;
+  }
+};
+
+// src/capabilities/remote/network.ts
+function hasBrowserNetworkAPI() {
+  return typeof globalThis.navigator !== "undefined" && "onLine" in globalThis.navigator;
+}
+function isBrowserOnline() {
+  if (typeof globalThis.navigator !== "undefined" && "onLine" in globalThis.navigator) {
+    return globalThis.navigator.onLine;
+  }
+  return true;
+}
+var NetworkTracker = class {
+  status = {
+    online: true,
+    failureCount: 0
+  };
+  getStatus() {
+    if (hasBrowserNetworkAPI()) {
+      return {
+        ...this.status,
+        online: isBrowserOnline() && this.status.failureCount < 3
+      };
+    }
+    return {
+      ...this.status,
+      online: this.status.failureCount < 3
+    };
+  }
+  recordSuccess() {
+    this.status = {
+      online: true,
+      lastSuccess: Date.now(),
+      failureCount: 0
+    };
+  }
+  recordFailure(error) {
+    this.status = {
+      ...this.status,
+      online: this.status.failureCount < 2,
+      lastError: error,
+      failureCount: this.status.failureCount + 1
+    };
+  }
+};
+var networkTracker = new NetworkTracker();
+function getNetworkStatus() {
+  return networkTracker.getStatus();
+}
+function recordNetworkSuccess() {
+  networkTracker.recordSuccess();
+}
+function recordNetworkFailure(error) {
+  networkTracker.recordFailure(error);
+}
+async function fetchWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "cuylabs-agent-core/1.0"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return response;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// src/capabilities/remote/transform.ts
+function transformModelsDevEntry(raw) {
+  const capabilities = {
+    reasoning: raw.reasoning ?? false,
+    toolCalling: raw.tool_call ?? false,
+    temperature: raw.temperature ?? true,
+    attachments: raw.attachment ?? false,
+    streaming: true,
+    inputModalities: raw.modalities?.input ?? ["text"],
+    outputModalities: raw.modalities?.output ?? ["text"],
+    contextWindow: raw.limit?.context,
+    maxOutput: raw.limit?.output
+  };
+  return {
+    id: raw.id,
+    name: raw.name,
+    provider: raw.provider ?? "unknown",
+    capabilities,
+    costInput: raw.cost?.input,
+    costOutput: raw.cost?.output,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/capabilities/remote/fetcher.ts
+var RemoteCapabilityFetcher = class {
+  apiUrl;
+  timeoutMs;
+  cache;
+  lastFetchTime = 0;
+  minFetchInterval = 60 * 1e3;
+  constructor(cache, options = {}) {
+    const opts = { ...DEFAULT_RESOLVER_OPTIONS, ...options };
+    this.apiUrl = opts.remoteApiUrl;
+    this.timeoutMs = opts.networkTimeoutMs;
+    this.cache = cache;
+  }
+  async fetchAll() {
+    const now = Date.now();
+    if (now - this.lastFetchTime < this.minFetchInterval) {
+      throw new Error("Fetch rate limited - try again later");
+    }
+    if (!getNetworkStatus().online) {
+      throw new Error("Network appears offline");
+    }
+    try {
+      const response = await fetchWithTimeout(`${this.apiUrl}/api.json`, this.timeoutMs);
+      const data = await response.json();
+      const entries = [];
+      if (data && typeof data === "object") {
+        for (const [providerId, providerData] of Object.entries(data)) {
+          if (typeof providerData !== "object" || providerData === null) continue;
+          const models = providerData.models;
+          if (!Array.isArray(models)) continue;
+          for (const model of models) {
+            entries.push(transformModelsDevEntry({
+              ...model,
+              provider: providerId
+            }));
+          }
+        }
+      }
+      await this.cache.setMany(entries);
+      await this.cache.persist();
+      this.lastFetchTime = now;
+      recordNetworkSuccess();
+      return entries;
+    } catch (error) {
+      recordNetworkFailure(error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  }
+  async ping() {
+    try {
+      const response = await fetchWithTimeout(this.apiUrl, 5e3);
+      recordNetworkSuccess();
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/capabilities/remote/source.ts
+var RemoteCapabilitySource = class {
+  priority = 4 /* RemoteAPI */;
+  name = "Remote API (models.dev)";
+  fetcher;
+  cache;
+  fetchPromise;
+  enabled;
+  constructor(cache, options = {}) {
+    const opts = { ...DEFAULT_RESOLVER_OPTIONS, ...options };
+    this.cache = cache;
+    this.fetcher = new RemoteCapabilityFetcher(cache, opts);
+    this.enabled = opts.enableRemoteFetch;
+  }
+  async lookup(modelId, provider) {
+    if (!this.enabled) {
+      return {
+        source: this.priority,
+        confident: false,
+        error: "Remote fetch disabled"
+      };
+    }
+    const cached = await this.cache.get(modelId, provider);
+    if (cached) {
+      return {
+        entry: cached,
+        source: 1 /* LocalCache */,
+        confident: true
+      };
+    }
+    if (!this.fetchPromise) {
+      this.fetchPromise = this.fetcher.fetchAll().finally(() => {
+        this.fetchPromise = void 0;
+      });
+    }
+    try {
+      await this.fetchPromise;
+      const entry = await this.cache.get(modelId, provider);
+      if (entry) {
+        return {
+          entry,
+          source: this.priority,
+          confident: true
+        };
+      }
+    } catch (error) {
+      return {
+        source: this.priority,
+        confident: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+    return {
+      source: this.priority,
+      confident: false,
+      error: "Model not found in remote database"
+    };
+  }
+  async isAvailable() {
+    return this.enabled && getNetworkStatus().online;
+  }
+  async refresh() {
+    if (!this.enabled) return;
+    await this.fetcher.fetchAll();
+  }
+};
+
+// src/capabilities/resolver.ts
+function extractModelId(model) {
+  return getModelId(model);
+}
+function extractProvider(model) {
+  const provider = getProviderId(model);
+  return provider ?? inferProvider(extractModelId(model));
+}
+var ModelCapabilityResolver = class {
+  options;
+  cache;
+  sources;
+  initialized = false;
+  initPromise;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_RESOLVER_OPTIONS, ...options };
+    this.cache = new CapabilityCache(this.options);
+    this.sources = [
+      new CacheCapabilitySource(this.cache),
+      new PatternCapabilitySource()
+    ];
+    if (this.options.enableRemoteFetch) {
+      this.sources.push(new RemoteCapabilitySource(this.cache, this.options));
+    }
+    this.sources.sort((a, b) => a.priority - b.priority);
+  }
+  /**
+   * Initialize the resolver (load cache, optionally fetch remote)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      if (this.options.enableRemoteFetch) {
+        const remoteSource = this.sources.find(
+          (s) => s instanceof RemoteCapabilitySource
+        );
+        if (remoteSource) {
+          remoteSource.refresh().catch((err) => {
+            console.warn("[agent-core] Background refresh failed:", err);
+          });
+        }
+      }
+      this.initialized = true;
+    })();
+    return this.initPromise;
+  }
+  /**
+   * Resolve capabilities for a model
+   */
+  async resolve(model) {
+    const start = Date.now();
+    await this.initialize();
+    const modelId = extractModelId(model);
+    const provider = extractProvider(model);
+    const overrideLookup = findCapabilityOverride(this.options.modelOverrides, modelId, provider);
+    let bestResult;
+    for (const source of this.sources) {
+      try {
+        const result = await source.lookup(modelId, provider);
+        if (result.entry) {
+          if (result.confident) {
+            bestResult = result;
+            break;
+          }
+          if (!bestResult) {
+            bestResult = result;
+          }
+        }
+      } catch (error) {
+        console.warn(`[agent-core] Source ${source.name} failed:`, error);
+      }
+    }
+    if (!bestResult?.entry) {
+      throw new Error(`Failed to resolve capabilities for model: ${modelId}`);
+    }
+    const entry = applyCapabilityOverride(bestResult.entry, overrideLookup.override);
+    return {
+      entry,
+      source: bestResult.source,
+      confident: bestResult.confident,
+      resolveTimeMs: Date.now() - start
+    };
+  }
+  /**
+   * Quick check if a model supports reasoning
+   * Uses cache/patterns only for speed
+   */
+  async supportsReasoning(model) {
+    const modelId = extractModelId(model);
+    const provider = extractProvider(model);
+    const cached = await this.cache.get(modelId, provider);
+    if (cached) {
+      return cached.capabilities.reasoning;
+    }
+    return likelySupportsReasoning(modelId);
+  }
+  /**
+   * Get capabilities for a model
+   */
+  async getCapabilities(model) {
+    const result = await this.resolve(model);
+    return result.entry.capabilities;
+  }
+  /**
+   * Get provider compatibility settings
+   */
+  async getCompatibility(model) {
+    const result = await this.resolve(model);
+    return result.entry.compatibility;
+  }
+  /**
+   * Force refresh from remote API
+   */
+  async refreshRemote() {
+    if (!this.options.enableRemoteFetch) {
+      throw new Error("Remote fetch is not enabled");
+    }
+    const remoteSource = this.sources.find(
+      (s) => s instanceof RemoteCapabilitySource
+    );
+    if (remoteSource) {
+      await remoteSource.refresh();
+    }
+  }
+  /**
+   * Get current network status
+   */
+  getNetworkStatus() {
+    return getNetworkStatus();
+  }
+  /**
+   * Get resolver statistics
+   */
+  getStats() {
+    const cacheStats = this.cache.stats();
+    const networkStatus = getNetworkStatus();
+    return {
+      cacheSize: cacheStats.size,
+      cacheLoaded: cacheStats.loaded,
+      remoteFetchEnabled: this.options.enableRemoteFetch,
+      networkOnline: networkStatus.online
+    };
+  }
+  /**
+   * Clear all cached data
+   */
+  async clearCache() {
+    await this.cache.clear();
+  }
+  /**
+   * List all available models
+   * Fetches from remote if cache is empty and remote is enabled
+   */
+  async listModels() {
+    await this.initialize();
+    const stats = this.cache.stats();
+    if (stats.size === 0 && this.options.enableRemoteFetch) {
+      const remoteSource = this.sources.find(
+        (s) => s instanceof RemoteCapabilitySource
+      );
+      if (remoteSource) {
+        await remoteSource.refresh();
+      }
+    }
+    return this.cache.getAll();
+  }
+  /**
+   * List all available models grouped by provider
+   */
+  async listModelsByProvider() {
+    await this.initialize();
+    const stats = this.cache.stats();
+    if (stats.size === 0 && this.options.enableRemoteFetch) {
+      const remoteSource = this.sources.find(
+        (s) => s instanceof RemoteCapabilitySource
+      );
+      if (remoteSource) {
+        await remoteSource.refresh();
+      }
+    }
+    return this.cache.getAllByProvider();
+  }
+};
+var defaultResolver;
+function getDefaultResolver() {
+  if (!defaultResolver) {
+    defaultResolver = new ModelCapabilityResolver({
+      enableRemoteFetch: process.env.CODE_AGENT_ENABLE_REMOTE_FETCH === "true",
+      remoteApiUrl: process.env.CODE_AGENT_MODELS_API || "https://models.dev"
+    });
+  }
+  return defaultResolver;
+}
+function configureResolver(options) {
+  defaultResolver = new ModelCapabilityResolver(options);
+}
+
+export {
+  SourcePriority,
+  DEFAULT_RESOLVER_OPTIONS,
+  inferProvider,
+  PatternCapabilitySource,
+  likelySupportsReasoning,
+  getProviderCompatibility,
+  findCapabilityOverride,
+  applyCapabilityOverride,
+  CapabilityCache,
+  CacheCapabilitySource,
+  getNetworkStatus,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  extractModelId,
+  extractProvider,
+  ModelCapabilityResolver,
+  getDefaultResolver,
+  configureResolver
+};