@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/shared/migration/model-versions.ts

@@ -1,50 +0,0 @@
-/**
- * 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 const MODEL_VERSION_MAP: Record<string, string> = {
-  "anthropic/claude-opus-4-5": "anthropic/claude-opus-4-6",
-  "anthropic/claude-sonnet-4-5": "anthropic/claude-sonnet-4-6",
-  "openai/gpt-5.3-codex": "openai/gpt-5.4",
-}
-
-function migrationKey(oldModel: string, newModel: string): string {
-  return `model-version:${oldModel}->${newModel}`
-}
-
-export function migrateModelVersions(
-  configs: Record<string, unknown>,
-  appliedMigrations?: Set<string>
-): { migrated: Record<string, unknown>; changed: boolean; newMigrations: string[] } {
-  const migrated: Record<string, unknown> = {}
-  let changed = false
-  const newMigrations: string[] = []
-
-  for (const [key, value] of Object.entries(configs)) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      const config = value as Record<string, unknown>
-      if (typeof config.model === "string" && MODEL_VERSION_MAP[config.model]) {
-        const oldModel = config.model
-        const newModel = MODEL_VERSION_MAP[oldModel]
-        const mKey = migrationKey(oldModel, newModel)
-
-        // Skip if this migration was already applied (user may have reverted)
-        if (appliedMigrations?.has(mKey)) {
-          migrated[key] = value
-          continue
-        }
-
-        migrated[key] = { ...config, model: newModel }
-        changed = true
-        newMigrations.push(mKey)
-        continue
-      }
-    }
-    migrated[key] = value
-  }
-
-  return { migrated, changed, newMigrations }
-}

package/src/shared/migration.ts

@@ -1,5 +0,0 @@
-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/src/shared/mode-routing.test.ts

@@ -1,88 +0,0 @@
-import { expect, test } from "bun:test"
-import { normalizeMode, resolveModeAgent, MODE_TO_AGENT, MODE_NAMES } from "./mode-routing"
-
-test("normalizeMode returns legacy aliases mapped to new names", () => {
-  expect(normalizeMode("unspecified-low")).toBe("bounded")
-  expect(normalizeMode("unspecified-high")).toBe("cross-module")
-})
-
-test("normalizeMode returns same name when not a legacy alias", () => {
-  expect(normalizeMode("quick")).toBe("quick")
-  expect(normalizeMode("deep")).toBe("deep")
-  expect(normalizeMode("writing")).toBe("writing")
-})
-
-test("resolveModeAgent maps quick to sub", () => {
-  expect(resolveModeAgent("quick")).toBe("sub")
-})
-
-test("resolveModeAgent maps writing to brainstormer", () => {
-  expect(resolveModeAgent("writing")).toBe("brainstormer")
-})
-
-test("resolveModeAgent maps deep to coder", () => {
-  expect(resolveModeAgent("deep")).toBe("coder")
-})
-
-test("resolveModeAgent maps ultrabrain to strategist", () => {
-  expect(resolveModeAgent("ultrabrain")).toBe("strategist")
-})
-
-test("resolveModeAgent maps visual-engineering to designer", () => {
-  expect(resolveModeAgent("visual-engineering")).toBe("designer")
-})
-
-test("resolveModeAgent maps artistry to designer", () => {
-  expect(resolveModeAgent("artistry")).toBe("designer")
-})
-
-test("resolveModeAgent maps git to platform-manager", () => {
-  expect(resolveModeAgent("git")).toBe("platform-manager")
-})
-
-test("resolveModeAgent maps git-ops to platform-manager", () => {
-  expect(resolveModeAgent("git-ops")).toBe("platform-manager")
-})
-
-test("resolveModeAgent maps bounded to sub", () => {
-  expect(resolveModeAgent("bounded")).toBe("sub")
-})
-
-test("resolveModeAgent maps cross-module to coder", () => {
-  expect(resolveModeAgent("cross-module")).toBe("coder")
-})
-
-test("resolveModeAgent falls back to coder for unknown mode", () => {
-  expect(resolveModeAgent("unknown-mode")).toBe("coder")
-})
-
-test("resolveModeAgent handles legacy aliases", () => {
-  expect(resolveModeAgent("unspecified-low")).toBe("sub")
-  expect(resolveModeAgent("unspecified-high")).toBe("coder")
-})
-
-test("MODE_NAMES contains all mode names", () => {
-  expect(MODE_NAMES).toContain("quick")
-  expect(MODE_NAMES).toContain("writing")
-  expect(MODE_NAMES).toContain("deep")
-  expect(MODE_NAMES).toContain("ultrabrain")
-  expect(MODE_NAMES).toContain("visual-engineering")
-  expect(MODE_NAMES).toContain("artistry")
-  expect(MODE_NAMES).toContain("git")
-  expect(MODE_NAMES).toContain("git-ops")
-  expect(MODE_NAMES).toContain("bounded")
-  expect(MODE_NAMES).toContain("cross-module")
-})
-
-test("MODE_TO_AGENT has correct mapping", () => {
-  expect(MODE_TO_AGENT.quick).toBe("sub")
-  expect(MODE_TO_AGENT.writing).toBe("brainstormer")
-  expect(MODE_TO_AGENT.deep).toBe("coder")
-  expect(MODE_TO_AGENT.ultrabrain).toBe("strategist")
-  expect(MODE_TO_AGENT["visual-engineering"]).toBe("designer")
-  expect(MODE_TO_AGENT.artistry).toBe("designer")
-  expect(MODE_TO_AGENT.git).toBe("platform-manager")
-  expect(MODE_TO_AGENT["git-ops"]).toBe("platform-manager")
-  expect(MODE_TO_AGENT.bounded).toBe("sub")
-  expect(MODE_TO_AGENT["cross-module"]).toBe("coder")
-})

package/src/shared/mode-routing.ts

@@ -1,30 +0,0 @@
-import type { CanonicalDelegateAgentKey } from "../tools/delegate-task/sub-agent"
-
-export const MODE_TO_AGENT: Record<string, CanonicalDelegateAgentKey> = {
-  quick: "sub",
-  writing: "brainstormer",
-  deep: "coder",
-  ultrabrain: "strategist",
-  "visual-engineering": "designer",
-  artistry: "designer",
-  git: "platform-manager",
-  "git-ops": "platform-manager",
-  bounded: "sub",
-  "cross-module": "coder",
-}
-
-const LEGACY_MODE_ALIASES: Record<string, string> = {
-  "unspecified-low": "bounded",
-  "unspecified-high": "cross-module",
-}
-
-export type ModeName = keyof typeof MODE_TO_AGENT
-export const MODE_NAMES = Object.keys(MODE_TO_AGENT) as ModeName[]
-
-export function normalizeMode(modeName: string): string {
-  return LEGACY_MODE_ALIASES[modeName] ?? modeName
-}
-
-export function resolveModeAgent(modeName: string): CanonicalDelegateAgentKey {
-  return MODE_TO_AGENT[normalizeMode(modeName)] ?? "coder"
-}

package/src/shared/model-availability.ts

@@ -1,294 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { join } from "path"
-import { log } from "./logger"
-import { getOpenCodeCacheDir } from "./data-path"
-import * as connectedProvidersCache from "./connected-providers-cache"
-import { normalizeSDKResponse } from "./normalize-sdk-response"
-
-/**
- * Fuzzy match a target model name against available models
- * 
- * @param target - The model name or substring to search for (e.g., "gpt-5.4", "claude-opus")
- * @param available - Set of available model names in format "provider/model-name"
- * @param providers - Optional array of provider names to filter by (e.g., ["openai", "anthropic"])
- * @returns The matched model name or null if no match found
- * 
- * Matching priority:
- * 1. Exact match (if exists)
- * 2. Shorter model name (more specific)
- * 
- * Matching is case-insensitive substring match.
- * If providers array is given, only models starting with "provider/" are considered.
- * 
- * @example
- * const available = new Set(["openai/gpt-5.4", "openai/gpt-5.3-codex", "anthropic/claude-opus-4-6"])
- * fuzzyMatchModel("gpt-5.4", available) // → "openai/gpt-5.4"
- * fuzzyMatchModel("claude", available, ["openai"]) // → null (provider filter excludes anthropic)
- */
-function normalizeModelName(name: string): string {
-	return name
-		.toLowerCase()
-		.replace(/claude-(opus|sonnet|haiku)-(\d+)[.-](\d+)/g, "claude-$1-$2.$3")
-}
-
-export function fuzzyMatchModel(
-	target: string,
-	available: Set<string>,
-	providers?: string[],
-): string | null {
-	log("[fuzzyMatchModel] called", { target, availableCount: available.size, providers })
-
-	if (available.size === 0) {
-		log("[fuzzyMatchModel] empty available set")
-		return null
-	}
-
-	const targetNormalized = normalizeModelName(target)
-
-	// Filter by providers if specified
-	let candidates = Array.from(available)
-	if (providers && providers.length > 0) {
-		const providerSet = new Set(providers)
-		candidates = candidates.filter((model) => {
-			const [provider] = model.split("/")
-			return providerSet.has(provider)
-		})
-		log("[fuzzyMatchModel] filtered by providers", { candidateCount: candidates.length, candidates: candidates.slice(0, 10) })
-	}
-
-	if (candidates.length === 0) {
-		log("[fuzzyMatchModel] no candidates after filter")
-		return null
-	}
-
-	// Find all matches (case-insensitive substring match with normalization)
-	const matches = candidates.filter((model) =>
-		normalizeModelName(model).includes(targetNormalized),
-	)
-
-	log("[fuzzyMatchModel] substring matches", { targetNormalized, matchCount: matches.length, matches })
-
-	if (matches.length === 0) {
-		log("[fuzzyMatchModel] WARNING: no match found", { target, availableCount: available.size, providers })
-		return null
-	}
-
-	// Priority 1: Exact match (normalized full model string)
-	const exactMatch = matches.find((model) => normalizeModelName(model) === targetNormalized)
-	if (exactMatch) {
-		log("[fuzzyMatchModel] exact match found", { exactMatch })
-		return exactMatch
-	}
-
-	// Priority 2: Exact model ID match (part after provider/)
-	// This ensures "big-pickle" matches "zai-coding-plan/big-pickle" over "zai-coding-plan/glm-5"
-	// Use filter + shortest to handle multi-provider cases (e.g., openai/gpt-5.4 + opencode/gpt-5.4)
-	const exactModelIdMatches = matches.filter((model) => {
-		const modelId = model.split("/").slice(1).join("/")
-		return normalizeModelName(modelId) === targetNormalized
-	})
-	if (exactModelIdMatches.length > 0) {
-		const result = exactModelIdMatches.reduce((shortest, current) =>
-			current.length < shortest.length ? current : shortest,
-		)
-		log("[fuzzyMatchModel] exact model ID match found", { result, candidateCount: exactModelIdMatches.length })
-		return result
-	}
-
-	// Priority 3: Shorter model name (more specific, fallback for partial matches)
-	const result = matches.reduce((shortest, current) =>
-		current.length < shortest.length ? current : shortest,
-	)
-	log("[fuzzyMatchModel] shortest match", { result })
-	return result
-}
-
-/**
- * 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 function isModelAvailable(
-	targetModel: string,
-	availableModels: Set<string>,
-): boolean {
-	return fuzzyMatchModel(targetModel, availableModels) !== null
-}
-
-export async function getConnectedProviders(client: any): Promise<string[]> {
-	if (!client?.provider?.list) {
-		log("[getConnectedProviders] client.provider.list not available")
-		return []
-	}
-
-	try {
-		const result = await client.provider.list()
-		const connected = result.data?.connected ?? []
-		log("[getConnectedProviders] connected providers", { count: connected.length, providers: connected })
-		return connected
-	} catch (err) {
-		log("[getConnectedProviders] SDK error", { error: String(err) })
-		return []
-	}
-}
-
-export async function fetchAvailableModels(
-	client?: any,
-	options?: { connectedProviders?: string[] | null }
-): Promise<Set<string>> {
-	let connectedProviders = options?.connectedProviders ?? null
-	let connectedProvidersUnknown = connectedProviders === null
-
-	log("[fetchAvailableModels] CALLED", { 
-		connectedProvidersUnknown,
-		connectedProviders: options?.connectedProviders 
-	})
-
-	if (connectedProvidersUnknown && client) {
-		const liveConnected = await getConnectedProviders(client)
-		if (liveConnected.length > 0) {
-			connectedProviders = liveConnected
-			connectedProvidersUnknown = false
-			log("[fetchAvailableModels] connected providers fetched from client", { count: liveConnected.length })
-		}
-	}
-
-	if (connectedProvidersUnknown) {
-		if (client?.model?.list) {
-			const modelSet = new Set<string>()
-			try {
-				const modelsResult = await client.model.list()
-				const models = normalizeSDKResponse(modelsResult, [] as Array<{ provider?: string; id?: string }>)
-				for (const model of models) {
-					if (model?.provider && model?.id) {
-						modelSet.add(`${model.provider}/${model.id}`)
-					}
-				}
-				log("[fetchAvailableModels] fetched models from client without provider filter", {
-					count: modelSet.size,
-				})
-				return modelSet
-			} catch (err) {
-				log("[fetchAvailableModels] client.model.list error", { error: String(err) })
-			}
-		}
-		log("[fetchAvailableModels] connected providers unknown, returning empty set for fallback resolution")
-		return new Set<string>()
-	}
-
-	const connectedProvidersList = connectedProviders ?? []
-	const connectedSet = new Set(connectedProvidersList)
-	const modelSet = new Set<string>()
-
-	const providerModelsCache = connectedProvidersCache.readProviderModelsCache()
-	if (providerModelsCache) {
-		const providerCount = Object.keys(providerModelsCache.models).length
-		if (providerCount === 0) {
-			log("[fetchAvailableModels] provider-models cache empty, falling back to models.json")
-		} else {
-		log("[fetchAvailableModels] using provider-models cache (whitelist-filtered)")
-		
-		const modelsByProvider = providerModelsCache.models as Record<string, Array<string | { id?: string }>>
-		for (const [providerId, modelIds] of Object.entries(modelsByProvider)) {
-			if (!connectedSet.has(providerId)) {
-				continue
-			}
-			for (const modelItem of modelIds) {
-				// Handle both string[] (legacy) and object[] (with metadata) formats
-				const modelId = typeof modelItem === 'string' 
-					? modelItem 
-					: modelItem?.id
-				
-				if (modelId) {
-					modelSet.add(`${providerId}/${modelId}`)
-				}
-			}
-		}
-
-			log("[fetchAvailableModels] parsed from provider-models cache", {
-				count: modelSet.size,
-				connectedProviders: connectedProvidersList.slice(0, 5)
-			})
-
-			if (modelSet.size > 0) {
-				return modelSet
-			}
-			log("[fetchAvailableModels] provider-models cache produced no models for connected providers, falling back to models.json")
-		}
-	}
-
-	log("[fetchAvailableModels] provider-models cache not found, falling back to models.json")
-	const cacheFile = join(getOpenCodeCacheDir(), "models.json")
-
-	if (!existsSync(cacheFile)) {
-		log("[fetchAvailableModels] models.json cache file not found, falling back to client")
-	} else {
-		try {
-			const content = readFileSync(cacheFile, "utf-8")
-			const data = JSON.parse(content) as Record<string, { id?: string; models?: Record<string, { id?: string }> }>
-
-			const providerIds = Object.keys(data)
-			log("[fetchAvailableModels] providers found in models.json", { count: providerIds.length, providers: providerIds.slice(0, 10) })
-
-			for (const providerId of providerIds) {
-				if (!connectedSet.has(providerId)) {
-					continue
-				}
-
-				const provider = data[providerId]
-				const models = provider?.models
-				if (!models || typeof models !== "object") continue
-
-				for (const modelKey of Object.keys(models)) {
-					modelSet.add(`${providerId}/${modelKey}`)
-				}
-			}
-
-			log("[fetchAvailableModels] parsed models from models.json (NO whitelist filtering)", {
-				count: modelSet.size,
-				connectedProviders: connectedProvidersList.slice(0, 5)
-			})
-
-			if (modelSet.size > 0) {
-				return modelSet
-			}
-		} catch (err) {
-			log("[fetchAvailableModels] error", { error: String(err) })
-		}
-	}
-
-	if (client?.model?.list) {
-		try {
-			const modelsResult = await client.model.list()
-			const models = normalizeSDKResponse(modelsResult, [] as Array<{ provider?: string; id?: string }>)
-
-			for (const model of models) {
-				if (!model?.provider || !model?.id) continue
-				if (connectedSet.has(model.provider)) {
-					modelSet.add(`${model.provider}/${model.id}`)
-				}
-			}
-
-			log("[fetchAvailableModels] fetched models from client (filtered)", {
-				count: modelSet.size,
-				connectedProviders: connectedProvidersList.slice(0, 5),
-			})
-		} catch (err) {
-			log("[fetchAvailableModels] client.model.list error", { error: String(err) })
-		}
-	}
-
-	return modelSet
-}
-
-export function __resetModelCache(): void {}
-
-export function isModelCacheAvailable(): boolean {
-	if (connectedProvidersCache.hasProviderModelsCache()) {
-		return true
-	}
-	const cacheFile = join(getOpenCodeCacheDir(), "models.json")
-	return existsSync(cacheFile)
-}

package/src/shared/model-capabilities/bundled-snapshot.ts

@@ -1,15 +0,0 @@
-import bundledModelCapabilitiesSnapshotJson from "../../config/data/model-capabilities.json"
-
-import type { ModelCapabilitiesSnapshot } from "./types"
-
-function normalizeSnapshot(
-	snapshot: ModelCapabilitiesSnapshot | typeof bundledModelCapabilitiesSnapshotJson,
-): ModelCapabilitiesSnapshot {
-	return snapshot as ModelCapabilitiesSnapshot
-}
-
-const bundledModelCapabilitiesSnapshot = normalizeSnapshot(bundledModelCapabilitiesSnapshotJson)
-
-export function getBundledModelCapabilitiesSnapshot(): ModelCapabilitiesSnapshot {
-	return bundledModelCapabilitiesSnapshot
-}

package/src/shared/model-capabilities/get-model-capabilities.ts

@@ -1,140 +0,0 @@
-import { findProviderModelMetadata } from "../connected-providers-cache"
-import { resolveModelIDAlias } from "../model-capability-aliases"
-import { detectHeuristicModelFamily } from "../model-capability-heuristics"
-
-import { getBundledModelCapabilitiesSnapshot } from "./bundled-snapshot"
-import {
-	readRuntimeModel,
-	readRuntimeModelLimitOutput,
-	readRuntimeModelModalities,
-	readRuntimeModelReasoningSupport,
-	readRuntimeModelTemperatureSupport,
-	readRuntimeModelThinkingSupport,
-	readRuntimeModelToolCallSupport,
-	readRuntimeModelTopPSupport,
-	readRuntimeModelVariants,
-} from "./runtime-model-readers"
-import type {
-	GetModelCapabilitiesInput,
-	ModelCapabilities,
-	ModelCapabilitiesDiagnostics,
-	ModelCapabilityOverride,
-} from "./types"
-
-const MODEL_ID_OVERRIDES: Record<string, ModelCapabilityOverride> = {}
-
-function normalizeLookupModelID(modelID: string): string {
-	return modelID.trim().toLowerCase()
-}
-
-function getOverride(modelID: string): ModelCapabilityOverride | undefined {
-	return MODEL_ID_OVERRIDES[normalizeLookupModelID(modelID)]
-}
-
-export function getModelCapabilities(input: GetModelCapabilitiesInput): ModelCapabilities {
-	const canonicalization = resolveModelIDAlias(input.modelID)
-	const override = getOverride(input.modelID)
-	const runtimeModel = readRuntimeModel(
-		input.runtimeModel ?? findProviderModelMetadata(input.providerID, input.modelID),
-	)
-	const runtimeSnapshot = input.runtimeSnapshot
-	const bundledSnapshot = input.bundledSnapshot ?? getBundledModelCapabilitiesSnapshot()
-	const snapshotEntry = runtimeSnapshot?.models?.[canonicalization.canonicalModelID]
-		?? bundledSnapshot.models[canonicalization.canonicalModelID]
-	const heuristicFamily = detectHeuristicModelFamily(canonicalization.canonicalModelID)
-
-	const runtimeVariants = readRuntimeModelVariants(runtimeModel)
-	const runtimeReasoning = readRuntimeModelReasoningSupport(runtimeModel)
-	const runtimeThinking = readRuntimeModelThinkingSupport(runtimeModel)
-	const runtimeTemperature = readRuntimeModelTemperatureSupport(runtimeModel)
-	const runtimeTopP = readRuntimeModelTopPSupport(runtimeModel)
-	const runtimeMaxOutputTokens = readRuntimeModelLimitOutput(runtimeModel)
-	const runtimeToolCall = readRuntimeModelToolCallSupport(runtimeModel)
-	const runtimeModalities = readRuntimeModelModalities(runtimeModel)
-
-	const snapshotSource: ModelCapabilitiesDiagnostics["snapshot"]["source"] =
-		runtimeSnapshot?.models?.[canonicalization.canonicalModelID]
-			? "runtime-snapshot"
-			: bundledSnapshot.models[canonicalization.canonicalModelID]
-			? "bundled-snapshot"
-			: "none"
-	const familySource: ModelCapabilitiesDiagnostics["family"]["source"] =
-		snapshotEntry?.family ? "snapshot" : heuristicFamily?.family ? "heuristic" : "none"
-	const variantsSource: ModelCapabilitiesDiagnostics["variants"]["source"] =
-		runtimeVariants ? "runtime" : override?.variants ? "override" : heuristicFamily?.variants ? "heuristic" : "none"
-	const reasoningEffortsSource: ModelCapabilitiesDiagnostics["reasoningEfforts"]["source"] =
-		override?.reasoningEfforts ? "override" : heuristicFamily?.reasoningEfforts ? "heuristic" : "none"
-	const reasoningSource: ModelCapabilitiesDiagnostics["reasoning"]["source"] =
-		runtimeReasoning === undefined ? snapshotEntry?.reasoning === undefined ? "none" : snapshotSource : "runtime"
-	const supportsThinkingSource: ModelCapabilitiesDiagnostics["supportsThinking"]["source"] =
-		override?.supportsThinking !== undefined
-			? "override"
-			: heuristicFamily?.supportsThinking !== undefined
-			? "heuristic"
-			: runtimeThinking !== undefined
-			? "runtime"
-			: snapshotEntry?.reasoning !== undefined
-			? snapshotSource
-			: "none"
-	const supportsTemperatureSource: ModelCapabilitiesDiagnostics["supportsTemperature"]["source"] =
-		runtimeTemperature !== undefined
-			? "runtime"
-			: override?.supportsTemperature !== undefined
-			? "override"
-			: snapshotEntry?.temperature !== undefined
-			? snapshotSource
-			: "none"
-	const supportsTopPSource: ModelCapabilitiesDiagnostics["supportsTopP"]["source"] =
-		runtimeTopP !== undefined ? "runtime" : override?.supportsTopP !== undefined ? "override" : "none"
-	const maxOutputTokensSource: ModelCapabilitiesDiagnostics["maxOutputTokens"]["source"] =
-		runtimeMaxOutputTokens !== undefined
-			? "runtime"
-			: snapshotEntry?.limit?.output !== undefined
-			? snapshotSource
-			: "none"
-	const toolCallSource: ModelCapabilitiesDiagnostics["toolCall"]["source"] =
-		runtimeToolCall !== undefined ? "runtime" : snapshotEntry?.toolCall !== undefined ? snapshotSource : "none"
-	const modalitiesSource: ModelCapabilitiesDiagnostics["modalities"]["source"] =
-		runtimeModalities !== undefined ? "runtime" : snapshotEntry?.modalities !== undefined ? snapshotSource : "none"
-	const resolutionMode: ModelCapabilitiesDiagnostics["resolutionMode"] =
-		snapshotSource !== "none" && canonicalization.source === "canonical"
-			? "snapshot-backed"
-			: snapshotSource !== "none"
-			? "alias-backed"
-			: familySource === "heuristic" || variantsSource === "heuristic" || reasoningEffortsSource === "heuristic"
-			? "heuristic-backed"
-			: "unknown"
-
-	return {
-		requestedModelID: canonicalization.requestedModelID,
-		canonicalModelID: canonicalization.canonicalModelID,
-		family: snapshotEntry?.family ?? heuristicFamily?.family,
-		variants: runtimeVariants ?? override?.variants ?? heuristicFamily?.variants,
-		reasoningEfforts: override?.reasoningEfforts ?? heuristicFamily?.reasoningEfforts,
-		reasoning: runtimeReasoning ?? snapshotEntry?.reasoning,
-		supportsThinking: override?.supportsThinking ?? heuristicFamily?.supportsThinking ?? runtimeThinking ?? snapshotEntry?.reasoning,
-		supportsTemperature: runtimeTemperature ?? override?.supportsTemperature ?? snapshotEntry?.temperature,
-		supportsTopP: runtimeTopP ?? override?.supportsTopP,
-		maxOutputTokens: runtimeMaxOutputTokens ?? snapshotEntry?.limit?.output,
-		toolCall: runtimeToolCall ?? snapshotEntry?.toolCall,
-		modalities: runtimeModalities ?? snapshotEntry?.modalities,
-		diagnostics: {
-			resolutionMode,
-			canonicalization: {
-				source: canonicalization.source,
-				...(canonicalization.ruleID ? { ruleID: canonicalization.ruleID } : {}),
-			},
-			snapshot: { source: snapshotSource },
-			family: { source: familySource },
-			variants: { source: variantsSource },
-			reasoningEfforts: { source: reasoningEffortsSource },
-			reasoning: { source: reasoningSource },
-			supportsThinking: { source: supportsThinkingSource },
-			supportsTemperature: { source: supportsTemperatureSource },
-			supportsTopP: { source: supportsTopPSource },
-			maxOutputTokens: { source: maxOutputTokensSource },
-			toolCall: { source: toolCallSource },
-			modalities: { source: modalitiesSource },
-		},
-	}
-}

package/src/shared/model-capabilities/index.ts

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