1  /**
  2   * InProcessTeammateTask - Manages in-process teammate lifecycle
  3   *
  4   * This component implements the Task interface for in-process teammates.
  5   * Unlike LocalAgentTask (background agents), in-process teammates:
  6   * 1. Run in the same Node.js process using AsyncLocalStorage for isolation
  7   * 2. Have team-aware identity (agentName@teamName)
  8   * 3. Support plan mode approval flow
  9   * 4. Can be idle (waiting for work) or active (processing)
 10   */
 11  
 12  import { isTerminalTaskStatus, type SetAppState, type Task, type TaskStateBase } from '../../Task.js';
 13  import type { Message } from '../../types/message.js';
 14  import { logForDebugging } from '../../utils/debug.js';
 15  import { createUserMessage } from '../../utils/messages.js';
 16  import { killInProcessTeammate } from '../../utils/swarm/spawnInProcess.js';
 17  import { updateTaskState } from '../../utils/task/framework.js';
 18  import type { InProcessTeammateTaskState } from './types.js';
 19  import { appendCappedMessage, isInProcessTeammateTask } from './types.js';
 20  
 21  /**
 22   * InProcessTeammateTask - Handles in-process teammate execution.
 23   */
 24  export const InProcessTeammateTask: Task = {
 25    name: 'InProcessTeammateTask',
 26    type: 'in_process_teammate',
 27    async kill(taskId, setAppState) {
 28      killInProcessTeammate(taskId, setAppState);
 29    }
 30  };
 31  
 32  /**
 33   * Request shutdown for a teammate.
 34   */
 35  export function requestTeammateShutdown(taskId: string, setAppState: SetAppState): void {
 36    updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {
 37      if (task.status !== 'running' || task.shutdownRequested) {
 38        return task;
 39      }
 40      return {
 41        ...task,
 42        shutdownRequested: true
 43      };
 44    });
 45  }
 46  
 47  /**
 48   * Append a message to a teammate's conversation history.
 49   * Used for zoomed view to show the teammate's conversation.
 50   */
 51  export function appendTeammateMessage(taskId: string, message: Message, setAppState: SetAppState): void {
 52    updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {
 53      if (task.status !== 'running') {
 54        return task;
 55      }
 56      return {
 57        ...task,
 58        messages: appendCappedMessage(task.messages, message)
 59      };
 60    });
 61  }
 62  
 63  /**
 64   * Inject a user message to a teammate's pending queue.
 65   * Used when viewing a teammate's transcript to send typed messages to them.
 66   * Also adds the message to task.messages so it appears immediately in the transcript.
 67   */
 68  export function injectUserMessageToTeammate(taskId: string, message: string, setAppState: SetAppState): void {
 69    updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {
 70      // Allow message injection when teammate is running or idle (waiting for input)
 71      // Only reject if teammate is in a terminal state
 72      if (isTerminalTaskStatus(task.status)) {
 73        logForDebugging(`Dropping message for teammate task ${taskId}: task status is "${task.status}"`);
 74        return task;
 75      }
 76      return {
 77        ...task,
 78        pendingUserMessages: [...task.pendingUserMessages, message],
 79        messages: appendCappedMessage(task.messages, createUserMessage({
 80          content: message
 81        }))
 82      };
 83    });
 84  }
 85  
 86  /**
 87   * Get teammate task by agent ID from AppState.
 88   * Prefers running tasks over killed/completed ones in case multiple tasks
 89   * with the same agentId exist.
 90   * Returns undefined if not found.
 91   */
 92  export function findTeammateTaskByAgentId(agentId: string, tasks: Record<string, TaskStateBase>): InProcessTeammateTaskState | undefined {
 93    let fallback: InProcessTeammateTaskState | undefined;
 94    for (const task of Object.values(tasks)) {
 95      if (isInProcessTeammateTask(task) && task.identity.agentId === agentId) {
 96        // Prefer running tasks in case old killed tasks still exist in AppState
 97        // alongside new running ones with the same agentId
 98        if (task.status === 'running') {
 99          return task;
100        }
101        // Keep first match as fallback in case no running task exists
102        if (!fallback) {
103          fallback = task;
104        }
105      }
106    }
107    return fallback;
108  }
109  
110  /**
111   * Get all in-process teammate tasks from AppState.
112   */
113  export function getAllInProcessTeammateTasks(tasks: Record<string, TaskStateBase>): InProcessTeammateTaskState[] {
114    return Object.values(tasks).filter(isInProcessTeammateTask);
115  }
116  
117  /**
118   * Get running in-process teammates sorted alphabetically by agentName.
119   * Shared between TeammateSpinnerTree display, PromptInput footer selector,
120   * and useBackgroundTaskNavigation — selectedIPAgentIndex maps into this
121   * array, so all three must agree on sort order.
122   */
123  export function getRunningTeammatesSorted(tasks: Record<string, TaskStateBase>): InProcessTeammateTaskState[] {
124    return getAllInProcessTeammateTasks(tasks).filter(t => t.status === 'running').sort((a, b) => a.identity.agentName.localeCompare(b.identity.agentName));
125  }
126  //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["isTerminalTaskStatus","SetAppState","Task","TaskStateBase","Message","logForDebugging","createUserMessage","killInProcessTeammate","updateTaskState","InProcessTeammateTaskState","appendCappedMessage","isInProcessTeammateTask","InProcessTeammateTask","name","type","kill","taskId","setAppState","requestTeammateShutdown","task","status","shutdownRequested","appendTeammateMessage","message","messages","injectUserMessageToTeammate","pendingUserMessages","content","findTeammateTaskByAgentId","agentId","tasks","Record","fallback","Object","values","identity","getAllInProcessTeammateTasks","filter","getRunningTeammatesSorted","t","sort","a","b","agentName","localeCompare"],"sources":["InProcessTeammateTask.tsx"],"sourcesContent":["/**\n * InProcessTeammateTask - Manages in-process teammate lifecycle\n *\n * This component implements the Task interface for in-process teammates.\n * Unlike LocalAgentTask (background agents), in-process teammates:\n * 1. Run in the same Node.js process using AsyncLocalStorage for isolation\n * 2. Have team-aware identity (agentName@teamName)\n * 3. Support plan mode approval flow\n * 4. Can be idle (waiting for work) or active (processing)\n */\n\nimport {\n  isTerminalTaskStatus,\n  type SetAppState,\n  type Task,\n  type TaskStateBase,\n} from '../../Task.js'\nimport type { Message } from '../../types/message.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { createUserMessage } from '../../utils/messages.js'\nimport { killInProcessTeammate } from '../../utils/swarm/spawnInProcess.js'\nimport { updateTaskState } from '../../utils/task/framework.js'\nimport type { InProcessTeammateTaskState } from './types.js'\nimport { appendCappedMessage, isInProcessTeammateTask } from './types.js'\n\n/**\n * InProcessTeammateTask - Handles in-process teammate execution.\n */\nexport const InProcessTeammateTask: Task = {\n  name: 'InProcessTeammateTask',\n  type: 'in_process_teammate',\n  async kill(taskId, setAppState) {\n    killInProcessTeammate(taskId, setAppState)\n  },\n}\n\n/**\n * Request shutdown for a teammate.\n */\nexport function requestTeammateShutdown(\n  taskId: string,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running' || task.shutdownRequested) {\n      return task\n    }\n\n    return {\n      ...task,\n      shutdownRequested: true,\n    }\n  })\n}\n\n/**\n * Append a message to a teammate's conversation history.\n * Used for zoomed view to show the teammate's conversation.\n */\nexport function appendTeammateMessage(\n  taskId: string,\n  message: Message,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running') {\n      return task\n    }\n\n    return {\n      ...task,\n      messages: appendCappedMessage(task.messages, message),\n    }\n  })\n}\n\n/**\n * Inject a user message to a teammate's pending queue.\n * Used when viewing a teammate's transcript to send typed messages to them.\n * Also adds the message to task.messages so it appears immediately in the transcript.\n */\nexport function injectUserMessageToTeammate(\n  taskId: string,\n  message: string,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {\n    // Allow message injection when teammate is running or idle (waiting for input)\n    // Only reject if teammate is in a terminal state\n    if (isTerminalTaskStatus(task.status)) {\n      logForDebugging(\n        `Dropping message for teammate task ${taskId}: task status is \"${task.status}\"`,\n      )\n      return task\n    }\n\n    return {\n      ...task,\n      pendingUserMessages: [...task.pendingUserMessages, message],\n      messages: appendCappedMessage(\n        task.messages,\n        createUserMessage({ content: message }),\n      ),\n    }\n  })\n}\n\n/**\n * Get teammate task by agent ID from AppState.\n * Prefers running tasks over killed/completed ones in case multiple tasks\n * with the same agentId exist.\n * Returns undefined if not found.\n */\nexport function findTeammateTaskByAgentId(\n  agentId: string,\n  tasks: Record<string, TaskStateBase>,\n): InProcessTeammateTaskState | undefined {\n  let fallback: InProcessTeammateTaskState | undefined\n  for (const task of Object.values(tasks)) {\n    if (isInProcessTeammateTask(task) && task.identity.agentId === agentId) {\n      // Prefer running tasks in case old killed tasks still exist in AppState\n      // alongside new running ones with the same agentId\n      if (task.status === 'running') {\n        return task\n      }\n      // Keep first match as fallback in case no running task exists\n      if (!fallback) {\n        fallback = task\n      }\n    }\n  }\n  return fallback\n}\n\n/**\n * Get all in-process teammate tasks from AppState.\n */\nexport function getAllInProcessTeammateTasks(\n  tasks: Record<string, TaskStateBase>,\n): InProcessTeammateTaskState[] {\n  return Object.values(tasks).filter(isInProcessTeammateTask)\n}\n\n/**\n * Get running in-process teammates sorted alphabetically by agentName.\n * Shared between TeammateSpinnerTree display, PromptInput footer selector,\n * and useBackgroundTaskNavigation — selectedIPAgentIndex maps into this\n * array, so all three must agree on sort order.\n */\nexport function getRunningTeammatesSorted(\n  tasks: Record<string, TaskStateBase>,\n): InProcessTeammateTaskState[] {\n  return getAllInProcessTeammateTasks(tasks)\n    .filter(t => t.status === 'running')\n    .sort((a, b) => a.identity.agentName.localeCompare(b.identity.agentName))\n}\n"],"mappings":"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","ignoreList":[]}