@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

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

@@ -1,149 +0,0 @@
-import type { ModelCapabilitiesSnapshot } from "./model-capabilities"
-import { getBundledModelCapabilitiesSnapshot } from "./model-capabilities"
-import {
-  getExactModelIDAliasRules,
-  getPatternModelIDAliasRules,
-  resolveModelIDAlias,
-} from "./model-capability-aliases"
-import { AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS } from "./model-requirements"
-
-export type ModelCapabilityGuardrailIssue =
-  | {
-      kind: "alias-target-missing-from-snapshot"
-      ruleID: string
-      aliasModelID: string
-      canonicalModelID: string
-      message: string
-    }
-  | {
-      kind: "exact-alias-collides-with-snapshot"
-      ruleID: string
-      aliasModelID: string
-      canonicalModelID: string
-      message: string
-    }
-  | {
-      kind: "pattern-alias-collides-with-snapshot"
-      ruleID: string
-      modelID: string
-      canonicalModelID: string
-      message: string
-    }
-  | {
-      kind: "built-in-model-relies-on-alias"
-      modelID: string
-      canonicalModelID: string
-      ruleID: string
-      message: string
-    }
-  | {
-      kind: "built-in-model-missing-from-snapshot"
-      modelID: string
-      canonicalModelID: string
-      message: string
-    }
-
-type CollectModelCapabilityGuardrailIssuesInput = {
-  snapshot?: ModelCapabilitiesSnapshot
-  requirementModelIDs?: Iterable<string>
-}
-
-function normalizeLookupModelID(modelID: string): string {
-  return modelID.trim().toLowerCase()
-}
-
-export function getBuiltInRequirementModelIDs(): string[] {
-  const modelIDs = new Set<string>()
-
-  for (const requirement of Object.values(AGENT_MODEL_REQUIREMENTS)) {
-    for (const entry of requirement.fallbackChain) {
-      modelIDs.add(entry.model)
-    }
-  }
-
-  for (const requirement of Object.values(CATEGORY_MODEL_REQUIREMENTS)) {
-    for (const entry of requirement.fallbackChain) {
-      modelIDs.add(entry.model)
-    }
-  }
-
-  return [...modelIDs].sort()
-}
-
-export function collectModelCapabilityGuardrailIssues(
-  input: CollectModelCapabilityGuardrailIssuesInput = {},
-): ModelCapabilityGuardrailIssue[] {
-  const snapshot = input.snapshot ?? getBundledModelCapabilitiesSnapshot()
-  const snapshotModelIDs = new Set(
-    Object.keys(snapshot.models).map((modelID) => normalizeLookupModelID(modelID)),
-  )
-  const requirementModelIDs = input.requirementModelIDs ?? getBuiltInRequirementModelIDs()
-  const issues: ModelCapabilityGuardrailIssue[] = []
-
-  for (const rule of getExactModelIDAliasRules()) {
-    if (!snapshotModelIDs.has(rule.canonicalModelID)) {
-      issues.push({
-        kind: "alias-target-missing-from-snapshot",
-        ruleID: rule.ruleID,
-        aliasModelID: rule.aliasModelID,
-        canonicalModelID: rule.canonicalModelID,
-        message: `Alias ${rule.aliasModelID} points to missing snapshot model ${rule.canonicalModelID}.`,
-      })
-    }
-
-    if (snapshotModelIDs.has(rule.aliasModelID)) {
-      issues.push({
-        kind: "exact-alias-collides-with-snapshot",
-        ruleID: rule.ruleID,
-        aliasModelID: rule.aliasModelID,
-        canonicalModelID: rule.canonicalModelID,
-        message: `Alias ${rule.aliasModelID} now exists in models.dev and should be reviewed instead of force-mapping to ${rule.canonicalModelID}.`,
-      })
-    }
-  }
-
-  for (const rule of getPatternModelIDAliasRules()) {
-    for (const modelID of snapshotModelIDs) {
-      if (!rule.match(modelID)) {
-        continue
-      }
-
-      const canonicalModelID = rule.canonicalize(modelID)
-      if (canonicalModelID === modelID) {
-        continue
-      }
-
-      issues.push({
-        kind: "pattern-alias-collides-with-snapshot",
-        ruleID: rule.ruleID,
-        modelID,
-        canonicalModelID,
-        message: `Pattern alias ${rule.ruleID} would rewrite canonical snapshot model ${modelID} to ${canonicalModelID}.`,
-      })
-    }
-  }
-
-  for (const modelID of requirementModelIDs) {
-    const aliasResolution = resolveModelIDAlias(modelID)
-    if (aliasResolution.source !== "canonical") {
-      issues.push({
-        kind: "built-in-model-relies-on-alias",
-        modelID: aliasResolution.requestedModelID,
-        canonicalModelID: aliasResolution.canonicalModelID,
-        ruleID: aliasResolution.ruleID ?? "unknown-alias-rule",
-        message: `Built-in requirement model ${aliasResolution.requestedModelID} should be canonical and not rely on alias rule ${aliasResolution.ruleID}.`,
-      })
-    }
-
-    if (!snapshotModelIDs.has(aliasResolution.canonicalModelID)) {
-      issues.push({
-        kind: "built-in-model-missing-from-snapshot",
-        modelID: aliasResolution.requestedModelID,
-        canonicalModelID: aliasResolution.canonicalModelID,
-        message: `Built-in requirement model ${aliasResolution.requestedModelID} resolves to ${aliasResolution.canonicalModelID}, which is missing from the bundled snapshot.`,
-      })
-    }
-  }
-
-  return issues
-}

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

@@ -1,32 +0,0 @@
-import { normalizeModelID } from "./model-normalization"
-import type { HeuristicModelFamilyDefinition, HiaiOpencodeConfig } from "../config/types"
-
-let HEURISTIC_MODEL_FAMILY_REGISTRY: Array<HeuristicModelFamilyDefinition & { _patternObj?: RegExp }> = [];
-
-/**
- * Initializes the model family heuristics from configuration.
- */
-export function initializeModelHeuristics(config: HiaiOpencodeConfig) {
-  if (config.modelFamilies) {
-    HEURISTIC_MODEL_FAMILY_REGISTRY = config.modelFamilies.map(def => ({
-      ...def,
-      _patternObj: def.pattern ? new RegExp(def.pattern) : undefined
-    }));
-  }
-}
-
-export function detectHeuristicModelFamily(modelID: string): HeuristicModelFamilyDefinition | undefined {
-  const normalizedModelID = normalizeModelID(modelID).toLowerCase()
-
-  for (const definition of HEURISTIC_MODEL_FAMILY_REGISTRY) {
-    if (definition._patternObj?.test(normalizedModelID)) {
-      return definition
-    }
-
-    if (definition.includes?.some((value) => normalizedModelID.includes(value.toLowerCase()))) {
-      return definition
-    }
-  }
-
-  return undefined
-}

package/src/shared/model-error-classifier.ts

@@ -1,214 +0,0 @@
-import type { FallbackEntry } from "./model-requirements"
-import { readConnectedProvidersCache } from "./connected-providers-cache"
-
-/**
- * Error names that indicate a retryable model error (deadstop).
- * These errors completely halt the action loop and should trigger fallback retry.
- */
-const RETRYABLE_ERROR_NAMES = new Set([
-  "providermodelnotfounderror",
-  "ratelimiterror",
-  "modelunavailableerror",
-  "providerconnectionerror",
-  "authenticationerror",
-])
-
-const STOP_ERROR_NAMES = new Set([
-  "quotaexceedederror",
-  "insufficientcreditserror",
-  "freeusagelimiterror",
-])
-
-/**
- * Error names that should NOT trigger retry.
- * These errors are typically user-induced or fixable without switching models.
- */
-const NON_RETRYABLE_ERROR_NAMES = new Set([
-  "messageabortederror",
-  "permissiondeniederror",
-  "contextlengtherror",
-  "timeouterror",
-  "validationerror",
-  "syntaxerror",
-  "usererror",
-])
-
-/**
- * Message patterns that indicate a retryable error even without a known error name.
- */
-const RETRYABLE_MESSAGE_PATTERNS = [
-  "rate_limit",
-  "rate limit",
-  "quota",
-  "all credentials for model",
-  "cooling down",
-  "exhausted your capacity",
-  "not found",
-  "unavailable",
-  "insufficient",
-  "too many requests",
-  "over limit",
-  "overloaded",
-  "bad gateway",
-  "bad request",
-  "unknown provider",
-  "provider not found",
-  "model_not_supported",
-  "model not supported",
-  "model is not supported",
-  "connection error",
-  "network error",
-  "timeout",
-  "service unavailable",
-  "internal_server_error",
-  "free usage",
-  "usage exceeded",
-  "credit",
-  "balance",
-  "temporarily unavailable",
-  "try again",
-  "503",
-  "502",
-  "504",
-  "429",
-  "529",
-]
-
-/**
- * Message patterns that indicate a non-retryable STOP error (quota/billing exhaustion).
- * These take precedence over RETRYABLE_MESSAGE_PATTERNS.
- */
-const STOP_MESSAGE_PATTERNS = [
-  "quota will reset after",
-  "quota exceeded",
-  "usage limit has been reached",
-  "free usage limit",
-  "billing limit",
-  "billing hard limit",
-  "monthly limit",
-  "plan limit",
-  "subscription quota",
-  "subscription limit",
-  "payment required",
-  "out of credits",
-  "credits exhausted",
-  "insufficient credits",
-  "insufficient balance",
-  "credit balance",
-  "usage limit for this month",
-  "exhausted your capacity",
-]
-
-const AUTO_RETRY_GATE_PATTERNS = [
-  "rate limit",
-  "cooling down",
-  "credentials for model",
-]
-
-function hasProviderAutoRetrySignal(message: string): boolean {
-  if (!message.includes("retrying in")) {
-    return false
-  }
-  return AUTO_RETRY_GATE_PATTERNS.some((pattern) => message.includes(pattern))
-}
-
-export interface ErrorInfo {
-  name?: string
-  message?: string
-}
-
-/**
- * Determines if an error is a retryable model error.
- * Returns true if the error is a known retryable type OR matches retryable message patterns.
- */
-export function isRetryableModelError(error: ErrorInfo): boolean {
-  // If we have an error name, check against known lists
-  if (error.name) {
-    const errorNameLower = error.name.toLowerCase()
-    // Explicit non-retryable takes precedence
-    if (NON_RETRYABLE_ERROR_NAMES.has(errorNameLower)) {
-      return false
-    }
-    if (STOP_ERROR_NAMES.has(errorNameLower)) {
-      return false
-    }
-    // Check if it's a known retryable error
-    if (RETRYABLE_ERROR_NAMES.has(errorNameLower)) {
-      return true
-    }
-  }
-
-  // Check message patterns for unknown errors
-  const msg = error.message?.toLowerCase() ?? ""
-
-  // STOP patterns take precedence over retryable patterns
-  if (STOP_MESSAGE_PATTERNS.some((pattern) => msg.includes(pattern))) {
-    return false
-  }
-
-  if (hasProviderAutoRetrySignal(msg)) {
-    return true
-  }
-  return RETRYABLE_MESSAGE_PATTERNS.some((pattern) => msg.includes(pattern))
-}
-
-/**
- * Determines if an error should trigger a fallback retry.
- * Returns true for deadstop errors that completely halt the action loop.
- */
-export function shouldRetryError(error: ErrorInfo): boolean {
-  return isRetryableModelError(error)
-}
-
-/**
- * Gets the next fallback model from the chain based on attempt count.
- * Returns undefined if all fallbacks have been exhausted.
- */
-export function getNextFallback(
-  fallbackChain: FallbackEntry[],
-  attemptCount: number,
-): FallbackEntry | undefined {
-  return fallbackChain[attemptCount]
-}
-
-/**
- * Checks if there are more fallbacks available after the current attempt.
- */
-export function hasMoreFallbacks(
-  fallbackChain: FallbackEntry[],
-  attemptCount: number,
-): boolean {
-  return attemptCount < fallbackChain.length
-}
-
-/**
- * Selects the best provider for a fallback entry.
- * Priority:
- * 1) First connected provider in the entry's provider preference order
- * 2) Preferred provider when connected (and entry providers are unavailable)
- * 3) First provider listed in the fallback entry
- */
-export function selectFallbackProvider(
-  providers: string[],
-  preferredProviderID?: string,
-): string {
-  const connectedProviders = readConnectedProvidersCache()
-  if (connectedProviders) {
-    const connectedSet = new Set(connectedProviders.map(p => p.toLowerCase()))
-
-    for (const provider of providers) {
-      if (connectedSet.has(provider.toLowerCase())) {
-        return provider
-      }
-    }
-
-    if (
-      preferredProviderID &&
-      connectedSet.has(preferredProviderID.toLowerCase())
-    ) {
-      return preferredProviderID
-    }
-  }
-
-  return providers[0] || preferredProviderID || "opencode"
-}

package/src/shared/model-format-normalizer.ts

@@ -1,20 +0,0 @@
-export function normalizeModelFormat(
-  model: string | { providerID: string; modelID: string }
-): { providerID: string; modelID: string } | undefined {
-  if (!model) {
-    return undefined
-  }
-
-  if (typeof model === "object" && "providerID" in model && "modelID" in model) {
-    return { providerID: model.providerID, modelID: model.modelID }
-  }
-
-  if (typeof model === "string") {
-    const parts = model.split("/")
-    if (parts.length >= 2) {
-      return { providerID: parts[0], modelID: parts.slice(1).join("/") }
-    }
-  }
-
-  return undefined
-}

package/src/shared/model-normalization.ts

@@ -1,8 +0,0 @@
-export function normalizeModel(model?: string): string | undefined {
-	const trimmed = model?.trim()
-	return trimmed || undefined
-}
-
-export function normalizeModelID(modelID: string): string {
-	return modelID.replace(/\.(\d+)/g, "-$1")
-}

package/src/shared/model-requirements.ts

@@ -1,26 +0,0 @@
-import type { HiaiOpencodeConfig, ModelRequirement } from "../config/types.js";
-
-export type { FallbackEntry, ModelRequirement } from "../config/types.js";
-
-/**
- * Model requirements for agents. Initialized at runtime from configuration.
- */
-export let AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement> = {};
-
-/**
- * Model requirements for categories. Initialized at runtime from configuration.
- */
-export let CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement> = {};
-
-/**
- * Initializes the model requirements from the provided configuration.
- * Should be called once during plugin startup.
- */
-export function initializeModelRequirements(config: HiaiOpencodeConfig) {
-  if (config.agentRequirements) {
-    AGENT_MODEL_REQUIREMENTS = config.agentRequirements;
-  }
-  if (config.categoryRequirements) {
-    CATEGORY_MODEL_REQUIREMENTS = config.categoryRequirements;
-  }
-}

package/src/shared/model-resolution-pipeline.ts

@@ -1,216 +0,0 @@
-import { log } from "./logger"
-import * as connectedProvidersCache from "./connected-providers-cache"
-import { fuzzyMatchModel } from "./model-availability"
-import type { FallbackEntry } from "./model-requirements"
-import { transformModelForProvider } from "./provider-model-id-transform"
-import { normalizeModel } from "./model-normalization"
-
-export type ModelResolutionRequest = {
-  intent?: {
-    uiSelectedModel?: string
-    userModel?: string
-    userFallbackModels?: string[]
-    categoryDefaultModel?: string
-  }
-  constraints: {
-    availableModels: Set<string>
-    connectedProviders?: string[] | null
-  }
-  policy?: {
-    fallbackChain?: FallbackEntry[]
-    systemDefaultModel?: string
-  }
-}
-
-export type ModelResolutionProvenance =
-  | "override"
-  | "category-default"
-  | "provider-fallback"
-  | "system-default"
-
-export type ModelResolutionResult = {
-  model: string
-  provenance: ModelResolutionProvenance
-  variant?: string
-  attempted?: string[]
-  reason?: string
-}
-
-
-export function resolveModelPipeline(
-  request: ModelResolutionRequest,
-): ModelResolutionResult | undefined {
-  const attempted: string[] = []
-  const { intent, constraints, policy } = request
-  const availableModels = constraints.availableModels
-  const fallbackChain = policy?.fallbackChain
-  const systemDefaultModel = policy?.systemDefaultModel
-
-  const normalizedUiModel = normalizeModel(intent?.uiSelectedModel)
-  if (normalizedUiModel) {
-    log("Model resolved via UI selection", { model: normalizedUiModel })
-    return { model: normalizedUiModel, provenance: "override" }
-  }
-
-  const normalizedUserModel = normalizeModel(intent?.userModel)
-  if (normalizedUserModel) {
-    log("Model resolved via config override", { model: normalizedUserModel })
-    return { model: normalizedUserModel, provenance: "override" }
-  }
-
-  const normalizedCategoryDefault = normalizeModel(intent?.categoryDefaultModel)
-  if (normalizedCategoryDefault) {
-    attempted.push(normalizedCategoryDefault)
-    if (availableModels.size > 0) {
-      const parts = normalizedCategoryDefault.split("/")
-      const providerHint = parts.length >= 2 ? [parts[0]] : undefined
-      const match = fuzzyMatchModel(normalizedCategoryDefault, availableModels, providerHint)
-      if (match) {
-        log("Model resolved via category default (fuzzy matched)", {
-          original: normalizedCategoryDefault,
-          matched: match,
-        })
-        return { model: match, provenance: "category-default", attempted }
-      }
-    } else {
-      const connectedProviders = constraints.connectedProviders ?? connectedProvidersCache.readConnectedProvidersCache()
-      if (connectedProviders === null) {
-        log("Model resolved via category default (no cache, first run)", {
-          model: normalizedCategoryDefault,
-        })
-        return { model: normalizedCategoryDefault, provenance: "category-default", attempted }
-      }
-      const parts = normalizedCategoryDefault.split("/")
-      if (parts.length >= 2) {
-        const provider = parts[0]
-        if (connectedProviders.includes(provider)) {
-          const modelName = parts.slice(1).join("/")
-          const transformedModel = `${provider}/${transformModelForProvider(provider, modelName)}`
-          log("Model resolved via category default (connected provider)", {
-            model: transformedModel,
-            original: normalizedCategoryDefault,
-          })
-          return { model: transformedModel, provenance: "category-default", attempted }
-        }
-      }
-    }
-    log("Category default model not available, falling through to fallback chain", {
-      model: normalizedCategoryDefault,
-    })
-  }
-
-  //#when - user configured fallback_models, try them before hardcoded fallback chain
-  const userFallbackModels = intent?.userFallbackModels
-  if (userFallbackModels && userFallbackModels.length > 0) {
-    if (availableModels.size === 0) {
-      const connectedProviders = constraints.connectedProviders ?? connectedProvidersCache.readConnectedProvidersCache()
-      const connectedSet = connectedProviders ? new Set(connectedProviders) : null
-
-      if (connectedSet !== null) {
-        for (const model of userFallbackModels) {
-          attempted.push(model)
-          const parts = model.split("/")
-          if (parts.length >= 2) {
-            const provider = parts[0]
-            if (connectedSet.has(provider)) {
-              const modelName = parts.slice(1).join("/")
-              const transformedModel = `${provider}/${transformModelForProvider(provider, modelName)}`
-              log("Model resolved via user fallback_models (connected provider)", { model: transformedModel, original: model })
-              return { model: transformedModel, provenance: "provider-fallback", attempted }
-            }
-          }
-        }
-        log("No connected provider found in user fallback_models, falling through to hardcoded chain")
-      }
-    } else {
-      for (const model of userFallbackModels) {
-        attempted.push(model)
-        const parts = model.split("/")
-        const providerHint = parts.length >= 2 ? [parts[0]] : undefined
-        const match = fuzzyMatchModel(model, availableModels, providerHint)
-        if (match) {
-          log("Model resolved via user fallback_models (availability confirmed)", { model: model, match })
-          return { model: match, provenance: "provider-fallback", attempted }
-        }
-      }
-      log("No available model found in user fallback_models, falling through to hardcoded chain")
-    }
-  }
-
-  if (fallbackChain && fallbackChain.length > 0) {
-    if (availableModels.size === 0) {
-      const connectedProviders = constraints.connectedProviders ?? connectedProvidersCache.readConnectedProvidersCache()
-      const connectedSet = connectedProviders ? new Set(connectedProviders) : null
-
-      if (connectedSet === null) {
-        log("Model fallback chain skipped (no connected providers cache) - falling through to system default")
-      } else {
-        for (const entry of fallbackChain) {
-          for (const provider of entry.providers) {
-            if (connectedSet.has(provider)) {
-              const transformedModelId = transformModelForProvider(provider, entry.model)
-              const model = `${provider}/${transformedModelId}`
-              log("Model resolved via fallback chain (connected provider)", {
-                provider,
-                model: transformedModelId,
-                variant: entry.variant,
-              })
-              return {
-                model,
-                provenance: "provider-fallback",
-                variant: entry.variant,
-                attempted,
-              }
-            }
-          }
-        }
-        log("No connected provider found in fallback chain, falling through to system default")
-      }
-    } else {
-      for (const entry of fallbackChain) {
-        for (const provider of entry.providers) {
-          const fullModel = `${provider}/${entry.model}`
-          const match = fuzzyMatchModel(fullModel, availableModels, [provider])
-          if (match) {
-            log("Model resolved via fallback chain (availability confirmed)", {
-              provider,
-              model: entry.model,
-              match,
-              variant: entry.variant,
-            })
-            return {
-              model: match,
-              provenance: "provider-fallback",
-              variant: entry.variant,
-              attempted,
-            }
-          }
-        }
-
-        const crossProviderMatch = fuzzyMatchModel(entry.model, availableModels)
-        if (crossProviderMatch) {
-          log("Model resolved via fallback chain (cross-provider fuzzy match)", {
-            model: entry.model,
-            match: crossProviderMatch,
-            variant: entry.variant,
-          })
-          return {
-            model: crossProviderMatch,
-            provenance: "provider-fallback",
-            variant: entry.variant,
-            attempted,
-          }
-        }
-      }
-      log("No available model found in fallback chain, falling through to system default")
-    }
-  }
-
-  if (systemDefaultModel === undefined) {
-    log("No model resolved - systemDefaultModel not configured")
-    return undefined
-  }
-
-  log("Model resolved via system default", { model: systemDefaultModel })
-  return { model: systemDefaultModel, provenance: "system-default", attempted }
-}