ummaya 0.2.4 → 0.2.5

package/tui/src/tools/AgentTool/foregroundProgress.tsx

@@ -0,0 +1,169 @@
+import * as React from 'react'
+import { getSdkAgentProgressSummariesEnabled } from '../../bootstrap/state.js'
+import {
+  createActivityDescriptionResolver,
+  createProgressTracker,
+  getProgressUpdate,
+  updateAgentProgress as updateAsyncAgentProgress,
+  updateProgressFromMessage,
+} from '../../tasks/LocalAgentTask/LocalAgentTask.js'
+import type { ToolUseContext } from '../../Tool.js'
+import type { Message as MessageType } from '../../types/message.js'
+import { normalizeMessages } from '../../utils/messages.js'
+import { getAssistantMessageContentLength } from '../../utils/tokens.js'
+import { BackgroundHint } from '../BashTool/UI.js'
+import { emitTaskProgress, getLastToolUseName } from './agentToolProgress.js'
+import {
+  isBackgroundTasksDisabled,
+  PROGRESS_THRESHOLD_MS,
+} from './runtimeConfig.js'
+import type { AgentToolProgressCallback } from './schemas.js'
+
+type SetAppState = Parameters<typeof updateAsyncAgentProgress>[2]
+export type AssistantProgressSource = {
+  readonly requestId?: string
+  readonly message?: { readonly id?: string }
+}
+
+export function emitInitialProgress(
+  promptMessages: MessageType[],
+  prompt: string,
+  syncAgentId: string,
+  assistantMessage: AssistantProgressSource | undefined,
+  onProgress: AgentToolProgressCallback | undefined,
+): void {
+  if (promptMessages.length === 0 || !onProgress) return
+  const normalizedFirstMessage = normalizeMessages(promptMessages).find(
+    message => message.type === 'user',
+  )
+  if (!normalizedFirstMessage) return
+  onProgress({
+    toolUseID: `agent_${assistantMessage?.message?.id}`,
+    data: {
+      message: normalizedFirstMessage,
+      type: 'agent_progress',
+      prompt,
+      agentId: syncAgentId,
+    },
+  })
+}
+
+export function showBackgroundHintIfNeeded(
+  backgroundHintShown: boolean,
+  agentStartTime: number,
+  toolUseContext: ToolUseContext,
+): boolean {
+  if (
+    isBackgroundTasksDisabled ||
+    backgroundHintShown ||
+    Date.now() - agentStartTime < PROGRESS_THRESHOLD_MS ||
+    !toolUseContext.setToolJSX
+  ) {
+    return backgroundHintShown
+  }
+  toolUseContext.setToolJSX({
+    jsx: React.createElement(BackgroundHint),
+    shouldHidePromptInput: false,
+    shouldContinueAnimation: true,
+    showSpinner: true,
+  })
+  return true
+}
+
+export function emitMessageProgress({
+  message,
+  syncTracker,
+  syncResolveActivity,
+  foregroundTaskId,
+  toolUseContext,
+  rootSetAppState,
+  description,
+  agentStartTime,
+  syncAgentId,
+  assistantMessage,
+  onProgress,
+}: {
+  readonly message: MessageType
+  readonly syncTracker: ReturnType<typeof createProgressTracker>
+  readonly syncResolveActivity: ReturnType<typeof createActivityDescriptionResolver>
+  readonly foregroundTaskId?: string
+  readonly toolUseContext: ToolUseContext
+  readonly rootSetAppState: SetAppState
+  readonly description: string
+  readonly agentStartTime: number
+  readonly syncAgentId: string
+  readonly assistantMessage: AssistantProgressSource | undefined
+  readonly onProgress: AgentToolProgressCallback | undefined
+}): void {
+  updateProgressFromMessage(
+    syncTracker,
+    message,
+    syncResolveActivity,
+    toolUseContext.options.tools,
+  )
+  if (foregroundTaskId) {
+    const lastToolName = getLastToolUseName(message)
+    if (lastToolName) {
+      emitTaskProgress(
+        syncTracker,
+        foregroundTaskId,
+        toolUseContext.toolUseId,
+        description,
+        agentStartTime,
+        lastToolName,
+      )
+      if (getSdkAgentProgressSummariesEnabled()) {
+        updateAsyncAgentProgress(
+          foregroundTaskId,
+          getProgressUpdate(syncTracker),
+          rootSetAppState,
+        )
+      }
+    }
+  }
+  if (
+    message.type === 'progress' &&
+    (message.data.type === 'bash_progress' ||
+      message.data.type === 'powershell_progress') &&
+    onProgress
+  ) {
+    onProgress({ toolUseID: message.toolUseID, data: message.data })
+  }
+  if (message.type !== 'assistant' && message.type !== 'user') return
+  if (message.type === 'assistant') {
+    const contentLength = getAssistantMessageContentLength(message)
+    if (contentLength > 0) {
+      toolUseContext.setResponseLength(length => length + contentLength)
+    }
+  }
+  emitNormalizedToolProgress(
+    message,
+    {
+      syncAgentId,
+      toolUseID: `agent_${assistantMessage?.message?.id}`,
+    },
+    onProgress,
+  )
+}
+
+function emitNormalizedToolProgress(
+  message: MessageType,
+  progressTarget: { readonly syncAgentId: string; readonly toolUseID: string },
+  onProgress: AgentToolProgressCallback | undefined,
+): void {
+  if (!onProgress) return
+  for (const normalizedMessage of normalizeMessages([message])) {
+    for (const content of normalizedMessage.message.content) {
+      if (content.type !== 'tool_use' && content.type !== 'tool_result') continue
+      onProgress({
+        toolUseID: progressTarget.toolUseID,
+        data: {
+          message: normalizedMessage,
+          type: 'agent_progress',
+          prompt: '',
+          agentId: progressTarget.syncAgentId,
+        },
+      })
+    }
+  }
+}

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

@@ -0,0 +1,89 @@
+import type { AppState } from '../../state/AppState.js'
+import type { ToolUseContext } from '../../Tool.js'
+import {
+  createProgressTracker,
+  getProgressUpdate,
+  registerAgentForeground,
+} from '../../tasks/LocalAgentTask/LocalAgentTask.js'
+import { enqueueSdkEvent } from '../../utils/sdkEventQueue.js'
+import type { AgentDefinition } from './loadAgentsDir.js'
+import {
+  getAutoBackgroundMs,
+  isBackgroundTasksDisabled,
+} from './runtimeConfig.js'
+
+type SetAppState = (f: (prev: AppState) => AppState) => void
+
+export type ForegroundTaskRuntime = {
+  readonly taskId?: string
+  readonly backgroundPromise?: Promise<{ readonly type: 'background' }>
+  readonly cancelAutoBackground?: () => void
+}
+
+export function setupForegroundTask({
+  syncAgentId,
+  selectedAgent,
+  description,
+  prompt,
+  rootSetAppState,
+  toolUseContext,
+}: {
+  readonly syncAgentId: string
+  readonly selectedAgent: AgentDefinition
+  readonly description: string
+  readonly prompt: string
+  readonly rootSetAppState: SetAppState
+  readonly toolUseContext: ToolUseContext
+}): ForegroundTaskRuntime {
+  if (isBackgroundTasksDisabled) return {}
+  const registration = registerAgentForeground({
+    agentId: syncAgentId,
+    description,
+    prompt,
+    selectedAgent,
+    setAppState: rootSetAppState,
+    toolUseId: toolUseContext.toolUseId,
+    autoBackgroundMs: getAutoBackgroundMs() || undefined,
+  })
+  return {
+    taskId: registration.taskId,
+    backgroundPromise: registration.backgroundSignal.then(() => ({
+      type: 'background',
+    })),
+    cancelAutoBackground: registration.cancelAutoBackground,
+  }
+}
+
+export function enqueueCompletionSdkEvent({
+  foregroundTaskId,
+  toolUseContext,
+  syncTracker,
+  syncAgentError,
+  wasAborted,
+  description,
+  agentStartTime,
+}: {
+  readonly foregroundTaskId: string
+  readonly toolUseContext: ToolUseContext
+  readonly syncTracker: ReturnType<typeof createProgressTracker>
+  readonly syncAgentError?: Error
+  readonly wasAborted: boolean
+  readonly description: string
+  readonly agentStartTime: number
+}): void {
+  const progress = getProgressUpdate(syncTracker)
+  enqueueSdkEvent({
+    type: 'system',
+    subtype: 'task_notification',
+    task_id: foregroundTaskId,
+    tool_use_id: toolUseContext.toolUseId,
+    status: syncAgentError ? 'failed' : wasAborted ? 'stopped' : 'completed',
+    output_file: '',
+    summary: description,
+    usage: {
+      total_tokens: progress.tokenCount,
+      tool_uses: progress.toolUseCount,
+      duration_ms: Date.now() - agentStartTime,
+    },
+  })
+}

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

@@ -1,12 +1,9 @@
-import { feature } from 'bun:bundle'
 import type { BetaToolUseBlock } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs'
 import { randomUUID } from 'crypto'
-import { getIsNonInteractiveSession } from '../../bootstrap/state.js'
 import {
   FORK_BOILERPLATE_TAG,
   FORK_DIRECTIVE_PREFIX,
 } from '../../constants/xml.js'
-import { isCoordinatorMode } from '../../coordinator/coordinatorMode.js'
 import type {
   AssistantMessage,
   Message as MessageType,
@@ -14,6 +11,7 @@ import type {
 import { logForDebugging } from '../../utils/debug.js'
 import { createUserMessage } from '../../utils/messages.js'
 import type { BuiltInAgentDefinition } from './loadAgentsDir.js'
+export { isForkSubagentEnabled } from './forkSubagentGate.js'
 
 /**
  * Fork subagent feature gate.
@@ -29,15 +27,6 @@ import type { BuiltInAgentDefinition } from './loadAgentsDir.js'
  * Mutually exclusive with coordinator mode — coordinator already owns the
  * orchestration role and has its own delegation model.
  */
-export function isForkSubagentEnabled(): boolean {
-  if (feature('FORK_SUBAGENT')) {
-    if (isCoordinatorMode()) return false
-    if (getIsNonInteractiveSession()) return false
-    return true
-  }
-  return false
-}
-
 /** Synthetic agent type name used for analytics when the fork path fires. */
 export const FORK_SUBAGENT_TYPE = 'fork'
 

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

@@ -0,0 +1,34 @@
+import { feature } from 'bun:bundle'
+import { getIsNonInteractiveSession } from '../../bootstrap/state.js'
+import { isCoordinatorMode } from '../../coordinator/coordinatorMode.js'
+import {
+  isEnvDefinedFalsy,
+  isEnvTruthy,
+} from '../../utils/envUtils.js'
+
+function readFeatureBoolean(value: string | undefined): boolean | undefined {
+  if (isEnvTruthy(value)) return true
+  if (isEnvDefinedFalsy(value)) return false
+  return undefined
+}
+
+function isForkSubagentFeatureEnabled(): boolean {
+  const ummayaOverride = readFeatureBoolean(
+    process.env.UMMAYA_FEATURE_FORK_SUBAGENT,
+  )
+  if (ummayaOverride !== undefined) return ummayaOverride
+
+  const claudeOverride = readFeatureBoolean(
+    process.env.CLAUDE_CODE_FEATURE_FORK_SUBAGENT,
+  )
+  return claudeOverride ?? (feature('FORK_SUBAGENT') ? true : false)
+}
+
+export function isForkSubagentEnabled(): boolean {
+  if (isForkSubagentFeatureEnabled()) {
+    if (isCoordinatorMode()) return false
+    if (getIsNonInteractiveSession()) return false
+    return true
+  }
+  return false
+}

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

@@ -0,0 +1,203 @@
+import type { AssistantMessage } from 'src/types/message.js'
+import type { AppState } from '../../state/AppState.js'
+import type { ToolPermissionContext, Tools, ToolUseContext } from '../../Tool.js'
+import { filterDeniedAgents, getDenyRuleForAgent } from '../../utils/permissions/permissions.js'
+import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'
+import { isInProcessTeammate } from '../../utils/teammateContext.js'
+import { isTeammate } from '../../utils/teammate.js'
+import { setAgentColor } from './agentColorManager.js'
+import { buildAgentSupportMetadata } from './orchestrationSupport.js'
+import { GENERAL_PURPOSE_AGENT } from './built-in/generalPurposeAgent.js'
+import { AGENT_TOOL_NAME } from './constants.js'
+import {
+  FORK_AGENT,
+  isForkSubagentEnabled,
+  isInForkChild,
+} from './forkSubagent.js'
+import type { AgentDefinition } from './loadAgentsDir.js'
+import { filterAgentsByMcpRequirements } from './loadAgentsDir.js'
+import { mcpServersWithTools, waitForRequiredMcpServers } from './mcpRouting.js'
+import { getPrompt } from './prompt.js'
+import type {
+  AgentToolCallResult,
+  AgentToolInput,
+  TeammateSpawnedOutput,
+} from './schemas.js'
+import { isCoordinatorEnvMode } from './runtimeConfig.js'
+
+export type SelectedAgentRoute = {
+  readonly selectedAgent: AgentDefinition
+  readonly isForkPath: boolean
+}
+
+export async function buildAgentToolPrompt({
+  agents,
+  tools,
+  getToolPermissionContext,
+  allowedAgentTypes,
+}: {
+  readonly agents: readonly AgentDefinition[]
+  readonly tools: Tools
+  readonly getToolPermissionContext: () => Promise<ToolPermissionContext>
+  readonly allowedAgentTypes?: readonly string[]
+}): Promise<string> {
+  const toolPermissionContext = await getToolPermissionContext()
+  const filteredAgents = filterDeniedAgents(
+    filterAgentsByMcpRequirements(agents, mcpServersWithTools(tools)),
+    toolPermissionContext,
+    AGENT_TOOL_NAME,
+  )
+  return getPrompt(filteredAgents, isCoordinatorEnvMode(), allowedAgentTypes)
+}
+
+export function resolveTeamName(
+  input: Pick<AgentToolInput, 'team_name'>,
+  appState: Pick<AppState, 'teamContext'>,
+): string | undefined {
+  if (!isAgentSwarmsEnabled()) return undefined
+  return input.team_name ?? appState.teamContext?.teamName
+}
+
+export function assertAgentLaunchAllowed({
+  input,
+  selectedAgent,
+  teamName,
+}: {
+  readonly input: AgentToolInput
+  readonly selectedAgent?: AgentDefinition
+  readonly teamName?: string
+}): void {
+  if (input.team_name && !isAgentSwarmsEnabled()) {
+    throw new Error('Agent Teams is not yet available on your plan.')
+  }
+  if (isTeammate() && teamName && input.name) {
+    throw new Error(
+      'Teammates cannot spawn other teammates — the team roster is flat. To spawn a subagent instead, omit the `name` parameter.',
+    )
+  }
+  if (isInProcessTeammate() && teamName && input.run_in_background === true) {
+    throw new Error(
+      'In-process teammates cannot spawn background agents. Use run_in_background=false for synchronous subagents.',
+    )
+  }
+  if (isInProcessTeammate() && teamName && selectedAgent?.background === true) {
+    throw new Error(
+      `In-process teammates cannot spawn background agents. Agent '${selectedAgent.agentType}' has background: true in its definition.`,
+    )
+  }
+}
+
+export async function launchTeammateIfRequested({
+  input,
+  teamName,
+  model,
+  toolUseContext,
+  assistantMessage,
+}: {
+  readonly input: AgentToolInput
+  readonly teamName?: string
+  readonly model?: string
+  readonly toolUseContext: ToolUseContext
+  readonly assistantMessage?: AssistantMessage
+}): Promise<AgentToolCallResult | undefined> {
+  if (!teamName || !input.name) return undefined
+  const agentDef = input.subagent_type
+    ? toolUseContext.options.agentDefinitions.activeAgents.find(
+        agent => agent.agentType === input.subagent_type,
+      )
+    : undefined
+  if (agentDef?.color) {
+    setAgentColor(input.subagent_type, agentDef.color)
+  }
+  const { spawnTeammate } = await import('../shared/spawnMultiAgent.js')
+  const result = await spawnTeammate(
+    {
+      name: input.name,
+      prompt: input.prompt,
+      description: input.description,
+      team_name: teamName,
+      use_splitpane: true,
+      plan_mode_required: input.mode === 'plan',
+      model: model ?? agentDef?.model,
+      agent_type: input.subagent_type,
+      invokingRequestId: assistantMessage?.requestId,
+    },
+    toolUseContext,
+  )
+  const spawnResult: TeammateSpawnedOutput = {
+    status: 'teammate_spawned',
+    prompt: input.prompt,
+    ...result.data,
+    ...buildAgentSupportMetadata({
+      agentId: result.data.agent_id,
+      parentToolUseId: toolUseContext.toolUseId,
+    }),
+  }
+  return { data: spawnResult }
+}
+
+export async function resolveSelectedAgentRoute({
+  input,
+  toolUseContext,
+  appState,
+}: {
+  readonly input: AgentToolInput
+  readonly toolUseContext: ToolUseContext
+  readonly appState: AppState
+}): Promise<SelectedAgentRoute> {
+  const effectiveType =
+    input.subagent_type ??
+    (isForkSubagentEnabled() ? undefined : GENERAL_PURPOSE_AGENT.agentType)
+  const isForkPath = effectiveType === undefined
+  const selectedAgent = isForkPath
+    ? resolveForkAgent(toolUseContext)
+    : resolveNamedAgent(effectiveType, toolUseContext, appState)
+
+  await waitForRequiredMcpServers(selectedAgent, toolUseContext, appState)
+  if (selectedAgent.color) setAgentColor(selectedAgent.agentType, selectedAgent.color)
+  return { selectedAgent, isForkPath }
+}
+
+function resolveForkAgent(toolUseContext: ToolUseContext): AgentDefinition {
+  if (
+    toolUseContext.options.querySource === `agent:builtin:${FORK_AGENT.agentType}` ||
+    isInForkChild(toolUseContext.messages)
+  ) {
+    throw new Error(
+      'Fork is not available inside a forked worker. Complete your task directly using your tools.',
+    )
+  }
+  return FORK_AGENT
+}
+
+function resolveNamedAgent(
+  effectiveType: string,
+  toolUseContext: ToolUseContext,
+  appState: AppState,
+): AgentDefinition {
+  const allAgents = toolUseContext.options.agentDefinitions.activeAgents
+  const allowedAgentTypes = toolUseContext.options.agentDefinitions.allowedAgentTypes
+  const visibleAgents = filterDeniedAgents(
+    allowedAgentTypes
+      ? allAgents.filter(agent => allowedAgentTypes.includes(agent.agentType))
+      : allAgents,
+    appState.toolPermissionContext,
+    AGENT_TOOL_NAME,
+  )
+  const found = visibleAgents.find(agent => agent.agentType === effectiveType)
+  if (found) return found
+  const denied = allAgents.find(agent => agent.agentType === effectiveType)
+  if (denied) {
+    const denyRule = getDenyRuleForAgent(
+      appState.toolPermissionContext,
+      AGENT_TOOL_NAME,
+      effectiveType,
+    )
+    throw new Error(
+      `Agent type '${effectiveType}' has been denied by permission rule '${AGENT_TOOL_NAME}(${effectiveType})' from ${denyRule?.source ?? 'settings'}.`,
+    )
+  }
+  throw new Error(
+    `Agent type '${effectiveType}' not found. Available agents: ${visibleAgents.map(agent => agent.agentType).join(', ')}`,
+  )
+}