@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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 }
-}

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

@@ -1,41 +0,0 @@
-import type { FallbackEntry } from "./model-requirements"
-
-export interface DelegatedModelConfig {
-  providerID: string
-  modelID: string
-  variant?: string
-  reasoningEffort?: string
-  temperature?: number
-  top_p?: number
-  maxTokens?: number
-  thinking?: { type: "enabled" | "disabled"; budgetTokens?: number }
-}
-
-export type ModelResolutionRequest = {
-  intent?: {
-    uiSelectedModel?: string
-    userModel?: string
-    categoryDefaultModel?: string
-  }
-  constraints: {
-    availableModels: Set<string>
-  }
-  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
-}

package/src/shared/model-resolver.ts

@@ -1,106 +0,0 @@
-import type { FallbackEntry } from "./model-requirements"
-import type { FallbackModelObject } from "../config/schema/fallback-models"
-import { normalizeModel } from "./model-normalization"
-import { resolveModelPipeline } from "./model-resolution-pipeline"
-import { KNOWN_VARIANTS } from "./known-variants"
-
-export type ModelResolutionInput = {
-	userModel?: string
-	inheritedModel?: string
-	systemDefault?: string
-}
-
-export type ModelSource =
-	| "override"
-	| "category-default"
-	| "provider-fallback"
-	| "system-default"
-
-export type ModelResolutionResult = {
-	model: string
-	source: ModelSource
-	variant?: string
-}
-
-export type ExtendedModelResolutionInput = {
-	uiSelectedModel?: string
-	userModel?: string
-	userFallbackModels?: string[]
-	categoryDefaultModel?: string
-	fallbackChain?: FallbackEntry[]
-	availableModels: Set<string>
-	systemDefaultModel?: string
-}
-
-
-export function resolveModel(input: ModelResolutionInput): string | undefined {
-	return (
-		normalizeModel(input.userModel) ??
-		normalizeModel(input.inheritedModel) ??
-		input.systemDefault
-	)
-}
-
-export function resolveModelWithFallback(
-	input: ExtendedModelResolutionInput,
-): ModelResolutionResult | undefined {
-	const { uiSelectedModel, userModel, userFallbackModels, categoryDefaultModel, fallbackChain, availableModels, systemDefaultModel } = input
-	const resolved = resolveModelPipeline({
-		intent: { uiSelectedModel, userModel, userFallbackModels, categoryDefaultModel },
-		constraints: { availableModels },
-		policy: { fallbackChain, systemDefaultModel },
-	})
-
-	if (!resolved) {
-		return undefined
-	}
-
-	return {
-		model: resolved.model,
-		source: resolved.provenance,
-		variant: resolved.variant,
-	}
-}
-
-/**
- * Normalizes fallback_models config to a mixed array.
- * Accepts string, string[], or mixed arrays of strings and FallbackModelObject entries.
- */
-export function normalizeFallbackModels(
-	models: string | (string | FallbackModelObject)[] | undefined,
-): (string | FallbackModelObject)[] | undefined {
-	if (!models) return undefined
-	if (typeof models === "string") return [models]
-	return models
-}
-
-/**
- * Extracts plain model strings from a mixed fallback models array.
- * Object entries are flattened to "model" or "model(variant)" strings.
- * Use this when consumers need string[] (e.g., resolveModelForDelegateTask).
- */
-export function flattenToFallbackModelStrings(
-	models: (string | FallbackModelObject)[] | undefined,
-): string[] | undefined {
-	if (!models) return undefined
-	return models.map((entry) => {
-		if (typeof entry === "string") return entry
-		const variant = entry.variant
-		if (variant) {
-			// Strip any supported inline variant syntax before appending explicit override.
-			// Supports both parenthesized and space-suffix forms so we don't emit
-			// invalid strings like "provider/model high(low)".
-			const model = entry.model
-				.replace(/\([^()]+\)\s*$/, "")
-				.replace(/\s+([a-z][a-z0-9_-]*)\s*$/i, (match: string, suffix: string) => {
-					const normalized = String(suffix).toLowerCase()
-					return KNOWN_VARIANTS.has(normalized)
-						? ""
-						: match
-				})
-				.trim()
-			return `${model}(${variant})`
-		}
-		return entry.model
-	})
-}

package/src/shared/model-sanitizer.ts

@@ -1,12 +0,0 @@
-type CommandSource = "claude-code" | "opencode"
-
-export function sanitizeModelField(model: unknown, source: CommandSource = "claude-code"): string | undefined {
-  if (source === "claude-code") {
-    return undefined
-  }
-  
-  if (typeof model === "string" && model.trim().length > 0) {
-    return model.trim()
-  }
-  return undefined
-}