@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/shared/model-capabilities/runtime-model-readers.ts

@@ -1,190 +0,0 @@
-import type { ModelMetadata } from "../connected-providers-cache"
-
-import type { ModelCapabilities } from "./types"
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function readNumber(value: unknown): number | undefined {
-	return typeof value === "number" ? value : undefined
-}
-
-function readStringArray(value: unknown): string[] | undefined {
-	if (!Array.isArray(value)) {
-		return undefined
-	}
-
-	const strings = value.filter((item): item is string => typeof item === "string")
-	return strings.length > 0 ? strings : undefined
-}
-
-function normalizeVariantKeys(value: unknown): string[] | undefined {
-	const arrayVariants = readStringArray(value)
-	if (arrayVariants) {
-		return arrayVariants.map((variant) => variant.toLowerCase())
-	}
-
-	if (!isRecord(value)) {
-		return undefined
-	}
-
-	const variants = Object.keys(value).map((variant) => variant.toLowerCase())
-	return variants.length > 0 ? variants : undefined
-}
-
-function readModalityKeys(value: unknown): string[] | undefined {
-	const stringArray = readStringArray(value)
-	if (stringArray) {
-		return stringArray.map((entry) => entry.toLowerCase())
-	}
-
-	if (!isRecord(value)) {
-		return undefined
-	}
-
-	const enabled = Object.entries(value)
-		.filter(([, supported]) => supported === true)
-		.map(([modality]) => modality.toLowerCase())
-
-	return enabled.length > 0 ? enabled : undefined
-}
-
-function normalizeModalities(value: unknown): ModelCapabilities["modalities"] | undefined {
-	if (!isRecord(value)) {
-		return undefined
-	}
-
-	const input = readModalityKeys(value.input)
-	const output = readModalityKeys(value.output)
-
-	if (!input && !output) {
-		return undefined
-	}
-
-	return {
-		...(input ? { input } : {}),
-		...(output ? { output } : {}),
-	}
-}
-
-function readRuntimeModelCapabilities(
-	runtimeModel: Record<string, unknown> | undefined,
-): Record<string, unknown> | undefined {
-	return isRecord(runtimeModel?.capabilities) ? runtimeModel.capabilities : undefined
-}
-
-function readRuntimeModelBoolean(
-	runtimeModel: Record<string, unknown> | undefined,
-	keys: string[],
-): boolean | undefined {
-	const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel)
-
-	for (const key of keys) {
-		const value = runtimeModel?.[key]
-		if (typeof value === "boolean") {
-			return value
-		}
-
-		const capabilityValue = runtimeCapabilities?.[key]
-		if (typeof capabilityValue === "boolean") {
-			return capabilityValue
-		}
-	}
-
-	return undefined
-}
-
-export function readRuntimeModel(
-	runtimeModel: ModelMetadata | Record<string, unknown> | undefined,
-): Record<string, unknown> | undefined {
-	return isRecord(runtimeModel) ? runtimeModel : undefined
-}
-
-export function readRuntimeModelVariants(
-	runtimeModel: Record<string, unknown> | undefined,
-): string[] | undefined {
-	const rootVariants = normalizeVariantKeys(runtimeModel?.variants)
-	if (rootVariants) {
-		return rootVariants
-	}
-
-	return normalizeVariantKeys(readRuntimeModelCapabilities(runtimeModel)?.variants)
-}
-
-export function readRuntimeModelModalities(
-	runtimeModel: Record<string, unknown> | undefined,
-): ModelCapabilities["modalities"] | undefined {
-	const rootModalities = normalizeModalities(runtimeModel?.modalities)
-	if (rootModalities) {
-		return rootModalities
-	}
-
-	const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel)
-	return (
-		normalizeModalities(runtimeCapabilities?.modalities)
-		?? normalizeModalities(runtimeCapabilities)
-	)
-}
-
-export function readRuntimeModelReasoningSupport(
-	runtimeModel: Record<string, unknown> | undefined,
-): boolean | undefined {
-	return readRuntimeModelBoolean(runtimeModel, ["reasoning"])
-}
-
-export function readRuntimeModelThinkingSupport(
-	runtimeModel: Record<string, unknown> | undefined,
-): boolean | undefined {
-	const capabilityValue = readRuntimeModelReasoningSupport(runtimeModel)
-	if (capabilityValue !== undefined) {
-		return capabilityValue
-	}
-
-	const thinkingSupport = readRuntimeModelBoolean(runtimeModel, ["thinking", "supportsThinking"])
-	if (thinkingSupport !== undefined) {
-		return thinkingSupport
-	}
-
-	const runtimeCapabilities = readRuntimeModelCapabilities(runtimeModel)
-	for (const key of ["thinking", "supportsThinking"] as const) {
-		const value = runtimeCapabilities?.[key]
-		if (typeof value === "boolean") {
-			return value
-		}
-	}
-
-	return undefined
-}
-
-export function readRuntimeModelTemperatureSupport(
-	runtimeModel: Record<string, unknown> | undefined,
-): boolean | undefined {
-	return readRuntimeModelBoolean(runtimeModel, ["temperature"])
-}
-
-export function readRuntimeModelTopPSupport(
-	runtimeModel: Record<string, unknown> | undefined,
-): boolean | undefined {
-	return readRuntimeModelBoolean(runtimeModel, ["topP", "top_p"])
-}
-
-export function readRuntimeModelToolCallSupport(
-	runtimeModel: Record<string, unknown> | undefined,
-): boolean | undefined {
-	return readRuntimeModelBoolean(runtimeModel, ["toolCall", "tool_call", "toolcall"])
-}
-
-export function readRuntimeModelLimitOutput(
-	runtimeModel: Record<string, unknown> | undefined,
-): number | undefined {
-	const limit = isRecord(runtimeModel?.limit)
-		? runtimeModel.limit
-		: readRuntimeModelCapabilities(runtimeModel)?.limit
-
-	if (!isRecord(limit)) {
-		return undefined
-	}
-
-	return readNumber(limit.output)
-}

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

@@ -1,80 +0,0 @@
-import type { ModelMetadata } from "../connected-providers-cache"
-
-export type ModelCapabilitiesSnapshotEntry = {
-	id: string
-	family?: string
-	reasoning?: boolean
-	temperature?: boolean
-	toolCall?: boolean
-	modalities?: {
-		input?: string[]
-		output?: string[]
-	}
-	limit?: {
-		context?: number
-		input?: number
-		output?: number
-	}
-}
-
-export type ModelCapabilitiesSnapshot = {
-	generatedAt: string
-	sourceUrl: string
-	models: Record<string, ModelCapabilitiesSnapshotEntry>
-}
-
-export type ModelCapabilitiesDiagnostics = {
-	resolutionMode: "snapshot-backed" | "alias-backed" | "heuristic-backed" | "unknown"
-	canonicalization: {
-		source: "canonical" | "exact-alias" | "pattern-alias"
-		ruleID?: string
-	}
-	snapshot: {
-		source: "runtime-snapshot" | "bundled-snapshot" | "none"
-	}
-	family: { source: "snapshot" | "heuristic" | "none" }
-	variants: { source: "none" | "runtime" | "override" | "heuristic" | "canonical" }
-	reasoningEfforts: { source: "none" | "override" | "heuristic" }
-	reasoning: { source: "runtime" | "runtime-snapshot" | "bundled-snapshot" | "none" }
-	supportsThinking: { source: "runtime" | "override" | "heuristic" | "runtime-snapshot" | "bundled-snapshot" | "none" }
-	supportsTemperature: { source: "runtime" | "override" | "runtime-snapshot" | "bundled-snapshot" | "none" }
-	supportsTopP: { source: "runtime" | "override" | "none" }
-	maxOutputTokens: { source: "runtime" | "runtime-snapshot" | "bundled-snapshot" | "none" }
-	toolCall: { source: "runtime" | "runtime-snapshot" | "bundled-snapshot" | "none" }
-	modalities: { source: "runtime" | "runtime-snapshot" | "bundled-snapshot" | "none" }
-}
-
-export type ModelCapabilities = {
-	requestedModelID: string
-	canonicalModelID: string
-	family?: string
-	variants?: string[]
-	reasoningEfforts?: string[]
-	reasoning?: boolean
-	supportsThinking?: boolean
-	supportsTemperature?: boolean
-	supportsTopP?: boolean
-	maxOutputTokens?: number
-	toolCall?: boolean
-	modalities?: {
-		input?: string[]
-		output?: string[]
-	}
-	diagnostics: ModelCapabilitiesDiagnostics
-}
-
-export type GetModelCapabilitiesInput = {
-	providerID: string
-	modelID: string
-	runtimeModel?: ModelMetadata | Record<string, unknown>
-	runtimeSnapshot?: ModelCapabilitiesSnapshot
-	bundledSnapshot?: ModelCapabilitiesSnapshot
-}
-
-export type ModelCapabilityOverride = {
-	variants?: string[]
-	reasoningEfforts?: string[]
-	supportsThinking?: boolean
-	supportsTemperature?: boolean
-	supportsTopP?: boolean
-}

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

@@ -1,213 +0,0 @@
-import * as dataPath from "./data-path"
-import { createJsonFileCacheStore } from "./json-file-cache-store"
-import type { ModelCapabilitiesSnapshot, ModelCapabilitiesSnapshotEntry } from "./model-capabilities"
-
-export const MODELS_DEV_SOURCE_URL = "https://models.dev/api.json"
-const MODEL_CAPABILITIES_CACHE_FILE = "model-capabilities.json"
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function readBoolean(value: unknown): boolean | undefined {
-  return typeof value === "boolean" ? value : undefined
-}
-
-function readNumber(value: unknown): number | undefined {
-  return typeof value === "number" ? value : undefined
-}
-
-function readString(value: unknown): string | undefined {
-  return typeof value === "string" ? value : undefined
-}
-
-function readStringArray(value: unknown): string[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined
-  }
-
-  const result = value.filter((item): item is string => typeof item === "string")
-  return result.length > 0 ? result : undefined
-}
-
-function normalizeSnapshotEntry(rawModelID: string, rawModel: unknown): ModelCapabilitiesSnapshotEntry | undefined {
-  if (!isRecord(rawModel)) {
-    return undefined
-  }
-
-  const id = readString(rawModel.id) ?? rawModelID
-  const family = readString(rawModel.family)
-  const reasoning = readBoolean(rawModel.reasoning)
-  const temperature = readBoolean(rawModel.temperature)
-  const toolCall = readBoolean(rawModel.tool_call)
-
-  const rawModalities = isRecord(rawModel.modalities) ? rawModel.modalities : undefined
-  const modalitiesInput = readStringArray(rawModalities?.input)
-  const modalitiesOutput = readStringArray(rawModalities?.output)
-  const modalities = modalitiesInput || modalitiesOutput
-    ? {
-        ...(modalitiesInput ? { input: modalitiesInput } : {}),
-        ...(modalitiesOutput ? { output: modalitiesOutput } : {}),
-      }
-    : undefined
-
-  const rawLimit = isRecord(rawModel.limit) ? rawModel.limit : undefined
-  const limitContext = readNumber(rawLimit?.context)
-  const limitInput = readNumber(rawLimit?.input)
-  const limitOutput = readNumber(rawLimit?.output)
-  const limit = limitContext !== undefined || limitInput !== undefined || limitOutput !== undefined
-    ? {
-        ...(limitContext !== undefined ? { context: limitContext } : {}),
-        ...(limitInput !== undefined ? { input: limitInput } : {}),
-        ...(limitOutput !== undefined ? { output: limitOutput } : {}),
-      }
-    : undefined
-
-  return {
-    id,
-    ...(family ? { family } : {}),
-    ...(reasoning !== undefined ? { reasoning } : {}),
-    ...(temperature !== undefined ? { temperature } : {}),
-    ...(toolCall !== undefined ? { toolCall } : {}),
-    ...(modalities ? { modalities } : {}),
-    ...(limit ? { limit } : {}),
-  }
-}
-
-function mergeSnapshotEntries(
-  existing: ModelCapabilitiesSnapshotEntry | undefined,
-  incoming: ModelCapabilitiesSnapshotEntry,
-): ModelCapabilitiesSnapshotEntry {
-  if (!existing) {
-    return incoming
-  }
-
-  const mergedModalities = existing.modalities || incoming.modalities
-    ? {
-        ...existing.modalities,
-        ...incoming.modalities,
-      }
-    : undefined
-  const mergedLimit = existing.limit || incoming.limit
-    ? {
-        ...existing.limit,
-        ...incoming.limit,
-      }
-    : undefined
-
-  return {
-    ...existing,
-    ...incoming,
-    ...(mergedModalities ? { modalities: mergedModalities } : {}),
-    ...(mergedLimit ? { limit: mergedLimit } : {}),
-  }
-}
-
-export function buildModelCapabilitiesSnapshotFromModelsDev(raw: unknown): ModelCapabilitiesSnapshot {
-  const models: Record<string, ModelCapabilitiesSnapshotEntry> = {}
-  const providers = isRecord(raw) ? raw : {}
-
-  for (const providerValue of Object.values(providers)) {
-    if (!isRecord(providerValue)) {
-      continue
-    }
-
-    const providerModels = providerValue.models
-    if (!isRecord(providerModels)) {
-      continue
-    }
-
-    for (const [rawModelID, rawModel] of Object.entries(providerModels)) {
-      const normalizedEntry = normalizeSnapshotEntry(rawModelID, rawModel)
-      if (!normalizedEntry) {
-        continue
-      }
-
-      models[normalizedEntry.id.toLowerCase()] = mergeSnapshotEntries(
-        models[normalizedEntry.id.toLowerCase()],
-        normalizedEntry,
-      )
-    }
-  }
-
-  return {
-    generatedAt: new Date().toISOString(),
-    sourceUrl: MODELS_DEV_SOURCE_URL,
-    models,
-  }
-}
-
-export async function fetchModelCapabilitiesSnapshot(args: {
-  sourceUrl?: string
-  fetchImpl?: typeof fetch
-} = {}): Promise<ModelCapabilitiesSnapshot> {
-  const sourceUrl = args.sourceUrl ?? MODELS_DEV_SOURCE_URL
-  const fetchImpl = args.fetchImpl ?? fetch
-  const response = await fetchImpl(sourceUrl)
-
-  if (!response.ok) {
-    throw new Error(`models.dev fetch failed with ${response.status}`)
-  }
-
-  const raw = await response.json()
-  const snapshot = buildModelCapabilitiesSnapshotFromModelsDev(raw)
-  return {
-    ...snapshot,
-    sourceUrl,
-  }
-}
-
-export function createModelCapabilitiesCacheStore(
-  getCacheDir: () => string = dataPath.getOmoOpenCodeCacheDir,
-) {
-  const snapshotCacheStore = createJsonFileCacheStore<ModelCapabilitiesSnapshot>({
-    getCacheDir,
-    filename: MODEL_CAPABILITIES_CACHE_FILE,
-    logPrefix: "model-capabilities-cache",
-    cacheLabel: "Cache",
-    describe: (snapshot) => ({
-      modelCount: Object.keys(snapshot.models).length,
-      generatedAt: snapshot.generatedAt,
-    }),
-    serialize: (snapshot) => `${JSON.stringify(snapshot, null, 2)}\n`,
-  })
-
-  function readModelCapabilitiesCache(): ModelCapabilitiesSnapshot | null {
-    return snapshotCacheStore.read()
-  }
-
-  function hasModelCapabilitiesCache(): boolean {
-    return snapshotCacheStore.has()
-  }
-
-  function writeModelCapabilitiesCache(snapshot: ModelCapabilitiesSnapshot): void {
-    snapshotCacheStore.write(snapshot)
-  }
-
-  async function refreshModelCapabilitiesCache(args: {
-    sourceUrl?: string
-    fetchImpl?: typeof fetch
-  } = {}): Promise<ModelCapabilitiesSnapshot> {
-    const snapshot = await fetchModelCapabilitiesSnapshot(args)
-    writeModelCapabilitiesCache(snapshot)
-    return snapshot
-  }
-
-  return {
-    readModelCapabilitiesCache,
-    hasModelCapabilitiesCache,
-    writeModelCapabilitiesCache,
-    refreshModelCapabilitiesCache,
-  }
-}
-
-const defaultModelCapabilitiesCacheStore = createModelCapabilitiesCacheStore(
-  () => dataPath.getOmoOpenCodeCacheDir(),
-)
-
-export const {
-  readModelCapabilitiesCache,
-  hasModelCapabilitiesCache,
-  writeModelCapabilitiesCache,
-  refreshModelCapabilitiesCache,
-} = defaultModelCapabilitiesCacheStore

package/src/shared/model-capability-aliases.ts

@@ -1,108 +0,0 @@
-export type ExactAliasRule = {
-  aliasModelID: string
-  ruleID: string
-  canonicalModelID: string
-  rationale: string
-}
-
-export type PatternAliasRule = {
-  ruleID: string
-  description: string
-  match: (normalizedModelID: string) => boolean
-  canonicalize: (normalizedModelID: string) => string
-}
-
-export type ModelIDAliasResolution = {
-  requestedModelID: string
-  canonicalModelID: string
-  source: "canonical" | "exact-alias" | "pattern-alias"
-  ruleID?: string
-}
-
-const EXACT_ALIAS_RULES: ReadonlyArray<ExactAliasRule> = [
-  {
-    aliasModelID: "gemini-3-pro-high",
-    ruleID: "gemini-3-pro-tier-alias",
-    canonicalModelID: "gemini-3-pro-preview",
-    rationale: "Legacy Gemini 3 tier suffixes still need to land on the canonical preview model.",
-  },
-  {
-    aliasModelID: "gemini-3-pro-low",
-    ruleID: "gemini-3-pro-tier-alias",
-    canonicalModelID: "gemini-3-pro-preview",
-    rationale: "Legacy Gemini 3 tier suffixes still need to land on the canonical preview model.",
-  },
-]
-
-const EXACT_ALIAS_RULES_BY_MODEL: ReadonlyMap<string, ExactAliasRule> = new Map(
-  EXACT_ALIAS_RULES.map((rule) => [rule.aliasModelID, rule]),
-)
-
-const PATTERN_ALIAS_RULES: ReadonlyArray<PatternAliasRule> = [
-  {
-    ruleID: "claude-thinking-legacy-alias",
-    description: "Normalizes the legacy Claude Opus 4.6 thinking suffix to the canonical snapshot ID.",
-    match: (normalizedModelID) => /^claude-opus-4-6-thinking$/.test(normalizedModelID),
-    canonicalize: () => "claude-opus-4-6",
-  },
-  {
-    ruleID: "gemini-3.1-pro-tier-alias",
-    description: "Normalizes Gemini 3.1 Pro tier suffixes to the canonical snapshot ID.",
-    match: (normalizedModelID) => /^gemini-3\.1-pro-(?:high|low)$/.test(normalizedModelID),
-    canonicalize: () => "gemini-3.1-pro",
-  },
-]
-
-function normalizeLookupModelID(modelID: string): string {
-  return modelID.trim().toLowerCase()
-}
-
-function stripProviderPrefixForAliasLookup(normalizedModelID: string): string {
-  const slashIndex = normalizedModelID.indexOf("/")
-  if (slashIndex <= 0 || slashIndex === normalizedModelID.length - 1) {
-    return normalizedModelID
-  }
-
-  return normalizedModelID.slice(slashIndex + 1)
-}
-
-export function resolveModelIDAlias(modelID: string): ModelIDAliasResolution {
-  const requestedModelID = normalizeLookupModelID(modelID)
-  const aliasLookupModelID = stripProviderPrefixForAliasLookup(requestedModelID)
-  const exactRule = EXACT_ALIAS_RULES_BY_MODEL.get(aliasLookupModelID)
-  if (exactRule) {
-    return {
-      requestedModelID,
-      canonicalModelID: exactRule.canonicalModelID,
-      source: "exact-alias",
-      ruleID: exactRule.ruleID,
-    }
-  }
-
-  for (const rule of PATTERN_ALIAS_RULES) {
-    if (!rule.match(aliasLookupModelID)) {
-      continue
-    }
-
-    return {
-      requestedModelID,
-      canonicalModelID: rule.canonicalize(aliasLookupModelID),
-      source: "pattern-alias",
-      ruleID: rule.ruleID,
-    }
-  }
-
-  return {
-    requestedModelID,
-    canonicalModelID: aliasLookupModelID,
-    source: "canonical",
-  }
-}
-
-export function getExactModelIDAliasRules(): ReadonlyArray<ExactAliasRule> {
-  return EXACT_ALIAS_RULES
-}
-
-export function getPatternModelIDAliasRules(): ReadonlyArray<PatternAliasRule> {
-  return PATTERN_ALIAS_RULES
-}