@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/features/background-agent/compaction-aware-message-resolver.ts

@@ -1,164 +0,0 @@
-import { readdirSync, readFileSync } from "node:fs"
-import { join } from "node:path"
-import type { StoredMessage } from "../hook-message-injector"
-import { getCompactionAgentConfigCheckpoint } from "../../shared/compaction-agent-config-checkpoint"
-import {
-  hasCompactionPartInStorage,
-  isCompactionAgent,
-  isCompactionMessage,
-} from "../../shared/compaction-marker"
-
-export { isCompactionAgent } from "../../shared/compaction-marker"
-
-type SessionMessage = {
-  id?: string
-  info?: {
-    agent?: string
-    model?: {
-      providerID?: string
-      modelID?: string
-      variant?: string
-    }
-    providerID?: string
-    modelID?: string
-    tools?: StoredMessage["tools"]
-  }
-  parts?: Array<{ type?: string }>
-}
-
-function hasFullAgentAndModel(message: StoredMessage): boolean {
-  return !!message.agent &&
-    !isCompactionAgent(message.agent) &&
-    !!message.model?.providerID &&
-    !!message.model?.modelID
-}
-
-function hasPartialAgentOrModel(message: StoredMessage): boolean {
-  const hasAgent = !!message.agent && !isCompactionAgent(message.agent)
-  const hasModel = !!message.model?.providerID && !!message.model?.modelID
-  return hasAgent || hasModel || !!message.tools
-}
-
-function convertSessionMessageToStoredMessage(message: SessionMessage): StoredMessage | null {
-  if (isCompactionMessage(message)) {
-    return null
-  }
-
-  const info = message.info
-  if (!info) {
-    return null
-  }
-
-  const providerID = info.model?.providerID ?? info.providerID
-  const modelID = info.model?.modelID ?? info.modelID
-
-  return {
-    ...(info.agent ? { agent: info.agent } : {}),
-    ...(providerID && modelID
-      ? {
-          model: {
-            providerID,
-            modelID,
-            ...(info.model?.variant ? { variant: info.model.variant } : {}),
-          },
-        }
-      : {}),
-    ...(info.tools ? { tools: info.tools } : {}),
-  }
-}
-
-function mergeStoredMessages(
-  messages: Array<StoredMessage | null>,
-  sessionID?: string,
-): StoredMessage | null {
-  const merged: StoredMessage = {}
-
-  for (const message of messages) {
-    if (!message || isCompactionAgent(message.agent)) {
-      continue
-    }
-
-    if (!merged.agent && message.agent) {
-      merged.agent = message.agent
-    }
-
-    if (!merged.model?.providerID && message.model?.providerID && message.model.modelID) {
-      merged.model = {
-        providerID: message.model.providerID,
-        modelID: message.model.modelID,
-        ...(message.model.variant ? { variant: message.model.variant } : {}),
-      }
-    }
-
-    if (!merged.tools && message.tools) {
-      merged.tools = message.tools
-    }
-
-    if (hasFullAgentAndModel(merged) && merged.tools) {
-      break
-    }
-  }
-
-  const checkpoint = sessionID
-    ? getCompactionAgentConfigCheckpoint(sessionID)
-    : undefined
-
-  if (!merged.agent && checkpoint?.agent) {
-    merged.agent = checkpoint.agent
-  }
-
-  if (!merged.model && checkpoint?.model) {
-    merged.model = {
-      providerID: checkpoint.model.providerID,
-      modelID: checkpoint.model.modelID,
-    }
-  }
-
-  if (!merged.tools && checkpoint?.tools) {
-    merged.tools = checkpoint.tools
-  }
-
-  return hasPartialAgentOrModel(merged) ? merged : null
-}
-
-export function resolvePromptContextFromSessionMessages(
-  messages: SessionMessage[],
-  sessionID?: string,
-): StoredMessage | null {
-  const convertedMessages = messages
-    .map(convertSessionMessageToStoredMessage)
-    .reverse()
-
-  return mergeStoredMessages(convertedMessages, sessionID)
-}
-
-export function findNearestMessageExcludingCompaction(
-  messageDir: string,
-  sessionID?: string,
-): StoredMessage | null {
-  try {
-    const files = readdirSync(messageDir)
-      .filter((name: string) => name.endsWith(".json"))
-      .sort()
-      .reverse()
-
-    const messages: Array<StoredMessage | null> = []
-
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(messageDir, file), "utf-8")
-        const parsed = JSON.parse(content) as StoredMessage & { id?: string }
-        if (hasCompactionPartInStorage(parsed.id) || isCompactionAgent(parsed.agent)) {
-          continue
-        }
-        messages.push(parsed)
-      } catch {
-        continue
-      }
-    }
-
-    return mergeStoredMessages(messages, sessionID)
-  } catch {
-    return null
-  }
-}

package/src/features/background-agent/concurrency.ts

@@ -1,137 +0,0 @@
-import type { BackgroundTaskConfig } from "../../config/schema"
-
-/**
- * Queue entry with settled-flag pattern to prevent double-resolution.
- *
- * The settled flag ensures that cancelWaiters() doesn't reject
- * an entry that was already resolved by release().
- */
-interface QueueEntry {
-  resolve: () => void
-  rawReject: (error: Error) => void
-  settled: boolean
-}
-
-export class ConcurrencyManager {
-  private config?: BackgroundTaskConfig
-  private counts: Map<string, number> = new Map()
-  private queues: Map<string, QueueEntry[]> = new Map()
-
-  constructor(config?: BackgroundTaskConfig) {
-    this.config = config
-  }
-
-  getConcurrencyLimit(model: string): number {
-    const modelLimit = this.config?.modelConcurrency?.[model]
-    if (modelLimit !== undefined) {
-      return modelLimit === 0 ? Infinity : modelLimit
-    }
-    const provider = model.split('/')[0]
-    const providerLimit = this.config?.providerConcurrency?.[provider]
-    if (providerLimit !== undefined) {
-      return providerLimit === 0 ? Infinity : providerLimit
-    }
-    const defaultLimit = this.config?.defaultConcurrency
-    if (defaultLimit !== undefined) {
-      return defaultLimit === 0 ? Infinity : defaultLimit
-    }
-    return 5
-  }
-
-  async acquire(model: string): Promise<void> {
-    const limit = this.getConcurrencyLimit(model)
-    if (limit === Infinity) {
-      return
-    }
-
-    const current = this.counts.get(model) ?? 0
-    if (current < limit) {
-      this.counts.set(model, current + 1)
-      return
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      const queue = this.queues.get(model) ?? []
-
-      const entry: QueueEntry = {
-        resolve: () => {
-          if (entry.settled) return
-          entry.settled = true
-          resolve()
-        },
-        rawReject: reject,
-        settled: false,
-      }
-
-      queue.push(entry)
-      this.queues.set(model, queue)
-    })
-  }
-
-  release(model: string): void {
-    const limit = this.getConcurrencyLimit(model)
-    if (limit === Infinity) {
-      return
-    }
-
-    const queue = this.queues.get(model)
-
-    // Try to hand off to a waiting entry (skip any settled entries from cancelWaiters)
-    while (queue && queue.length > 0) {
-      const next = queue.shift()!
-      if (!next.settled) {
-        // Hand off the slot to this waiter (count stays the same)
-        next.resolve()
-        return
-      }
-    }
-
-    // No handoff occurred - decrement the count to free the slot
-    const current = this.counts.get(model) ?? 0
-    if (current > 0) {
-      this.counts.set(model, current - 1)
-    }
-  }
-
-  /**
-   * Cancel all waiting acquires for a model. Used during cleanup.
-   */
-  cancelWaiters(model: string): void {
-    const queue = this.queues.get(model)
-    if (queue) {
-      for (const entry of queue) {
-        if (!entry.settled) {
-          entry.settled = true
-          entry.rawReject(new Error(`Concurrency queue cancelled for model: ${model}`))
-        }
-      }
-      this.queues.delete(model)
-    }
-  }
-
-  /**
-   * Clear all state. Used during manager cleanup/shutdown.
-   * Cancels all pending waiters.
-   */
-  clear(): void {
-    for (const [model] of this.queues) {
-      this.cancelWaiters(model)
-    }
-    this.counts.clear()
-    this.queues.clear()
-  }
-
-  /**
-   * Get current count for a model (for testing/debugging)
-   */
-  getCount(model: string): number {
-    return this.counts.get(model) ?? 0
-  }
-
-  /**
-   * Get queue length for a model (for testing/debugging)
-   */
-  getQueueLength(model: string): number {
-    return this.queues.get(model)?.length ?? 0
-  }
-}

package/src/features/background-agent/constants.ts

@@ -1,58 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { BackgroundTask, LaunchInput } from "./types"
-
-export const TASK_TTL_MS = 30 * 60 * 1000
-export const TERMINAL_TASK_TTL_MS = 30 * 60 * 1000
-export const MIN_STABILITY_TIME_MS = 10 * 1000
-export const DEFAULT_STALE_TIMEOUT_MS = 2_700_000
-export const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 3_600_000
-export const DEFAULT_MAX_TOOL_CALLS = 4000
-export const DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD = 20
-export const DEFAULT_CIRCUIT_BREAKER_ENABLED = true
-export const MIN_RUNTIME_BEFORE_STALE_MS = 30_000
-export const DEFAULT_SESSION_GONE_TIMEOUT_MS = 60_000
-export const MIN_IDLE_TIME_MS = 5000
-export const POLLING_INTERVAL_MS = 3000
-export const TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000
-export const TMUX_CALLBACK_DELAY_MS = 200
-
-export type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit"
-
-export type OpencodeClient = PluginInput["client"]
-
-export interface MessagePartInfo {
-  sessionID?: string
-  type?: string
-  tool?: string
-}
-
-export interface EventProperties {
-  sessionID?: string
-  info?: { id?: string }
-  [key: string]: unknown
-}
-
-export interface BackgroundEvent {
-  type: string
-  properties?: EventProperties
-}
-
-export interface Todo {
-  content: string;
-  status: string;
-  priority: string;
-  id?: string;
-}
-
-export interface QueueItem {
-  task: BackgroundTask
-  input: LaunchInput
-}
-
-export interface SubagentSessionCreatedEvent {
-  sessionID: string
-  parentID: string
-  title: string
-}
-
-export type OnSubagentSessionCreated = (event: SubagentSessionCreatedEvent) => Promise<void>

package/src/features/background-agent/duration-formatter.ts

@@ -1,14 +0,0 @@
-export function formatDuration(start: Date, end?: Date): string {
-  const duration = (end ?? new Date()).getTime() - start.getTime()
-  const seconds = Math.floor(duration / 1000)
-  const minutes = Math.floor(seconds / 60)
-  const hours = Math.floor(minutes / 60)
-
-  if (hours > 0) {
-    return `${hours}h ${minutes % 60}m ${seconds % 60}s`
-  }
-  if (minutes > 0) {
-    return `${minutes}m ${seconds % 60}s`
-  }
-  return `${seconds}s`
-}

package/src/features/background-agent/error-classifier.ts

@@ -1,83 +0,0 @@
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}
-
-export function isAbortedSessionError(error: unknown): boolean {
-  const message = getErrorText(error)
-  return message.toLowerCase().includes("aborted")
-}
-
-export function getErrorText(error: unknown): string {
-  if (!error) return ""
-  if (typeof error === "string") return error
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`
-  }
-  if (typeof error === "object" && error !== null) {
-    if ("message" in error && typeof error.message === "string") {
-      return error.message
-    }
-    if ("name" in error && typeof error.name === "string") {
-      return error.name
-    }
-  }
-  return ""
-}
-
-export function extractErrorName(error: unknown): string | undefined {
-  if (isRecord(error) && typeof error["name"] === "string") return error["name"]
-  if (error instanceof Error) return error.name
-  return undefined
-}
-
-export function extractErrorMessage(error: unknown): string | undefined {
-  if (!error) return undefined
-  if (typeof error === "string") return error
-  if (error instanceof Error) return error.message
-
-  if (isRecord(error)) {
-    const dataRaw = error["data"]
-    const candidates: unknown[] = [
-      error,
-      dataRaw,
-      error["error"],
-      isRecord(dataRaw) ? (dataRaw as Record<string, unknown>)["error"] : undefined,
-      error["cause"],
-    ]
-
-    for (const candidate of candidates) {
-      if (typeof candidate === "string" && candidate.length > 0) return candidate
-      if (
-        isRecord(candidate) &&
-        typeof candidate["message"] === "string" &&
-        candidate["message"].length > 0
-      ) {
-        return candidate["message"]
-      }
-    }
-  }
-
-  try {
-    return JSON.stringify(error)
-  } catch {
-    return String(error)
-  }
-}
-
-interface EventPropertiesLike {
-  [key: string]: unknown
-}
-
-export function getSessionErrorMessage(properties: EventPropertiesLike): string | undefined {
-  const errorRaw = properties["error"]
-  if (!isRecord(errorRaw)) return undefined
-
-  const dataRaw = errorRaw["data"]
-  if (isRecord(dataRaw)) {
-    const message = dataRaw["message"]
-    if (typeof message === "string") return message
-  }
-
-  const message = errorRaw["message"]
-  return typeof message === "string" ? message : undefined
-}

package/src/features/background-agent/fallback-retry-handler.ts

@@ -1,134 +0,0 @@
-import type { BackgroundTask, LaunchInput } from "./types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import type { ConcurrencyManager } from "./concurrency"
-import type { OpencodeClient, QueueItem } from "./constants"
-import { log, readConnectedProvidersCache, readProviderModelsCache } from "../../shared"
-import {
-  shouldRetryError,
-  getNextFallback,
-  hasMoreFallbacks,
-  selectFallbackProvider,
-} from "../../shared/model-error-classifier"
-import { transformModelForProvider } from "../../shared/provider-model-id-transform"
-import { abortWithTimeout } from "./abort-with-timeout"
-
-export async function tryFallbackRetry(args: {
-  task: BackgroundTask
-  errorInfo: { name?: string; message?: string }
-  source: string
-  concurrencyManager: ConcurrencyManager
-  client: OpencodeClient
-  idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>
-  queuesByKey: Map<string, QueueItem[]>
-  processKey: (key: string) => void
-}): Promise<boolean> {
-  const { task, errorInfo, source, concurrencyManager, client, idleDeferralTimers, queuesByKey, processKey } = args
-  const fallbackChain = task.fallbackChain
-  const canRetry =
-    shouldRetryError(errorInfo) &&
-    fallbackChain &&
-    fallbackChain.length > 0 &&
-    hasMoreFallbacks(fallbackChain, task.attemptCount ?? 0)
-
-  if (!canRetry) return false
-
-  const attemptCount = task.attemptCount ?? 0
-  const providerModelsCache = readProviderModelsCache()
-  const connectedProviders = providerModelsCache?.connected ?? readConnectedProvidersCache()
-  const connectedSet = connectedProviders ? new Set(connectedProviders.map(p => p.toLowerCase())) : null
-  const preferredProvider = task.model?.providerID?.toLowerCase()
-
-  const isReachable = (entry: FallbackEntry): boolean => {
-    if (!connectedSet) return true
-    if (entry.providers.some((provider) => connectedSet.has(provider.toLowerCase()))) {
-      return true
-    }
-    return preferredProvider ? connectedSet.has(preferredProvider) : false
-  }
-
-  let selectedAttemptCount = attemptCount
-  let nextFallback: FallbackEntry | undefined
-  while (fallbackChain && selectedAttemptCount < fallbackChain.length) {
-    const candidate = getNextFallback(fallbackChain, selectedAttemptCount)
-    if (!candidate) break
-    selectedAttemptCount++
-    if (!isReachable(candidate)) {
-      log("[background-agent] Skipping unreachable fallback:", {
-        taskId: task.id,
-        source,
-        model: candidate.model,
-        providers: candidate.providers,
-      })
-      continue
-    }
-    nextFallback = candidate
-    break
-  }
-  if (!nextFallback) return false
-
-  const providerID = selectFallbackProvider(
-    nextFallback.providers,
-    task.model?.providerID,
-  )
-
-  log("[background-agent] Retryable error, attempting fallback:", {
-    taskId: task.id,
-    source,
-    errorName: errorInfo.name,
-    errorMessage: errorInfo.message?.slice(0, 100),
-    attemptCount: selectedAttemptCount,
-    nextModel: `${providerID}/${nextFallback.model}`,
-  })
-
-  if (task.concurrencyKey) {
-    concurrencyManager.release(task.concurrencyKey)
-    task.concurrencyKey = undefined
-  }
-
-  const idleTimer = idleDeferralTimers.get(task.id)
-  if (idleTimer) {
-    clearTimeout(idleTimer)
-    idleDeferralTimers.delete(task.id)
-  }
-
-  const previousSessionID = task.sessionID
-
-  task.attemptCount = selectedAttemptCount
-  const transformedModelId = transformModelForProvider(providerID, nextFallback.model)
-  task.model = {
-    providerID,
-    modelID: transformedModelId,
-    variant: nextFallback.variant,
-  }
-  task.status = "pending"
-  task.sessionID = undefined
-  task.startedAt = undefined
-  task.queuedAt = new Date()
-  task.error = undefined
-
-  const key = task.model ? `${task.model.providerID}/${task.model.modelID}` : task.agent
-  const queue = queuesByKey.get(key) ?? []
-  const retryInput: LaunchInput = {
-    description: task.description,
-    prompt: task.prompt,
-    agent: task.agent,
-    parentSessionID: task.parentSessionID,
-    parentMessageID: task.parentMessageID,
-    parentModel: task.parentModel,
-    parentAgent: task.parentAgent,
-    parentTools: task.parentTools,
-    model: task.model,
-    fallbackChain: task.fallbackChain,
-    category: task.category,
-    isUnstableAgent: task.isUnstableAgent,
-  }
-
-  if (previousSessionID) {
-    await abortWithTimeout(client, previousSessionID).catch(() => {})
-  }
-
-  queue.push({ task, input: retryInput })
-  queuesByKey.set(key, queue)
-  processKey(key)
-  return true
-}

package/src/features/background-agent/index.ts

@@ -1,2 +0,0 @@
-export * from "./types"
-export { BackgroundManager, type SubagentSessionCreatedEvent, type OnSubagentSessionCreated } from "./manager"

package/src/features/background-agent/loop-detector.ts

@@ -1,102 +0,0 @@
-import type { BackgroundTaskConfig } from "../../config/schema"
-import {
-  DEFAULT_CIRCUIT_BREAKER_ENABLED,
-  DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD,
-  DEFAULT_MAX_TOOL_CALLS,
-} from "./constants"
-import type { ToolCallWindow } from "./types"
-
-export interface CircuitBreakerSettings {
-  enabled: boolean
-  maxToolCalls: number
-  consecutiveThreshold: number
-}
-
-export interface ToolLoopDetectionResult {
-  triggered: boolean
-  toolName?: string
-  repeatedCount?: number
-}
-
-export function resolveCircuitBreakerSettings(
-  config?: BackgroundTaskConfig
-): CircuitBreakerSettings {
-  return {
-    enabled: config?.circuitBreaker?.enabled ?? DEFAULT_CIRCUIT_BREAKER_ENABLED,
-    maxToolCalls:
-      config?.circuitBreaker?.maxToolCalls ?? config?.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS,
-    consecutiveThreshold:
-      config?.circuitBreaker?.consecutiveThreshold ?? DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD,
-  }
-}
-
-export function recordToolCall(
-  window: ToolCallWindow | undefined,
-  toolName: string,
-  settings: CircuitBreakerSettings,
-  toolInput?: Record<string, unknown> | null
-): ToolCallWindow {
-  if (toolInput == null) {
-    return {
-      lastSignature: `${toolName}::__unknown-input__`,
-      consecutiveCount: 1,
-      threshold: settings.consecutiveThreshold,
-    }
-  }
-
-  const signature = createToolCallSignature(toolName, toolInput)
-
-  if (window && window.lastSignature === signature) {
-    return {
-      lastSignature: signature,
-      consecutiveCount: window.consecutiveCount + 1,
-      threshold: settings.consecutiveThreshold,
-    }
-  }
-
-  return {
-    lastSignature: signature,
-    consecutiveCount: 1,
-    threshold: settings.consecutiveThreshold,
-  }
-}
-
-function sortObject(obj: unknown): unknown {
-  if (obj == null) return obj
-  if (typeof obj !== "object") return obj
-  if (Array.isArray(obj)) return obj.map(sortObject)
-
-  const sorted: Record<string, unknown> = {}
-  const keys = Object.keys(obj as Record<string, unknown>).sort()
-  for (const key of keys) {
-    sorted[key] = sortObject((obj as Record<string, unknown>)[key])
-  }
-  return sorted
-}
-
-export function createToolCallSignature(
-  toolName: string,
-  toolInput?: Record<string, unknown> | null
-): string {
-  if (toolInput == null) {
-    return toolName
-  }
-  if (Object.keys(toolInput).length === 0) {
-    return toolName
-  }
-  return `${toolName}::${JSON.stringify(sortObject(toolInput))}`
-}
-
-export function detectRepetitiveToolUse(
-  window: ToolCallWindow | undefined
-): ToolLoopDetectionResult {
-  if (!window || window.consecutiveCount < window.threshold) {
-    return { triggered: false }
-  }
-
-  return {
-    triggered: true,
-    toolName: window.lastSignature.split("::")[0],
-    repeatedCount: window.consecutiveCount,
-  }
-}