@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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

@@ -1,259 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin"
-import type { DelegateTaskArgs, DelegatedModelConfig, ToolContextWithMetadata, DelegateTaskToolOptions } from "./types"
-import { CATEGORY_DESCRIPTIONS } from "./constants"
-import { mergeCategories } from "../../shared/merge-categories"
-import { log } from "../../shared/logger"
-import { buildSystemContent } from "./prompt-builder"
-import type {
-  AvailableCategory,
-  AvailableSkill,
-} from "../../agents/dynamic-agent-prompt-builder"
-import {
-  resolveSkillContent,
-  resolveParentContext,
-  executeBackgroundContinuation,
-  executeSyncContinuation,
-  resolveCategoryExecution,
-  resolveSubagentExecution,
-  executeUnstableAgentTask,
-  executeBackgroundTask,
-  executeSyncTask,
-} from "./executor"
-
-export { resolveCategoryConfig } from "./categories"
-export type { SyncSessionCreatedEvent, DelegateTaskToolOptions, BuildSystemContentInput } from "./types"
-export { buildSystemContent, buildTaskPrompt } from "./prompt-builder"
-
-export function createDelegateTask(options: DelegateTaskToolOptions): ToolDefinition {
-  const { userCategories } = options
-
-  const allCategories = mergeCategories(userCategories)
-  const categoryNames = Object.keys(allCategories)
-  const categoryExamples = categoryNames.join(", ")
-
-  const availableCategories: AvailableCategory[] = options.availableCategories
-    ?? Object.entries(allCategories).map(([name, categoryConfig]) => {
-      const userDesc = userCategories?.[name]?.description
-      const builtinDesc = CATEGORY_DESCRIPTIONS[name]
-      const description = userDesc || builtinDesc || "General tasks"
-      return {
-        name,
-        description,
-        model: categoryConfig.model,
-      }
-    })
-
-  const availableSkills: AvailableSkill[] = options.availableSkills ?? []
-
-  const categoryList = categoryNames.map(name => {
-    const userDesc = userCategories?.[name]?.description
-    const builtinDesc = CATEGORY_DESCRIPTIONS[name]
-    const desc = userDesc || builtinDesc
-    return desc ? `  - ${name}: ${desc}` : `  - ${name}`
-  }).join("\n")
-
-  const description = `Spawn agent task with category-based or direct agent selection.
-  
-  ⚠️  CRITICAL: You MUST provide EITHER category OR subagent_type. Omitting BOTH will FAIL.
-  
-  **COMMON MISTAKE (DO NOT DO THIS):**
-  \`\`\`
-  task(description="...", prompt="...", run_in_background=false)  // ❌ FAILS - missing category AND subagent_type
-  \`\`\`
-  
-  **CORRECT - Using category:**
-  \`\`\`
-  task(category="quick", load_skills=[], description="Fix type error", prompt="...", run_in_background=false)
-  \`\`\`
-  
-  **CORRECT - Using subagent_type:**
-  \`\`\`
-  task(subagent_type="researcher", load_skills=[], description="Find patterns", prompt="...", run_in_background=true)
-  \`\`\`
-  
-  REQUIRED: Provide ONE of:
-  - category: For task delegation (routes to the appropriate bounded executor profile)
-  - subagent_type: For direct agent invocation (\`researcher\`, \`strategist\`, \`critic\`, etc.)
-  
-  **DO NOT provide both.** If category is provided, subagent_type is ignored.
-  
-  - load_skills: ALWAYS REQUIRED. Pass [] if no skills needed, or ["skill-1", "skill-2"] for category tasks.
-  - category: Use predefined category → routes to the appropriate canonical executor
-    Available categories:
-  ${categoryList}
-  - subagent_type: Use a specific canonical agent directly (\`researcher\`, \`strategist\`, \`critic\`, \`multimodal\`, \`designer\`, \`brainstormer\`, \`platform-manager\`, etc.)
-  - run_in_background: REQUIRED. true=async (returns task_id), false=sync (waits). Use background=true primarily for parallel researcher work or other non-blocking delegated tasks.
-  - session_id: Existing Task session to continue (from previous task output). Continues agent with FULL CONTEXT PRESERVED - saves tokens, maintains continuity.
-  - command: The command that triggered this task (optional, for slash command tracking).
-  
-  **WHEN TO USE session_id:**
-  - Task failed/incomplete → session_id with "fix: [specific issue]"
-  - Need follow-up on previous result → session_id with additional question
-  - Multi-turn conversation with same agent → always session_id instead of new task
-  
-  Prompts MUST be in English.`
-
-  return tool({
-    description,
-    args: {
-      load_skills: tool.schema.array(tool.schema.string()).describe("Skill names to inject. REQUIRED - pass [] if no skills needed."),
-      description: tool.schema.string().optional().describe("Short task description (3-5 words). Auto-generated from prompt if omitted."),
-      prompt: tool.schema.string().describe("Full detailed prompt for the agent"),
-      run_in_background: tool.schema.boolean().describe("REQUIRED. true=async (returns task_id), false=sync (waits). Use false for task delegation, true ONLY for parallel exploration."),
-      category: tool.schema.string().optional().describe(`REQUIRED if subagent_type not provided. Do NOT provide both category and subagent_type.`),
-      subagent_type: tool.schema.string().optional().describe("REQUIRED if category not provided. Do NOT provide both category and subagent_type."),
-      session_id: tool.schema.string().optional().describe("Existing Task session to continue"),
-      command: tool.schema.string().optional().describe("The command that triggered this task"),
-    },
-    async execute(args: DelegateTaskArgs, toolContext) {
-      const ctx = toolContext as ToolContextWithMetadata
-
-      if (args.category) {
-        if (args.subagent_type) {
-          log("[task] category provided - ignoring explicit subagent_type", {
-            category: args.category,
-            subagent_type: args.subagent_type,
-          })
-        }
-        args.subagent_type = undefined
-      }
-      // Auto-generate description from prompt when missing or empty
-      if (!args.description || typeof args.description !== "string" || args.description.trim() === "") {
-        const words = (args.prompt || "").trim().split(/\s+/)
-        args.description = words.slice(0, 4).join(" ") || "Delegated task"
-      }
-      await ctx.metadata?.({
-        title: args.description,
-      })
-      if (args.run_in_background === undefined) {
-        throw new Error(`Invalid arguments: 'run_in_background' parameter is REQUIRED. Specify run_in_background=false for task delegation, or run_in_background=true for parallel exploration.`)
-      }
-      if (typeof args.load_skills === "string") {
-        try {
-          const parsed = JSON.parse(args.load_skills)
-          args.load_skills = Array.isArray(parsed) ? parsed : []
-        } catch {
-          args.load_skills = []
-        }
-      }
-      if (args.load_skills === undefined) {
-        throw new Error(`Invalid arguments: 'load_skills' parameter is REQUIRED. Pass [] if no skills needed.`)
-      }
-      if (args.load_skills === null) {
-        throw new Error(`Invalid arguments: load_skills=null is not allowed. Pass [] if no skills needed.`)
-      }
-
-      const runInBackground = args.run_in_background === true
-
-      const { content: skillContent, contents: skillContents, error: skillError } = await resolveSkillContent(args.load_skills, {
-        gitMasterConfig: options.gitMasterConfig,
-        browserProvider: options.browserProvider,
-        disabledSkills: options.disabledSkills,
-        directory: options.directory,
-      })
-      if (skillError) {
-        return skillError
-      }
-
-      const parentContext = await resolveParentContext(ctx, options.client)
-
-      if (args.session_id) {
-        if (runInBackground) {
-          return executeBackgroundContinuation(args, ctx, options, parentContext)
-        }
-        return executeSyncContinuation(args, ctx, options)
-      }
-
-      if (!args.category && !args.subagent_type) {
-        return `Invalid arguments: Must provide either category or subagent_type.`
-      }
-
-      let systemDefaultModel: string | undefined
-      try {
-        const openCodeConfig = await options.client.config.get()
-        systemDefaultModel = (openCodeConfig as { data?: { model?: string } })?.data?.model
-      } catch {
-        systemDefaultModel = undefined
-      }
-
-      const inheritedModel = parentContext.model
-        ? `${parentContext.model.providerID}/${parentContext.model.modelID}`
-        : undefined
-
-      let agentToUse: string
-      let categoryModel: DelegatedModelConfig | undefined
-      let categoryPromptAppend: string | undefined
-      let modelInfo: import("../../features/task-toast-manager/types").ModelFallbackInfo | undefined
-      let actualModel: string | undefined
-      let isUnstableAgent = false
-      let fallbackChain: import("../../shared/model-requirements").FallbackEntry[] | undefined
-      let maxPromptTokens: number | undefined
-
-      if (args.category) {
-        const resolution = await resolveCategoryExecution(args, options, inheritedModel, systemDefaultModel)
-        if (resolution.error) {
-          return resolution.error
-        }
-        agentToUse = resolution.agentToUse
-        categoryModel = resolution.categoryModel
-        categoryPromptAppend = resolution.categoryPromptAppend
-        modelInfo = resolution.modelInfo
-        actualModel = resolution.actualModel
-        isUnstableAgent = resolution.isUnstableAgent
-        fallbackChain = resolution.fallbackChain
-        maxPromptTokens = resolution.maxPromptTokens
-
-        const isRunInBackgroundExplicitlyFalse = args.run_in_background === false || args.run_in_background === "false" as unknown as boolean
-
-        log("[task] unstable agent detection", {
-          category: args.category,
-          actualModel,
-          isUnstableAgent,
-          run_in_background_value: args.run_in_background,
-          run_in_background_type: typeof args.run_in_background,
-          isRunInBackgroundExplicitlyFalse,
-          willForceBackground: isUnstableAgent && isRunInBackgroundExplicitlyFalse,
-        })
-
-        if (isUnstableAgent && isRunInBackgroundExplicitlyFalse) {
-          const systemContent = buildSystemContent({
-            skillContent,
-            skillContents,
-            categoryPromptAppend,
-            agentName: agentToUse,
-            maxPromptTokens,
-            model: categoryModel,
-            availableCategories,
-            availableSkills,
-          })
-          return executeUnstableAgentTask(args, ctx, options, parentContext, agentToUse, categoryModel, systemContent, actualModel)
-        }
-      } else {
-        const resolution = await resolveSubagentExecution(args, options, parentContext.agent, categoryExamples)
-        if (resolution.error) {
-          return resolution.error
-        }
-        agentToUse = resolution.agentToUse
-        categoryModel = resolution.categoryModel
-        fallbackChain = resolution.fallbackChain
-      }
-
-      const systemContent = buildSystemContent({
-        skillContent,
-        skillContents,
-        categoryPromptAppend,
-        agentName: agentToUse,
-        maxPromptTokens,
-        model: categoryModel,
-        availableCategories,
-        availableSkills,
-      })
-
-      if (runInBackground) {
-        return executeBackgroundTask(args, ctx, options, parentContext, agentToUse, categoryModel, systemContent, fallbackChain)
-      }
-
-      return executeSyncTask(args, ctx, options, parentContext, agentToUse, categoryModel, systemContent, modelInfo, fallbackChain)
-    },
-  })
-}

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

@@ -1,89 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { BackgroundManager } from "../../features/background-agent"
-import type { CategoriesConfig, GitMasterConfig, BrowserAutomationProvider, AgentOverrides, BobAgentConfig } from "../../config/schema"
-import type {
-  AvailableCategory,
-  AvailableSkill,
-} from "../../agents/dynamic-agent-prompt-builder"
-
-export type OpencodeClient = PluginInput["client"]
-
-export interface DelegateTaskArgs {
-  description: string
-  prompt: string
-  category?: string
-  subagent_type?: string
-  run_in_background: boolean
-  session_id?: string
-  command?: string
-  load_skills: string[]
-  execute?: {
-    task_id: string
-    task_dir?: string
-  }
-}
-
-export interface ToolContextWithMetadata {
-  sessionID: string
-  messageID: string
-  agent: string
-  abort: AbortSignal
-  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void | Promise<void>
-  /**
-   * Tool call ID injected by OpenCode's internal context (not in plugin ToolContext type,
-   * but present at runtime via spread in fromPlugin()). Used for metadata store keying.
-   */
-  callID?: string
-  /** @deprecated OpenCode internal naming may vary across versions */
-  callId?: string
-  /** @deprecated OpenCode internal naming may vary across versions */
-  call_id?: string
-}
-
-export interface SyncSessionCreatedEvent {
-  sessionID: string
-  parentID: string
-  title: string
-}
-
-export interface DelegateTaskToolOptions {
-  manager: BackgroundManager
-  client: OpencodeClient
-  directory: string
-  /**
-   * Test hook: bypass global cache reads (Bun runs tests in parallel).
-   * If provided, resolveCategoryExecution/resolveSubagentExecution uses this instead of reading from disk cache.
-   */
-  connectedProvidersOverride?: string[] | null
-  /**
-   * Test hook: bypass fetchAvailableModels() by providing an explicit available model set.
-   */
-  availableModelsOverride?: Set<string>
-  userCategories?: CategoriesConfig
-  gitMasterConfig?: GitMasterConfig
-  bobJuniorModel?: string
-  browserProvider?: BrowserAutomationProvider
-  disabledSkills?: Set<string>
-  availableCategories?: AvailableCategory[]
-  availableSkills?: AvailableSkill[]
-  agentOverrides?: AgentOverrides
-  bobAgentConfig?: BobAgentConfig
-  onSyncSessionCreated?: (event: SyncSessionCreatedEvent) => Promise<void>
-  syncPollTimeoutMs?: number
-}
-
-import type { DelegatedModelConfig } from "../../shared/model-resolution-types"
-export type { DelegatedModelConfig }
-
-export interface BuildSystemContentInput {
-  skillContent?: string
-  skillContents?: string[]
-  categoryPromptAppend?: string
-  agentsContext?: string
-  planAgentPrepend?: string
-  maxPromptTokens?: number
-  model?: DelegatedModelConfig
-  agentName?: string
-  availableCategories?: AvailableCategory[]
-  availableSkills?: AvailableSkill[]
-}

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

@@ -1,243 +0,0 @@
-import type { DelegateTaskArgs, ToolContextWithMetadata, DelegatedModelConfig } from "./types"
-import type { ExecutorContext, ParentContext, SessionMessage } from "./executor-types"
-import { DEFAULT_SYNC_POLL_TIMEOUT_MS, getTimingConfig } from "./timing"
-import { buildTaskPrompt } from "./prompt-builder"
-import { cancelUnstableAgentTask } from "./cancel-unstable-agent-task"
-import { storeToolMetadata } from "../../features/tool-metadata-store"
-import { resolveCallID } from "./resolve-call-id"
-import { formatDuration } from "./time-formatter"
-import { formatDetailedError } from "./error-formatting"
-import { getSessionTools } from "../../shared/session-tools-store"
-import { normalizeSDKResponse } from "../../shared"
-import { QUESTION_DENIED_SESSION_PERMISSION } from "../../shared/question-denied-session-permission"
-
-export async function executeUnstableAgentTask(
-  args: DelegateTaskArgs,
-  ctx: ToolContextWithMetadata,
-  executorCtx: ExecutorContext,
-  parentContext: ParentContext,
-  agentToUse: string,
-  categoryModel: DelegatedModelConfig | undefined,
-  systemContent: string | undefined,
-  actualModel: string | undefined
-): Promise<string> {
-  const { manager, client, syncPollTimeoutMs, bobAgentConfig } = executorCtx
-  let cleanupReason: string | undefined
-  let launchedTaskID: string | undefined
-
-  try {
-    const tddEnabled = bobAgentConfig?.tdd
-    const effectivePrompt = buildTaskPrompt(args.prompt, agentToUse, tddEnabled)
-    const task = await manager.launch({
-      description: args.description,
-      prompt: effectivePrompt,
-      agent: agentToUse,
-      parentSessionID: parentContext.sessionID,
-      parentMessageID: parentContext.messageID,
-      parentModel: parentContext.model,
-      parentAgent: parentContext.agent,
-      parentTools: getSessionTools(parentContext.sessionID),
-      model: categoryModel,
-      skills: args.load_skills.length > 0 ? args.load_skills : undefined,
-      skillContent: systemContent,
-      category: args.category,
-      sessionPermission: QUESTION_DENIED_SESSION_PERMISSION,
-    })
-    launchedTaskID = task.id
-
-    const timing = getTimingConfig()
-    const waitStart = Date.now()
-    let sessionID = task.sessionID
-    while (!sessionID && Date.now() - waitStart < timing.WAIT_FOR_SESSION_TIMEOUT_MS) {
-      if (ctx.abort?.aborted) {
-        cleanupReason = "Parent aborted while waiting for unstable task session start"
-        return `Task aborted while waiting for session to start.\n\nTask ID: ${task.id}`
-      }
-      await new Promise(resolve => setTimeout(resolve, timing.WAIT_FOR_SESSION_INTERVAL_MS))
-      const updated = manager.getTask(task.id)
-      sessionID = updated?.sessionID
-    }
-    if (!sessionID) {
-      cleanupReason = "Unstable task session start timed out before session became available"
-      return formatDetailedError(new Error(`Task failed to start within timeout (30s). Task ID: ${task.id}, Status: ${task.status}`), {
-        operation: "Launch monitored background task",
-        args,
-        agent: agentToUse,
-        category: args.category,
-      })
-    }
-
-    const bgTaskMeta = {
-      title: args.description,
-      metadata: {
-        prompt: args.prompt,
-        agent: agentToUse,
-        category: args.category,
-        load_skills: args.load_skills,
-        description: args.description,
-        run_in_background: args.run_in_background,
-        sessionId: sessionID,
-        command: args.command,
-        model: categoryModel ? { providerID: categoryModel.providerID, modelID: categoryModel.modelID } : undefined,
-      },
-    }
-    await ctx.metadata?.(bgTaskMeta)
-    const callID = resolveCallID(ctx)
-    if (callID) {
-      storeToolMetadata(ctx.sessionID, callID, bgTaskMeta)
-    }
-
-    const startTime = new Date()
-    const timingCfg = getTimingConfig()
-    const pollStart = Date.now()
-    let lastMsgCount = 0
-    let stablePolls = 0
-    let terminalStatus: { status: string; error?: string } | undefined
-    let completedDuringMonitoring = false
-
-    while (Date.now() - pollStart < (syncPollTimeoutMs ?? DEFAULT_SYNC_POLL_TIMEOUT_MS)) {
-      if (ctx.abort?.aborted) {
-        cleanupReason = "Parent aborted while monitoring unstable background task"
-        return `Task aborted (was running in background mode).\n\nSession ID: ${sessionID}`
-      }
-
-      await new Promise(resolve => setTimeout(resolve, timingCfg.POLL_INTERVAL_MS))
-
-      const currentTask = manager.getTask(task.id)
-      if (currentTask && (currentTask.status === "interrupt" || currentTask.status === "error" || currentTask.status === "cancelled")) {
-        terminalStatus = { status: currentTask.status, error: currentTask.error }
-        break
-      }
-
-      const statusResult = await client.session.status()
-      const allStatuses = normalizeSDKResponse(statusResult, {} as Record<string, { type: string }>)
-      const sessionStatus = allStatuses[sessionID]
-
-      if (sessionStatus && sessionStatus.type !== "idle") {
-        stablePolls = 0
-        lastMsgCount = 0
-        continue
-      }
-
-      if (Date.now() - pollStart < timingCfg.MIN_STABILITY_TIME_MS) continue
-
-      const messagesCheck = await client.session.messages({ path: { id: sessionID } })
-      const msgs = normalizeSDKResponse(messagesCheck, [] as Array<unknown>, {
-        preferResponseOnMissingData: true,
-      })
-      const currentMsgCount = msgs.length
-
-      if (currentMsgCount === lastMsgCount) {
-        stablePolls++
-        if (stablePolls >= timingCfg.STABILITY_POLLS_REQUIRED) {
-          completedDuringMonitoring = true
-          break
-        }
-      } else {
-        stablePolls = 0
-        lastMsgCount = currentMsgCount
-      }
-    }
-
-    if (terminalStatus) {
-      const duration = formatDuration(startTime)
-      return `SUPERVISED TASK FAILED (${terminalStatus.status})
-
-Task was interrupted/failed while running in monitored background mode.
-${terminalStatus.error ? `Error: ${terminalStatus.error}` : ""}
-
-Duration: ${duration}
-Agent: ${agentToUse}${args.category ? ` (category: ${args.category})` : ""}
-Model: ${actualModel}
-
-The task session may contain partial results.
-
-<task_metadata>
-session_id: ${sessionID}
-</task_metadata>`
-    }
-
-    if (!completedDuringMonitoring) {
-      cleanupReason = "Monitored unstable background task exceeded timeout budget"
-      const duration = formatDuration(startTime)
-      const timeoutBudgetMs = syncPollTimeoutMs ?? DEFAULT_SYNC_POLL_TIMEOUT_MS
-      return `SUPERVISED TASK TIMED OUT
-
-Task did not reach a stable completion signal within the monitored timeout budget.
-Timeout budget: ${timeoutBudgetMs}ms
-
-Duration: ${duration}
-Agent: ${agentToUse}${args.category ? ` (category: ${args.category})` : ""}
-Model: ${actualModel}
-
-The task session may still contain partial results.
-
-<task_metadata>
-session_id: ${sessionID}
-</task_metadata>`
-    }
-
-    const messagesResult = await client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(messagesResult, [] as SessionMessage[], {
-      preferResponseOnMissingData: true,
-    })
-
-    const assistantMessages = messages
-      .filter((m) => m.info?.role === "assistant")
-      .sort((a, b) => (b.info?.time?.created ?? 0) - (a.info?.time?.created ?? 0))
-    const lastMessage = assistantMessages[0]
-
-    if (!lastMessage) {
-      return `No assistant response found (task ran in background mode).\n\nSession ID: ${sessionID}`
-    }
-
-    let textContent = ""
-    for (const msg of assistantMessages) {
-      const textParts = msg.parts?.filter((p) => p.type === "text" || p.type === "reasoning") ?? []
-      const content = textParts.map((p) => p.text ?? "").filter(Boolean).join("\n")
-      if (content) {
-        textContent = content
-        break
-      }
-    }
-    const duration = formatDuration(startTime)
-
-    return `SUPERVISED TASK COMPLETED SUCCESSFULLY
-
-IMPORTANT: This model (${actualModel}) is marked as unstable/experimental.
-Your run_in_background=false was automatically converted to background mode for reliability monitoring.
-
-Duration: ${duration}
-Agent: ${agentToUse}${args.category ? ` (category: ${args.category})` : ""}
-
-MONITORING INSTRUCTIONS:
-- The task was monitored and completed successfully
-- If you observe this agent behaving erratically in future calls, actively monitor its progress
-- Use background_cancel(task_id="...") to abort if the agent seems stuck or producing garbage output
-- Do NOT retry automatically if you see this message - the task already succeeded
-
----
-
-RESULT:
-
-${textContent || "(No text output)"}
-
-<task_metadata>
-session_id: ${sessionID}
-</task_metadata>`
-  } catch (error) {
-    if (!cleanupReason) {
-      cleanupReason = "exception"
-    }
-    return formatDetailedError(error, {
-      operation: "Launch monitored background task",
-      args,
-      agent: agentToUse,
-      category: args.category,
-    })
-  } finally {
-    if (cleanupReason) {
-      await cancelUnstableAgentTask(manager, launchedTaskID, cleanupReason)
-    }
-  }
-}