@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/hooks/runtime-fallback/auto-retry.ts

@@ -1,228 +0,0 @@
-import type { HookDeps, RuntimeFallbackTimeout } from "./types"
-import { HOOK_NAME } from "./constants"
-import { log } from "../../shared/logger"
-import { normalizeAgentName, resolveAgentForSession } from "./agent-resolver"
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import { getFallbackModelsForSession } from "./fallback-models"
-import { prepareFallback } from "./fallback-state"
-import { SessionCategoryRegistry } from "../../shared/session-category-registry"
-import { buildRetryModelPayload } from "./retry-model-payload"
-import { getLastUserRetryParts } from "./last-user-retry-parts"
-import { extractSessionMessages } from "./session-messages"
-import { resolveRegisteredAgentName } from "../../features/claude-code-session-state"
-
-const SESSION_TTL_MS = 30 * 60 * 1000
-
-declare function setTimeout(callback: () => void | Promise<void>, delay?: number): RuntimeFallbackTimeout
-declare function clearTimeout(timeout: RuntimeFallbackTimeout): void
-
-export function createAutoRetryHelpers(deps: HookDeps) {
-  const {
-    ctx,
-    config,
-    options,
-    sessionStates,
-    sessionLastAccess,
-    sessionRetryInFlight,
-    sessionAwaitingFallbackResult,
-    sessionFallbackTimeouts,
-    pluginConfig,
-    sessionStatusRetryKeys,
-  } = deps
-
-  const abortSessionRequest = async (sessionID: string, source: string): Promise<void> => {
-    try {
-      await ctx.client.session.abort({ path: { id: sessionID } })
-      log(`[${HOOK_NAME}] Aborted in-flight session request (${source})`, { sessionID })
-    } catch (error) {
-      log(`[${HOOK_NAME}] Failed to abort in-flight session request (${source})`, {
-        sessionID,
-        error: String(error),
-      })
-    }
-  }
-
-  const clearSessionFallbackTimeout = (sessionID: string) => {
-    const timer = sessionFallbackTimeouts.get(sessionID)
-    if (timer) {
-      clearTimeout(timer)
-      sessionFallbackTimeouts.delete(sessionID)
-    }
-  }
-
-  const scheduleSessionFallbackTimeout = (sessionID: string, resolvedAgent?: string) => {
-    clearSessionFallbackTimeout(sessionID)
-
-    const timeoutMs = options?.session_timeout_ms ?? config.timeout_seconds * 1000
-    if (timeoutMs <= 0) return
-
-    const timer = setTimeout(async () => {
-      sessionFallbackTimeouts.delete(sessionID)
-
-      const state = sessionStates.get(sessionID)
-      if (!state) return
-
-      if (sessionRetryInFlight.has(sessionID)) {
-        log(`[${HOOK_NAME}] Overriding in-flight retry due to session timeout`, { sessionID })
-      }
-
-      await abortSessionRequest(sessionID, "session.timeout")
-      sessionRetryInFlight.delete(sessionID)
-
-      if (state.pendingFallbackModel) {
-        state.pendingFallbackModel = undefined
-      }
-
-      const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig)
-      if (fallbackModels.length === 0) return
-
-      log(`[${HOOK_NAME}] Session fallback timeout reached`, {
-        sessionID,
-        timeoutSeconds: config.timeout_seconds,
-        currentModel: state.currentModel,
-      })
-
-      const result = prepareFallback(sessionID, state, fallbackModels, config)
-      if (result.success && result.newModel) {
-        await autoRetryWithFallback(sessionID, result.newModel, resolvedAgent, "session.timeout")
-      }
-    }, timeoutMs)
-
-    sessionFallbackTimeouts.set(sessionID, timer)
-  }
-
-  const autoRetryWithFallback = async (
-    sessionID: string,
-    newModel: string,
-    resolvedAgent: string | undefined,
-    source: string,
-  ): Promise<void> => {
-    if (sessionRetryInFlight.has(sessionID)) {
-      log(`[${HOOK_NAME}] Retry already in flight, skipping (${source})`, { sessionID })
-      return
-    }
-
-    const agentSettings = resolvedAgent
-      ? pluginConfig?.agents?.[resolvedAgent as keyof typeof pluginConfig.agents]
-      : undefined
-    const retryModelPayload = buildRetryModelPayload(newModel, agentSettings ? {
-      variant: agentSettings.variant,
-      reasoningEffort: agentSettings.reasoningEffort,
-    } : undefined)
-    if (!retryModelPayload) {
-      log(`[${HOOK_NAME}] Invalid model format (missing provider prefix): ${newModel}`)
-      const state = sessionStates.get(sessionID)
-      if (state?.pendingFallbackModel) {
-        state.pendingFallbackModel = undefined
-      }
-      return
-    }
-
-    sessionRetryInFlight.add(sessionID)
-    let retryDispatched = false
-    try {
-      const messagesResp = await ctx.client.session.messages({
-        path: { id: sessionID },
-        query: { directory: ctx.directory },
-      })
-      const retryParts = getLastUserRetryParts(messagesResp)
-      if (retryParts.length > 0) {
-        log(`[${HOOK_NAME}] Auto-retrying with fallback model (${source})`, {
-          sessionID,
-          model: newModel,
-        })
-
-        const retryAgent = resolvedAgent ?? getSessionAgent(sessionID)
-        const launchAgent = resolveRegisteredAgentName(retryAgent)
-        sessionAwaitingFallbackResult.add(sessionID)
-        scheduleSessionFallbackTimeout(sessionID, retryAgent)
-
-        await ctx.client.session.promptAsync({
-          path: { id: sessionID },
-          body: {
-            ...(launchAgent ? { agent: launchAgent } : {}),
-            ...retryModelPayload,
-            parts: retryParts,
-          },
-          query: { directory: ctx.directory },
-        })
-        retryDispatched = true
-      } else {
-        log(`[${HOOK_NAME}] No user message found for auto-retry (${source})`, { sessionID })
-      }
-    } catch (retryError) {
-      log(`[${HOOK_NAME}] Auto-retry failed (${source})`, { sessionID, error: String(retryError) })
-    } finally {
-      sessionRetryInFlight.delete(sessionID)
-      if (!retryDispatched) {
-        sessionAwaitingFallbackResult.delete(sessionID)
-        clearSessionFallbackTimeout(sessionID)
-        const state = sessionStates.get(sessionID)
-        if (state?.pendingFallbackModel) {
-          state.pendingFallbackModel = undefined
-        }
-      }
-    }
-  }
-
-  const resolveAgentForSessionFromContext = async (
-    sessionID: string,
-    eventAgent?: string,
-  ): Promise<string | undefined> => {
-    const resolved = resolveAgentForSession(sessionID, eventAgent)
-    if (resolved) return resolved
-
-    try {
-      const messagesResp = await ctx.client.session.messages({
-        path: { id: sessionID },
-        query: { directory: ctx.directory },
-      })
-      const msgs = extractSessionMessages(messagesResp)
-      if (!msgs || msgs.length === 0) return undefined
-
-      for (let i = msgs.length - 1; i >= 0; i--) {
-        const info = msgs[i]?.info
-        const infoAgent = typeof info?.agent === "string" ? info.agent : undefined
-        const normalized = normalizeAgentName(infoAgent)
-        if (normalized) {
-          return normalized
-        }
-      }
-    } catch {
-      return undefined
-    }
-
-    return undefined
-  }
-
-  const cleanupStaleSessions = () => {
-    const now = Date.now()
-    let cleanedCount = 0
-    for (const [sessionID, lastAccess] of sessionLastAccess.entries()) {
-      if (now - lastAccess > SESSION_TTL_MS) {
-        sessionStates.delete(sessionID)
-        sessionLastAccess.delete(sessionID)
-        sessionRetryInFlight.delete(sessionID)
-        sessionAwaitingFallbackResult.delete(sessionID)
-        clearSessionFallbackTimeout(sessionID)
-        SessionCategoryRegistry.remove(sessionID)
-        sessionStatusRetryKeys.delete(sessionID)
-        cleanedCount++
-      }
-    }
-    if (cleanedCount > 0) {
-      log(`[${HOOK_NAME}] Cleaned up ${cleanedCount} stale session states`)
-    }
-  }
-
-  return {
-    abortSessionRequest,
-    clearSessionFallbackTimeout,
-    scheduleSessionFallbackTimeout,
-    autoRetryWithFallback,
-    resolveAgentForSessionFromContext,
-    cleanupStaleSessions,
-  }
-}
-
-export type AutoRetryHelpers = ReturnType<typeof createAutoRetryHelpers>

package/src/hooks/runtime-fallback/chat-message-handler.ts

@@ -1,62 +0,0 @@
-import type { HookDeps } from "./types"
-import { HOOK_NAME } from "./constants"
-import { log } from "../../shared/logger"
-import { createFallbackState } from "./fallback-state"
-
-export function createChatMessageHandler(deps: HookDeps) {
-  const { config, sessionStates, sessionLastAccess } = deps
-
-  return async (
-    input: { sessionID: string; agent?: string; model?: { providerID: string; modelID: string } },
-    output: { message: { model?: { providerID: string; modelID: string } }; parts?: Array<{ type: string; text?: string }> }
-  ) => {
-    if (!config.enabled) return
-
-    const { sessionID } = input
-    let state = sessionStates.get(sessionID)
-
-    if (!state) return
-
-    sessionLastAccess.set(sessionID, Date.now())
-
-    const requestedModel = input.model
-      ? `${input.model.providerID}/${input.model.modelID}`
-      : undefined
-
-    if (requestedModel && requestedModel !== state.currentModel) {
-      if (state.pendingFallbackModel && state.pendingFallbackModel === requestedModel) {
-        state.pendingFallbackModel = undefined
-        return
-      }
-
-      log(`[${HOOK_NAME}] Detected manual model change, resetting fallback state`, {
-        sessionID,
-        from: state.currentModel,
-        to: requestedModel,
-      })
-      state = createFallbackState(requestedModel)
-      sessionStates.set(sessionID, state)
-      return
-    }
-
-    if (state.currentModel === state.originalModel) return
-
-    const activeModel = state.currentModel
-
-    log(`[${HOOK_NAME}] Applying fallback model override`, {
-      sessionID,
-      from: input.model,
-      to: activeModel,
-    })
-
-    if (output.message && activeModel) {
-      const parts = activeModel.split("/")
-      if (parts.length >= 2) {
-        output.message.model = {
-          providerID: parts[0],
-          modelID: parts.slice(1).join("/"),
-        }
-      }
-    }
-  }
-}

package/src/hooks/runtime-fallback/constants.ts

@@ -1,47 +0,0 @@
-/**
- * Runtime Fallback Hook - Constants
- *
- * Default values and configuration constants for the runtime fallback feature.
- */
-
-import type { RuntimeFallbackConfig } from "../../config"
-
-/**
- * Default configuration values for runtime fallback
- */
-export const DEFAULT_CONFIG: Required<RuntimeFallbackConfig> = {
-  enabled: false,
-  retry_on_errors: [429, 500, 502, 503, 504],
-  max_fallback_attempts: 3,
-  cooldown_seconds: 60,
-  timeout_seconds: 30,
-  notify_on_fallback: true,
-}
-
-/**
- * Error patterns that indicate rate limiting or temporary failures
- * These are checked in addition to HTTP status codes
- */
-export const RETRYABLE_ERROR_PATTERNS = [
-  /rate.?limit/i,
-  /too.?many.?requests/i,
-  /quota\s+will\s+reset\s+after/i,
-  /quota.?exceeded/i,
-  /exhausted\s+your\s+capacity/i,
-  /all\s+credentials\s+for\s+model/i,
-  /cool(?:ing)?\s+down/i,
-  /model.{0,20}?not.{0,10}?supported/i,
-  /model_not_supported/i,
-  /service.?unavailable/i,
-  /overloaded/i,
-  /temporarily.?unavailable/i,
-  /try.?again/i,
-  /(?:^|\s)429(?:\s|$)/,
-  /(?:^|\s)503(?:\s|$)/,
-  /(?:^|\s)529(?:\s|$)/,
-]
-
-/**
- * Hook name for identification and logging
- */
-export const HOOK_NAME = "runtime-fallback"

package/src/hooks/runtime-fallback/error-classifier.ts

@@ -1,183 +0,0 @@
-import { DEFAULT_CONFIG, RETRYABLE_ERROR_PATTERNS } from "./constants"
-
-export { extractAutoRetrySignal } from "./auto-retry-signal"
-
-export function getErrorMessage(error: unknown): string {
-  if (!error) return ""
-  if (typeof error === "string") return error.toLowerCase()
-
-  const errorObj = error as Record<string, unknown>
-  const paths = [
-    errorObj.data,
-    errorObj.error,
-    errorObj,
-    (errorObj.data as Record<string, unknown>)?.error,
-  ]
-
-  for (const obj of paths) {
-    if (obj && typeof obj === "object") {
-      const msg = (obj as Record<string, unknown>).message
-      if (typeof msg === "string" && msg.length > 0) {
-        return msg.toLowerCase()
-      }
-    }
-  }
-
-  const errorObj2 = error as Record<string, unknown>
-  const name = errorObj2.name
-  if (typeof name === "string" && name.length > 0) {
-    const nameColonMatch = name.match(/:\s*(.+)/)
-    if (nameColonMatch) return nameColonMatch[1].trim().toLowerCase()
-  }
-
-  try {
-    return JSON.stringify(error).toLowerCase()
-  } catch {
-    return ""
-  }
-}
-
-const DEFAULT_RETRY_PATTERN = new RegExp(`\\b(${DEFAULT_CONFIG.retry_on_errors.join("|")})\\b`)
-
-export function extractStatusCode(error: unknown, retryOnErrors?: number[]): number | undefined {
-  if (!error) return undefined
-
-  const errorObj = error as Record<string, unknown>
-
-  const statusCode = [
-    errorObj.statusCode,
-    errorObj.status,
-    (errorObj.data as Record<string, unknown>)?.statusCode,
-    (errorObj.error as Record<string, unknown>)?.statusCode,
-    (errorObj.cause as Record<string, unknown>)?.statusCode,
-  ].find((code): code is number => typeof code === "number")
-
-  if (statusCode !== undefined) {
-    return statusCode
-  }
-
-  const pattern = retryOnErrors 
-    ? new RegExp(`\\b(${retryOnErrors.join("|")})\\b`)
-    : DEFAULT_RETRY_PATTERN
-  const message = getErrorMessage(error)
-  const statusMatch = message.match(pattern)
-  if (statusMatch) {
-    return parseInt(statusMatch[1], 10)
-  }
-
-  return undefined
-}
-
-export function extractErrorName(error: unknown): string | undefined {
-  if (!error || typeof error !== "object") return undefined
-
-  const errorObj = error as Record<string, unknown>
-  const directName = errorObj.name
-  if (typeof directName === "string" && directName.length > 0) {
-    return directName
-  }
-
-  const dataName = (errorObj.data as Record<string, unknown> | undefined)?.name
-  if (typeof dataName === "string" && dataName.length > 0) {
-    return dataName
-  }
-
-  const nestedError = errorObj.error as Record<string, unknown> | undefined
-  const nestedName = nestedError?.name
-  if (typeof nestedName === "string" && nestedName.length > 0) {
-    return nestedName
-  }
-
-  const dataError = (errorObj.data as Record<string, unknown> | undefined)?.error as Record<string, unknown> | undefined
-  const dataErrorName = dataError?.name
-  if (typeof dataErrorName === "string" && dataErrorName.length > 0) {
-    return dataErrorName
-  }
-
-  return undefined
-}
-
-export function classifyErrorType(error: unknown): string | undefined {
-  const message = getErrorMessage(error)
-  const errorName = extractErrorName(error)?.toLowerCase()
-
-  if (
-    errorName?.includes("ai_loadapikeyerror") ||
-    errorName?.includes("loadapi") ||
-    (/api.?key.?is.?missing/i.test(message) && /environment variable/i.test(message))
-  ) {
-    return "missing_api_key"
-  }
-
-  if (/api.?key/i.test(message) && /must be a string/i.test(message)) {
-    return "invalid_api_key"
-  }
-
-  if (
-    errorName?.includes("providermodelnotfounderror") ||
-    errorName?.includes("modelnotfounderror") ||
-    (errorName?.includes("unknownerror") && /model\s+not\s+found/i.test(message))
-  ) {
-    return "model_not_found"
-  }
-
-  if (
-    errorName?.includes("quotaexceeded") ||
-    errorName?.includes("insufficientquota") ||
-    errorName?.includes("billingerror") ||
-    /quota.?exceeded/i.test(message) ||
-    /subscription.*quota/i.test(message) ||
-    /insufficient.?quota/i.test(message) ||
-    /billing.?(?:hard.?)?limit/i.test(message) ||
-    /exhausted\s+your\s+capacity/i.test(message) ||
-    /out\s+of\s+credits?/i.test(message) ||
-    /payment.?required/i.test(message) ||
-    /usage\s+limit/i.test(message)
-  ) {
-    return "quota_exceeded"
-  }
-
-  return undefined
-}
-
-export function containsErrorContent(
-  parts: Array<{ type?: string; text?: string }> | undefined
-): { hasError: boolean; errorMessage?: string } {
-  if (!parts || parts.length === 0) return { hasError: false }
-
-  const errorParts = parts.filter((p) => p.type === "error")
-  if (errorParts.length > 0) {
-    const errorMessages = errorParts.map((p) => p.text).filter((text): text is string => typeof text === "string")
-    const errorMessage = errorMessages.length > 0 ? errorMessages.join("\n") : undefined
-    return { hasError: true, errorMessage }
-  }
-
-  return { hasError: false }
-}
-
-export function isRetryableError(error: unknown, retryOnErrors: number[]): boolean {
-  const statusCode = extractStatusCode(error, retryOnErrors)
-  const message = getErrorMessage(error)
-  const errorType = classifyErrorType(error)
-
-  if (errorType === "missing_api_key") {
-    return true
-  }
-
-  if (errorType === "model_not_found") {
-    return true
-  }
-
-  if (errorType === "quota_exceeded") {
-    // When a provider signals an auto-retry (e.g. "retrying in ~2 weeks"),
-    // we should still trigger fallback to another model rather than STOP.
-    const hasAutoRetrySignal = /retrying\s+in/i.test(message)
-    return hasAutoRetrySignal
-  }
-
-  if (statusCode && retryOnErrors.includes(statusCode)) {
-    return true
-  }
-
-  return RETRYABLE_ERROR_PATTERNS.some((pattern) => pattern.test(message))
-}