@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/delegate-task/builtin-category-definition.ts

@@ -1,8 +0,0 @@
-import type { CategoryConfig } from "../../config/schema"
-
-export type BuiltinCategoryDefinition = {
-  name: string
-  config: CategoryConfig
-  description: string
-  promptAppend: string
-}

package/src/tools/delegate-task/cancel-unstable-agent-task.ts

@@ -1,19 +0,0 @@
-import type { ExecutorContext } from "./executor-types"
-
-export async function cancelUnstableAgentTask(
-  manager: ExecutorContext["manager"],
-  taskID: string | undefined,
-  reason: string
-): Promise<void> {
-  if (!taskID || typeof manager.cancelTask !== "function") {
-    return
-  }
-
-  await Promise.allSettled([
-    manager.cancelTask(taskID, {
-      source: "unstable-agent-task",
-      reason,
-      skipNotification: true,
-    }),
-  ])
-}

package/src/tools/delegate-task/categories.test.ts

@@ -1,87 +0,0 @@
-import { expect, test } from "bun:test"
-import { resolveCategoryConfig } from "./categories"
-
-test("resolveCategoryConfig returns null for unknown category with no config", () => {
-  const result = resolveCategoryConfig("nonexistent-category", {
-    userCategories: {},
-    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
-  })
-  expect(result).toBeNull()
-})
-
-test("resolveCategoryConfig returns null when category is disabled", () => {
-  const result = resolveCategoryConfig("quick", {
-    userCategories: { quick: { disable: true } },
-  })
-  expect(result).toBeNull()
-})
-
-test("resolveCategoryConfig merges default config with user config", () => {
-  const result = resolveCategoryConfig("quick", {
-    userCategories: { quick: { temperature: 0.9 } },
-    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
-  })
-  expect(result).not.toBeNull()
-  expect(result!.config.temperature).toBe(0.9)
-})
-
-test("resolveCategoryConfig user model takes precedence over default", () => {
-  const result = resolveCategoryConfig("quick", {
-    userCategories: { quick: { model: "openrouter/deepseek/deepseek-v4-flash" } },
-    availableModels: new Set(["openrouter/deepseek/deepseek-v4-flash"]),
-  })
-  expect(result).not.toBeNull()
-  expect(result!.model).toBe("openrouter/deepseek/deepseek-v4-flash")
-})
-
-test("resolveCategoryConfig returns promptAppend for category", () => {
-  const result = resolveCategoryConfig("deep", {
-    userCategories: {},
-    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
-  })
-  expect(result).not.toBeNull()
-  expect(result!.promptAppend).toBeDefined()
-})
-
-test("resolveCategoryConfig isUserConfiguredModel true when user provides model", () => {
-  const result = resolveCategoryConfig("quick", {
-    userCategories: { quick: { model: "openrouter/deepseek/deepseek-v4-flash" } },
-    availableModels: new Set(["openrouter/deepseek/deepseek-v4-flash"]),
-  })
-  expect(result).not.toBeNull()
-  expect(result!.isUserConfiguredModel).toBe(true)
-})
-
-test("resolveCategoryConfig isUserConfiguredModel false when no user model", () => {
-  const result = resolveCategoryConfig("quick", {
-    userCategories: { quick: {} },
-    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
-  })
-  expect(result).not.toBeNull()
-  expect(result!.isUserConfiguredModel).toBe(false)
-})
-
-test("resolveCategoryConfig concatenates prompt_append with default", () => {
-  const result = resolveCategoryConfig("quick", {
-    userCategories: { quick: { prompt_append: "Extra instructions" } },
-    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
-  })
-  expect(result).not.toBeNull()
-  expect(result!.promptAppend).toContain("Extra instructions")
-})
-
-test("resolveCategoryConfig returns null when category not in defaults or user config", () => {
-  const result = resolveCategoryConfig("nonexistent", {
-    userCategories: {},
-  })
-  expect(result).toBeNull()
-})
-
-test("resolveCategoryConfig applies user variant over default variant", () => {
-  const result = resolveCategoryConfig("deep", {
-    userCategories: { deep: { variant: "high" } },
-    availableModels: new Set(["openrouter/minimax/minimax-m2.7"]),
-  })
-  expect(result).not.toBeNull()
-  expect(result!.config.variant).toBe("high")
-})

package/src/tools/delegate-task/categories.ts

@@ -1,77 +0,0 @@
-import type { CategoryConfig, CategoriesConfig } from "../../config/schema"
-import { DEFAULT_CATEGORIES, CATEGORY_PROMPT_APPENDS } from "./constants"
-import { resolveModel } from "../../shared/model-resolver"
-import { isModelAvailable } from "../../shared/model-availability"
-import { normalizeModel } from "../../shared/model-normalization"
-import { CATEGORY_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
-import { log } from "../../shared/logger"
-
-export interface ResolveCategoryConfigOptions {
-  userCategories?: CategoriesConfig
-  inheritedModel?: string
-  systemDefaultModel?: string
-  availableModels?: Set<string>
-}
-
-export interface ResolveCategoryConfigResult {
-  config: CategoryConfig
-  promptAppend: string
-  model: string | undefined
-  isUserConfiguredModel: boolean
-}
-
-/**
- * Resolve the configuration for a given category name.
- * Merges default and user configurations, handles model resolution.
- */
-export function resolveCategoryConfig(
-  categoryName: string,
-  options: ResolveCategoryConfigOptions
-): ResolveCategoryConfigResult | null {
-  const { userCategories, inheritedModel: _inheritedModel, systemDefaultModel, availableModels } = options
-
-  const defaultConfig = DEFAULT_CATEGORIES[categoryName]
-  const userConfig = userCategories?.[categoryName]
-  const hasExplicitUserConfig = userConfig !== undefined
-
-  if (userConfig?.disable) {
-    return null
-  }
-
-  const categoryReq = CATEGORY_MODEL_REQUIREMENTS[categoryName]
-  if (categoryReq?.requiresModel && availableModels && !hasExplicitUserConfig) {
-    if (!isModelAvailable(categoryReq.requiresModel, availableModels)) {
-      log(`[resolveCategoryConfig] Category ${categoryName} requires ${categoryReq.requiresModel} but not available`)
-      return null
-    }
-  }
-  const defaultPromptAppend = CATEGORY_PROMPT_APPENDS[categoryName] ?? ""
-
-  if (!defaultConfig && !userConfig) {
-    return null
-  }
-
-  // Model priority for categories: user override > category default > system default
-  // Categories have explicit models - no inheritance from parent session
-  const model = resolveModel({
-    userModel: userConfig?.model,
-    inheritedModel: defaultConfig?.model, // Category's built-in model takes precedence over system default
-    systemDefault: systemDefaultModel,
-  })
-  const isUserConfiguredModel = normalizeModel(userConfig?.model) !== undefined
-  const config: CategoryConfig = {
-    ...defaultConfig,
-    ...userConfig,
-    model,
-    variant: userConfig?.variant ?? defaultConfig?.variant,
-  }
-
-  let promptAppend = defaultPromptAppend
-  if (userConfig?.prompt_append) {
-    promptAppend = defaultPromptAppend
-      ? defaultPromptAppend + "\n\n" + userConfig.prompt_append
-      : userConfig.prompt_append
-  }
-
-  return { config, promptAppend, model, isUserConfiguredModel }
-}

package/src/tools/delegate-task/category-resolver.ts

@@ -1,309 +0,0 @@
-import type { ModelFallbackInfo } from "../../features/task-toast-manager/types"
-import type { DelegateTaskArgs } from "./types"
-import type { ExecutorContext } from "./executor-types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { mergeCategories } from "../../shared/merge-categories"
-import { resolveCategoryConfig } from "./categories"
-import { parseModelString } from "./model-string-parser"
-import { CATEGORY_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
-import { normalizeFallbackModels, flattenToFallbackModelStrings } from "../../shared/model-resolver"
-import { buildFallbackChainFromModels, findMostSpecificFallbackEntry } from "../../shared/fallback-chain-from-models"
-import { CONFIG_BASENAME } from "../../shared/plugin-identity"
-import { getAvailableModelsForDelegateTask } from "./available-models"
-import { resolveModelForDelegateTask } from "./model-selection"
-import { getAgentDisplayName } from "../../shared/agent-display-names"
-import { resolveModeAgent } from "../../shared/mode-routing"
-
-import type { CategoryConfig } from "../../config/schema"
-import type { DelegatedModelConfig } from "./types"
-
-function applyCategoryParams(base: DelegatedModelConfig, config: CategoryConfig): DelegatedModelConfig {
-  const result = { ...base }
-  if (config.temperature !== undefined) result.temperature = config.temperature
-  if (config.top_p !== undefined) result.top_p = config.top_p
-  if (config.maxTokens !== undefined) result.maxTokens = config.maxTokens
-  if (config.reasoningEffort !== undefined) result.reasoningEffort = config.reasoningEffort
-  if (config.thinking !== undefined) result.thinking = config.thinking
-  return result
-}
-
-export interface CategoryResolutionResult {
-  agentToUse: string
-  categoryModel: DelegatedModelConfig | undefined
-  categoryPromptAppend: string | undefined
-  maxPromptTokens?: number
-  modelInfo: ModelFallbackInfo | undefined
-  actualModel: string | undefined
-  isUnstableAgent: boolean
-  fallbackChain?: FallbackEntry[]  // For runtime retry on model errors
-  error?: string
-}
-
-function resolveCategoryExecutorAgentKey(
-  categoryName: string,
-  config: CategoryConfig,
-): string {
-  void config
-  return resolveModeAgent(categoryName)
-}
-
-export async function resolveCategoryExecution(
-  args: DelegateTaskArgs,
-  executorCtx: ExecutorContext,
-  inheritedModel: string | undefined,
-  systemDefaultModel: string | undefined
-): Promise<CategoryResolutionResult> {
-  const { client, userCategories, agentOverrides } = executorCtx
-
-  const categoryName = args.category!
-  const enabledCategories = mergeCategories(userCategories)
-  const categoryExists = enabledCategories[categoryName] !== undefined
-
-  if (!categoryExists) {
-    const allCategoryNames = Object.keys(enabledCategories).join(", ")
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      categoryPromptAppend: undefined,
-      maxPromptTokens: undefined,
-      modelInfo: undefined,
-      actualModel: undefined,
-      isUnstableAgent: false,
-      error: `Unknown category: "${categoryName}". Available: ${allCategoryNames}`,
-    }
-  }
-
-  const availableModels = await getAvailableModelsForDelegateTask(client)
-
-  const resolved = resolveCategoryConfig(categoryName, {
-    userCategories,
-    inheritedModel,
-    systemDefaultModel,
-    availableModels,
-  })
-
-  if (!resolved) {
-    const requirement = CATEGORY_MODEL_REQUIREMENTS[categoryName]
-    const allCategoryNames = Object.keys(enabledCategories).join(", ")
-
-    if (categoryExists && requirement?.requiresModel) {
-      return {
-        agentToUse: "",
-        categoryModel: undefined,
-        categoryPromptAppend: undefined,
-        maxPromptTokens: undefined,
-        modelInfo: undefined,
-        actualModel: undefined,
-        isUnstableAgent: false,
-        error: `Category "${categoryName}" requires model "${requirement.requiresModel}" which is not available.
-
-To use this category:
-1. Connect a provider with this model: ${requirement.requiresModel}
-2. Or configure an alternative model in your ${CONFIG_BASENAME}.json for this category
-
-Available categories: ${allCategoryNames}`,
-      }
-    }
-
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      categoryPromptAppend: undefined,
-      maxPromptTokens: undefined,
-      modelInfo: undefined,
-      actualModel: undefined,
-      isUnstableAgent: false,
-      error: `Unknown category: "${categoryName}". Available: ${allCategoryNames}`,
-    }
-  }
-
-  const categoryExecutorAgentKey = resolveCategoryExecutorAgentKey(categoryName, resolved.config)
-  const categoryExecutorAgentName = getAgentDisplayName(categoryExecutorAgentKey)
-  const categoryExecutorOverride = agentOverrides?.[categoryExecutorAgentKey as keyof typeof agentOverrides]
-    ?? (agentOverrides
-      ? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === categoryExecutorAgentKey)?.[1]
-      : undefined)
-
-  const requirement = CATEGORY_MODEL_REQUIREMENTS[args.category!]
-  const normalizedConfiguredFallbackModels = normalizeFallbackModels(
-    categoryExecutorOverride?.fallback_models ?? resolved.config.fallback_models
-  )
-  let actualModel: string | undefined
-  let modelInfo: ModelFallbackInfo | undefined
-  let categoryModel: DelegatedModelConfig | undefined
-  let isModelResolutionSkipped = false
-  let fallbackEntry: FallbackEntry | undefined
-  let matchedFallback = false
-
-  const overrideModel = categoryExecutorOverride?.model
-  const explicitCategoryModel = userCategories?.[args.category!]?.model
-
-  if (!requirement) {
-    // Precedence: explicit category model > routed executor agent's override model > category resolved model.
-    // The routed executor agent is selected per-mode via resolveModeAgent (see shared/mode-routing.ts);
-    // its agentOverrides[<agent>].model serves as the fallback when no explicit category model is set.
-    actualModel = explicitCategoryModel ?? overrideModel ?? resolved.model
-    if (actualModel) {
-      modelInfo = explicitCategoryModel || overrideModel
-        ? { model: actualModel, type: "user-defined", source: "override" }
-        : { model: actualModel, type: "system-default", source: "system-default" }
-      const parsedModel = parseModelString(actualModel)
-      const variantToUse = userCategories?.[args.category!]?.variant
-        ?? categoryExecutorOverride?.variant
-        ?? resolved.config.variant
-      categoryModel = parsedModel
-        ? applyCategoryParams({ ...parsedModel, variant: variantToUse ?? parsedModel.variant }, resolved.config)
-        : undefined
-    }
-  } else {
-    const resolution = resolveModelForDelegateTask({
-      userModel: explicitCategoryModel ?? overrideModel,
-      userFallbackModels: flattenToFallbackModelStrings(normalizedConfiguredFallbackModels),
-      categoryDefaultModel: resolved.model,
-      isUserConfiguredCategoryModel: resolved.isUserConfiguredModel,
-      fallbackChain: requirement.fallbackChain,
-      availableModels,
-      systemDefaultModel,
-    })
-
-    if (resolution && "skipped" in resolution) {
-      isModelResolutionSkipped = true
-      const userModelOverride = explicitCategoryModel ?? overrideModel
-      if (userModelOverride) {
-        actualModel = userModelOverride
-        const parsedModel = parseModelString(userModelOverride)
-        const variantToUse = userCategories?.[args.category!]?.variant
-          ?? categoryExecutorOverride?.variant
-          ?? resolved.config.variant
-        categoryModel = parsedModel
-          ? applyCategoryParams({ ...parsedModel, variant: variantToUse ?? parsedModel.variant }, resolved.config)
-          : undefined
-        modelInfo = { model: userModelOverride, type: "user-defined", source: "override" }
-      }
-    } else if (resolution) {
-      const {
-        model: resolvedModel,
-        variant: resolvedVariant,
-        fallbackEntry: resolvedFallbackEntry,
-        matchedFallback: resolvedMatchedFallback,
-      } = resolution
-      fallbackEntry = resolvedFallbackEntry
-      matchedFallback = resolvedMatchedFallback === true
-      actualModel = resolvedModel
-
-      if (!parseModelString(actualModel)) {
-        return {
-          agentToUse: "",
-          categoryModel: undefined,
-          categoryPromptAppend: undefined,
-          maxPromptTokens: undefined,
-          modelInfo: undefined,
-          actualModel: undefined,
-          isUnstableAgent: false,
-          error: `Invalid model format "${actualModel}". Expected "provider/model" format (e.g., "anthropic/claude-3-5-sonnet-latest").`,
-        }
-      }
-
-      const type: "user-defined" | "inherited" | "category-default" | "system-default" =
-        (explicitCategoryModel || overrideModel)
-          ? "user-defined"
-          : (systemDefaultModel && actualModel === systemDefaultModel)
-              ? "system-default"
-              : "category-default"
-
-      const source: "override" | "category-default" | "system-default" =
-        type === "user-defined"
-          ? "override"
-          : type === "system-default"
-              ? "system-default"
-              : "category-default"
-
-      modelInfo = { model: actualModel, type, source }
-
-      const parsedModel = parseModelString(actualModel)
-      const variantToUse = userCategories?.[args.category!]?.variant
-        ?? categoryExecutorOverride?.variant
-        ?? resolvedVariant
-        ?? resolved.config.variant
-      categoryModel = parsedModel
-        ? applyCategoryParams({ ...parsedModel, variant: variantToUse ?? parsedModel.variant }, resolved.config)
-        : undefined
-    }
-  }
-
-  if (!categoryModel && actualModel) {
-    const parsedModel = parseModelString(actualModel)
-    categoryModel = parsedModel ?? undefined
-  }
-  const categoryPromptAppend = resolved.promptAppend || undefined
-
-  if (!categoryModel && !actualModel && !isModelResolutionSkipped) {
-    const categoryNames = Object.keys(enabledCategories)
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      categoryPromptAppend: undefined,
-      maxPromptTokens: undefined,
-      modelInfo: undefined,
-      actualModel: undefined,
-      isUnstableAgent: false,
-      error: `Model not configured for category "${args.category}".
-
-Configure in one of:
-1. OpenCode: Set "model" in opencode.json
-2. Oh-My-OpenCode: Set category model in ${CONFIG_BASENAME}.json
-3. Provider: Connect a provider with available models
-
-Current category: ${args.category}
-Available categories: ${categoryNames.join(", ")}`,
-    }
-  }
-
-  const resolvedModel = actualModel?.toLowerCase()
-  const isUnstableAgent = resolved.config.is_unstable_agent ?? (resolvedModel ? resolvedModel.includes("gemini") || resolvedModel.includes("minimax") : false)
-
-  const defaultProviderID = categoryModel?.providerID
-    ?? parseModelString(actualModel ?? "")?.providerID
-    ?? "opencode"
-  const configuredFallbackChain = buildFallbackChainFromModels(
-    normalizedConfiguredFallbackModels,
-    defaultProviderID,
-  )
-
-  // Only promote fallback-only settings when resolution actually selected a fallback model.
-  const effectiveEntry = matchedFallback && categoryModel
-    ? (
-        fallbackEntry
-        ?? (configuredFallbackChain
-          ? findMostSpecificFallbackEntry(categoryModel.providerID, categoryModel.modelID, configuredFallbackChain)
-          : undefined)
-      )
-    : undefined
-
-  if (categoryModel && effectiveEntry) {
-    categoryModel = {
-      ...categoryModel,
-      variant: userCategories?.[args.category!]?.variant
-        ?? categoryExecutorOverride?.variant
-        ?? effectiveEntry.variant
-        ?? categoryModel.variant,
-      reasoningEffort: effectiveEntry.reasoningEffort ?? categoryModel.reasoningEffort,
-      temperature: effectiveEntry.temperature ?? categoryModel.temperature,
-      top_p: effectiveEntry.top_p ?? categoryModel.top_p,
-      maxTokens: effectiveEntry.maxTokens ?? categoryModel.maxTokens,
-      thinking: effectiveEntry.thinking ?? categoryModel.thinking,
-    }
-  }
-
-  return {
-    agentToUse: categoryExecutorAgentName,
-    categoryModel,
-    categoryPromptAppend,
-    maxPromptTokens: resolved.config.max_prompt_tokens,
-    modelInfo,
-    actualModel,
-    isUnstableAgent,
-    // Don't use hardcoded fallback chain when resolution was skipped (cold cache)
-    fallbackChain: configuredFallbackChain ?? ((isModelResolutionSkipped || explicitCategoryModel || overrideModel) ? undefined : requirement?.fallbackChain),
-  }
-}