@comma-agents/core 2.0.0-rc.0

package/dist/language/index.d.ts

@@ -0,0 +1 @@
+export type { LanguageDiagnostic, LanguageDiagnosticSeverity, LanguageHoverResult, LanguageLocation, LanguagePosition, LanguageRange, LanguageService, LanguageSymbol, LspMethod, LspRequest, LspResponse, } from "./language.types";

package/dist/language/language.types.d.ts

@@ -0,0 +1,60 @@
+export type LspMethod = "textDocument/diagnostic" | "textDocument/hover" | "textDocument/definition" | "textDocument/typeDefinition" | "textDocument/implementation" | "textDocument/references" | "textDocument/documentSymbol" | "workspace/symbol";
+export interface LanguagePosition {
+    readonly path: string;
+    /** 1-indexed line number. */
+    readonly line: number;
+    /** 1-indexed character number. */
+    readonly character: number;
+    readonly absolutePath?: string;
+}
+export interface LspRequest {
+    readonly method: LspMethod;
+    readonly languageId?: string;
+    readonly path?: string;
+    readonly absolutePath?: string;
+    readonly position?: {
+        readonly line: number;
+        readonly character: number;
+    };
+    readonly query?: string;
+}
+export interface LanguageRange {
+    readonly startLine: number;
+    readonly startCharacter: number;
+    readonly endLine: number;
+    readonly endCharacter: number;
+}
+export interface LanguageLocation {
+    readonly path: string;
+    readonly range: LanguageRange;
+}
+export type LanguageDiagnosticSeverity = "error" | "warning" | "information" | "hint";
+export interface LanguageDiagnostic {
+    readonly path: string;
+    readonly range: LanguageRange;
+    readonly severity: LanguageDiagnosticSeverity;
+    readonly message: string;
+    readonly code?: string | number;
+    readonly source?: string;
+}
+export interface LanguageHoverResult {
+    readonly contents: string;
+    readonly range?: LanguageRange;
+}
+export interface LanguageSymbol {
+    readonly name: string;
+    readonly kind: string;
+    readonly path: string;
+    readonly range: LanguageRange;
+    readonly containerName?: string;
+}
+export interface LspResponse {
+    readonly diagnostics?: readonly LanguageDiagnostic[];
+    readonly hover?: LanguageHoverResult | null;
+    readonly locations?: readonly LanguageLocation[];
+    readonly symbols?: readonly LanguageSymbol[];
+}
+export interface LanguageService {
+    readonly languageIds: readonly string[];
+    request(request: LspRequest, signal?: AbortSignal): Promise<LspResponse>;
+}

package/dist/model/index.d.ts

@@ -0,0 +1,5 @@
+export { registerModel, resetModelRegistry, resolveModel, unregisterModel, } from "./model";
+export type { ParsedModel, ProviderFactory, ProviderInfo, ProviderResolver, } from "./model.types";
+export { extractProviderIds, formatProviderName, getModelCapabilities, getModelMetadata, getProviderInfo, getProviderPackage, getQualifiedModelMetadata, isKnownProvider, listProviders, parseModel, } from "./model.utils";
+export type { CatalogData, CatalogModel, CatalogProvider, ListModelsContext, ListModelsFn, ListModelsResult, Modality, ModelCapabilities, ModelCost, ModelInfo, ModelModalities, ModelStatus, ModelsSource, ProviderDefinition, ProviderWithModels, } from "./providers/index";
+export { getCatalogModels, getCatalogProvider, getCatalogProviderSync, getCatalogSnapshot, getProviderDefinition, getProviderPackageNameSync, getProvidersForModel, getRegisteredProviderIds, getReverseModelIndex, isKnownProviderSync, listAllProviderModels, listCatalogProviders, listProviderDefinitions, listProviderModels, loadCatalog, mergeCatalogWithLive, mergeModelInfo, refreshCatalog, registerProviderDefinition, resetCatalog, resetProviderRegistry, resolveCatalogCachePath, resolveCredentialForProvider, sortModels, toModelInfo, unregisterProviderDefinition, } from "./providers/index";

package/dist/model/model.d.ts

@@ -0,0 +1,63 @@
+import type { LanguageModel } from "ai";
+/**
+ * Register a LanguageModel instance for a specific model string.
+ *
+ * Registered models take precedence over provider-based resolution.
+ * This is the simplest way to provide mock models for tests.
+ *
+ * @param modelString - The full "providerID/modelID" string to register under.
+ * @param model - The LanguageModel instance to associate with the string.
+ *
+ * @example
+ * ```ts
+ * import { registerModel } from "@comma-agents/core";
+ *
+ * const mockModel = createSimpleMockModel(["Hello!"]);
+ * registerModel("mock/test", mockModel);
+ *
+ * const agent = createAgent({ name: "test", model: "mock/test" });
+ * ```
+ */
+export declare function registerModel(modelString: string, model: LanguageModel): void;
+/**
+ * Remove a previously registered model.
+ *
+ * @param modelString - The string originally passed to `registerModel`.
+ * @returns `true` if the model was registered and removed.
+ */
+export declare function unregisterModel(modelString: string): boolean;
+/** Reset the global model registry to empty state. Primarily for tests. */
+export declare function resetModelRegistry(): void;
+/**
+ * Resolve a model string into a live LanguageModel instance.
+ *
+ * Supports two formats:
+ * 1. `"providerID/modelID"` — explicit provider selection (e.g. `"openai/gpt-4o"`).
+ * 2. Bare model ID — auto-resolves the provider from the models.dev catalog
+ *    by finding providers that list the model and have configured credentials.
+ *
+ * Resolution order:
+ * 1. Direct model registry (via `registerModel()`) — exact match on the full string.
+ * 2. If the string contains `/`: parse as `providerID/modelID`, resolve credential
+ *    for that provider, and instantiate the model.
+ * 3. If the string has no `/`: query the reverse model index for candidate providers.
+ *    For each candidate (alphabetically sorted), check if a credential is configured.
+ *    The first provider with a credential wins. If none have credentials, throw
+ *    with a list of candidate providers that support the model.
+ *
+ * @param modelString - `"providerID/modelID"` or a bare model ID like `"gpt-4o"`.
+ * @throws {ModelResolutionError} If the model string cannot be resolved.
+ *
+ * @example
+ * ```ts
+ * // Explicit provider
+ * const model = await resolveModel("openai/gpt-4o");
+ *
+ * // Auto-resolved — finds the first provider with credentials for this model
+ * const model = await resolveModel("gpt-4o");
+ *
+ * // With a pre-registered model (e.g., in tests)
+ * registerModel("mock/simple", mockLanguageModel);
+ * ```
+ */
+export declare function resolveModel(modelString: string): Promise<LanguageModel>;

package/dist/model/model.types.d.ts

@@ -0,0 +1,85 @@
+import type { LanguageModel } from "ai";
+import type { Credential } from "../credentials/credentials.types";
+import type { CredentialType, ModelInfo, ModelsSource } from "./providers/providers.types";
+/** Result of parsing a model string like "openai/gpt-4o". */
+export interface ParsedModel {
+    /** The provider identifier (e.g., "openai", "anthropic"). */
+    readonly providerId: string;
+    /** The model identifier (e.g., "gpt-4o", "claude-sonnet-4-5"). */
+    readonly modelId: string;
+    /** The npm package for the provider, if known. Undefined for custom providers. */
+    readonly packageName: string | undefined;
+}
+/**
+ * A function that creates a LanguageModel from a model ID.
+ * Each provider (openai, anthropic, etc.) supplies one of these.
+ *
+ * @example
+ * ```ts
+ * import { createOpenAI } from "@ai-sdk/openai";
+ * const providers = { openai: (id) => createOpenAI({ apiKey: "...", model: id }) };
+ * ```
+ */
+export type ProviderFactory = (modelId: string) => LanguageModel;
+/**
+ * A function that translates a (providerId, credential) pair into a
+ * ProviderFactory. Allows the strategy loader to auto-resolve credentials
+ * from a CredentialStore and create provider instances on demand.
+ *
+ * Implementations are supplied by the consuming layer (daemon, CLI, examples)
+ * so that core remains provider-agnostic.
+ *
+ * @example
+ * ```ts
+ * const resolver: ProviderResolver = async (providerId, credential) => {
+ *   if (credential.type !== "api") throw new Error("Only API keys supported");
+ *   const { createOpenAI } = await import("@ai-sdk/openai");
+ *   return (modelId) => createOpenAI({ apiKey: credential.key })(modelId);
+ * };
+ * ```
+ */
+export type ProviderResolver = (providerId: string, credential: Credential) => ProviderFactory | Promise<ProviderFactory>;
+/**
+ * Aggregate metadata for a single provider.
+ *
+ * Emitted by `listProviders()` and the daemon's `list_providers` protocol
+ * message. Consumers (like the TUI) use this to present provider/model
+ * pickers and auth status indicators.
+ *
+ * Models are returned as rich `ModelInfo[]` entries with cost, context
+ * window, capabilities, and modality metadata merged from the models.dev
+ * catalog and (optionally) the provider's live API.
+ */
+export interface ProviderInfo {
+    /** Canonical provider id (matches models.dev keys, e.g., `"github-copilot"`). */
+    readonly id: string;
+    /** Human-friendly display name (catalog `name` when available). */
+    readonly name: string;
+    /**
+     * Expected credential type for this provider.
+     * Defaults to `"api"` for catalog-derived providers.
+     */
+    readonly credentialType: CredentialType;
+    /**
+     * Configuration-level auth status. `"configured"` means a credential
+     * was found via env var, strategy scope, or global scope. Not validated
+     * against the provider's API.
+     */
+    readonly authStatus: "none" | "configured";
+    /**
+     * Normalized model metadata. Combines the catalog baseline with live
+     * data (when `live === true` and credentials are available).
+     */
+    readonly models: readonly ModelInfo[];
+    /** Provenance of the model list for this provider. */
+    readonly modelsSource: ModelsSource;
+    /** ISO timestamp when live data was fetched, if any. */
+    readonly fetchedAt?: string;
+    /** Error message when live discovery failed and we fell back to catalog. */
+    readonly error?: string;
+    /**
+     * `true` if this provider was added via `registerProvider()` rather
+     * than being derived from the models.dev catalog or built-in overrides.
+     */
+    readonly isCustom: boolean;
+}

package/dist/model/model.utils.d.ts

@@ -0,0 +1,151 @@
+import type { CredentialStore } from "../credentials/credentials.types";
+import type { ParsedModel, ProviderInfo } from "./model.types";
+import type { ModelCapabilities, ModelInfo } from "./providers/providers.types";
+/**
+ * Parse a model string in the format `providerID/modelID`.
+ *
+ * The model ID may contain slashes (e.g., `"ollama/meta-llama/llama-3"`),
+ * so only the first slash is used as the separator.
+ *
+ * @param modelString - Raw model string to parse.
+ * @throws {ModelResolutionError} If the string is empty or has no slash separator.
+ *
+ * @example
+ * ```ts
+ * parseModel("openai/gpt-4o")
+ * // => { providerId: "openai", modelId: "gpt-4o", packageName: "@ai-sdk/openai" }
+ *
+ * parseModel("ollama/meta-llama/llama-3")
+ * // => { providerId: "ollama", modelId: "meta-llama/llama-3", packageName: "ollama-ai-provider" }
+ * ```
+ */
+export declare function parseModel(modelString: string): ParsedModel;
+/**
+ * Check whether a provider is known to the runtime (catalog entry or
+ * built-in override).
+ */
+export declare function isKnownProvider(providerId: string): boolean;
+/**
+ * Get the npm package name for a known provider.
+ *
+ * Returns `undefined` for providers that have no catalog entry and no
+ * built-in override; callers may fall back to guessing `@ai-sdk/<id>`.
+ */
+export declare function getProviderPackage(providerId: string): string | undefined;
+/**
+ * Extract unique provider IDs from a raw (already-parsed) strategy object.
+ *
+ * Scans each agent's `model` field for "providerID/modelID" strings.
+ * Returns the set of unique provider IDs. Works on pre-validation data —
+ * silently skips invalid model strings so callers can discover required
+ * providers before the full Zod validation pass.
+ *
+ * @param raw - Parsed but unvalidated strategy object.
+ *
+ * @example
+ * ```ts
+ * const raw = JSON.parse(strategyJson);
+ * const providerIds = extractProviderIds(raw);
+ * // => Set { "openai", "anthropic" }
+ * ```
+ */
+export declare function extractProviderIds(raw: Record<string, unknown>): Set<string>;
+/**
+ * Aggregate metadata for a single provider.
+ *
+ * Resolves the provider's models from the models.dev catalog (and,
+ * when `live === true` and credentials are present, the provider's
+ * live API). Auth status is a configuration-level check only.
+ *
+ * @param providerId - The provider ID to inspect.
+ * @param credentialStore - The credential store used to check auth status.
+ * @param options - `scope` for scoped credential resolution; `live` to enable live discovery.
+ *
+ * @example
+ * ```ts
+ * const info = await getProviderInfo("openai", credentialStore, { live: true });
+ * // => { id: "openai", name: "OpenAI", authStatus: "configured", models: [...], modelsSource: "merged", isCustom: false }
+ * ```
+ */
+export declare function getProviderInfo(providerId: string, credentialStore: CredentialStore, options?: {
+    readonly scope?: string;
+    readonly live?: boolean;
+}): Promise<ProviderInfo>;
+/**
+ * List all known providers along with their auth status and model metadata.
+ *
+ * Returns every provider derived from the models.dev catalog, plus any
+ * built-in overrides (Ollama, DeepSeek) and user-registered custom
+ * providers. Auth status is a configuration-level check (env var /
+ * credential store presence) and never performs network calls unless
+ * `live === true` is passed.
+ *
+ * @param credentialStore - The credential store used to check auth status.
+ * @param options - `scope` for scoped credential resolution; `live` to enable live model discovery.
+ *
+ * @example
+ * ```ts
+ * const providers = await listProviders(credentialStore, { live: true });
+ * for (const provider of providers) {
+ *   console.log(`${provider.name}: ${provider.authStatus} (${provider.models.length} models, ${provider.modelsSource})`);
+ * }
+ * ```
+ */
+export declare function listProviders(credentialStore: CredentialStore, options?: {
+    readonly scope?: string;
+    readonly live?: boolean;
+}): Promise<readonly ProviderInfo[]>;
+/**
+ * Look up normalized metadata for a bare model ID from the catalog.
+ *
+ * Scans the reverse model index for the first provider that lists the
+ * model, then returns the full `ModelInfo` (including capabilities,
+ * modalities, cost, context window, etc.). Returns `undefined` if the
+ * model is not found in any provider catalog.
+ *
+ * @example
+ * ```ts
+ * const info = getModelMetadata("gpt-4o");
+ * console.log(info?.capabilities?.reasoning); // true
+ * console.log(info?.contextWindow);           // 128000
+ * ```
+ */
+export declare function getModelMetadata(modelId: string): ModelInfo | undefined;
+/**
+ * Look up normalized metadata for a provider-qualified model string.
+ *
+ * @param model - Model identifier in "providerID/modelID" format.
+ * @example
+ * ```ts
+ * const info = getQualifiedModelMetadata("openai/gpt-4o");
+ * console.log(info?.contextWindow);
+ * ```
+ */
+export declare function getQualifiedModelMetadata(model: string): ModelInfo | undefined;
+/**
+ * Look up capability flags for a bare model ID.
+ *
+ * Returns the model's `ModelCapabilities` (tools, reasoning, vision,
+ * attachment, structuredOutput) from the catalog. Returns `undefined` if
+ * the model is not found in any provider catalog.
+ *
+ * This is a convenience wrapper around `getModelMetadata()` for the common
+ * case of checking what features a model supports at runtime.
+ *
+ * @example
+ * ```ts
+ * const caps = getModelCapabilities("gpt-4o");
+ * if (caps?.reasoning) {
+ *   // use reasoning-related options
+ * }
+ * ```
+ */
+export declare function getModelCapabilities(modelId: string): ModelCapabilities | undefined;
+/**
+ * Convert a provider ID to a human-friendly display name.
+ *
+ * Hyphen-separated tokens are capitalized (e.g., `github-copilot` ->
+ * `Github Copilot`). This is a best-effort default; consumers that want
+ * brand-accurate names should rely on the catalog-provided `name`.
+ */
+export declare function formatProviderName(providerId: string): string;

package/dist/model/providers/catalog/catalog.d.ts

@@ -0,0 +1,57 @@
+import type { ModelInfo } from "../providers.types";
+import type { CatalogData, CatalogProvider } from "./catalog.types";
+/** Source URL for the live catalog. */
+export declare const CATALOG_SOURCE_URL = "https://models.dev/api.json";
+/** Default cache TTL — 24 hours. */
+export declare const CATALOG_CACHE_TTL_MS: number;
+/** Force re-evaluation on next `loadCatalog()` call. Used by tests. */
+export declare function resetCatalog(): void;
+/**
+ * Synchronous snapshot access. Returns whatever is currently loaded in
+ * memory, falling back to the bundled snapshot without touching disk or
+ * network. Use this in sync paths (e.g., the provider resolver) where
+ * awaiting is not practical.
+ */
+export declare function getCatalogSnapshot(): CatalogData;
+/** Sync counterpart to `getCatalogProvider`. */
+export declare function getCatalogProviderSync(providerId: string): CatalogProvider | undefined;
+/**
+ * Load the models.dev catalog, preferring (fresh cache) → (network refresh) →
+ * (bundled snapshot). The first successful source wins; subsequent calls
+ * return the memoized result until `resetCatalog()` is invoked.
+ */
+export declare function loadCatalog(options?: {
+    readonly forceRefresh?: boolean;
+}): Promise<CatalogData>;
+/**
+ * Force a network refresh of the catalog. Updates the disk cache on success;
+ * falls back to the existing cache or bundled snapshot on failure.
+ */
+export declare function refreshCatalog(): Promise<CatalogData>;
+/** Look up a single provider entry from the catalog. */
+export declare function getCatalogProvider(providerId: string): Promise<CatalogProvider | undefined>;
+/** Return every provider entry from the catalog. */
+export declare function listCatalogProviders(): Promise<readonly CatalogProvider[]>;
+/** Return the normalized `ModelInfo[]` for a provider, or an empty array if unknown. */
+export declare function getCatalogModels(providerId: string): Promise<readonly ModelInfo[]>;
+/**
+ * Return a lazy-built reverse model index.
+ *
+ * The index maps each model ID (e.g. `"gpt-4o"`) to an alphabetically-sorted
+ * array of provider IDs that list that model in the models.dev catalog.
+ * Providers are sorted alphabetically for deterministic resolution order.
+ *
+ * Built once from `getCatalogSnapshot()` and invalidated via `resetCatalog()`.
+ */
+export declare function getReverseModelIndex(): Map<string, string[]>;
+/**
+ * Return the list of provider IDs known to offer a given model ID.
+ *
+ * Only includes providers registered in the models.dev catalog. Live-only
+ * providers (ollama, GitHub Copilot models fetched at runtime) are NOT
+ * included here.
+ *
+ * @param modelId - The bare model ID to look up (e.g. `"gpt-4o"`).
+ * @returns Sorted array of provider IDs, or empty array if unknown.
+ */
+export declare function getProvidersForModel(modelId: string): string[];

package/dist/model/providers/catalog/catalog.types.d.ts

@@ -0,0 +1,50 @@
+import type { ModelStatus } from "../providers.types";
+/** Raw model entry shape used by `https://models.dev/api.json`. */
+export interface CatalogModel {
+    readonly id: string;
+    readonly name: string;
+    readonly family?: string;
+    readonly attachment: boolean;
+    readonly reasoning: boolean;
+    readonly tool_call: boolean;
+    readonly temperature?: boolean;
+    readonly structured_output?: boolean;
+    readonly open_weights: boolean;
+    readonly interleaved?: boolean | {
+        readonly field?: string;
+    };
+    readonly knowledge?: string;
+    readonly release_date: string;
+    readonly last_updated: string;
+    readonly status?: ModelStatus | string;
+    readonly modalities: {
+        readonly input: readonly string[];
+        readonly output: readonly string[];
+    };
+    readonly limit: {
+        readonly context: number;
+        readonly input?: number;
+        readonly output: number;
+    };
+    readonly cost?: {
+        readonly input?: number;
+        readonly output?: number;
+        readonly reasoning?: number;
+        readonly cache_read?: number;
+        readonly cache_write?: number;
+        readonly input_audio?: number;
+        readonly output_audio?: number;
+    };
+}
+/** Raw provider entry shape used by `https://models.dev/api.json`. */
+export interface CatalogProvider {
+    readonly id: string;
+    readonly name: string;
+    readonly npm: string;
+    readonly env: readonly string[];
+    readonly doc: string;
+    readonly api?: string;
+    readonly models: Readonly<Record<string, CatalogModel>>;
+}
+/** Top-level shape: provider-id → provider entry. */
+export type CatalogData = Readonly<Record<string, CatalogProvider>>;

package/dist/model/providers/catalog/catalog.utils.d.ts

@@ -0,0 +1,15 @@
+import type { ModelInfo } from "../providers.types";
+import type { CatalogModel } from "./catalog.types";
+/** Map a raw catalog model entry to our normalized `ModelInfo` shape. */
+export declare function toModelInfo(catalogModel: CatalogModel): ModelInfo;
+/** Filename used for the on-disk catalog snapshot. */
+export declare const CATALOG_CACHE_FILENAME = "models-catalog.json";
+/**
+ * Resolve the platform-aware cache directory for comma-agents.
+ *
+ * Mirrors the conventions used by `resolveDataDir` but targets cache storage:
+ * - macOS:   ~/Library/Caches/comma-agents/
+ * - Windows: %LOCALAPPDATA%/comma-agents/Cache/ (fallback ~/AppData/Local)
+ * - Linux:   $XDG_CACHE_HOME/comma-agents/ (fallback ~/.cache)
+ */
+export declare function resolveCatalogCachePath(env?: Readonly<Record<string, string | undefined>>, platform?: NodeJS.Platform): string;

package/dist/model/providers/catalog/index.d.ts

@@ -0,0 +1,3 @@
+export { CATALOG_CACHE_TTL_MS, CATALOG_SOURCE_URL, getCatalogModels, getCatalogProvider, getCatalogProviderSync, getCatalogSnapshot, getProvidersForModel, getReverseModelIndex, listCatalogProviders, loadCatalog, refreshCatalog, resetCatalog, } from "./catalog";
+export type { CatalogData, CatalogModel, CatalogProvider, } from "./catalog.types";
+export { resolveCatalogCachePath, toModelInfo, } from "./catalog.utils";

package/dist/model/providers/index.d.ts

@@ -0,0 +1,7 @@
+export type { CatalogData, CatalogModel, CatalogProvider, } from "./catalog/index";
+export { CATALOG_CACHE_TTL_MS, CATALOG_SOURCE_URL, getCatalogModels, getCatalogProvider, getCatalogProviderSync, getCatalogSnapshot, getProvidersForModel, getReverseModelIndex, listCatalogProviders, loadCatalog, refreshCatalog, resetCatalog, resolveCatalogCachePath, toModelInfo, } from "./catalog/index";
+export { listCopilotModels, listOllamaModels } from "./listers/index";
+export type { ProviderWithModels } from "./providers";
+export { getProviderDefinition, getProviderPackageNameSync, getRegisteredProviderIds, isKnownProviderSync, listAllProviderModels, listProviderDefinitions, listProviderModels, registerProviderDefinition, resetProviderRegistry, resolveCredentialForProvider, unregisterProviderDefinition, } from "./providers";
+export type { ListModelsContext, ListModelsFn, ListModelsResult, Modality, ModelCapabilities, ModelCost, ModelInfo, ModelModalities, ModelStatus, ModelsSource, ProviderDefinition, } from "./providers.types";
+export { mergeCatalogWithLive, mergeModelInfo, sortModels, } from "./providers.utils";

package/dist/model/providers/listers/copilot.d.ts

@@ -0,0 +1,10 @@
+import type { ListModelsFn } from "../providers.types";
+/**
+ * List GitHub Copilot models via `GET {base}/models`.
+ *
+ * Requires an OAuth credential (GitHub access token). Filters out models
+ * where `model_picker_enabled` is false or `policy.state === "disabled"`.
+ * Populates capabilities/limits from the response and leaves pricing blank
+ * (Copilot is subscription-based, not per-token).
+ */
+export declare const listCopilotModels: ListModelsFn;

package/dist/model/providers/listers/index.d.ts

@@ -0,0 +1,2 @@
+export { listCopilotModels } from "./copilot";
+export { listOllamaModels } from "./ollama";

package/dist/model/providers/listers/ollama.d.ts

@@ -0,0 +1,9 @@
+import type { ListModelsFn } from "../providers.types";
+/**
+ * List locally installed Ollama models via `GET {baseURL}/api/tags`.
+ *
+ * Ollama is absent from the models.dev catalog because the set of installed
+ * models is user-specific. This lister returns whatever the local daemon
+ * reports; capabilities and context windows are unknown from the tags endpoint.
+ */
+export declare const listOllamaModels: ListModelsFn;

package/dist/model/providers/providers.d.ts

@@ -0,0 +1,69 @@
+import type { Credential, CredentialStore } from "../../credentials/credentials.types";
+import type { ListModelsResult, ProviderDefinition } from "./providers.types";
+/**
+ * Register (or override) a provider definition. Custom registrations take
+ * precedence over catalog-derived defaults and persist across catalog reloads.
+ *
+ * @example
+ * ```ts
+ * registerProviderDefinition({
+ *   id: "acme",
+ *   name: "Acme Labs",
+ *   packageName: "@acme/ai-sdk",
+ *   listModels: async () => [{ id: "acme-1" }],
+ * });
+ * ```
+ */
+export declare function registerProviderDefinition(definition: ProviderDefinition): void;
+/** Remove a previously registered provider. Catalog-derived entries return on next init. */
+export declare function unregisterProviderDefinition(providerId: string): boolean;
+/** Reset all provider registrations. Primarily for tests. */
+export declare function resetProviderRegistry(): void;
+/** Look up a single provider definition by id. */
+export declare function getProviderDefinition(providerId: string): Promise<ProviderDefinition | undefined>;
+/** Every registered provider definition, alphabetically by id. */
+export declare function listProviderDefinitions(): Promise<readonly ProviderDefinition[]>;
+/**
+ * Resolve the model list for a single provider.
+ *
+ * When `options.live` is false, only catalog data is returned. When `live`
+ * is true and the provider defines `listModels`, the live response is
+ * merged with the catalog baseline. Live errors fall back to catalog
+ * (if any) and are reported via `result.error`.
+ */
+export declare function listProviderModels(providerId: string, credential: Credential | undefined, options?: {
+    readonly live?: boolean;
+    readonly signal?: AbortSignal;
+}): Promise<ListModelsResult>;
+/**
+ * Resolve a credential for a provider via its credential store. Swallows
+ * `undefined` (not found) cases so callers can treat missing credentials
+ * as "skip live listing".
+ */
+export declare function resolveCredentialForProvider(credentialStore: CredentialStore, providerId: string, scope?: string): Promise<Credential | undefined>;
+/** Convenience re-export: every provider definition paired with its models. */
+export interface ProviderWithModels {
+    readonly definition: ProviderDefinition;
+    readonly result: ListModelsResult;
+}
+/** Resolve models for every registered provider in parallel. */
+export declare function listAllProviderModels(credentialStore: CredentialStore, options?: {
+    readonly live?: boolean;
+    readonly scope?: string;
+}): Promise<readonly ProviderWithModels[]>;
+/** Expose a snapshot of the current registry for inspection (test helper). */
+export declare function getRegisteredProviderIds(): readonly string[];
+/**
+ * Synchronously resolve the npm package name for a provider.
+ *
+ * Checks built-in overrides first (ollama, deepseek), then falls back to
+ * the bundled catalog snapshot. Returns `undefined` for providers that have
+ * no known package (the resolver may guess `@ai-sdk/<id>` in that case).
+ *
+ * Designed for sync paths like the provider resolver; async callers should
+ * prefer `getProviderDefinition()` which reflects the live registry.
+ */
+export declare function getProviderPackageNameSync(providerId: string): string | undefined;
+/** Check whether a provider is known to the runtime (catalog or built-in). */
+export declare function isKnownProviderSync(providerId: string): boolean;
+export type { ModelInfo } from "./providers.types";