@adecore/agents-react 0.31.12 → 0.32.0

package/dist/chat/logic/scrubber.js

@@ -17,163 +17,215 @@ const WIDTH_PERSON_PX = 8;
 const WIDTH_WAKE_PX = 5;
 /* `marks` is what `bookmarkRows` answers: the bookmark drawn at a row, by row id. */
 export function ticksOf(rows, marks = new Map()) {
-    return rows.flatMap((row, rowIndex) => {
-        const bookmark = marks.get(row.id) ?? null;
-        if (row.kind === 'user') {
-            // A message of only attachments still has a place in the thread; its names stand in for the text.
-            const text = row.item.text !== '' ? row.item.text : (row.item.attachments ?? []).map((attachment) => attachment.name).join(', ');
-            return [{ id: row.id, rowIndex, kind: 'person', text, createdAt: row.item.createdAt, turnId: row.item.turnId, bookmark }];
-        }
-        // The other turns nobody asked for (a sub-agent that finished, the CLI going on) are no place to return to.
-        if (row.kind === 'turn-start' && ((row.turn.taskIds?.length ?? 0) > 0 || (row.turn.messageFrom?.length ?? 0) > 0)) {
-            return [{ id: row.id, rowIndex, kind: 'wake', text: row.label, createdAt: row.turn.createdAt, turnId: row.turn.id, bookmark: null }];
-        }
-        if (bookmark === null) {
-            return [];
-        }
-        if (row.kind === 'assistant') {
-            return [{ id: row.id, rowIndex, kind: 'bookmark', text: row.item.text, createdAt: row.item.createdAt, turnId: row.item.turnId, bookmark }];
-        }
-        // The fold of a turn a marked reply is hidden in; the card reads the start the bookmark kept.
-        const turnId = row.kind === 'turn-fold' ? row.turn.id : null;
-        return [{ id: row.id, rowIndex, kind: 'bookmark', text: bookmark.excerpt, createdAt: bookmark.createdAt, turnId, bookmark }];
-    });
+  return rows.flatMap((row, rowIndex) => {
+    const bookmark = marks.get(row.id) ?? null;
+    if (row.kind === 'user') {
+      // A message of only attachments still has a place in the thread; its names stand in for the text.
+      const text = row.item.text !== '' ? row.item.text : (row.item.attachments ?? []).map(attachment => attachment.name).join(', ');
+      return [{
+        id: row.id,
+        rowIndex,
+        kind: 'person',
+        text,
+        createdAt: row.item.createdAt,
+        turnId: row.item.turnId,
+        bookmark
+      }];
+    }
+    // The other turns nobody asked for (a sub-agent that finished, the CLI going on) are no place to return to.
+    if (row.kind === 'turn-start' && ((row.turn.taskIds?.length ?? 0) > 0 || (row.turn.messageFrom?.length ?? 0) > 0)) {
+      return [{
+        id: row.id,
+        rowIndex,
+        kind: 'wake',
+        text: row.label,
+        createdAt: row.turn.createdAt,
+        turnId: row.turn.id,
+        bookmark: null
+      }];
+    }
+    if (bookmark === null) {
+      return [];
+    }
+    if (row.kind === 'assistant') {
+      return [{
+        id: row.id,
+        rowIndex,
+        kind: 'bookmark',
+        text: row.item.text,
+        createdAt: row.item.createdAt,
+        turnId: row.item.turnId,
+        bookmark
+      }];
+    }
+    // The fold of a turn a marked reply is hidden in; the card reads the start the bookmark kept.
+    const turnId = row.kind === 'turn-fold' ? row.turn.id : null;
+    return [{
+      id: row.id,
+      rowIndex,
+      kind: 'bookmark',
+      text: bookmark.excerpt,
+      createdAt: bookmark.createdAt,
+      turnId,
+      bookmark
+    }];
+  });
 }
 /* `marked` and `found` say per message whether it has a bookmark and whether a find hit falls under it; absent, none has. */
 export function layoutTicks(kinds, height, marked = [], found = []) {
-    const count = kinds.length;
-    const room = Math.max(0, Math.floor(height));
-    const slotCount = Math.min(count, Math.floor(room / MIN_PITCH_PX));
-    if (slotCount === 0) {
-        return { top: 0, pitch: MIN_PITCH_PX, count, slots: [] };
-    }
-    const pitch = Math.min(PITCH_PX, Math.floor(room / slotCount));
-    const top = Math.floor((room - slotCount * pitch) / 2);
-    const inset = Math.floor((pitch - TICK_HEIGHT_PX) / 2);
-    const slots = [];
-    for (let i = 0; i < slotCount; i++) {
-        const first = Math.floor((i * count) / slotCount);
-        const last = Math.floor(((i + 1) * count) / slotCount) - 1;
-        // A merged tick is the person's as soon as one message in it is, since those are what the strip is for.
-        const run = kinds.slice(first, last + 1);
-        const kind = run.includes('person') ? 'person' : run.includes('bookmark') ? 'bookmark' : 'wake';
-        slots.push({
-            first,
-            last,
-            kind,
-            marked: marked.slice(first, last + 1).includes(true),
-            found: found.slice(first, last + 1).includes(true),
-            y: top + i * pitch + inset
-        });
-    }
-    return { top, pitch, count, slots };
+  const count = kinds.length;
+  const room = Math.max(0, Math.floor(height));
+  const slotCount = Math.min(count, Math.floor(room / MIN_PITCH_PX));
+  if (slotCount === 0) {
+    return {
+      top: 0,
+      pitch: MIN_PITCH_PX,
+      count,
+      slots: []
+    };
+  }
+  const pitch = Math.min(PITCH_PX, Math.floor(room / slotCount));
+  const top = Math.floor((room - slotCount * pitch) / 2);
+  const inset = Math.floor((pitch - TICK_HEIGHT_PX) / 2);
+  const slots = [];
+  for (let i = 0; i < slotCount; i++) {
+    const first = Math.floor(i * count / slotCount);
+    const last = Math.floor((i + 1) * count / slotCount) - 1;
+    // A merged tick is the person's as soon as one message in it is, since those are what the strip is for.
+    const run = kinds.slice(first, last + 1);
+    const kind = run.includes('person') ? 'person' : run.includes('bookmark') ? 'bookmark' : 'wake';
+    slots.push({
+      first,
+      last,
+      kind,
+      marked: marked.slice(first, last + 1).includes(true),
+      found: found.slice(first, last + 1).includes(true),
+      y: top + i * pitch + inset
+    });
+  }
+  return {
+    top,
+    pitch,
+    count,
+    slots
+  };
 }
 /*
  * The tick whose stretch of the thread a row falls in: a tick stands for its row and every row up to
  * the next tick's, and a row above the first tick counts under the first. Null without ticks.
  */
 export function tickOfRow(ticks, rowIndex) {
-    if (ticks.length === 0) {
-        return null;
-    }
-    return Math.max(0, lastIndexAtOrBelow(ticks.length, (index) => ticks[index].rowIndex, rowIndex));
+  if (ticks.length === 0) {
+    return null;
+  }
+  return Math.max(0, lastIndexAtOrBelow(ticks.length, index => ticks[index].rowIndex, rowIndex));
 }
 /* Per tick, whether any of the rows has a find hit in its stretch. */
 export function ticksWithHits(ticks, hitRows) {
-    const found = ticks.map(() => false);
-    for (const row of hitRows) {
-        const tick = tickOfRow(ticks, row);
-        if (tick !== null) {
-            found[tick] = true;
-        }
+  const found = ticks.map(() => false);
+  for (const row of hitRows) {
+    const tick = tickOfRow(ticks, row);
+    if (tick !== null) {
+      found[tick] = true;
     }
-    return found;
+  }
+  return found;
 }
 /* The message under a height in the strip; inside a merged tick the height picks among its messages. */
 export function messageAt(layout, y) {
-    const { slots, top, pitch } = layout;
-    if (slots.length === 0) {
-        return null;
-    }
-    const offset = y - top;
-    const index = Math.min(slots.length - 1, Math.max(0, Math.floor(offset / pitch)));
-    const slot = slots[index];
-    const fraction = Math.min(1, Math.max(0, (offset - index * pitch) / pitch));
-    return slot.first + Math.min(slot.last - slot.first, Math.floor(fraction * (slot.last - slot.first + 1)));
+  const {
+    slots,
+    top,
+    pitch
+  } = layout;
+  if (slots.length === 0) {
+    return null;
+  }
+  const offset = y - top;
+  const index = Math.min(slots.length - 1, Math.max(0, Math.floor(offset / pitch)));
+  const slot = slots[index];
+  const fraction = Math.min(1, Math.max(0, (offset - index * pitch) / pitch));
+  return slot.first + Math.min(slot.last - slot.first, Math.floor(fraction * (slot.last - slot.first + 1)));
 }
 export function slotOf(layout, message) {
-    const { slots } = layout;
-    let low = 0;
-    let high = slots.length - 1;
-    while (low <= high) {
-        const middle = (low + high) >> 1;
-        const slot = slots[middle];
-        if (message < slot.first) {
-            high = middle - 1;
-        }
-        else if (message > slot.last) {
-            low = middle + 1;
-        }
-        else {
-            return middle;
-        }
+  const {
+    slots
+  } = layout;
+  let low = 0;
+  let high = slots.length - 1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    const slot = slots[middle];
+    if (message < slot.first) {
+      high = middle - 1;
+    } else if (message > slot.last) {
+      low = middle + 1;
+    } else {
+      return middle;
     }
-    return null;
+  }
+  return null;
 }
 /*
  * At rest every tick of a kind is as long as the next, so length never competes with the brightness
  * that says what is on screen. Only a pointer on the strip magnifies, the way a dock does, one step out.
  */
 export function tickWidth(kind, distanceFromPointer) {
-    if (distanceFromPointer === 0) {
-        return WIDTH_HOVERED_PX;
-    }
-    if (distanceFromPointer === 1) {
-        return kind === 'wake' ? WIDTH_NEAR_WAKE_PX : WIDTH_NEAR_PERSON_PX;
-    }
-    return kind === 'wake' ? WIDTH_WAKE_PX : WIDTH_PERSON_PX;
+  if (distanceFromPointer === 0) {
+    return WIDTH_HOVERED_PX;
+  }
+  if (distanceFromPointer === 1) {
+    return kind === 'wake' ? WIDTH_NEAR_WAKE_PX : WIDTH_NEAR_PERSON_PX;
+  }
+  return kind === 'wake' ? WIDTH_WAKE_PX : WIDTH_PERSON_PX;
 }
 /* The last index whose value is at most `limit`, or -1. The values only grow. */
 function lastIndexAtOrBelow(length, valueAt, limit) {
-    let low = 0;
-    let high = length - 1;
-    let found = -1;
-    while (low <= high) {
-        const middle = (low + high) >> 1;
-        if (valueAt(middle) <= limit) {
-            found = middle;
-            low = middle + 1;
-        }
-        else {
-            high = middle - 1;
-        }
+  let low = 0;
+  let high = length - 1;
+  let found = -1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    if (valueAt(middle) <= limit) {
+      found = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
     }
-    return found;
+  }
+  return found;
 }
 /* The last index whose start lies at or above a line, or -1. */
 function lastAtOrAbove(starts, line) {
-    return lastIndexAtOrBelow(starts.length, (index) => starts[index], line);
+  return lastIndexAtOrBelow(starts.length, index => starts[index], line);
 }
 /*
  * The messages on screen. A message counts from its own start to the start of the next one, so the
  * question whose answer fills the screen is in view even after it scrolled out at the top.
  */
-export function messagesInView({ starts, scrollTop, visibleHeight }) {
-    const bottom = scrollTop + visibleHeight;
-    if (starts.length === 0 || visibleHeight <= 0 || starts[0] >= bottom) {
-        return null;
-    }
-    const first = Math.max(0, lastAtOrAbove(starts, scrollTop));
-    let last = lastAtOrAbove(starts, bottom);
-    // A row that starts on the very last line has not a pixel on screen yet.
-    if (starts[last] >= bottom) {
-        last--;
-    }
-    return { first, last: Math.max(first, last) };
+export function messagesInView({
+  starts,
+  scrollTop,
+  visibleHeight
+}) {
+  const bottom = scrollTop + visibleHeight;
+  if (starts.length === 0 || visibleHeight <= 0 || starts[0] >= bottom) {
+    return null;
+  }
+  const first = Math.max(0, lastAtOrAbove(starts, scrollTop));
+  let last = lastAtOrAbove(starts, bottom);
+  // A row that starts on the very last line has not a pixel on screen yet.
+  if (starts[last] >= bottom) {
+    last--;
+  }
+  return {
+    first,
+    last: Math.max(first, last)
+  };
 }
 /* Whether a drawn tick covers any of the messages on screen. */
 export function slotInView(slot, range) {
-    return range !== null && slot.last >= range.first && slot.first <= range.last;
+  return range !== null && slot.last >= range.first && slot.first <= range.last;
 }
 /*
  * The message a step back or forward lands on, among the ones `eligible` allows. A jump puts a
@@ -181,20 +233,20 @@ export function slotInView(slot, range) {
  * a long answer is the question it belongs to. A pixel of slack absorbs rounding in the scroller.
  */
 export function stepMessage(starts, eligible, scrollTop, direction) {
-    if (direction === -1) {
-        for (let i = lastAtOrAbove(starts, scrollTop - 1.5); i >= 0; i--) {
-            if (eligible(i)) {
-                return i;
-            }
-        }
-        return null;
-    }
-    for (let i = lastAtOrAbove(starts, scrollTop + 1) + 1; i < starts.length; i++) {
-        if (eligible(i)) {
-            return i;
-        }
+  if (direction === -1) {
+    for (let i = lastAtOrAbove(starts, scrollTop - 1.5); i >= 0; i--) {
+      if (eligible(i)) {
+        return i;
+      }
     }
     return null;
+  }
+  for (let i = lastAtOrAbove(starts, scrollTop + 1) + 1; i < starts.length; i++) {
+    if (eligible(i)) {
+      return i;
+    }
+  }
+  return null;
 }
 /*
  * The left padding of the thread in a view that draws the strip at its left edge. A wide view keeps
@@ -203,10 +255,10 @@ export function stepMessage(starts, eligible, scrollTop, direction) {
  * widest the content column runs (`readingMeasure`).
  */
 export function threadPaddingLeft(width, strip, measure = readingMeasure(DEFAULT_READING_WIDTH)) {
-    if (!strip) {
-        return THREAD_PADDING_PX;
-    }
-    // The column's margin is half of what the padding leaves, so the padding counts the clearance twice.
-    const padding = 2 * STRIP_CLEARANCE_PX + measure + THREAD_PADDING_PX - Math.floor(width);
-    return Math.min(STRIP_CLEARANCE_PX, Math.max(THREAD_PADDING_PX, padding));
-}
+  if (!strip) {
+    return THREAD_PADDING_PX;
+  }
+  // The column's margin is half of what the padding leaves, so the padding counts the clearance twice.
+  const padding = 2 * STRIP_CLEARANCE_PX + measure + THREAD_PADDING_PX - Math.floor(width);
+  return Math.min(STRIP_CLEARANCE_PX, Math.max(THREAD_PADDING_PX, padding));
+}

package/dist/chat/logic/thought.js

@@ -6,30 +6,27 @@ const LIST_MARKER = /^[ \t]*(?:[-*+]|\d+[.)])[ \t]+/gm;
 const SENTENCE_END = /[.!?]["'”’)\]]*(?=\s)/;
 /* The thought as one line of plain text: the marks gone and every run of white space one space. */
 export function flattenThought(text) {
-    return stripMarkdown(text.replace(LIST_MARKER, '')).replace(/\s+/g, ' ').trim();
+  return stripMarkdown(text.replace(LIST_MARKER, '')).replace(/\s+/g, ' ').trim();
 }
 function headingOf(line) {
-    return HEADING_LINE.exec(line)?.[1] ?? null;
+  return HEADING_LINE.exec(line)?.[1] ?? null;
 }
 /* What a folded thought shows on its one line: the heading it opens with, or the whole thought flattened for the row to cut off. */
 export function thoughtPreview(text) {
-    const heading = headingOf(text.trimStart().split('\n', 1)[0] ?? '');
-    return flattenThought(heading ?? text);
+  const heading = headingOf(text.trimStart().split('\n', 1)[0] ?? '');
+  return flattenThought(heading ?? text);
 }
 /*
  * What the model is thinking about now, in a line: the heading of the last stretch it titled, which
  * is the one it is on, or the first sentence of a thought that titles nothing.
  */
 export function thoughtLine(text) {
-    const headings = text
-        .split('\n')
-        .map(headingOf)
-        .filter((heading) => heading !== null);
-    const last = headings.at(-1);
-    if (last !== undefined) {
-        return flattenThought(last);
-    }
-    const flat = flattenThought(text);
-    const end = SENTENCE_END.exec(flat);
-    return end === null ? flat : flat.slice(0, end.index + end[0].length);
-}
+  const headings = text.split('\n').map(headingOf).filter(heading => heading !== null);
+  const last = headings.at(-1);
+  if (last !== undefined) {
+    return flattenThought(last);
+  }
+  const flat = flattenThought(text);
+  const end = SENTENCE_END.exec(flat);
+  return end === null ? flat : flat.slice(0, end.index + end[0].length);
+}

package/dist/chat/logic/thread-cards.js

@@ -4,34 +4,41 @@
  * goes above it.
  */
 function rowTime(row) {
-    switch (row.kind) {
-        case 'user':
-        case 'assistant':
-        case 'thinking':
-        case 'approval':
-        case 'question':
-        case 'subagent':
-            return row.item.createdAt;
-        case 'turn-start':
-        case 'turn-fold':
-            return row.turn.createdAt;
-        case 'work':
-        case 'work-live':
-        case 'workflow':
-            return row.tool.createdAt;
-        case 'work-group':
-            return row.tools[0]?.createdAt ?? null;
-        case 'live-thought':
-            return row.at;
-        case 'working':
-            return Number.POSITIVE_INFINITY;
-        default:
-            return null;
-    }
+  switch (row.kind) {
+    case 'user':
+    case 'assistant':
+    case 'thinking':
+    case 'approval':
+    case 'question':
+    case 'subagent':
+      return row.item.createdAt;
+    case 'turn-start':
+    case 'turn-fold':
+      return row.turn.createdAt;
+    case 'work':
+    case 'work-live':
+    case 'workflow':
+      return row.tool.createdAt;
+    case 'work-group':
+      return row.tools[0]?.createdAt ?? null;
+    case 'live-thought':
+      return row.at;
+    case 'working':
+      return Number.POSITIVE_INFINITY;
+    default:
+      return null;
+  }
 }
 /* Prefixed, so a card never shares a key with a row of the chat's own. */
 export function cardRows(cards) {
-    return cards.map((card) => ({ at: card.at, row: { kind: 'app-card', id: `app-card-${card.id}`, card } }));
+  return cards.map(card => ({
+    at: card.at,
+    row: {
+      kind: 'app-card',
+      id: `app-card-${card.id}`,
+      card
+    }
+  }));
 }
 /*
  * The visuals as rows, keyed apart from the chat's own rows. `heldFrom` is when the first item this
@@ -39,9 +46,14 @@ export function cardRows(cards) {
  * page and waits for it, rather than stacking up at the top of the thread.
  */
 export function visualRows(visuals, heldFrom = null) {
-    return visuals
-        .filter((visual) => heldFrom === null || visual.at >= heldFrom)
-        .map((visual) => ({ at: visual.at, row: { kind: 'visual', id: `visual-${visual.id}`, visual } }));
+  return visuals.filter(visual => heldFrom === null || visual.at >= heldFrom).map(visual => ({
+    at: visual.at,
+    row: {
+      kind: 'visual',
+      id: `visual-${visual.id}`,
+      visual
+    }
+  }));
 }
 /*
  * The thread's rows with timed rows among them: each goes right before the first row that began after
@@ -50,30 +62,30 @@ export function visualRows(visuals, heldFrom = null) {
  * timed rows the rows come back as they are, the same array.
  */
 export function withTimedRows(rows, timed) {
-    if (timed.length === 0) {
-        return rows;
+  if (timed.length === 0) {
+    return rows;
+  }
+  // Sorting is stable, which is what keeps rows of the same moment in the order they came.
+  const pending = [...timed].sort((first, second) => first.at - second.at);
+  const merged = [];
+  let next = 0;
+  for (const row of rows) {
+    const time = rowTime(row);
+    while (time !== null && next < pending.length && pending[next].at < time) {
+      merged.push(pending[next].row);
+      next += 1;
     }
-    // Sorting is stable, which is what keeps rows of the same moment in the order they came.
-    const pending = [...timed].sort((first, second) => first.at - second.at);
-    const merged = [];
-    let next = 0;
-    for (const row of rows) {
-        const time = rowTime(row);
-        while (time !== null && next < pending.length && pending[next].at < time) {
-            merged.push(pending[next].row);
-            next += 1;
-        }
-        merged.push(row);
-    }
-    for (; next < pending.length; next++) {
-        merged.push(pending[next].row);
-    }
-    return merged;
+    merged.push(row);
+  }
+  for (; next < pending.length; next++) {
+    merged.push(pending[next].row);
+  }
+  return merged;
 }
 /*
  * What goes among a thread's rows by its moment: the visuals, then the app's cards, so a visual comes
  * first among rows of the same moment. `visuals` is null where the host draws none.
  */
 export function timedRowsOf(cards, visuals, heldFrom = null) {
-    return [...(visuals === null ? [] : visualRows(visuals, heldFrom)), ...cardRows(cards)];
-}
+  return [...(visuals === null ? [] : visualRows(visuals, heldFrom)), ...cardRows(cards)];
+}

package/dist/chat/logic/timeline-copy.js

@@ -10,50 +10,42 @@ import { stripAnsi } from './ansi.js';
  * `file_path`.
  */
 export function stripMarkdown(text) {
-    return text
-        .replace(/^ *```[^\n]*\n?/gm, '')
-        .replace(/^ *(#{1,6}) +/gm, '')
-        .replace(/^ *> ?/gm, '')
-        .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
-        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
-        .replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/g, '$2')
-        .replace(/\*(?=\S)([^*\n]*\S)\*/g, '$1')
-        .replace(/`+([^`]+)`+/g, '$1')
-        .trim();
+  return text.replace(/^ *```[^\n]*\n?/gm, '').replace(/^ *(#{1,6}) +/gm, '').replace(/^ *> ?/gm, '').replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/g, '$2').replace(/\*(?=\S)([^*\n]*\S)\*/g, '$1').replace(/`+([^`]+)`+/g, '$1').trim();
 }
 /* What a tool call has to show for itself: what it answered, or what it has answered so far. */
 function outputOf(tool) {
-    const output = tool.output ?? tool.progress?.output ?? null;
-    return output === null ? null : stripAnsi(output);
+  const output = tool.output ?? tool.progress?.output ?? null;
+  return output === null ? null : stripAnsi(output);
 }
 /* The whole item under the pointer as plain text, or null for a row that carries no message. */
 export function messageTextOf(row) {
-    switch (row.kind) {
-        case 'user':
-            return row.item.text || null;
-        case 'assistant':
-            return stripMarkdown(row.item.text) || null;
-        case 'report':
-            return stripMarkdown(row.text) || null;
-        case 'thinking':
-            return row.item.text || null;
-        case 'work':
-        case 'work-live':
-        case 'workflow':
-            return outputOf(row.tool);
-        case 'work-group': {
-            const outputs = row.tools.map(outputOf).filter((output) => output !== null);
-            return outputs.length > 0 ? outputs.join('\n\n') : null;
-        }
-        case 'subagent':
-            return row.item.result ?? row.item.summary ?? null;
-        case 'note':
-            return row.text;
-        default:
-            return null;
-    }
+  switch (row.kind) {
+    case 'user':
+      return row.item.text || null;
+    case 'assistant':
+      return stripMarkdown(row.item.text) || null;
+    case 'report':
+      return stripMarkdown(row.text) || null;
+    case 'thinking':
+      return row.item.text || null;
+    case 'work':
+    case 'work-live':
+    case 'workflow':
+      return outputOf(row.tool);
+    case 'work-group':
+      {
+        const outputs = row.tools.map(outputOf).filter(output => output !== null);
+        return outputs.length > 0 ? outputs.join('\n\n') : null;
+      }
+    case 'subagent':
+      return row.item.result ?? row.item.summary ?? null;
+    case 'note':
+      return row.text;
+    default:
+      return null;
+  }
 }
 /* The markdown an answer was written in; every other row has none to copy. */
 export function markdownOf(row) {
-    return row.kind === 'assistant' ? row.item.text || null : row.kind === 'report' ? row.text || null : null;
-}
+  return row.kind === 'assistant' ? row.item.text || null : row.kind === 'report' ? row.text || null : null;
+}