ummaya 0.2.4 → 0.2.5

package/tui/src/tools/AgentTool/resultMapping.ts

@@ -0,0 +1,116 @@
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
+import { BASH_TOOL_NAME } from '../BashTool/toolName.js'
+import { FILE_READ_TOOL_NAME } from '../FileReadTool/prompt.js'
+import { formatSourceVerificationForModel } from '../WebFetchTool/sourceVerification.js'
+import { ONE_SHOT_BUILTIN_AGENT_TYPES } from './constants.js'
+import type { AgentToolOutput } from './schemas.js'
+
+function assertNever(value: never): never {
+  throw new Error(`Unexpected agent tool result status: ${JSON.stringify(value)}`)
+}
+
+export function mapAgentToolResultToToolResultBlockParam(
+  data: AgentToolOutput,
+  toolUseID: string,
+): ToolResultBlockParam {
+  switch (data.status) {
+    case 'teammate_spawned':
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: [
+          {
+            type: 'text',
+            text: `Spawned successfully.
+agent_id: ${data.teammate_id}
+name: ${data.name}
+team_name: ${data.team_name}
+evidence_join_key: ${data.evidenceJoinKey}
+parent_tool_use_id: ${data.parentToolUseId}
+resume_token: ${data.resumeToken}
+permission_flow: ${data.permissionFlow}
+The agent is now running and will receive instructions via mailbox.`,
+          },
+        ],
+      }
+    case 'remote_launched':
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: [
+          {
+            type: 'text',
+            text: `Remote agent launched in CCR.\ntaskId: ${data.taskId}\nsession_url: ${data.sessionUrl}\noutput_file: ${data.outputFile}\nThe agent is running remotely. You will be notified automatically when it completes.\nBriefly tell the user what you launched and end your response.`,
+          },
+        ],
+      }
+    case 'async_launched':
+      return mapAsyncAgentResult(data, toolUseID)
+    case 'completed':
+      return mapCompletedAgentResult(data, toolUseID)
+    default:
+      return assertNever(data)
+  }
+}
+
+function mapAsyncAgentResult(
+  data: Extract<AgentToolOutput, { readonly status: 'async_launched' }>,
+  toolUseID: string,
+): ToolResultBlockParam {
+  const supportMetadata = `evidence_join_key: ${data.evidenceJoinKey}\nparent_tool_use_id: ${data.parentToolUseId}\nresume_token: ${data.resumeToken}\npermission_flow: ${data.permissionFlow}`
+  const prefix = `Async agent launched successfully.\nagentId: ${data.agentId} (internal ID - do not mention to user. Use SendMessage with to: '${data.agentId}' to continue this agent.)\n${supportMetadata}\nThe agent is working in the background. You will be notified automatically when it completes.`
+  const instructions = data.canReadOutputFile
+    ? `Do not duplicate this agent's work — avoid working with the same files or topics it is using. Work on non-overlapping tasks, or briefly tell the user what you launched and end your response.\noutput_file: ${data.outputFile}\nIf asked, you can check progress before completion by using ${FILE_READ_TOOL_NAME} or ${BASH_TOOL_NAME} tail on the output file.`
+    : `Briefly tell the user what you launched and end your response. Do not generate any other text — agent results will arrive in a subsequent message.`
+  return {
+    tool_use_id: toolUseID,
+    type: 'tool_result',
+    content: [{ type: 'text', text: `${prefix}\n${instructions}` }],
+  }
+}
+
+function mapCompletedAgentResult(
+  data: Extract<AgentToolOutput, { readonly status: 'completed' }>,
+  toolUseID: string,
+): ToolResultBlockParam {
+  const worktreeInfoText = data.worktreePath
+    ? `\nworktreePath: ${data.worktreePath}\nworktreeBranch: ${data.worktreeBranch}`
+    : ''
+  const sourceVerificationText = formatSourceVerificationForModel(
+    data.sourceVerification,
+  )
+  const sourceVerificationSuffix = sourceVerificationText
+    ? `\n${sourceVerificationText}`
+    : ''
+  const contentOrMarker =
+    data.content.length > 0
+      ? data.content
+      : [{ type: 'text' as const, text: '(Subagent completed but returned no output.)' }]
+
+  if (
+    data.agentType &&
+    ONE_SHOT_BUILTIN_AGENT_TYPES.has(data.agentType) &&
+    !worktreeInfoText
+  ) {
+    return { tool_use_id: toolUseID, type: 'tool_result', content: contentOrMarker }
+  }
+
+  return {
+    tool_use_id: toolUseID,
+    type: 'tool_result',
+    content: [
+      ...contentOrMarker,
+      {
+        type: 'text',
+        text: `agentId: ${data.agentId} (use SendMessage with to: '${data.agentId}' to continue this agent)${worktreeInfoText}
+evidence_join_key: ${data.evidenceJoinKey}
+parent_tool_use_id: ${data.parentToolUseId}
+resume_token: ${data.resumeToken}
+permission_flow: ${data.permissionFlow}
+<usage>total_tokens: ${data.totalTokens}
+tool_uses: ${data.totalToolUseCount}
+duration_ms: ${data.totalDurationMs}</usage>${sourceVerificationSuffix}`,
+      },
+    ],
+  }
+}

package/tui/src/tools/AgentTool/resumeAgent.ts

@@ -1,6 +1,4 @@
-import { promises as fsp } from 'fs'
 import { getSdkAgentProgressSummariesEnabled } from '../../bootstrap/state.js'
-import { getSystemPrompt } from '../../constants/prompts.js'
 import { isCoordinatorMode } from '../../coordinator/coordinatorMode.js'
 import type { CanUseToolFn } from '../../hooks/useCanUseTool.js'
 import type { ToolUseContext } from '../../Tool.js'
@@ -9,29 +7,21 @@ import { assembleToolPool } from '../../tools.js'
 import { asAgentId } from '../../types/ids.js'
 import { runWithAgentContext } from '../../utils/agentContext.js'
 import { runWithCwdOverride } from '../../utils/cwd.js'
-import { logForDebugging } from '../../utils/debug.js'
-import {
-  createUserMessage,
-  filterOrphanedThinkingOnlyMessages,
-  filterUnresolvedToolUses,
-  filterWhitespaceOnlyAssistantMessages,
-} from '../../utils/messages.js'
+import { createUserMessage } from '../../utils/messages.js'
 import { getAgentModel } from '../../utils/model/agent.js'
 import { getQuerySourceForAgent } from '../../utils/promptCategory.js'
-import {
-  getAgentTranscript,
-  readAgentMetadata,
-} from '../../utils/sessionStorage.js'
-import { buildEffectiveSystemPrompt } from '../../utils/systemPrompt.js'
-import type { SystemPrompt } from '../../utils/systemPromptType.js'
 import { getTaskOutputPath } from '../../utils/task/diskOutput.js'
 import { getParentSessionId } from '../../utils/teammate.js'
-import { reconstructForSubagentResume } from '../../utils/toolResultStorage.js'
-import { runAsyncAgentLifecycle } from './agentToolUtils.js'
-import { GENERAL_PURPOSE_AGENT } from './built-in/generalPurposeAgent.js'
+import { runAsyncAgentLifecycle } from './asyncAgentLifecycle.js'
 import { FORK_AGENT, isForkSubagentEnabled } from './forkSubagent.js'
-import type { AgentDefinition } from './loadAgentsDir.js'
 import { isBuiltInAgent } from './loadAgentsDir.js'
+import { buildCoordinatorWorkerPermissionContext } from './orchestrationSupport.js'
+import {
+  buildForkParentSystemPrompt,
+  loadResumeTranscriptState,
+  resolveResumedWorktreePath,
+  selectResumeAgentDefinition,
+} from './resumeAgentHelpers.js'
 import { runAgent } from './runAgent.js'
 
 export type ResumeAgentResult = {
@@ -39,6 +29,7 @@ export type ResumeAgentResult = {
   description: string
   outputFile: string
 }
+
 export async function resumeAgentBackground({
   agentId,
   prompt,
@@ -60,92 +51,25 @@ export async function resumeAgentBackground({
     toolUseContext.setAppStateForTasks ?? toolUseContext.setAppState
   const permissionMode = appState.toolPermissionContext.mode
 
-  const [transcript, meta] = await Promise.all([
-    getAgentTranscript(asAgentId(agentId)),
-    readAgentMetadata(asAgentId(agentId)),
-  ])
-  if (!transcript) {
-    throw new Error(`No transcript found for agent ID: ${agentId}`)
-  }
-  const resumedMessages = filterWhitespaceOnlyAssistantMessages(
-    filterOrphanedThinkingOnlyMessages(
-      filterUnresolvedToolUses(transcript.messages),
-    ),
-  )
-  const resumedReplacementState = reconstructForSubagentResume(
-    toolUseContext.contentReplacementState,
-    resumedMessages,
-    transcript.contentReplacements,
-  )
-  // Best-effort: if the original worktree was removed externally, fall back
-  // to parent cwd rather than crashing on chdir later.
-  const resumedWorktreePath = meta?.worktreePath
-    ? await fsp.stat(meta.worktreePath).then(
-        s => (s.isDirectory() ? meta.worktreePath : undefined),
-        () => {
-          logForDebugging(
-            `Resumed worktree ${meta.worktreePath} no longer exists; falling back to parent cwd`,
-          )
-          return undefined
-        },
-      )
-    : undefined
-  if (resumedWorktreePath) {
-    // Bump mtime so stale-worktree cleanup doesn't delete a just-resumed worktree (#22355)
-    const now = new Date()
-    await fsp.utimes(resumedWorktreePath, now, now)
-  }
-
-  // Skip filterDeniedAgents re-gating — original spawn already passed permission checks
-  let selectedAgent: AgentDefinition
-  let isResumedFork = false
-  if (meta?.agentType === FORK_AGENT.agentType) {
-    selectedAgent = FORK_AGENT
-    isResumedFork = true
-  } else if (meta?.agentType) {
-    const found = toolUseContext.options.agentDefinitions.activeAgents.find(
-      a => a.agentType === meta.agentType,
+  const resumeAgentId = asAgentId(agentId)
+  const { resumedMessages, resumedReplacementState, meta } =
+    await loadResumeTranscriptState(
+      resumeAgentId,
+      toolUseContext.contentReplacementState,
     )
-    selectedAgent = found ?? GENERAL_PURPOSE_AGENT
-  } else {
-    selectedAgent = GENERAL_PURPOSE_AGENT
-  }
+  const resumedWorktreePath = await resolveResumedWorktreePath(
+    meta?.worktreePath,
+  )
+  const { selectedAgent, isResumedFork } = selectResumeAgentDefinition({
+    agentType: meta?.agentType,
+    activeAgents: toolUseContext.options.agentDefinitions.activeAgents,
+  })
 
   const uiDescription = meta?.description ?? '(resumed)'
 
-  let forkParentSystemPrompt: SystemPrompt | undefined
-  if (isResumedFork) {
-    if (toolUseContext.renderedSystemPrompt) {
-      forkParentSystemPrompt = toolUseContext.renderedSystemPrompt
-    } else {
-      const mainThreadAgentDefinition = appState.agent
-        ? appState.agentDefinitions.activeAgents.find(
-            a => a.agentType === appState.agent,
-          )
-        : undefined
-      const additionalWorkingDirectories = Array.from(
-        appState.toolPermissionContext.additionalWorkingDirectories.keys(),
-      )
-      const defaultSystemPrompt = await getSystemPrompt(
-        toolUseContext.options.tools,
-        toolUseContext.options.mainLoopModel,
-        additionalWorkingDirectories,
-        toolUseContext.options.mcpClients,
-      )
-      forkParentSystemPrompt = buildEffectiveSystemPrompt({
-        mainThreadAgentDefinition,
-        toolUseContext,
-        customSystemPrompt: toolUseContext.options.customSystemPrompt,
-        defaultSystemPrompt,
-        appendSystemPrompt: toolUseContext.options.appendSystemPrompt,
-      })
-    }
-    if (!forkParentSystemPrompt) {
-      throw new Error(
-        'Cannot resume fork agent: unable to reconstruct parent system prompt',
-      )
-    }
-  }
+  const forkParentSystemPrompt = isResumedFork
+    ? await buildForkParentSystemPrompt({ toolUseContext, appState })
+    : undefined
 
   // Resolve model for analytics metadata (runAgent resolves its own internally)
   const resolvedAgentModel = getAgentModel(
@@ -155,10 +79,10 @@ export async function resumeAgentBackground({
     permissionMode,
   )
 
-  const workerPermissionContext = {
-    ...appState.toolPermissionContext,
-    mode: selectedAgent.permissionMode ?? 'acceptEdits',
-  }
+  const workerPermissionContext = buildCoordinatorWorkerPermissionContext(
+    appState.toolPermissionContext,
+    selectedAgent.permissionMode,
+  )
   const workerTools = isResumedFork
     ? toolUseContext.options.tools
     : assembleToolPool(workerPermissionContext, appState.mcp.tools)
@@ -211,6 +135,7 @@ export async function resumeAgentBackground({
     startTime,
     agentType: selectedAgent.agentType,
     isAsync: true,
+    parentToolUseId: toolUseContext.toolUseId,
   }
 
   const asyncAgentContext = {
@@ -227,18 +152,25 @@ export async function resumeAgentBackground({
   const wrapWithCwd = <T>(fn: () => T): T =>
     resumedWorktreePath ? runWithCwdOverride(resumedWorktreePath, fn) : fn()
 
+  const abortController = agentBackgroundTask.abortController
+  if (!abortController) {
+    throw new Error(
+      `Cannot resume agent ${agentBackgroundTask.agentId}: missing abort controller`,
+    )
+  }
+
   void runWithAgentContext(asyncAgentContext, () =>
     wrapWithCwd(() =>
       runAsyncAgentLifecycle({
         taskId: agentBackgroundTask.agentId,
-        abortController: agentBackgroundTask.abortController!,
+        abortController,
         makeStream: onCacheSafeParams =>
           runAgent({
             ...runAgentParams,
             override: {
               ...runAgentParams.override,
               agentId: asAgentId(agentBackgroundTask.agentId),
-              abortController: agentBackgroundTask.abortController!,
+              abortController,
             },
             onCacheSafeParams,
           }),

package/tui/src/tools/AgentTool/resumeAgentHelpers.ts

@@ -0,0 +1,140 @@
+import { promises as fsp } from 'fs'
+import { getSystemPrompt } from '../../constants/prompts.js'
+import type { AppState } from '../../state/AppState.js'
+import type { ToolUseContext } from '../../Tool.js'
+import type { AgentId } from '../../types/ids.js'
+import type { Message as MessageType } from '../../types/message.js'
+import { logForDebugging } from '../../utils/debug.js'
+import {
+  filterOrphanedThinkingOnlyMessages,
+  filterUnresolvedToolUses,
+  filterWhitespaceOnlyAssistantMessages,
+} from '../../utils/messages.js'
+import {
+  getAgentTranscript,
+  readAgentMetadata,
+  type AgentMetadata,
+} from '../../utils/sessionStorage.js'
+import { buildEffectiveSystemPrompt } from '../../utils/systemPrompt.js'
+import type { SystemPrompt } from '../../utils/systemPromptType.js'
+import type { ContentReplacementState } from '../../utils/toolResultStorage.js'
+import { reconstructForSubagentResume } from '../../utils/toolResultStorage.js'
+import { GENERAL_PURPOSE_AGENT } from './built-in/generalPurposeAgent.js'
+import { FORK_AGENT } from './forkSubagent.js'
+import type { AgentDefinition } from './loadAgentsDir.js'
+
+export type ResumeTranscriptState = {
+  readonly resumedMessages: MessageType[]
+  readonly resumedReplacementState: ContentReplacementState | undefined
+  readonly meta: AgentMetadata | null
+}
+
+export type ResumeAgentSelection = {
+  readonly selectedAgent: AgentDefinition
+  readonly isResumedFork: boolean
+}
+
+export async function loadResumeTranscriptState(
+  agentId: AgentId,
+  parentReplacementState: ContentReplacementState | undefined,
+): Promise<ResumeTranscriptState> {
+  const [transcript, meta] = await Promise.all([
+    getAgentTranscript(agentId),
+    readAgentMetadata(agentId),
+  ])
+  if (!transcript) {
+    throw new Error(`No transcript found for agent ID: ${agentId}`)
+  }
+
+  const resumedMessages = filterWhitespaceOnlyAssistantMessages(
+    filterOrphanedThinkingOnlyMessages(
+      filterUnresolvedToolUses(transcript.messages),
+    ),
+  )
+  const resumedReplacementState = reconstructForSubagentResume(
+    parentReplacementState,
+    resumedMessages,
+    transcript.contentReplacements,
+  )
+  return { resumedMessages, resumedReplacementState, meta }
+}
+
+export async function resolveResumedWorktreePath(
+  worktreePath: string | undefined,
+): Promise<string | undefined> {
+  if (!worktreePath) return undefined
+  const stat = await fsp.stat(worktreePath).then(
+    value => value,
+    () => undefined,
+  )
+  if (!stat?.isDirectory()) {
+    logForDebugging(
+      `Resumed worktree ${worktreePath} no longer exists; falling back to parent cwd`,
+    )
+    return undefined
+  }
+  const now = new Date()
+  await fsp.utimes(worktreePath, now, now)
+  return worktreePath
+}
+
+export function selectResumeAgentDefinition({
+  agentType,
+  activeAgents,
+}: {
+  agentType: string | undefined
+  activeAgents: readonly AgentDefinition[]
+}): ResumeAgentSelection {
+  if (agentType === FORK_AGENT.agentType) {
+    return { selectedAgent: FORK_AGENT, isResumedFork: true }
+  }
+  const selectedAgent = agentType
+    ? (activeAgents.find(agent => agent.agentType === agentType) ??
+      GENERAL_PURPOSE_AGENT)
+    : GENERAL_PURPOSE_AGENT
+  return { selectedAgent, isResumedFork: false }
+}
+
+export async function buildForkParentSystemPrompt({
+  toolUseContext,
+  appState,
+}: {
+  toolUseContext: ToolUseContext
+  appState: AppState
+}): Promise<SystemPrompt> {
+  if (toolUseContext.renderedSystemPrompt) {
+    return toolUseContext.renderedSystemPrompt
+  }
+  const mainThreadAgentDefinition = appState.agent
+    ? appState.agentDefinitions.activeAgents.find(
+        agent => agent.agentType === appState.agent,
+      )
+    : undefined
+  const defaultSystemPrompt = await getSystemPrompt(
+    toolUseContext.options.tools,
+    toolUseContext.options.mainLoopModel,
+    additionalWorkingDirectoryPaths(toolUseContext),
+    toolUseContext.options.mcpClients,
+  )
+  const forkParentSystemPrompt = buildEffectiveSystemPrompt({
+    mainThreadAgentDefinition,
+    toolUseContext,
+    customSystemPrompt: toolUseContext.options.customSystemPrompt,
+    defaultSystemPrompt,
+    appendSystemPrompt: toolUseContext.options.appendSystemPrompt,
+  })
+  if (!forkParentSystemPrompt) {
+    throw new Error(
+      'Cannot resume fork agent: unable to reconstruct parent system prompt',
+    )
+  }
+  return forkParentSystemPrompt
+}
+
+function additionalWorkingDirectoryPaths(
+  toolUseContext: Pick<ToolUseContext, 'getAppState'>,
+): string[] {
+  return Array.from(
+    toolUseContext.getAppState().toolPermissionContext.additionalWorkingDirectories.keys(),
+  ).filter(path => typeof path === 'string')
+}

package/tui/src/tools/AgentTool/runAgent.ts

@@ -887,7 +887,7 @@ export function filterIncompleteToolCalls(messages: Message[]): Message[] {
       const assistantMessage = message as AssistantMessage
       const content = assistantMessage.message.content
       if (Array.isArray(content)) {
-        // Check if this assistant message has any tool uses without results
+        // Check if this assistant message includes tool uses without results
         const hasIncompleteToolCall = content.some(
           block =>
             block.type === 'tool_use' &&

package/tui/src/tools/AgentTool/runtimeConfig.ts

@@ -0,0 +1,57 @@
+import { feature } from 'bun:bundle'
+import type { ToolUseContext } from '../../Tool.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+type ProactiveModule = {
+  readonly isProactiveActive: () => boolean
+}
+
+const BUILD_FLAVOR = 'external'
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const proactiveModule: ProactiveModule | null =
+  feature('PROACTIVE') || feature('KAIROS')
+    ? require('../../proactive/index.js')
+    : null
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+export const isBackgroundTasksDisabled =
+  // eslint-disable-next-line custom-rules/no-process-env-top-level -- Intentional: schema must be defined at module load
+  isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS)
+
+export const PROGRESS_THRESHOLD_MS = 2000
+
+export function isAntBuild(): boolean {
+  return BUILD_FLAVOR === 'ant'
+}
+
+export function getAutoBackgroundMs(): number {
+  if (
+    isEnvTruthy(process.env.CLAUDE_AUTO_BACKGROUND_TASKS) ||
+    getFeatureValue_CACHED_MAY_BE_STALE('tengu_auto_background_agents', false)
+  ) {
+    return 120_000
+  }
+  return 0
+}
+
+export function isCoordinatorEnvMode(): boolean {
+  return feature('COORDINATOR_MODE')
+    ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)
+    : false
+}
+
+export function isProactiveAgentActive(): boolean {
+  return proactiveModule?.isProactiveActive() ?? false
+}
+
+export function additionalWorkingDirectoryPaths(
+  toolUseContext: Pick<ToolUseContext, 'getAppState'>,
+): string[] {
+  return Array.from(
+    toolUseContext
+      .getAppState()
+      .toolPermissionContext.additionalWorkingDirectories.keys(),
+  ).filter(path => typeof path === 'string')
+}