omctest 0.0.1

package/dist/shared/contains-path.d.ts

@@ -0,0 +1,2 @@
+export declare function containsPath(rootPath: string, candidatePath: string): boolean;
+export declare function isWithinProject(candidatePath: string, projectRoot: string): boolean;

package/dist/shared/context-limit-resolver.d.ts

@@ -0,0 +1,5 @@
+export type ContextLimitModelCacheState = {
+    anthropicContext1MEnabled: boolean;
+    modelContextLimitsCache?: Map<string, number>;
+};
+export declare function resolveActualContextLimit(providerID: string, modelID: string, modelCacheState?: ContextLimitModelCacheState): number | null;

package/dist/shared/data-path.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Returns the user-level data directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_DATA_HOME or ~/.local/share
+ *
+ * Note: OpenCode uses xdg-basedir which returns ~/.local/share on ALL platforms
+ * including Windows, so we match that behavior exactly.
+ */
+export declare function getDataDir(): string;
+/**
+ * Returns the OpenCode storage directory path.
+ * All platforms: ~/.local/share/opencode/storage
+ */
+export declare function getOpenCodeStorageDir(): string;
+/**
+ * Returns the user-level cache directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_CACHE_HOME or ~/.cache
+ */
+export declare function getCacheDir(): string;
+/**
+ * Returns the oh-my-opencode cache directory.
+ * All platforms: ~/.cache/oh-my-opencode
+ */
+export declare function getOmoOpenCodeCacheDir(): string;
+/**
+ * Returns the OpenCode cache directory (for reading OpenCode's cache).
+ * All platforms: ~/.cache/opencode
+ */
+export declare function getOpenCodeCacheDir(): string;

package/dist/shared/deep-merge.d.ts

@@ -0,0 +1,13 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Deep merges two objects, with override values taking precedence.
+ * - Objects are recursively merged
+ * - Arrays are replaced (not concatenated)
+ * - undefined values in override do not overwrite base values
+ *
+ * @example
+ * deepMerge({ a: 1, b: { c: 2, d: 3 } }, { b: { c: 10 }, e: 5 })
+ * // => { a: 1, b: { c: 10, d: 3 }, e: 5 }
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(base: T, override: Partial<T>, depth?: number): T;
+export declare function deepMerge<T extends Record<string, unknown>>(base: T | undefined, override: T | undefined, depth?: number): T | undefined;

package/dist/shared/disabled-tools.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+export declare function filterDisabledTools(tools: Record<string, ToolDefinition>, disabledTools: readonly string[] | undefined): Record<string, ToolDefinition>;

package/dist/shared/dynamic-truncator.d.ts

@@ -0,0 +1,27 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { type ContextLimitModelCacheState } from "./context-limit-resolver";
+type ContextWindowUsage = {
+    usedTokens: number;
+    remainingTokens: number;
+    usagePercentage: number;
+};
+export declare function invalidateContextWindowUsageCache(ctx: PluginInput, sessionID?: string): void;
+export interface TruncationResult {
+    result: string;
+    truncated: boolean;
+    removedCount?: number;
+}
+export interface TruncationOptions {
+    targetMaxTokens?: number;
+    preserveHeaderLines?: number;
+    contextWindowLimit?: number;
+}
+export declare function truncateToTokenLimit(output: string, maxTokens: number, preserveHeaderLines?: number): TruncationResult;
+export declare function getContextWindowUsage(ctx: PluginInput, sessionID: string, modelCacheState?: ContextLimitModelCacheState): Promise<ContextWindowUsage | null>;
+export declare function dynamicTruncate(ctx: PluginInput, sessionID: string, output: string, options?: TruncationOptions, modelCacheState?: ContextLimitModelCacheState): Promise<TruncationResult>;
+export declare function createDynamicTruncator(ctx: PluginInput, modelCacheState?: ContextLimitModelCacheState): {
+    truncate: (sessionID: string, output: string, options?: TruncationOptions) => Promise<TruncationResult>;
+    getUsage: (sessionID: string) => Promise<ContextWindowUsage | null>;
+    truncateSync: (output: string, maxTokens: number, preserveHeaderLines?: number) => TruncationResult;
+};
+export {};

package/dist/shared/excluded-dirs.d.ts

@@ -0,0 +1 @@
+export declare const EXCLUDED_DIRS: ReadonlySet<string>;

package/dist/shared/external-plugin-detector.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Detects external plugins that may conflict with oh-my-opencode features.
+ * Used to prevent crashes from concurrent notification plugins.
+ */
+export interface ExternalNotifierResult {
+    detected: boolean;
+    pluginName: string | null;
+    allPlugins: string[];
+}
+export interface ExternalSkillPluginResult {
+    detected: boolean;
+    pluginName: string | null;
+    allPlugins: string[];
+}
+/**
+ * Detect if any external notification plugin is configured.
+ * Returns information about detected plugins for logging/warning.
+ */
+export declare function detectExternalNotificationPlugin(directory: string): ExternalNotifierResult;
+/**
+ * Detect if any external skill plugin is configured.
+ * Returns information about detected plugins for logging/warning.
+ */
+export declare function detectExternalSkillPlugin(directory: string): ExternalSkillPluginResult;
+/**
+ * Generate a warning message for users with conflicting notification plugins.
+ */
+export declare function getNotificationConflictWarning(pluginName: string): string;
+/**
+ * Generate a warning message for users with conflicting skill plugins.
+ */
+export declare function getSkillPluginConflictWarning(pluginName: string): string;

package/dist/shared/fallback-chain-from-models.d.ts

@@ -0,0 +1,12 @@
+import type { FallbackEntry } from "./model-requirements";
+import type { FallbackModelObject } from "../config/schema/fallback-models";
+export declare function parseFallbackModelEntry(model: string, contextProviderID: string | undefined, defaultProviderID?: string): FallbackEntry | undefined;
+export declare function parseFallbackModelObjectEntry(obj: FallbackModelObject, contextProviderID: string | undefined, defaultProviderID?: string): FallbackEntry | undefined;
+/**
+ * Find the most specific FallbackEntry whose `provider/model` is a prefix of
+ * the resolved `provider/modelID`.  Longest match wins so that e.g.
+ * `openai/gpt-5.4-preview` picks the entry for `openai/gpt-5.4-preview` over
+ * the shorter `openai/gpt-5.4`.
+ */
+export declare function findMostSpecificFallbackEntry(providerID: string, modelID: string, chain: FallbackEntry[]): FallbackEntry | undefined;
+export declare function buildFallbackChainFromModels(fallbackModels: string | (string | FallbackModelObject)[] | undefined, contextProviderID: string | undefined, defaultProviderID?: string): FallbackEntry[] | undefined;

package/dist/shared/fallback-model-availability.d.ts

@@ -0,0 +1,12 @@
+type FallbackEntry = {
+    providers: string[];
+    model: string;
+};
+type ResolvedFallbackModel = {
+    provider: string;
+    model: string;
+};
+export declare function resolveFirstAvailableFallback(fallbackChain: FallbackEntry[], availableModels: Set<string>): ResolvedFallbackModel | null;
+export declare function isAnyFallbackModelAvailable(fallbackChain: FallbackEntry[], availableModels: Set<string>): boolean;
+export declare function isAnyProviderConnected(providers: string[], availableModels: Set<string>): boolean;
+export {};

package/dist/shared/file-reference-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveFilePath(filePath: string, cwd: string): string;
+export declare function resolveFileReferencesInText(text: string, cwd?: string, depth?: number, maxDepth?: number): Promise<string>;

package/dist/shared/file-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function isMarkdownFile(entry: {
+    name: string;
+    isFile: () => boolean;
+}): boolean;
+export declare function isSymbolicLink(filePath: string): boolean;
+export declare function resolveSymlink(filePath: string): string;
+export declare function resolveSymlinkAsync(filePath: string): Promise<string>;

package/dist/shared/first-message-variant.d.ts

@@ -0,0 +1,11 @@
+type SessionInfo = {
+    id?: string;
+    parentID?: string;
+};
+export declare function createFirstMessageVariantGate(): {
+    markSessionCreated(info?: SessionInfo): void;
+    shouldOverride(sessionID?: string): boolean;
+    markApplied(sessionID?: string): void;
+    clear(sessionID?: string): void;
+};
+export {};

package/dist/shared/frontmatter.d.ts

@@ -0,0 +1,7 @@
+export interface FrontmatterResult<T = Record<string, unknown>> {
+    data: T;
+    body: string;
+    hadFrontmatter: boolean;
+    parseError: boolean;
+}
+export declare function parseFrontmatter<T = Record<string, unknown>>(content: string): FrontmatterResult<T>;

package/dist/shared/git-worktree/collect-git-diff-stats.d.ts

@@ -0,0 +1,2 @@
+import type { GitFileStat } from "./types";
+export declare function collectGitDiffStats(directory: string): GitFileStat[];

package/dist/shared/git-worktree/format-file-changes.d.ts

@@ -0,0 +1,2 @@
+import type { GitFileStat } from "./types";
+export declare function formatFileChanges(stats: GitFileStat[], notepadPath?: string): string;

package/dist/shared/git-worktree/index.d.ts

@@ -0,0 +1,7 @@
+export type { GitFileStatus, GitFileStat } from "./types";
+export type { ParsedGitStatusPorcelainLine } from "./parse-status-porcelain-line";
+export { parseGitStatusPorcelainLine } from "./parse-status-porcelain-line";
+export { parseGitStatusPorcelain } from "./parse-status-porcelain";
+export { parseGitDiffNumstat } from "./parse-diff-numstat";
+export { collectGitDiffStats } from "./collect-git-diff-stats";
+export { formatFileChanges } from "./format-file-changes";

package/dist/shared/git-worktree/parse-diff-numstat.d.ts

@@ -0,0 +1,2 @@
+import type { GitFileStat, GitFileStatus } from "./types";
+export declare function parseGitDiffNumstat(output: string, statusMap: Map<string, GitFileStatus>): GitFileStat[];

package/dist/shared/git-worktree/parse-status-porcelain-line.d.ts

@@ -0,0 +1,6 @@
+import type { GitFileStatus } from "./types";
+export interface ParsedGitStatusPorcelainLine {
+    filePath: string;
+    status: GitFileStatus;
+}
+export declare function parseGitStatusPorcelainLine(line: string): ParsedGitStatusPorcelainLine | null;

package/dist/shared/git-worktree/parse-status-porcelain.d.ts

@@ -0,0 +1,2 @@
+import type { GitFileStatus } from "./types";
+export declare function parseGitStatusPorcelain(output: string): Map<string, GitFileStatus>;

package/dist/shared/git-worktree/types.d.ts

@@ -0,0 +1,7 @@
+export type GitFileStatus = "modified" | "added" | "deleted";
+export interface GitFileStat {
+    path: string;
+    added: number;
+    removed: number;
+    status: GitFileStatus;
+}

package/dist/shared/hook-disabled.d.ts

@@ -0,0 +1,2 @@
+import type { ClaudeHookEvent, PluginConfig } from "../hooks/claude-code-hooks/types";
+export declare function isHookDisabled(config: PluginConfig, hookType: ClaudeHookEvent): boolean;

package/dist/shared/index.d.ts

@@ -0,0 +1,74 @@
+export * from "./frontmatter";
+export * from "./command-executor";
+export * from "./contains-path";
+export * from "./file-reference-resolver";
+export * from "./model-sanitizer";
+export * from "./logger";
+export * from "./snake-case";
+export * from "./tool-name";
+export * from "./pattern-matcher";
+export * from "./hook-disabled";
+export * from "./deep-merge";
+export * from "./file-utils";
+export * from "./dynamic-truncator";
+export * from "./data-path";
+export * from "./config-errors";
+export * from "./claude-config-dir";
+export * from "./jsonc-parser";
+export * from "./migration";
+export * from "./opencode-config-dir";
+export * from "./resolve-agent-definition-paths";
+export type { OpenCodeBinaryType, OpenCodeConfigDirOptions, OpenCodeConfigPaths, } from "./opencode-config-dir-types";
+export * from "./opencode-version";
+export * from "./opencode-storage-detection";
+export * from "./permission-compat";
+export * from "./external-plugin-detector";
+export * from "./zip-extractor";
+export * from "./binary-downloader";
+export * from "./write-file-atomically";
+export * from "./agent-variant";
+export * from "./session-cursor";
+export * from "./shell-env";
+export * from "./system-directive";
+export * from "./agent-tool-restrictions";
+export * from "./model-requirements";
+export * from "./model-resolver";
+export { normalizeModel, normalizeModelID } from "./model-normalization";
+export { normalizeFallbackModels, flattenToFallbackModelStrings } from "./model-resolver";
+export { resolveModelPipeline } from "./model-resolution-pipeline";
+export type { ModelResolutionRequest, ModelResolutionProvenance, ModelResolutionResult, } from "./model-resolution-types";
+export * from "./model-availability";
+export * from "./model-capabilities";
+export * from "./model-capabilities-cache";
+export * from "./model-capability-heuristics";
+export * from "./model-settings-compatibility";
+export * from "./fallback-model-availability";
+export * from "./connected-providers-cache";
+export * from "./context-limit-resolver";
+export * from "./session-utils";
+export * from "./tmux";
+export * from "./model-suggestion-retry";
+export * from "./opencode-server-auth";
+export * from "./opencode-provider-auth";
+export * from "./opencode-http-api";
+export * from "./port-utils";
+export * from "./git-worktree";
+export * from "./safe-create-hook";
+export * from "./truncate-description";
+export * from "./opencode-storage-paths";
+export * from "./opencode-message-dir";
+export * from "./opencode-command-dirs";
+export * from "./project-discovery-dirs";
+export * from "./normalize-sdk-response";
+export * from "./session-directory-resolver";
+export * from "./prompt-tools";
+export * from "./compaction-marker";
+export * from "./internal-initiator-marker";
+export * from "./plugin-command-discovery";
+export { SessionCategoryRegistry } from "./session-category-registry";
+export * from "./plugin-identity";
+export * from "./log-legacy-plugin-startup-warning";
+export * from "./task-system-enabled";
+export * from "./parse-tools-config";
+export { parseModelString } from "./model-string-parser";
+export { EXCLUDED_DIRS } from "./excluded-dirs";

package/dist/shared/internal-initiator-marker.d.ts

@@ -0,0 +1,6 @@
+export declare const OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+export declare function stripInternalInitiatorMarkers(text: string): string;
+export declare function createInternalAgentTextPart(text: string): {
+    type: "text";
+    text: string;
+};

package/dist/shared/is-abort-error.d.ts

@@ -0,0 +1 @@
+export declare function isAbortError(error: unknown): boolean;

package/dist/shared/json-file-cache-store.d.ts

@@ -0,0 +1,16 @@
+type JsonFileCacheStoreOptions<TValue> = {
+    getCacheDir: () => string;
+    filename: string;
+    logPrefix: string;
+    cacheLabel: string;
+    describe: (value: TValue) => Record<string, unknown>;
+    serialize?: (value: TValue) => string;
+};
+type JsonFileCacheStore<TValue> = {
+    read: () => TValue | null;
+    has: () => boolean;
+    write: (value: TValue) => void;
+    resetMemory: () => void;
+};
+export declare function createJsonFileCacheStore<TValue>(options: JsonFileCacheStoreOptions<TValue>): JsonFileCacheStore<TValue>;
+export {};

package/dist/shared/jsonc-parser.d.ts

@@ -0,0 +1,23 @@
+export interface JsoncParseResult<T> {
+    data: T | null;
+    errors: Array<{
+        message: string;
+        offset: number;
+        length: number;
+    }>;
+}
+type DetectPluginConfigResult = {
+    format: "json" | "jsonc" | "none";
+    path: string;
+    legacyPath?: string;
+};
+export declare function parseJsonc<T = unknown>(content: string): T;
+export declare function parseJsoncSafe<T = unknown>(content: string): JsoncParseResult<T>;
+export declare function readJsoncFile<T = unknown>(filePath: string): T | null;
+export declare function detectConfigFile(basePath: string): {
+    format: "json" | "jsonc" | "none";
+    path: string;
+};
+export declare function clearPluginConfigFileDetectionCache(): void;
+export declare function detectPluginConfigFile(dir: string): DetectPluginConfigResult;
+export {};

package/dist/shared/known-variants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Canonical set of recognised variant / effort tokens.
+ * Used by parseFallbackModelEntry (space-suffix detection) and
+ * flattenToFallbackModelStrings (inline-variant stripping).
+ */
+export declare const KNOWN_VARIANTS: Set<string>;

package/dist/shared/legacy-plugin-warning.d.ts

@@ -0,0 +1,7 @@
+export interface LegacyPluginCheckResult {
+    hasLegacyEntry: boolean;
+    hasCanonicalEntry: boolean;
+    legacyEntries: string[];
+    configPath: string | null;
+}
+export declare function checkForLegacyPluginEntry(overrideConfigDir?: string): LegacyPluginCheckResult;

package/dist/shared/load-opencode-plugins.d.ts

@@ -0,0 +1,2 @@
+export declare function loadOpencodePlugins(directory: string): string[];
+export declare function clearOpencodePluginsCache(): void;

package/dist/shared/log-legacy-plugin-startup-warning.d.ts

@@ -0,0 +1,10 @@
+import { checkForLegacyPluginEntry } from "./legacy-plugin-warning";
+import { log } from "./logger";
+import { migrateLegacyPluginEntry } from "./migrate-legacy-plugin-entry";
+type LogLegacyPluginStartupWarningDeps = {
+    checkForLegacyPluginEntry?: typeof checkForLegacyPluginEntry;
+    log?: typeof log;
+    migrateLegacyPluginEntry?: typeof migrateLegacyPluginEntry;
+};
+export declare function logLegacyPluginStartupWarning(deps?: LogLegacyPluginStartupWarningDeps): void;
+export {};

package/dist/shared/logger.d.ts

@@ -0,0 +1,2 @@
+export declare function log(message: string, data?: unknown): void;
+export declare function getLogFilePath(): string;

package/dist/shared/merge-categories.d.ts

@@ -0,0 +1,6 @@
+import type { CategoriesConfig, CategoryConfig } from "../config/schema";
+/**
+ * Merge default and user categories, filtering out disabled ones.
+ * Single source of truth for category merging across the codebase.
+ */
+export declare function mergeCategories(userCategories?: CategoriesConfig): Record<string, CategoryConfig>;

package/dist/shared/migrate-legacy-config-file.d.ts

@@ -0,0 +1 @@
+export declare function migrateLegacyConfigFile(legacyPath: string): boolean;

package/dist/shared/migrate-legacy-plugin-entry.d.ts

@@ -0,0 +1 @@
+export declare function migrateLegacyPluginEntry(configPath: string): boolean;

package/dist/shared/migration/agent-category.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @deprecated LEGACY MIGRATION ONLY
+ *
+ * This map exists solely for migrating old configs that used hardcoded model strings.
+ * It maps legacy model strings to semantic category names, allowing users to migrate
+ * from explicit model configs to category-based configs.
+ *
+ * DO NOT add new entries here. New agents should use:
+ * - Category-based config (preferred): { category: "unspecified-high" }
+ * - Or inherit from OpenCode's config.model
+ *
+ * This map will be removed in a future major version once migration period ends.
+ */
+export declare const MODEL_TO_CATEGORY_MAP: Record<string, string>;
+export declare function migrateAgentConfigToCategory(config: Record<string, unknown>): {
+    migrated: Record<string, unknown>;
+    changed: boolean;
+};
+export declare function shouldDeleteAgentConfig(config: Record<string, unknown>, category: string): boolean;

package/dist/shared/migration/agent-names.d.ts

@@ -0,0 +1,6 @@
+export declare const AGENT_NAME_MAP: Record<string, string>;
+export declare const BUILTIN_AGENT_NAMES: Set<string>;
+export declare function migrateAgentNames(agents: Record<string, unknown>): {
+    migrated: Record<string, unknown>;
+    changed: boolean;
+};

package/dist/shared/migration/config-migration.d.ts

@@ -0,0 +1 @@
+export declare function migrateConfigFile(configPath: string, rawConfig: Record<string, unknown>): boolean;

package/dist/shared/migration/hook-names.d.ts

@@ -0,0 +1,6 @@
+export declare const HOOK_NAME_MAP: Record<string, string | null>;
+export declare function migrateHookNames(hooks: string[]): {
+    migrated: string[];
+    changed: boolean;
+    removed: string[];
+};

package/dist/shared/migration/migrations-sidecar.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Sidecar state file that tracks applied config migrations outside the user's
+ * config file.
+ *
+ * Why this exists (#3263): users who revert an auto-migrated value (e.g.
+ * `gpt-5.4` → `gpt-5.3-codex`) and then delete the `_migrations` field from
+ * their config would fall into an infinite migration loop — every startup
+ * re-applied the migration because there was no memory of the previous
+ * application. The sidecar remembers applied migrations even when the user
+ * scrubs the config, and only "resets" when the user explicitly deletes both
+ * the config and the sidecar.
+ *
+ * The sidecar lives next to the config file as
+ * `<configFileName>.migrations.json`. One sidecar per config file. The file
+ * format is a flat JSON object:
+ *
+ *     {
+ *       "appliedMigrations": [
+ *         "model-version:openai/gpt-5.3-codex->openai/gpt-5.4",
+ *         "model-version:anthropic/claude-opus-4-5->anthropic/claude-opus-4-7"
+ *       ]
+ *     }
+ */
+export interface MigrationsSidecar {
+    appliedMigrations: string[];
+}
+export declare function getSidecarPath(configPath: string): string;
+/**
+ * Read the set of applied migration keys from the sidecar next to
+ * `configPath`. Returns an empty set on any read or parse failure so the
+ * caller can still trust the return value and safely fall back to the
+ * config's `_migrations` field.
+ */
+export declare function readAppliedMigrations(configPath: string): Set<string>;
+/**
+ * Persist the given set of applied migration keys to the sidecar next to
+ * `configPath`. The sidecar is written atomically. Returns true on success,
+ * false if the write failed (the caller can still proceed — the next
+ * startup will re-run the migration, which is idempotent by design).
+ */
+export declare function writeAppliedMigrations(configPath: string, migrations: Set<string>): boolean;

package/dist/shared/migration/model-versions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Model version migration map: old full model strings → new full model strings.
+ * Used to auto-upgrade hardcoded model versions in user configs when the plugin
+ * bumps to newer model versions.
+ *
+ * Keys are full "provider/model" strings. Only openai and anthropic entries needed.
+ */
+export declare const MODEL_VERSION_MAP: Record<string, string>;
+export declare function migrateModelVersions(configs: Record<string, unknown>, appliedMigrations?: Set<string>): {
+    migrated: Record<string, unknown>;
+    changed: boolean;
+    newMigrations: string[];
+};

package/dist/shared/migration.d.ts

@@ -0,0 +1,5 @@
+export { AGENT_NAME_MAP, BUILTIN_AGENT_NAMES, migrateAgentNames } from "./migration/agent-names";
+export { HOOK_NAME_MAP, migrateHookNames } from "./migration/hook-names";
+export { MODEL_VERSION_MAP, migrateModelVersions } from "./migration/model-versions";
+export { MODEL_TO_CATEGORY_MAP, migrateAgentConfigToCategory, shouldDeleteAgentConfig } from "./migration/agent-category";
+export { migrateConfigFile } from "./migration/config-migration";

package/dist/shared/model-availability.d.ts

@@ -0,0 +1,15 @@
+export declare function fuzzyMatchModel(target: string, available: Set<string>, providers?: string[]): string | null;
+/**
+ * Check if a target model is available (fuzzy match by model name, no provider filtering)
+ *
+ * @param targetModel - Model name to check (e.g., "gpt-5.3-codex")
+ * @param availableModels - Set of available models in "provider/model" format
+ * @returns true if model is available, false otherwise
+ */
+export declare function isModelAvailable(targetModel: string, availableModels: Set<string>): boolean;
+export declare function getConnectedProviders(client: any): Promise<string[]>;
+export declare function fetchAvailableModels(client?: any, options?: {
+    connectedProviders?: string[] | null;
+}): Promise<Set<string>>;
+export declare function __resetModelCache(): void;
+export declare function isModelCacheAvailable(): boolean;

package/dist/shared/model-capabilities/bundled-snapshot.d.ts

@@ -0,0 +1,2 @@
+import type { ModelCapabilitiesSnapshot } from "./types";
+export declare function getBundledModelCapabilitiesSnapshot(): ModelCapabilitiesSnapshot;

package/dist/shared/model-capabilities/get-model-capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { GetModelCapabilitiesInput, ModelCapabilities } from "./types";
+export declare function getModelCapabilities(input: GetModelCapabilitiesInput): ModelCapabilities;

package/dist/shared/model-capabilities/index.d.ts

@@ -0,0 +1,3 @@
+export { getBundledModelCapabilitiesSnapshot } from "./bundled-snapshot";
+export { getModelCapabilities } from "./get-model-capabilities";
+export type { GetModelCapabilitiesInput, ModelCapabilities, ModelCapabilitiesDiagnostics, ModelCapabilitiesSnapshot, ModelCapabilitiesSnapshotEntry, } from "./types";

package/dist/shared/model-capabilities/runtime-model-readers.d.ts

@@ -0,0 +1,11 @@
+import type { ModelMetadata } from "../connected-providers-cache";
+import type { ModelCapabilities } from "./types";
+export declare function readRuntimeModel(runtimeModel: ModelMetadata | Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+export declare function readRuntimeModelVariants(runtimeModel: Record<string, unknown> | undefined): string[] | undefined;
+export declare function readRuntimeModelModalities(runtimeModel: Record<string, unknown> | undefined): ModelCapabilities["modalities"] | undefined;
+export declare function readRuntimeModelReasoningSupport(runtimeModel: Record<string, unknown> | undefined): boolean | undefined;
+export declare function readRuntimeModelThinkingSupport(runtimeModel: Record<string, unknown> | undefined): boolean | undefined;
+export declare function readRuntimeModelTemperatureSupport(runtimeModel: Record<string, unknown> | undefined): boolean | undefined;
+export declare function readRuntimeModelTopPSupport(runtimeModel: Record<string, unknown> | undefined): boolean | undefined;
+export declare function readRuntimeModelToolCallSupport(runtimeModel: Record<string, unknown> | undefined): boolean | undefined;
+export declare function readRuntimeModelLimitOutput(runtimeModel: Record<string, unknown> | undefined): number | undefined;

package/dist/shared/model-capabilities/supplemental-entries.d.ts

@@ -0,0 +1,2 @@
+import type { ModelCapabilitiesSnapshotEntry } from "./types";
+export declare const SUPPLEMENTAL_MODEL_CAPABILITIES: Record<string, ModelCapabilitiesSnapshotEntry>;