@oar-sh/oar 0.9.2 → 0.9.4

package/server/copilot-worker/copilot-sdk-event-normalizer.mjs

@@ -22,6 +22,11 @@
 import { sanitizeSubagentRunId } from '../../shared/subagent-run-id.mjs';
 import { capThought } from '../../shared/thought-cap.mjs';
 import { shouldEmitStreamUpdate } from '../../shared/stream-emit-gating.mjs';
+import {
+  REMOTE_RELAY_TOOL_NAME,
+  isRemoteRelayToolName,
+  remoteRelayActivitySummary,
+} from '../../shared/remote-relay-tool-core.mjs';
 
 const MAX_TOOL_DETAIL_LENGTH = 140;
 
@@ -78,8 +83,13 @@ export function summarizeToolInput(input) {
 }
 
 export function formatToolActivityText(toolName, input) {
-  const name = String(toolName || '').trim() || 'tool';
-  const summary = summarizeToolInput(input);
+  const rawName = String(toolName || '').trim() || 'tool';
+  // `remote_relay` (bare, or namespaced by an MCP server) reads as what it
+  // does on which relay (`send → linux-test session 01234567: “…”`); its
+  // arguments may arrive as a JSON string.
+  const isRemoteRelay = isRemoteRelayToolName(rawName);
+  const name = isRemoteRelay ? REMOTE_RELAY_TOOL_NAME : rawName;
+  const summary = (isRemoteRelay && remoteRelayActivitySummary(input)) || summarizeToolInput(input);
   return truncate(summary ? `Tool (${name}): ${summary}` : `Tool (${name})`);
 }
 
@@ -228,7 +238,11 @@ function createUsageAccumulator() {
  * `{ channel, payload }` actions; the session process dispatches them to the
  * relay and treats the first `result` action as the turn's terminator.
  */
-export function createCopilotEventNormalizer() {
+export function createCopilotEventNormalizer({
+  // The runner's answer to "is this agent id a background agent?" — shared
+  // across turns, unlike this normalizer's own `backgroundRuns`.
+  isBackgroundAgent = () => false,
+} = {}) {
   let sessionModel = '';
   let sessionId = '';
   let lastEmittedStreamText = '';
@@ -306,6 +320,13 @@ export function createCopilotEventNormalizer() {
   // runtime tags only one of them.
   const subagentRuns = new Map(); // runId -> { displayName, status, opened }
   const subagentAliases = new Map(); // agentId|toolCallId -> runId
+  // Runs spawned with `executionMode: "background"`: task-panel cards, not
+  // lanes. This normalizer lives for ONE turn while a background agent
+  // outlives it, so the runner's knowledge (`isBackgroundAgent`) is consulted
+  // too — a later turn must not open a lane for an agent spawned earlier.
+  const backgroundRuns = new Set();
+  const isBackgroundRun = (runId, agentId) => backgroundRuns.has(runId)
+    || (!!agentId && isBackgroundAgent(agentId) === true);
 
   /**
    * `useToolCallId` is true only for `subagent.*` lifecycle events, where
@@ -432,6 +453,17 @@ export function createCopilotEventNormalizer() {
     return { channel: 'activity', payload: { text, subagentRunId } };
   }
 
+  /**
+   * A line that only tracks background work: the main agent polling its
+   * background agent (`read_agent`), or a permission granted for a tool call
+   * (the call's own line, when it is the main agent's, is the real work). It
+   * still shows on the row; it just does not make a runtime-opened row worth
+   * keeping on its own (the task card covers the background agent).
+   */
+  function bookkeepingActivityAction(text) {
+    return { ...activityAction(text), bookkeeping: true };
+  }
+
   /**
    * Build the single terminal `result` action for this turn. Guarded so a
    * `session.error` arriving after a `session.idle` (or a second error) cannot
@@ -498,23 +530,43 @@ export function createCopilotEventNormalizer() {
       case 'subagent.started': {
         const runId = resolveSubagentRun(event, { useToolCallId: true });
         if (!runId) return [];
+        // A BACKGROUND agent (`executionMode: "background"`) is not a lane in
+        // this reply: it outlives the turn and shows in the task panel as a
+        // stoppable card (the runner reads `rpc.tasks`), and its completion
+        // arrives as a continuation. Opening a lane for it would leave a
+        // bubble spinning after the reply settled — or, if closed at the
+        // terminal, would mark a running agent failed. A one-line note keeps
+        // the transcript honest; its tagged events are dropped below.
+        if (String(data.executionMode || '').trim().toLowerCase() === 'background') {
+          backgroundRuns.add(runId);
+          const name = subagentDisplayName(data);
+          const agentType = String(data.agentType || '').trim();
+          return [activityAction(truncate(
+            `Started background agent: ${name}${agentType && agentType !== name ? ` (${agentType})` : ''} — see the task panel`,
+          ))];
+        }
         return ensureSubagentRun(runId, subagentDisplayName(data));
       }
       case 'subagent.configured':
       case 'subagent.selected': {
-        // `subagent.configured` is UNDOCUMENTED — it appears in no published
-        // schema and a live probe found it between started and completed,
-        // carrying `agentId` but neither `toolCallId` nor a display name. It is
-        // handled rather than ignored so the lane still opens if it ever
-        // arrives first, and it must never clobber the roster's display name
-        // with its own absent one (hence the `||` in ensureSubagentRun).
+        // `subagent.configured` (since documented: `{model, multiTurn, …}`)
+        // arrives between started and completed, carrying `agentId` but
+        // neither `toolCallId` nor a display name. It is handled rather than
+        // ignored so the lane still opens if it ever arrives first, and it
+        // must never clobber the roster's display name with its own absent
+        // one (hence the `||` in ensureSubagentRun). A background agent's
+        // arrives too, and must not open the lane `subagent.started` withheld.
         const runId = resolveSubagentRun(event, { useToolCallId: true });
         if (!runId) return [];
+        if (isBackgroundRun(runId, subagentEventKeys(event).agentId)) return [];
         return ensureSubagentRun(runId, subagentDisplayName(data));
       }
       case 'subagent.completed': {
         const runId = resolveSubagentRun(event, { useToolCallId: true });
         if (!runId) return [];
+        // A background agent finishing inside a later turn is the task panel's
+        // business (the runner watches the same event); no lane to close.
+        if (isBackgroundRun(runId, subagentEventKeys(event).agentId)) return [];
         const actions = closeSubagentRun(runId, 'completed', subagentDisplayName(data));
         const stats = formatSubagentStats(data);
         if (stats) actions.push(activityAction(truncate(`Finished · ${stats}`), runId));
@@ -525,6 +577,11 @@ export function createCopilotEventNormalizer() {
         if (!runId) return [];
         const name = subagentDisplayName(data);
         const reason = String(data.error || '').trim() || 'unknown error';
+        // A background agent's failure still deserves a main-thread line (the
+        // parent agent recovers silently), but there is no lane to close.
+        if (isBackgroundRun(runId, subagentEventKeys(event).agentId)) {
+          return [activityAction(truncate(`Background agent failed (${name}): ${reason}`))];
+        }
         const actions = closeSubagentRun(runId, 'failed', name);
         actions.push(activityAction(truncate(`Subagent failed: ${reason}`), runId));
         // ALSO on the main thread. The parent agent recovers from a failed
@@ -551,6 +608,14 @@ export function createCopilotEventNormalizer() {
     if (isSubagentEvent(event)) {
       const runId = resolveSubagentRun(event);
       if (!runId) return [];
+      // A background agent's traffic belongs to its task card (the runner
+      // tracks its live tool call and tokens from the same events), not to a
+      // lane in this reply — but its model calls still cost real money, so
+      // they count toward the spend of whichever turn is live, as before.
+      if (isBackgroundRun(runId, subagentEventKeys(event).agentId)) {
+        if (type === 'assistant.usage') usage.add(data, { allowModel: false });
+        return [];
+      }
       if (type === 'assistant.message') {
         const content = String(data.content || '');
         if (!content.trim()) return [];
@@ -718,7 +783,8 @@ export function createCopilotEventNormalizer() {
           lastEmittedStreamText = text;
           return [{ channel: 'stream', payload: { text, done: false, subagentRunId: null } }];
         }
-        return [activityAction(formatToolActivityText(toolName, data.arguments))];
+        const toolLine = formatToolActivityText(toolName, data.arguments);
+        return [toolName === 'read_agent' ? bookkeepingActivityAction(toolLine) : activityAction(toolLine)];
       }
       case 'tool.execution_complete': {
         // There is no `tool.*_failed` event type — failure is `success: false`
@@ -743,9 +809,9 @@ export function createCopilotEventNormalizer() {
         const summary = permissionRequests.get(requestId) || '';
         permissionRequests.delete(requestId);
         const kind = String(data.result?.kind || 'unknown').trim();
-        return [activityAction(truncate(summary
-          ? `Permission ${kind}: ${summary}`
-          : `Permission ${kind}`))];
+        const line = truncate(summary ? `Permission ${kind}: ${summary}` : `Permission ${kind}`);
+        // A denial is news; a grant is bookkeeping for the call it unblocked.
+        return [kind.startsWith('approved') ? bookkeepingActivityAction(line) : activityAction(line)];
       }
       case 'user_input.requested': {
         // The question is forwarded to the relay as a question card; this row
@@ -791,7 +857,40 @@ export function createCopilotEventNormalizer() {
         lastEmittedStreamText = text;
         return [{ channel: 'stream', payload: { text, done: false, subagentRunId: null } }];
       }
-      // ---- the one true terminator -----------------------------------------
+      // ---- compaction ------------------------------------------------------
+      //
+      // Surfaced as activity lines so a long pause reads as what it is. The
+      // runner ALSO watches these two events directly for its steering hold
+      // (a message must not be pushed into a compaction's replay).
+      case 'session.compaction_start': {
+        return [activityAction('Compacting the conversation context…')];
+      }
+      case 'session.compaction_complete': {
+        if (data.success === false) {
+          const reason = String(data.error || '').trim();
+          return [activityAction(truncate(reason ? `Context compaction failed: ${reason}` : 'Context compaction failed'))];
+        }
+        const removed = Number(data.messagesRemoved);
+        const tokens = Number(data.tokensRemoved);
+        const parts = [];
+        if (Number.isFinite(removed) && removed > 0) parts.push(`${removed} messages`);
+        if (Number.isFinite(tokens) && tokens > 0) parts.push(`${Math.round(tokens / 1000)}k tokens`);
+        return [activityAction(parts.length ? `Context compacted (removed ${parts.join(', ')})` : 'Context compacted')];
+      }
+      // ---- the terminators ---------------------------------------------------
+      //
+      // `assistant.idle` is "the main agent's processing loop went idle" and
+      // fires even while background agents / attached shells keep the
+      // session-level idle deferred (runtime 1.0.88, live-probed 2026-09-25).
+      // It is the terminator that lets a row settle while a background agent
+      // the turn spawned keeps running under the task panel — exactly the
+      // Claude worker's lingering model. `session.idle` stays the hard
+      // terminator for runtimes that do not emit the assistant-level one and
+      // for the drain's end; `terminalEmitted` makes the second a no-op.
+      case 'assistant.idle': {
+        if (data.aborted === true) aborted = true;
+        return terminalAction({ subtype: aborted ? 'aborted' : 'completed' });
+      }
       case 'session.idle': {
         if (data.aborted === true) aborted = true;
         return terminalAction({ subtype: aborted ? 'aborted' : 'completed' });