@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

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

@@ -1,242 +0,0 @@
-import type { DelegateTaskArgs } from "./types"
-import type { ExecutorContext } from "./executor-types"
-import type { DelegatedModelConfig } from "./types"
-import { isPlanFamily } from "./constants"
-import {
-  SUB_AGENT_CONFIG_KEY,
-  resolveCanonicalDelegateAgentKey,
-} from "./sub-agent"
-import { applyCategoryParams } from "./delegated-model-config"
-import { resolveEffectiveFallbackEntry } from "./fallback-entry-resolution"
-import { applyFallbackEntrySettings } from "./fallback-entry-settings"
-import {
-  type AgentInfo,
-  sanitizeSubagentType,
-  mergeWithClaudeCodeAgents,
-  findPrimaryAgentMatch,
-  findCallableAgentMatch,
-  listCallableAgentNames,
-} from "./subagent-discovery"
-import { normalizeModelFormat } from "../../shared/model-format-normalizer"
-import { AGENT_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
-import { normalizeFallbackModels, flattenToFallbackModelStrings } from "../../shared/model-resolver"
-import { buildFallbackChainFromModels } from "../../shared/fallback-chain-from-models"
-import { getAgentConfigKey, stripAgentListSortPrefix } from "../../shared/agent-display-names"
-import { normalizeSDKResponse } from "../../shared"
-import { log } from "../../shared/logger"
-import { getAvailableModelsForDelegateTask } from "./available-models"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { resolveModelForDelegateTask } from "./model-selection"
-import { fuzzyMatchModel } from "../../shared/model-availability"
-
-export async function resolveSubagentExecution(
-  args: DelegateTaskArgs,
-  executorCtx: ExecutorContext,
-  parentAgent: string | undefined,
-  categoryExamples: string
-): Promise<{ agentToUse: string; categoryModel: DelegatedModelConfig | undefined; fallbackChain?: FallbackEntry[]; error?: string }> {
-  const { client, agentOverrides, userCategories } = executorCtx
-
-  if (!args.subagent_type?.trim()) {
-    return { agentToUse: "", categoryModel: undefined, error: `Agent name cannot be empty.` }
-  }
-
-  const requestedAgentName = sanitizeSubagentType(args.subagent_type)
-  const requestedCanonicalAgentKey = resolveCanonicalDelegateAgentKey(requestedAgentName)
-
-  if (requestedCanonicalAgentKey === SUB_AGENT_CONFIG_KEY) {
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      error: `Cannot use subagent_type="${args.subagent_type}" directly. Use category parameter instead (e.g., ${categoryExamples}).
-
-SubAgent is spawned automatically when you specify a category. Pick the appropriate category for your task domain.`,
-    }
-  }
-
-  if (requestedCanonicalAgentKey === "agent-skills") {
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      error: `Cannot use subagent_type="${args.subagent_type}" directly. Agent Skills is a hidden system agent for skill registry and discovery, not a normal task executor.`,
-    }
-  }
-
-  const canonicalParentAgent = parentAgent ? resolveCanonicalDelegateAgentKey(parentAgent) : undefined
-  if (isPlanFamily(requestedCanonicalAgentKey) && isPlanFamily(canonicalParentAgent)) {
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-    error: `You are a plan-family agent (plan/strategist). You cannot delegate to other plan-family agents via task.
-
-Create the work plan directly - that's your job as the planning agent.`,
-    }
-  }
-
-  const ORCHESTRATOR_AGENTS: Set<string> = new Set(["bob"])
-  if (ORCHESTRATOR_AGENTS.has(requestedCanonicalAgentKey)) {
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      error: `Cannot delegate to orchestrator agent "${requestedCanonicalAgentKey}". Bob is the entry-point orchestrator and is not callable as a subagent. Use a specific subagent (researcher/strategist/coder/...) or a mode (quick/deep/...).`,
-    }
-  }
-
-  if (canonicalParentAgent && canonicalParentAgent === requestedCanonicalAgentKey) {
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      error: `Self-delegation not allowed: agent "${requestedCanonicalAgentKey}" cannot delegate to itself via task. Continue the work directly or use session_id=... to continue an existing subagent session.`,
-    }
-  }
-
-  let agentToUse = requestedAgentName
-  let categoryModel: DelegatedModelConfig | undefined
-  let fallbackChain: FallbackEntry[] | undefined = undefined
-
-  try {
-    const agentsResult = await client.app.agents()
-    const agents = normalizeSDKResponse(agentsResult, [] as AgentInfo[], {
-      preferResponseOnMissingData: true,
-    })
-
-    const mergedAgents = mergeWithClaudeCodeAgents(agents, executorCtx.directory)
-
-    const matchedPrimaryAgent = findPrimaryAgentMatch(mergedAgents, agentToUse)
-    if (matchedPrimaryAgent) {
-      return {
-        agentToUse: "",
-        categoryModel: undefined,
-        error: `Cannot delegate to primary agent "${stripAgentListSortPrefix(matchedPrimaryAgent.name)}" via task. Select that agent directly instead.`,
-      }
-    }
-
-    const matchedAgent = findCallableAgentMatch(mergedAgents, agentToUse)
-    if (!matchedAgent) {
-      return {
-        agentToUse: "",
-        categoryModel: undefined,
-        error: `Unknown agent: "${requestedAgentName}". Available agents: ${listCallableAgentNames(mergedAgents)}`,
-      }
-    }
-
-    agentToUse = stripAgentListSortPrefix(matchedAgent.name)
-
-    const matchedAgentConfigKey = getAgentConfigKey(agentToUse).toLowerCase()
-    const canonicalAgentConfigKey = resolveCanonicalDelegateAgentKey(agentToUse).toLowerCase()
-    const agentConfigLookupKeys = Array.from(new Set([
-      canonicalAgentConfigKey,
-      matchedAgentConfigKey,
-    ]))
-
-    const agentOverride = agentOverrides
-      ? Object.entries(agentOverrides).find(([key]) => agentConfigLookupKeys.includes(key.toLowerCase()))?.[1]
-      : undefined
-    const agentRequirement = agentConfigLookupKeys
-      .map((key) => AGENT_MODEL_REQUIREMENTS[key])
-      .find((requirement): requirement is NonNullable<typeof requirement> => requirement !== undefined)
-    const agentCategoryConfig = agentOverride?.category
-      ? userCategories?.[agentOverride.category]
-      : undefined
-    const agentCategoryModel = agentCategoryConfig?.model
-    const normalizedAgentFallbackModels = normalizeFallbackModels(
-      agentOverride?.fallback_models
-      ?? agentCategoryConfig?.fallback_models
-    )
-
-    const availableModels = await getAvailableModelsForDelegateTask(client)
-
-    if (agentOverride?.model || agentCategoryModel || agentRequirement || matchedAgent.model) {
-
-      const normalizedMatchedModel = matchedAgent.model
-        ? normalizeModelFormat(matchedAgent.model)
-        : undefined
-      const matchedAgentModelStr = normalizedMatchedModel
-        ? `${normalizedMatchedModel.providerID}/${normalizedMatchedModel.modelID}`
-        : undefined
-
-      const resolution = resolveModelForDelegateTask({
-        userModel: agentOverride?.model ?? agentCategoryModel,
-        userFallbackModels: flattenToFallbackModelStrings(normalizedAgentFallbackModels),
-        categoryDefaultModel: matchedAgentModelStr,
-        fallbackChain: agentRequirement?.fallbackChain,
-        availableModels,
-        systemDefaultModel: undefined,
-      })
-
-      const resolutionSkipped = resolution && 'skipped' in resolution
-
-      if (resolution && !resolutionSkipped) {
-        const normalized = normalizeModelFormat(resolution.model)
-        if (normalized) {
-          const variantToUse = agentOverride?.variant ?? resolution.variant ?? agentCategoryConfig?.variant
-          const resolvedModel = variantToUse ? { ...normalized, variant: variantToUse } : normalized
-          categoryModel = applyCategoryParams(resolvedModel, agentCategoryConfig)
-        }
-      } else if (resolutionSkipped && (agentOverride?.model ?? agentCategoryModel)) {
-        const normalized = normalizeModelFormat((agentOverride?.model ?? agentCategoryModel)!)
-        if (normalized) {
-          const variantToUse = agentOverride?.variant ?? agentCategoryConfig?.variant
-          const resolvedModel = variantToUse ? { ...normalized, variant: variantToUse } : normalized
-          categoryModel = applyCategoryParams(resolvedModel, agentCategoryConfig)
-          log("[delegate-task] Cold cache: using explicit user override for subagent", {
-            agent: agentToUse,
-            model: agentOverride?.model ?? agentCategoryModel,
-          })
-        }
-      }
-
-      const defaultProviderID = categoryModel?.providerID
-        ?? normalizedMatchedModel?.providerID
-        ?? "opencode"
-      const configuredFallbackChain = buildFallbackChainFromModels(
-        normalizedAgentFallbackModels,
-        defaultProviderID,
-      )
-      fallbackChain = configuredFallbackChain ?? (resolutionSkipped ? undefined : agentRequirement?.fallbackChain)
-      const effectiveEntry = resolveEffectiveFallbackEntry({
-        categoryModel,
-        configuredFallbackChain,
-        resolution,
-      })
-
-      if (categoryModel && effectiveEntry) {
-        categoryModel = applyFallbackEntrySettings({
-          categoryModel,
-          effectiveEntry,
-          variantOverride: agentOverride?.variant,
-        })
-      }
-    }
-
-    if (!categoryModel && matchedAgent.model) {
-      const normalizedMatchedModel = normalizeModelFormat(matchedAgent.model)
-      if (normalizedMatchedModel) {
-        const fullModel = `${normalizedMatchedModel.providerID}/${normalizedMatchedModel.modelID}`
-        if (availableModels.size === 0 || fuzzyMatchModel(fullModel, availableModels, [normalizedMatchedModel.providerID])) {
-          categoryModel = normalizedMatchedModel
-        } else {
-          log("[delegate-task] Skipping unavailable agent default model", {
-            agent: agentToUse,
-            model: fullModel,
-          })
-        }
-      }
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    log("[delegate-task] Failed to resolve subagent execution", {
-      requestedAgent: agentToUse,
-      parentAgent,
-      error: errorMessage,
-    })
-
-    return {
-      agentToUse: "",
-      categoryModel: undefined,
-      error: `Failed to delegate to agent "${agentToUse}": ${errorMessage}`,
-    }
-  }
-
-  return { agentToUse, categoryModel, fallbackChain }
-}

package/src/tools/delegate-task/sync-continuation-deps.ts

@@ -1,9 +0,0 @@
-import { pollSyncSession } from "./sync-session-poller"
-import { fetchSyncResult } from "./sync-result-fetcher"
-
-export const syncContinuationDeps = {
-  pollSyncSession,
-  fetchSyncResult,
-}
-
-export type SyncContinuationDeps = typeof syncContinuationDeps

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

@@ -1,149 +0,0 @@
-import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types"
-import type { ExecutorContext, SessionMessage } from "./executor-types"
-import { isPlanFamily } from "./constants"
-import { storeToolMetadata } from "../../features/tool-metadata-store"
-import { resolveCallID } from "./resolve-call-id"
-import { getTaskToastManager } from "../../features/task-toast-manager"
-import { getAgentToolRestrictions } from "../../shared/agent-tool-restrictions"
-import { getMessageDir } from "../../shared"
-import { promptWithModelSuggestionRetry } from "../../shared/model-suggestion-retry"
-import { findNearestMessageWithFields } from "../../features/hook-message-injector"
-import { formatDuration } from "./time-formatter"
-import { syncContinuationDeps, type SyncContinuationDeps } from "./sync-continuation-deps"
-import { setSessionTools } from "../../shared/session-tools-store"
-import { normalizeSDKResponse } from "../../shared"
-import { buildTaskPrompt } from "./prompt-builder"
-
-export async function executeSyncContinuation(
-  args: DelegateTaskArgs,
-  ctx: ToolContextWithMetadata,
-  executorCtx: ExecutorContext,
-  deps: SyncContinuationDeps = syncContinuationDeps
-): Promise<string> {
-  const { client, syncPollTimeoutMs, bobAgentConfig } = executorCtx
-  const toastManager = getTaskToastManager()
-  const taskId = `resume_sync_${args.session_id!.slice(0, 8)}`
-  const startTime = new Date()
-
-  if (toastManager) {
-    toastManager.addTask({
-      id: taskId,
-      description: args.description,
-      agent: "continue",
-      isBackground: false,
-    })
-  }
-
-  let syncContMeta: { title: string; metadata: Record<string, unknown> } | undefined
-
-  let resumeAgent: string | undefined
-  let resumeModel: { providerID: string; modelID: string } | undefined
-  let resumeVariant: string | undefined
-  let anchorMessageCount: number | undefined
-
-  try {
-    try {
-      const messagesResp = await client.session.messages({ path: { id: args.session_id! } })
-      const messages = normalizeSDKResponse(messagesResp, [] as SessionMessage[])
-      anchorMessageCount = messages.length
-      for (let i = messages.length - 1; i >= 0; i--) {
-        const info = messages[i].info
-        if (info?.agent || info?.model || (info?.modelID && info?.providerID)) {
-          resumeAgent = info.agent
-          resumeModel = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
-          resumeVariant = info.variant
-          break
-        }
-      }
-    } catch {
-      const resumeMessageDir = getMessageDir(args.session_id!)
-      const resumeMessage = resumeMessageDir ? findNearestMessageWithFields(resumeMessageDir) : null
-      resumeAgent = resumeMessage?.agent
-      resumeModel = resumeMessage?.model?.providerID && resumeMessage?.model?.modelID
-        ? { providerID: resumeMessage.model.providerID, modelID: resumeMessage.model.modelID }
-        : undefined
-      resumeVariant = resumeMessage?.model?.variant
-    }
-
-    syncContMeta = {
-      title: `Continue: ${args.description}`,
-      metadata: {
-        prompt: args.prompt,
-        load_skills: args.load_skills,
-        description: args.description,
-        run_in_background: args.run_in_background,
-        sessionId: args.session_id,
-        sync: true,
-        command: args.command,
-        model: resumeModel,
-      },
-    }
-    await ctx.metadata?.(syncContMeta)
-    const callID = resolveCallID(ctx)
-    if (callID) {
-      storeToolMetadata(ctx.sessionID, callID, syncContMeta)
-    }
-
-    const allowTask = isPlanFamily(resumeAgent)
-    const tddEnabled = bobAgentConfig?.tdd
-    const effectivePrompt = buildTaskPrompt(args.prompt, resumeAgent, tddEnabled)
-    const tools = {
-      task: allowTask,
-      call_omo_agent: true,
-      question: false,
-      ...(resumeAgent ? getAgentToolRestrictions(resumeAgent) : {}),
-    }
-    setSessionTools(args.session_id!, tools)
-
-    await promptWithModelSuggestionRetry(client, {
-      path: { id: args.session_id! },
-      body: {
-        ...(resumeAgent !== undefined ? { agent: resumeAgent } : {}),
-        ...(resumeModel !== undefined ? { model: resumeModel } : {}),
-        ...(resumeVariant !== undefined ? { variant: resumeVariant } : {}),
-        tools,
-        parts: [{ type: "text", text: effectivePrompt }],
-      },
-    })
-   } catch (promptError) {
-     if (toastManager) {
-       toastManager.removeTask(taskId)
-     }
-     const errorMessage = promptError instanceof Error ? promptError.message : String(promptError)
-     return `Failed to send continuation prompt: ${errorMessage}\n\nSession ID: ${args.session_id}`
-   }
-
-    try {
-      const pollError = await deps.pollSyncSession(ctx, client, {
-        sessionID: args.session_id!,
-        agentToUse: resumeAgent ?? "continue",
-        toastManager,
-        taskId,
-        anchorMessageCount,
-      }, syncPollTimeoutMs)
-      if (pollError) {
-        return pollError
-      }
-
-      const result = await deps.fetchSyncResult(client, args.session_id!, anchorMessageCount)
-      if (!result.ok) {
-        return result.error
-      }
-
-     const duration = formatDuration(startTime)
-
-     return `Task continued and completed in ${duration}.
-
----
-
-${result.textContent || "(No text output)"}
-
-<task_metadata>
-session_id: ${args.session_id}
-${resumeAgent ? `subagent: ${resumeAgent}\n` : ""}</task_metadata>`
-   } finally {
-     if (toastManager) {
-       toastManager.removeTask(taskId)
-     }
-   }
-}

package/src/tools/delegate-task/sync-prompt-sender.ts

@@ -1,137 +0,0 @@
-import type { DelegateTaskArgs, OpencodeClient, DelegatedModelConfig } from "./types"
-import type { BobAgentConfig } from "../../config/schema"
-import { isPlanFamily } from "./constants"
-import { buildTaskPrompt } from "./prompt-builder"
-import {
-  promptSyncWithModelSuggestionRetry,
-  promptWithModelSuggestionRetry,
-} from "../../shared/model-suggestion-retry"
-import { formatDetailedError } from "./error-formatting"
-import { getAgentToolRestrictions } from "../../shared/agent-tool-restrictions"
-import { stripInvisibleAgentCharacters } from "../../shared/agent-display-names"
-import { applySessionPromptParams } from "../../shared/session-prompt-params-helpers"
-import { setSessionTools } from "../../shared/session-tools-store"
-import { createInternalAgentTextPart } from "../../shared/internal-initiator-marker"
-
-type SendSyncPromptDeps = {
-  promptWithModelSuggestionRetry: typeof promptWithModelSuggestionRetry
-  promptSyncWithModelSuggestionRetry: typeof promptSyncWithModelSuggestionRetry
-}
-
-const sendSyncPromptDeps: SendSyncPromptDeps = {
-  promptWithModelSuggestionRetry,
-  promptSyncWithModelSuggestionRetry,
-}
-
-function buildPromptGenerationParams(model: DelegatedModelConfig | undefined): Record<string, unknown> {
-  if (!model) {
-    return {}
-  }
-
-  const promptOptions: Record<string, unknown> = {
-    ...(model.reasoningEffort ? { reasoningEffort: model.reasoningEffort } : {}),
-    ...(model.thinking ? { thinking: model.thinking } : {}),
-  }
-
-  return {
-    ...(model.temperature !== undefined ? { temperature: model.temperature } : {}),
-    ...(model.top_p !== undefined ? { topP: model.top_p } : {}),
-    ...(model.maxTokens !== undefined ? { maxOutputTokens: model.maxTokens } : {}),
-    ...(Object.keys(promptOptions).length > 0 ? { options: promptOptions } : {}),
-  }
-}
-
-function isStrategistAgent(agentToUse: string): boolean {
-  const normalizedAgent = stripInvisibleAgentCharacters(agentToUse).toLowerCase()
-  return normalizedAgent === "strategist"
-}
-
-function isUnexpectedEofError(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error)
-  const lowered = message.toLowerCase()
-  return lowered.includes("unexpected eof") || lowered.includes("json parse error")
-}
-
-export async function sendSyncPrompt(
-  client: OpencodeClient,
-  input: {
-    sessionID: string
-    agentToUse: string
-    args: DelegateTaskArgs
-    systemContent: string | undefined
-    categoryModel: DelegatedModelConfig | undefined
-    toastManager: { removeTask: (id: string) => void } | null | undefined
-    taskId: string | undefined
-    bobAgentConfig?: BobAgentConfig
-  },
-  deps: SendSyncPromptDeps = sendSyncPromptDeps
-): Promise<string | null> {
-  const allowTask = isPlanFamily(input.agentToUse)
-  const tddEnabled = input.bobAgentConfig?.tdd
-  const effectivePrompt = buildTaskPrompt(input.args.prompt, input.agentToUse, tddEnabled)
-  const tools = {
-    task: allowTask,
-    call_omo_agent: true,
-    question: false,
-    ...getAgentToolRestrictions(input.agentToUse),
-  }
-  setSessionTools(input.sessionID, tools)
-
-  applySessionPromptParams(input.sessionID, input.categoryModel)
-
-  const promptArgs = {
-    path: { id: input.sessionID },
-    body: {
-      agent: stripInvisibleAgentCharacters(input.agentToUse),
-      system: input.systemContent,
-      tools,
-      parts: [createInternalAgentTextPart(effectivePrompt)],
-      ...(input.categoryModel
-        ? {
-            model: {
-              providerID: input.categoryModel.providerID,
-              modelID: input.categoryModel.modelID,
-            },
-          }
-        : {}),
-      ...(input.categoryModel?.variant ? { variant: input.categoryModel.variant } : {}),
-      ...buildPromptGenerationParams(input.categoryModel),
-    },
-  }
-
-  try {
-    await deps.promptWithModelSuggestionRetry(client, promptArgs)
-  } catch (promptError) {
-    if (isStrategistAgent(input.agentToUse) && isUnexpectedEofError(promptError)) {
-      try {
-        await deps.promptSyncWithModelSuggestionRetry(client, promptArgs)
-        return null
-      } catch (strategistRetryError) {
-        promptError = strategistRetryError
-      }
-    }
-
-    if (input.toastManager && input.taskId !== undefined) {
-      input.toastManager.removeTask(input.taskId)
-    }
-    const errorMessage = promptError instanceof Error ? promptError.message : String(promptError)
-    if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
-      return formatDetailedError(new Error(`Agent "${input.agentToUse}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`), {
-        operation: "Send prompt to agent",
-        args: input.args,
-        sessionID: input.sessionID,
-        agent: input.agentToUse,
-        category: input.args.category,
-      })
-    }
-    return formatDetailedError(promptError, {
-      operation: "Send prompt",
-      args: input.args,
-      sessionID: input.sessionID,
-      agent: input.agentToUse,
-      category: input.args.category,
-    })
-  }
-
-  return null
-}

package/src/tools/delegate-task/sync-result-fetcher.ts

@@ -1,60 +0,0 @@
-import type { OpencodeClient } from "./types"
-import type { SessionMessage } from "./executor-types"
-import { normalizeSDKResponse } from "../../shared"
-
-export async function fetchSyncResult(
-  client: OpencodeClient,
-  sessionID: string,
-  anchorMessageCount?: number
-): Promise<{ ok: true; textContent: string } | { ok: false; error: string }> {
-  const messagesResult = await client.session.messages({
-    path: { id: sessionID },
-  })
-
-  if ((messagesResult as { error?: unknown }).error) {
-    return { ok: false, error: `Error fetching result: ${(messagesResult as { error: unknown }).error}\n\nSession ID: ${sessionID}` }
-  }
-
-  const messages = normalizeSDKResponse(messagesResult, [] as SessionMessage[], {
-    preferResponseOnMissingData: true,
-  })
-
-  const messagesAfterAnchor = anchorMessageCount !== undefined ? messages.slice(anchorMessageCount) : messages
-
-  if (anchorMessageCount !== undefined && messagesAfterAnchor.length === 0) {
-    return {
-      ok: false,
-      error: `Session completed but no new response was generated. The model may have failed silently.\n\nSession ID: ${sessionID}`,
-    }
-  }
-
-  const assistantMessages = messagesAfterAnchor
-    .filter((m) => m.info?.role === "assistant")
-    .sort((a, b) => (b.info?.time?.created ?? 0) - (a.info?.time?.created ?? 0))
-  const lastMessage = assistantMessages[0]
-
-  if (anchorMessageCount !== undefined && !lastMessage) {
-    return {
-      ok: false,
-      error: `Session completed but no new response was generated. The model may have failed silently.\n\nSession ID: ${sessionID}`,
-    }
-  }
-
-  if (!lastMessage) {
-    return { ok: false, error: `No assistant response found.\n\nSession ID: ${sessionID}` }
-  }
-
-  // Search assistant messages (newest first) for one with text/reasoning content.
-  // The last assistant message may only contain tool calls with no text.
-  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
-    }
-  }
-
-  return { ok: true, textContent }
-}

package/src/tools/delegate-task/sync-session-creator.ts

@@ -1,29 +0,0 @@
-import type { OpencodeClient } from "./types"
-import { QUESTION_DENIED_SESSION_PERMISSION } from "../../shared/question-denied-session-permission"
-
-export async function createSyncSession(
-  client: OpencodeClient,
-  input: { parentSessionID: string; agentToUse: string; description: string; defaultDirectory: string }
-): Promise<{ ok: true; sessionID: string; parentDirectory: string } | { ok: false; error: string }> {
-  const parentSession = client.session.get
-    ? await client.session.get({ path: { id: input.parentSessionID } }).catch(() => null)
-    : null
-  const parentDirectory = parentSession?.data?.directory ?? input.defaultDirectory
-
-  const createResult = await client.session.create({
-    body: {
-      parentID: input.parentSessionID,
-      title: `${input.description} (@${input.agentToUse} subagent)`,
-      permission: QUESTION_DENIED_SESSION_PERMISSION,
-    } as Record<string, unknown>,
-    query: {
-      directory: parentDirectory,
-    },
-  })
-
-  if (createResult.error) {
-    return { ok: false, error: `Failed to create session: ${createResult.error}` }
-  }
-
-  return { ok: true, sessionID: createResult.data.id, parentDirectory }
-}