@athenaintel/react 0.43.0 → 0.48.0

package/dist/chat/super-grouping/activity-timeline.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"activity-timeline.cjs","sources":["../../../src/chat/super-grouping/activity-timeline.ts"],"sourcesContent":["/**\n * The assistant turn's activity timeline — the one derivation of \"what did\n * this turn do, and how did each step end\" behind the collapsed view\n * (previously called the conversational view) on every surface: the SDK's\n * `AthenaChat`, Olympus's Spaces chat, and the Chrome extension. Pure\n * functions over assistant-ui message parts; `SuperGroupingCard` renders them.\n *\n * Step states come from the shared classifier (`classifyToolResult`) plus the\n * approval outcomes a part carries (`approval`, `interrupt`, a rejection\n * result), so a call that reads as failed, paused, or rejected on one surface\n * cannot read as a green check on another. Copy comes from the shared tool\n * summary registry (`summarizeToolCall`), itself built on the display\n * registry.\n */\nimport type {\n  MessageStatus,\n  ThreadAssistantMessagePart,\n  ToolCallMessagePartStatus,\n} from '@assistant-ui/react';\nimport {\n  classifyToolResult,\n  isRunningToolPlaceholderArtifact,\n  isSpokenTurnTextPart,\n  readRejectedToolResult,\n  type ToolStatusLabelState,\n} from '@athenaintel/agent-runtime';\nimport { summarizeToolCall, type ToolCallSummary } from '../../tools/tool-summary';\nimport type { GroupablePart, GroupingFunction } from './grouping-function';\n\nexport type ActivityToolState = ToolStatusLabelState;\n\nexport type ActivityItem =\n  | {\n      kind: 'reasoning';\n      id?: string;\n      /** Position of the part in the message's content. */\n      partIndex?: number;\n      text: string;\n      state: 'running' | 'complete';\n    }\n  | {\n      kind: 'tool';\n      id?: string;\n      /** Position of the part in the message's content. */\n      partIndex?: number;\n      toolName: string;\n      args?: ToolCallPart['args'];\n      /** The tool's real result; absent while it runs or holds only the streaming placeholder. */\n      result?: unknown;\n      state: ActivityToolState;\n    };\n\n/** The turn as a whole: still working, parked on the person, ended in error, or done. */\nexport type ActivityPhase = 'running' | 'waiting' | 'complete' | 'error';\n\ntype ToolCallPart = Extract<ThreadAssistantMessagePart, { type: 'tool-call' }>;\n\nexport interface ActivityTimelineOptions {\n  /**\n   * Tools whose unresolved call means the turn is waiting on the person even\n   * without an interrupt or approval on the part (the Chrome extension's\n   * device plan approval, which the tool UI itself collects).\n   */\n  waitingTools?: ReadonlySet<string>;\n  /**\n   * Calls the run is parked on, by tool-call id, as the host reads them off\n   * its pending approval: a gated call, or (in Olympus) a `task` call whose\n   * subagent waits on an approval. Any of them still without its real result\n   * reads as waiting.\n   */\n  waitingToolCallIds?: ReadonlySet<string>;\n  /**\n   * Tools whose result is an application payload relayed verbatim (the Chrome\n   * extension's page JavaScript), so a `success: false` flag counts only with\n   * an error detail — see `classifyToolResult`'s `passThroughPayload`.\n   */\n  passThroughTools?: ReadonlySet<string>;\n}\n\nconst NO_TOOLS: ReadonlySet<string> = new Set();\nconst NO_TOOL_CALLS: ReadonlySet<string> = new Set();\n\n/**\n * Whether a tool-call part still holds the backend's running-tool placeholder\n * result rather than the tool's real output. Long-running tools (task\n * subagents, studio and Python execution, deep research) append a ToolMessage\n * the moment they start so their card can fill in live; its marker reaches the\n * part's artifact (`isRunningToolPlaceholderArtifact`). The real ToolMessage\n * that replaces it has no such marker, so a defined `result` alone does not\n * mean the tool is done.\n */\nexport function isStreamingToolPlaceholder(part: Pick<ToolCallPart, 'artifact'>): boolean {\n  return isRunningToolPlaceholderArtifact(part.artifact);\n}\n\n/** The tool's real result: undefined while it has none or only the streaming placeholder. */\nfunction finalResult(part: ToolCallPart): unknown {\n  return isStreamingToolPlaceholder(part) ? undefined : part.result;\n}\n\nfunction toolCallStatus(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n): ToolCallMessagePartStatus | undefined {\n  if (finalResult(part) !== undefined) return { type: 'complete' };\n  if (messageStatus?.type === 'incomplete') {\n    return {\n      type: 'incomplete',\n      reason: messageStatus.reason === 'tool-calls' ? 'other' : messageStatus.reason,\n      error: messageStatus.error,\n    };\n  }\n  if (messageStatus?.type === 'complete') {\n    // The placeholder is the backend's word that the call is still in flight.\n    // A turn reads `complete` whenever nothing streams (a run parked on an\n    // approval inside a subagent, the gap before a drained run resumes), and\n    // assistant-ui counts the placeholder as the call's result when it settles\n    // that status, so the turn's status cannot finish the call.\n    return isStreamingToolPlaceholder(part) ? { type: 'running' } : { type: 'complete' };\n  }\n  if (messageStatus?.type === 'requires-action') {\n    return { type: 'requires-action', reason: messageStatus.reason };\n  }\n  if (messageStatus?.type === 'running') return { type: 'running' };\n  return undefined;\n}\n\n/** How one tool call ended (or is going), reading the approval fields before the result. */\nexport function getActivityToolState(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n  {\n    waitingTools = NO_TOOLS,\n    waitingToolCallIds = NO_TOOL_CALLS,\n    passThroughTools = NO_TOOLS,\n  }: ActivityTimelineOptions = {},\n): ActivityToolState {\n  if (part.approval?.approved === false || readRejectedToolResult(part.result) !== null) {\n    return 'rejected';\n  }\n  if (part.approval?.resolution === 'cancelled' || part.approval?.resolution === 'expired') {\n    return 'cancelled';\n  }\n  const result = finalResult(part);\n  const unresolved = result === undefined;\n  const messageIsActive =\n    messageStatus === undefined ||\n    messageStatus.type === 'running' ||\n    messageStatus.type === 'requires-action';\n  if (\n    unresolved &&\n    (part.interrupt?.type === 'human' ||\n      (part.approval !== undefined &&\n        part.approval.approved === undefined &&\n        part.approval.resolution === undefined) ||\n      waitingToolCallIds.has(part.toolCallId) ||\n      (waitingTools.has(part.toolName) && messageIsActive))\n  ) {\n    return 'waiting';\n  }\n\n  const classification = classifyToolResult({\n    status: toolCallStatus(part, messageStatus),\n    result,\n    isError: part.isError,\n    passThroughPayload: passThroughTools.has(part.toolName),\n  });\n  if (classification.state === 'requires-action') return 'waiting';\n  return classification.state;\n}\n\n/**\n * The compact reasoning/tool timeline in the order the parts streamed.\n *\n * A reasoning part is still streaming only while it is the final part of a\n * running message — once any later part appears, the thought has settled.\n * Settled reasoning parts with no text are dropped so the list never shows an\n * empty thinking row.\n */\nexport function buildActivityTimeline(\n  content: readonly ThreadAssistantMessagePart[] | undefined,\n  messageStatus: MessageStatus | undefined,\n  options: ActivityTimelineOptions = {},\n): ActivityItem[] {\n  if (!content?.length) return [];\n\n  const lastPartIndex = content.length - 1;\n  const timeline: ActivityItem[] = [];\n  for (let index = 0; index < content.length; index += 1) {\n    const part = content[index];\n    if (part.type === 'tool-call') {\n      const result = finalResult(part);\n      timeline.push({\n        kind: 'tool',\n        id: part.toolCallId,\n        partIndex: index,\n        args: part.args,\n        ...(result !== undefined ? { result } : {}),\n        toolName: part.toolName,\n        state: getActivityToolState(part, messageStatus, options),\n      });\n      continue;\n    }\n    if (part.type !== 'reasoning') continue;\n\n    const text = typeof part.text === 'string' ? part.text : '';\n    const stillStreaming = messageStatus?.type === 'running' && index === lastPartIndex;\n    if (!stillStreaming && text.trim() === '') continue;\n    timeline.push({\n      kind: 'reasoning',\n      id: `reasoning-${index}`,\n      partIndex: index,\n      text,\n      state: stillStreaming ? 'running' : 'complete',\n    });\n  }\n  return timeline;\n}\n\n/** Number of tool calls in the timeline. */\nexport function countActivityTools(timeline: readonly ActivityItem[]): number {\n  return timeline.reduce((count, item) => (item.kind === 'tool' ? count + 1 : count), 0);\n}\n\n/**\n * The turn's phase. Waiting on the person wins over everything — a\n * `requires-action` status, a waiting tool, or a host's own `waitingForInput`\n * assertion (no in-repo host passes one) — then the message's own status. A\n * complete turn with a step still running is running: only a step holding the\n * backend's running placeholder reads so once nothing streams (a run parked on\n * an approval inside a subagent, the gap before a drained run resumes).\n */\nexport function resolveActivityPhase(\n  status: MessageStatus | undefined,\n  timeline: readonly ActivityItem[],\n  { waitingForInput = false }: { waitingForInput?: boolean } = {},\n): ActivityPhase {\n  if (\n    waitingForInput ||\n    status?.type === 'requires-action' ||\n    timeline.some((item) => item.kind === 'tool' && item.state === 'waiting')\n  ) {\n    return 'waiting';\n  }\n  if (status?.type === 'running') return 'running';\n  if (status?.type === 'incomplete') return 'error';\n  if (\n    status?.type === 'complete' &&\n    timeline.some((item) => item.kind === 'tool' && item.state === 'running')\n  ) {\n    return 'running';\n  }\n  return 'complete';\n}\n\n/**\n * A settled thought's row: the heading a reasoning summary opens with\n * (\"**Checking the workstation**\" → \"Checking the workstation\"), else the\n * generic wording. The thought itself stays in the run's details.\n */\nexport function getReasoningLabel(text: string, state: 'running' | 'complete'): string {\n  if (state === 'running') return 'Thinking';\n  const heading = /^\\s*\\*\\*([^*\\n]{3,80}?)\\*\\*/.exec(text)?.[1]?.trim();\n  return heading ? heading.replace(/[.:]+$/, '') : 'Thought through the next step';\n}\n\n/**\n * The status-row copy for one step: the call's own summary from the shared\n * summary registry (`summarizeToolCall`: \"Ran git status\", \"Read config.ts\").\n * `resolveToolDisplayName` lets a host with a richer tool catalog name tools\n * neither registry has an entry for; `assetTitles` names the machine or\n * document a call targeted by id when an earlier result in the turn did.\n */\nexport function getActivityItemLabel(\n  item: ActivityItem,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n  assetTitles?: ReadonlyMap<string, string>,\n): string {\n  if (item.kind === 'reasoning') return getReasoningLabel(item.text, item.state);\n  return summarizeActivityTool(item, resolveToolDisplayName, assetTitles).label;\n}\n\n/** The summary of one tool step (see {@link getActivityItemLabel}). */\nexport function summarizeActivityTool(\n  item: Extract<ActivityItem, { kind: 'tool' }>,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n  assetTitles?: ReadonlyMap<string, string>,\n): ToolCallSummary {\n  return summarizeToolCall({\n    toolName: item.toolName,\n    args: item.args,\n    result: item.result,\n    status: item.state,\n    ...(assetTitles ? { assetTitles } : {}),\n    ...(resolveToolDisplayName ? { displayName: resolveToolDisplayName(item.toolName) } : {}),\n  });\n}\n\n/**\n * The collapsed-card summary of a finished turn. \"Completed with issues\" means\n * the turn ended on a problem: a call the person refused, or a failed call\n * that no later call completed after. A failed command the agent then got past\n * (a search that found nothing, a retry that worked) is ordinary work, so a\n * long turn that recovered from it reads as the tools it used.\n */\nexport function getActivitySummary(timeline: readonly ActivityItem[]): string {\n  const toolCount = countActivityTools(timeline);\n  const tools = timeline.filter((item) => item.kind === 'tool');\n  const lastFailure = tools.findLastIndex((item) => item.state === 'error');\n  const endedOnFailure =\n    lastFailure >= 0 && !tools.slice(lastFailure + 1).some((item) => item.state === 'complete');\n  const hasIssue = endedOnFailure || tools.some((item) => item.state === 'rejected');\n  if (hasIssue) return 'Completed with issues';\n  if (timeline.some((item) => item.kind === 'tool' && item.state === 'cancelled')) {\n    return 'Action cancelled';\n  }\n  if (timeline.some((item) => item.kind === 'tool' && item.state === 'paused')) {\n    return 'Paused during tool use';\n  }\n  if (toolCount > 0) return `Used ${toolCount} ${toolCount === 1 ? 'tool' : 'tools'}`;\n  return 'Reasoning complete';\n}\n\n/** The part shape the final-text read needs; any message role's parts satisfy it. */\nexport type FinalTextPart = { readonly type: string; readonly text?: string };\n\n/**\n * Whether a text part shows below the card instead of in the details panel:\n * it comes after the final tool call, or it holds a spoken voice turn's words\n * (a live turn heard during a delegated run lands between the run's tool\n * calls, see `isSpokenTurnTextPart`; it is the conversation, not narration).\n */\nfunction isAnswerTextPart(\n  part: { readonly type: string } | undefined,\n  index: number,\n  lastToolIndex: number,\n): boolean {\n  return part?.type === 'text' && (index > lastToolIndex || isSpokenTurnTextPart(part));\n}\n\n/**\n * The visible answer of a grouped turn: the text after the final tool call\n * (all of it when the turn never called a tool), plus the words of every\n * spoken voice turn in the message, in order. Other intermediate text (before\n * or between tool calls) stays available in the details panel.\n */\nexport function getFinalText(content: readonly FinalTextPart[] | undefined): string | null {\n  const parts = getFinalTextParts(content);\n  return parts.length > 0 ? parts.map((part) => part.text).join('\\n\\n') : null;\n}\n\n/** One text part of the visible answer, with its index in the message content. */\nexport interface FinalTextSegment {\n  index: number;\n  text: string;\n}\n\n/**\n * The parts `getFinalText` joins, each kept separate with its content index.\n * A spoken turn and the run's own reply can stream at the same time, so the\n * earlier part may grow while a later one exists: rendered as one joined\n * string, that text changes in the middle rather than at its end, and the\n * streaming reveal restarts from an empty bubble on every word.\n */\nexport function getFinalTextParts(content: readonly FinalTextPart[] | undefined): FinalTextSegment[] {\n  if (!content?.length) return [];\n\n  const lastToolIndex = content.findLastIndex((part) => part?.type === 'tool-call');\n  const parts: FinalTextSegment[] = [];\n  content.forEach((part, index) => {\n    if (part.text && isAnswerTextPart(part, index, lastToolIndex)) parts.push({ index, text: part.text });\n  });\n  return parts;\n}\n\n/**\n * Keep the answer out of the details panel: it renders below the card\n * (`SuperGroupingFinalText`), so the details grouping drops every text part\n * `getFinalText` shows and any group that becomes empty.\n */\nexport function excludeFinalTextFromGroups(grouping: GroupingFunction): GroupingFunction {\n  return (parts) => {\n    const lastToolIndex = parts.findLastIndex((part) => part?.type === 'tool-call');\n    return grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => !isAnswerTextPart(parts[index], index, lastToolIndex)),\n      }))\n      .filter((group) => group.indices.length > 0);\n  };\n}\n\n/**\n * Drop the parts `exclude` matches from every group, and any group left\n * empty: `SuperGroupingCard` renders inline tool calls outside the details,\n * so they must not render a second time inside it.\n */\nexport function excludePartsFromGroups(\n  grouping: GroupingFunction,\n  exclude: (part: GroupablePart) => boolean,\n): GroupingFunction {\n  return (parts) =>\n    grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => {\n          const part = parts[index];\n          return part === undefined || !exclude(part);\n        }),\n      }))\n      .filter((group) => group.indices.length > 0);\n}\n"],"names":["isRunningToolPlaceholderArtifact","readRejectedToolResult","classifyToolResult","summarizeToolCall","isSpokenTurnTextPart"],"mappings":"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"}
+{"version":3,"file":"activity-timeline.cjs","sources":["../../../src/chat/super-grouping/activity-timeline.ts"],"sourcesContent":["/**\n * The assistant turn's activity timeline — the one derivation of \"what did\n * this turn do, and how did each step end\" behind the collapsed view\n * (previously called the conversational view) on every surface: the SDK's\n * `AthenaChat`, Olympus's Spaces chat, and the Chrome extension. Pure\n * functions over assistant-ui message parts; `SuperGroupingCard` renders them.\n *\n * Step states come from the shared classifier (`classifyToolResult`) plus the\n * approval outcomes a part carries (`approval`, `interrupt`, a rejection\n * result), so a call that reads as failed, paused, or rejected on one surface\n * cannot read as a green check on another. Copy comes from the shared tool\n * summary registry (`summarizeToolCall`), itself built on the display\n * registry.\n */\nimport type {\n  MessageStatus,\n  ThreadAssistantMessagePart,\n  ToolCallMessagePartStatus,\n} from '@assistant-ui/react';\nimport {\n  classifyToolResult,\n  countInEvalDispatches,\n  EVAL_TOOL_NAME,\n  isRunningToolPlaceholderArtifact,\n  isSpokenTurnTextPart,\n  readRejectedToolResult,\n  TASK_TOOL_NAME,\n  type ToolStatusLabelState,\n} from '@athenaintel/agent-runtime';\nimport { summarizeToolCall, type ToolCallSummary } from '../../tools/tool-summary';\nimport type { GroupablePart, GroupingFunction } from './grouping-function';\n\nexport type ActivityToolState = ToolStatusLabelState;\n\nexport type ActivityItem =\n  | {\n      kind: 'reasoning';\n      id?: string;\n      /** Position of the part in the message's content. */\n      partIndex?: number;\n      text: string;\n      state: 'running' | 'complete';\n    }\n  | {\n      kind: 'tool';\n      id?: string;\n      /** Position of the part in the message's content. */\n      partIndex?: number;\n      toolName: string;\n      args?: ToolCallPart['args'];\n      /** The tool's real result; absent while it runs or holds only the streaming placeholder. */\n      result?: unknown;\n      state: ActivityToolState;\n      /**\n       * Subagents the call delegated to: for a `task` call one, or none when it\n       * was refused, withdrawn or expired at its approval and never ran; for an\n       * `eval` call its in-interpreter `task()` dispatches\n       * (`countInEvalDispatches`), absent when it made none.\n       */\n      delegations?: number;\n    };\n\n/** The turn as a whole: still working, parked on the person, ended in error, or done. */\nexport type ActivityPhase = 'running' | 'waiting' | 'complete' | 'error';\n\ntype ToolCallPart = Extract<ThreadAssistantMessagePart, { type: 'tool-call' }>;\n\nexport interface ActivityTimelineOptions {\n  /**\n   * Tools whose unresolved call means the turn is waiting on the person even\n   * without an interrupt or approval on the part (the Chrome extension's\n   * device plan approval, which the tool UI itself collects).\n   */\n  waitingTools?: ReadonlySet<string>;\n  /**\n   * Calls the run is parked on, by tool-call id, as the host reads them off\n   * its pending approval: a gated call, or (in Olympus) a `task` call whose\n   * subagent waits on an approval. Any of them still without its real result\n   * reads as waiting.\n   */\n  waitingToolCallIds?: ReadonlySet<string>;\n  /**\n   * Tools whose result is an application payload relayed verbatim (the Chrome\n   * extension's page JavaScript), so a `success: false` flag counts only with\n   * an error detail — see `classifyToolResult`'s `passThroughPayload`.\n   */\n  passThroughTools?: ReadonlySet<string>;\n}\n\nconst NO_TOOLS: ReadonlySet<string> = new Set();\nconst NO_TOOL_CALLS: ReadonlySet<string> = new Set();\n\n/**\n * Whether a tool-call part still holds the backend's running-tool placeholder\n * result rather than the tool's real output. Long-running tools (task\n * subagents, studio and Python execution, deep research) append a ToolMessage\n * the moment they start so their card can fill in live; its marker reaches the\n * part's artifact (`isRunningToolPlaceholderArtifact`). The real ToolMessage\n * that replaces it has no such marker, so a defined `result` alone does not\n * mean the tool is done.\n */\nexport function isStreamingToolPlaceholder(part: Pick<ToolCallPart, 'artifact'>): boolean {\n  return isRunningToolPlaceholderArtifact(part.artifact);\n}\n\n/** The tool's real result: undefined while it has none or only the streaming placeholder. */\nfunction finalResult(part: ToolCallPart): unknown {\n  return isStreamingToolPlaceholder(part) ? undefined : part.result;\n}\n\nfunction toolCallStatus(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n): ToolCallMessagePartStatus | undefined {\n  if (finalResult(part) !== undefined) return { type: 'complete' };\n  if (messageStatus?.type === 'incomplete') {\n    return {\n      type: 'incomplete',\n      reason: messageStatus.reason === 'tool-calls' ? 'other' : messageStatus.reason,\n      error: messageStatus.error,\n    };\n  }\n  if (messageStatus?.type === 'complete') {\n    // The placeholder is the backend's word that the call is still in flight.\n    // A turn reads `complete` whenever nothing streams (a run parked on an\n    // approval inside a subagent, the gap before a drained run resumes), and\n    // assistant-ui counts the placeholder as the call's result when it settles\n    // that status, so the turn's status cannot finish the call.\n    return isStreamingToolPlaceholder(part) ? { type: 'running' } : { type: 'complete' };\n  }\n  if (messageStatus?.type === 'requires-action') {\n    return { type: 'requires-action', reason: messageStatus.reason };\n  }\n  if (messageStatus?.type === 'running') return { type: 'running' };\n  return undefined;\n}\n\n/** How one tool call ended (or is going), reading the approval fields before the result. */\nexport function getActivityToolState(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n  {\n    waitingTools = NO_TOOLS,\n    waitingToolCallIds = NO_TOOL_CALLS,\n    passThroughTools = NO_TOOLS,\n  }: ActivityTimelineOptions = {},\n): ActivityToolState {\n  if (part.approval?.approved === false || readRejectedToolResult(part.result) !== null) {\n    return 'rejected';\n  }\n  if (part.approval?.resolution === 'cancelled' || part.approval?.resolution === 'expired') {\n    return 'cancelled';\n  }\n  const result = finalResult(part);\n  const unresolved = result === undefined;\n  const messageIsActive =\n    messageStatus === undefined ||\n    messageStatus.type === 'running' ||\n    messageStatus.type === 'requires-action';\n  if (\n    unresolved &&\n    (part.interrupt?.type === 'human' ||\n      (part.approval !== undefined &&\n        part.approval.approved === undefined &&\n        part.approval.resolution === undefined) ||\n      waitingToolCallIds.has(part.toolCallId) ||\n      (waitingTools.has(part.toolName) && messageIsActive))\n  ) {\n    return 'waiting';\n  }\n\n  const classification = classifyToolResult({\n    status: toolCallStatus(part, messageStatus),\n    result,\n    isError: part.isError,\n    passThroughPayload: passThroughTools.has(part.toolName),\n  });\n  if (classification.state === 'requires-action') return 'waiting';\n  return classification.state;\n}\n\n/**\n * The compact reasoning/tool timeline in the order the parts streamed.\n *\n * A reasoning part is still streaming only while it is the final part of a\n * running message — once any later part appears, the thought has settled.\n * Settled reasoning parts with no text are dropped so the list never shows an\n * empty thinking row.\n */\nexport function buildActivityTimeline(\n  content: readonly ThreadAssistantMessagePart[] | undefined,\n  messageStatus: MessageStatus | undefined,\n  options: ActivityTimelineOptions = {},\n): ActivityItem[] {\n  if (!content?.length) return [];\n\n  const lastPartIndex = content.length - 1;\n  const timeline: ActivityItem[] = [];\n  for (let index = 0; index < content.length; index += 1) {\n    const part = content[index];\n    if (part.type === 'tool-call') {\n      const result = finalResult(part);\n      const state = getActivityToolState(part, messageStatus, options);\n      const delegations = toolCallDelegations({ part, state });\n      timeline.push({\n        kind: 'tool',\n        id: part.toolCallId,\n        partIndex: index,\n        args: part.args,\n        ...(result !== undefined ? { result } : {}),\n        toolName: part.toolName,\n        state,\n        ...(delegations !== null ? { delegations } : {}),\n      });\n      continue;\n    }\n    if (part.type !== 'reasoning') continue;\n\n    const text = typeof part.text === 'string' ? part.text : '';\n    const stillStreaming = messageStatus?.type === 'running' && index === lastPartIndex;\n    if (!stillStreaming && text.trim() === '') continue;\n    timeline.push({\n      kind: 'reasoning',\n      id: `reasoning-${index}`,\n      partIndex: index,\n      text,\n      state: stillStreaming ? 'running' : 'complete',\n    });\n  }\n  return timeline;\n}\n\n/**\n * Subagents one tool call delegated to (see `ActivityItem.delegations`), or\n * `null` for a call that delegates by nature of neither: a `task` call one,\n * unless the person refused it or its approval was withdrawn or expired (it\n * never ran); an `eval` call its in-interpreter dispatches, when it made any.\n */\nfunction toolCallDelegations({\n  part,\n  state,\n}: {\n  part: ToolCallPart;\n  state: ActivityToolState;\n}): number | null {\n  if (part.toolName === TASK_TOOL_NAME) {\n    const withdrawn =\n      part.approval?.resolution === 'cancelled' || part.approval?.resolution === 'expired';\n    return state === 'rejected' || withdrawn ? 0 : 1;\n  }\n  if (part.toolName === EVAL_TOOL_NAME) {\n    const dispatches = countInEvalDispatches(part.artifact);\n    return dispatches > 0 ? dispatches : null;\n  }\n  return null;\n}\n\n/** Number of tool calls in the timeline. */\nexport function countActivityTools(timeline: readonly ActivityItem[]): number {\n  return timeline.reduce((count, item) => (item.kind === 'tool' ? count + 1 : count), 0);\n}\n\n/**\n * Subagents the turn delegated to: its `task` calls that ran, plus the\n * `task()` dispatches its `eval` calls made from inside the interpreter. A\n * `task` step built without its count (a host's own timeline) counts unless it\n * reads refused or cancelled.\n */\nexport function countActivityDelegations(timeline: readonly ActivityItem[]): number {\n  return timeline.reduce((count, item) => {\n    if (item.kind !== 'tool') return count;\n    if (item.delegations !== undefined) return count + item.delegations;\n    const ranTask =\n      item.toolName === TASK_TOOL_NAME && item.state !== 'rejected' && item.state !== 'cancelled';\n    return ranTask ? count + 1 : count;\n  }, 0);\n}\n\n/**\n * The turn's phase. Waiting on the person wins over everything — a\n * `requires-action` status, a waiting tool, or a host's own `waitingForInput`\n * assertion (no in-repo host passes one) — then the message's own status. A\n * complete turn with a step still running is running: only a step holding the\n * backend's running placeholder reads so once nothing streams (a run parked on\n * an approval inside a subagent, the gap before a drained run resumes).\n */\nexport function resolveActivityPhase(\n  status: MessageStatus | undefined,\n  timeline: readonly ActivityItem[],\n  { waitingForInput = false }: { waitingForInput?: boolean } = {},\n): ActivityPhase {\n  if (\n    waitingForInput ||\n    status?.type === 'requires-action' ||\n    timeline.some((item) => item.kind === 'tool' && item.state === 'waiting')\n  ) {\n    return 'waiting';\n  }\n  if (status?.type === 'running') return 'running';\n  if (status?.type === 'incomplete') return 'error';\n  if (\n    status?.type === 'complete' &&\n    timeline.some((item) => item.kind === 'tool' && item.state === 'running')\n  ) {\n    return 'running';\n  }\n  return 'complete';\n}\n\n/**\n * A settled thought's row: the heading a reasoning summary opens with\n * (\"**Checking the workstation**\" → \"Checking the workstation\"), else the\n * generic wording. The thought itself stays in the run's details.\n */\nexport function getReasoningLabel(text: string, state: 'running' | 'complete'): string {\n  if (state === 'running') return 'Thinking';\n  const heading = /^\\s*\\*\\*([^*\\n]{3,80}?)\\*\\*/.exec(text)?.[1]?.trim();\n  return heading ? heading.replace(/[.:]+$/, '') : 'Thought through the next step';\n}\n\n/**\n * The status-row copy for one step: the call's own summary from the shared\n * summary registry (`summarizeToolCall`: \"Ran git status\", \"Read config.ts\").\n * `resolveToolDisplayName` lets a host with a richer tool catalog name tools\n * neither registry has an entry for; `assetTitles` names the machine or\n * document a call targeted by id when an earlier result in the turn did.\n */\nexport function getActivityItemLabel(\n  item: ActivityItem,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n  assetTitles?: ReadonlyMap<string, string>,\n): string {\n  if (item.kind === 'reasoning') return getReasoningLabel(item.text, item.state);\n  return summarizeActivityTool(item, resolveToolDisplayName, assetTitles).label;\n}\n\n/** The summary of one tool step (see {@link getActivityItemLabel}). */\nexport function summarizeActivityTool(\n  item: Extract<ActivityItem, { kind: 'tool' }>,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n  assetTitles?: ReadonlyMap<string, string>,\n): ToolCallSummary {\n  return summarizeToolCall({\n    toolName: item.toolName,\n    args: item.args,\n    result: item.result,\n    status: item.state,\n    ...(assetTitles ? { assetTitles } : {}),\n    ...(resolveToolDisplayName ? { displayName: resolveToolDisplayName(item.toolName) } : {}),\n  });\n}\n\n/**\n * The collapsed-card summary of a finished turn. \"Completed with issues\" means\n * the turn ended on a problem: a call the person refused, or a failed call\n * that no later call completed after. A failed command the agent then got past\n * (a search that found nothing, a retry that worked) is ordinary work, so a\n * long turn that recovered from it reads as the tools it used.\n *\n * A turn that delegated work leads with it — \"Delegated to 10 agents · used 6\n * tools\" — counting its `task` calls and the `task()` dispatches its `eval`\n * calls made from inside the interpreter (`countActivityDelegations`). A\n * `task` call is the delegation itself, so the tools it is followed by are the\n * turn's other calls; an outcome above replaces them (\"Delegated to 3 agents ·\n * completed with issues\").\n */\nexport function getActivitySummary(timeline: readonly ActivityItem[]): string {\n  const tools = timeline.filter((item): item is ToolActivityItem => item.kind === 'tool');\n  const outcome = activityOutcome(tools);\n  const delegations = countActivityDelegations(timeline);\n  if (delegations > 0) {\n    const lead = `Delegated to ${delegations} ${delegations === 1 ? 'agent' : 'agents'}`;\n    const otherTools = tools.filter((item) => item.toolName !== TASK_TOOL_NAME).length;\n    const rest = outcome\n      ? `${outcome.charAt(0).toLowerCase()}${outcome.slice(1)}`\n      : otherTools > 0\n        ? `used ${otherTools} ${otherTools === 1 ? 'tool' : 'tools'}`\n        : null;\n    return rest ? `${lead} · ${rest}` : lead;\n  }\n  if (outcome) return outcome;\n  if (tools.length > 0) return `Used ${tools.length} ${tools.length === 1 ? 'tool' : 'tools'}`;\n  return 'Reasoning complete';\n}\n\ntype ToolActivityItem = Extract<ActivityItem, { kind: 'tool' }>;\n\n/** How a finished turn's tool calls ended, when that is not simply the tools it used. */\nfunction activityOutcome(tools: readonly ToolActivityItem[]): string | null {\n  const lastFailure = tools.findLastIndex((item) => item.state === 'error');\n  const endedOnFailure =\n    lastFailure >= 0 && !tools.slice(lastFailure + 1).some((item) => item.state === 'complete');\n  if (endedOnFailure || tools.some((item) => item.state === 'rejected')) return 'Completed with issues';\n  if (tools.some((item) => item.state === 'cancelled')) return 'Action cancelled';\n  if (tools.some((item) => item.state === 'paused')) return 'Paused during tool use';\n  return null;\n}\n\n/** The part shape the final-text read needs; any message role's parts satisfy it. */\nexport type FinalTextPart = { readonly type: string; readonly text?: string };\n\n/**\n * Whether a text part shows below the card instead of in the details panel:\n * it comes after the final tool call, or it holds a spoken voice turn's words\n * (a live turn heard during a delegated run lands between the run's tool\n * calls, see `isSpokenTurnTextPart`; it is the conversation, not narration).\n */\nfunction isAnswerTextPart(\n  part: { readonly type: string } | undefined,\n  index: number,\n  lastToolIndex: number,\n): boolean {\n  return part?.type === 'text' && (index > lastToolIndex || isSpokenTurnTextPart(part));\n}\n\n/**\n * The visible answer of a grouped turn: the text after the final tool call\n * (all of it when the turn never called a tool), plus the words of every\n * spoken voice turn in the message, in order. Other intermediate text (before\n * or between tool calls) stays available in the details panel.\n */\nexport function getFinalText(content: readonly FinalTextPart[] | undefined): string | null {\n  const parts = getFinalTextParts(content);\n  return parts.length > 0 ? parts.map((part) => part.text).join('\\n\\n') : null;\n}\n\n/** One text part of the visible answer, with its index in the message content. */\nexport interface FinalTextSegment {\n  index: number;\n  text: string;\n}\n\n/**\n * The parts `getFinalText` joins, each kept separate with its content index.\n * A spoken turn and the run's own reply can stream at the same time, so the\n * earlier part may grow while a later one exists: rendered as one joined\n * string, that text changes in the middle rather than at its end, and the\n * streaming reveal restarts from an empty bubble on every word.\n */\nexport function getFinalTextParts(content: readonly FinalTextPart[] | undefined): FinalTextSegment[] {\n  if (!content?.length) return [];\n\n  const lastToolIndex = content.findLastIndex((part) => part?.type === 'tool-call');\n  const parts: FinalTextSegment[] = [];\n  content.forEach((part, index) => {\n    if (part.text && isAnswerTextPart(part, index, lastToolIndex)) parts.push({ index, text: part.text });\n  });\n  return parts;\n}\n\n/**\n * Keep the answer out of the details panel: it renders below the card\n * (`SuperGroupingFinalText`), so the details grouping drops every text part\n * `getFinalText` shows and any group that becomes empty.\n */\nexport function excludeFinalTextFromGroups(grouping: GroupingFunction): GroupingFunction {\n  return (parts) => {\n    const lastToolIndex = parts.findLastIndex((part) => part?.type === 'tool-call');\n    return grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => !isAnswerTextPart(parts[index], index, lastToolIndex)),\n      }))\n      .filter((group) => group.indices.length > 0);\n  };\n}\n\n/**\n * Drop the parts `exclude` matches from every group, and any group left\n * empty: `SuperGroupingCard` renders inline tool calls outside the details,\n * so they must not render a second time inside it.\n */\nexport function excludePartsFromGroups(\n  grouping: GroupingFunction,\n  exclude: (part: GroupablePart) => boolean,\n): GroupingFunction {\n  return (parts) =>\n    grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => {\n          const part = parts[index];\n          return part === undefined || !exclude(part);\n        }),\n      }))\n      .filter((group) => group.indices.length > 0);\n}\n"],"names":["isRunningToolPlaceholderArtifact","readRejectedToolResult","classifyToolResult","TASK_TOOL_NAME","EVAL_TOOL_NAME","countInEvalDispatches","summarizeToolCall","isSpokenTurnTextPart"],"mappings":";;;;;;;;AAyFA,MAAM,+BAAoC,IAAA;AAC1C,MAAM,oCAAyC,IAAA;AAWxC,SAAS,2BAA2B,MAA+C;AACxF,SAAOA,uBAAAA,iCAAiC,KAAK,QAAQ;AACvD;AAGA,SAAS,YAAY,MAA6B;AAChD,SAAO,2BAA2B,IAAI,IAAI,SAAY,KAAK;AAC7D;AAEA,SAAS,eACP,MACA,eACuC;AACvC,MAAI,YAAY,IAAI,MAAM,OAAW,QAAO,EAAE,MAAM,WAAA;AACpD,OAAI,+CAAe,UAAS,cAAc;AACxC,WAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,cAAc,WAAW,eAAe,UAAU,cAAc;AAAA,MACxE,OAAO,cAAc;AAAA,IAAA;AAAA,EAEzB;AACA,OAAI,+CAAe,UAAS,YAAY;AAMtC,WAAO,2BAA2B,IAAI,IAAI,EAAE,MAAM,cAAc,EAAE,MAAM,WAAA;AAAA,EAC1E;AACA,OAAI,+CAAe,UAAS,mBAAmB;AAC7C,WAAO,EAAE,MAAM,mBAAmB,QAAQ,cAAc,OAAA;AAAA,EAC1D;AACA,OAAI,+CAAe,UAAS,UAAW,QAAO,EAAE,MAAM,UAAA;AACtD,SAAO;AACT;AAGO,SAAS,qBACd,MACA,eACA;AAAA,EACE,eAAe;AAAA,EACf,qBAAqB;AAAA,EACrB,mBAAmB;AACrB,IAA6B,IACV;;AACnB,QAAI,UAAK,aAAL,mBAAe,cAAa,SAASC,WAAAA,uBAAuB,KAAK,MAAM,MAAM,MAAM;AACrF,WAAO;AAAA,EACT;AACA,QAAI,UAAK,aAAL,mBAAe,gBAAe,iBAAe,UAAK,aAAL,mBAAe,gBAAe,WAAW;AACxF,WAAO;AAAA,EACT;AACA,QAAM,SAAS,YAAY,IAAI;AAC/B,QAAM,aAAa,WAAW;AAC9B,QAAM,kBACJ,kBAAkB,UAClB,cAAc,SAAS,aACvB,cAAc,SAAS;AACzB,MACE,iBACC,UAAK,cAAL,mBAAgB,UAAS,WACvB,KAAK,aAAa,UACjB,KAAK,SAAS,aAAa,UAC3B,KAAK,SAAS,eAAe,UAC/B,mBAAmB,IAAI,KAAK,UAAU,KACrC,aAAa,IAAI,KAAK,QAAQ,KAAK,kBACtC;AACA,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiBC,WAAAA,mBAAmB;AAAA,IACxC,QAAQ,eAAe,MAAM,aAAa;AAAA,IAC1C;AAAA,IACA,SAAS,KAAK;AAAA,IACd,oBAAoB,iBAAiB,IAAI,KAAK,QAAQ;AAAA,EAAA,CACvD;AACD,MAAI,eAAe,UAAU,kBAAmB,QAAO;AACvD,SAAO,eAAe;AACxB;AAUO,SAAS,sBACd,SACA,eACA,UAAmC,CAAA,GACnB;AAChB,MAAI,EAAC,mCAAS,QAAQ,QAAO,CAAA;AAE7B,QAAM,gBAAgB,QAAQ,SAAS;AACvC,QAAM,WAA2B,CAAA;AACjC,WAAS,QAAQ,GAAG,QAAQ,QAAQ,QAAQ,SAAS,GAAG;AACtD,UAAM,OAAO,QAAQ,KAAK;AAC1B,QAAI,KAAK,SAAS,aAAa;AAC7B,YAAM,SAAS,YAAY,IAAI;AAC/B,YAAM,QAAQ,qBAAqB,MAAM,eAAe,OAAO;AAC/D,YAAM,cAAc,oBAAoB,EAAE,MAAM,OAAO;AACvD,eAAS,KAAK;AAAA,QACZ,MAAM;AAAA,QACN,IAAI,KAAK;AAAA,QACT,WAAW;AAAA,QACX,MAAM,KAAK;AAAA,QACX,GAAI,WAAW,SAAY,EAAE,OAAA,IAAW,CAAA;AAAA,QACxC,UAAU,KAAK;AAAA,QACf;AAAA,QACA,GAAI,gBAAgB,OAAO,EAAE,gBAAgB,CAAA;AAAA,MAAC,CAC/C;AACD;AAAA,IACF;AACA,QAAI,KAAK,SAAS,YAAa;AAE/B,UAAM,OAAO,OAAO,KAAK,SAAS,WAAW,KAAK,OAAO;AACzD,UAAM,kBAAiB,+CAAe,UAAS,aAAa,UAAU;AACtE,QAAI,CAAC,kBAAkB,KAAK,KAAA,MAAW,GAAI;AAC3C,aAAS,KAAK;AAAA,MACZ,MAAM;AAAA,MACN,IAAI,aAAa,KAAK;AAAA,MACtB,WAAW;AAAA,MACX;AAAA,MACA,OAAO,iBAAiB,YAAY;AAAA,IAAA,CACrC;AAAA,EACH;AACA,SAAO;AACT;AAQA,SAAS,oBAAoB;AAAA,EAC3B;AAAA,EACA;AACF,GAGkB;;AAChB,MAAI,KAAK,aAAaC,0BAAgB;AACpC,UAAM,cACJ,UAAK,aAAL,mBAAe,gBAAe,iBAAe,UAAK,aAAL,mBAAe,gBAAe;AAC7E,WAAO,UAAU,cAAc,YAAY,IAAI;AAAA,EACjD;AACA,MAAI,KAAK,aAAaC,0BAAgB;AACpC,UAAM,aAAaC,UAAAA,sBAAsB,KAAK,QAAQ;AACtD,WAAO,aAAa,IAAI,aAAa;AAAA,EACvC;AACA,SAAO;AACT;AAGO,SAAS,mBAAmB,UAA2C;AAC5E,SAAO,SAAS,OAAO,CAAC,OAAO,SAAU,KAAK,SAAS,SAAS,QAAQ,IAAI,OAAQ,CAAC;AACvF;AAQO,SAAS,yBAAyB,UAA2C;AAClF,SAAO,SAAS,OAAO,CAAC,OAAO,SAAS;AACtC,QAAI,KAAK,SAAS,OAAQ,QAAO;AACjC,QAAI,KAAK,gBAAgB,OAAW,QAAO,QAAQ,KAAK;AACxD,UAAM,UACJ,KAAK,aAAaF,UAAAA,kBAAkB,KAAK,UAAU,cAAc,KAAK,UAAU;AAClF,WAAO,UAAU,QAAQ,IAAI;AAAA,EAC/B,GAAG,CAAC;AACN;AAUO,SAAS,qBACd,QACA,UACA,EAAE,kBAAkB,MAAA,IAAyC,IAC9C;AACf,MACE,oBACA,iCAAQ,UAAS,qBACjB,SAAS,KAAK,CAAC,SAAS,KAAK,SAAS,UAAU,KAAK,UAAU,SAAS,GACxE;AACA,WAAO;AAAA,EACT;AACA,OAAI,iCAAQ,UAAS,UAAW,QAAO;AACvC,OAAI,iCAAQ,UAAS,aAAc,QAAO;AAC1C,OACE,iCAAQ,UAAS,cACjB,SAAS,KAAK,CAAC,SAAS,KAAK,SAAS,UAAU,KAAK,UAAU,SAAS,GACxE;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAOO,SAAS,kBAAkB,MAAc,OAAuC;;AACrF,MAAI,UAAU,UAAW,QAAO;AAChC,QAAM,WAAU,yCAA8B,KAAK,IAAI,MAAvC,mBAA2C,OAA3C,mBAA+C;AAC/D,SAAO,UAAU,QAAQ,QAAQ,UAAU,EAAE,IAAI;AACnD;AASO,SAAS,qBACd,MACA,wBACA,aACQ;AACR,MAAI,KAAK,SAAS,YAAa,QAAO,kBAAkB,KAAK,MAAM,KAAK,KAAK;AAC7E,SAAO,sBAAsB,MAAM,wBAAwB,WAAW,EAAE;AAC1E;AAGO,SAAS,sBACd,MACA,wBACA,aACiB;AACjB,SAAOG,8BAAkB;AAAA,IACvB,UAAU,KAAK;AAAA,IACf,MAAM,KAAK;AAAA,IACX,QAAQ,KAAK;AAAA,IACb,QAAQ,KAAK;AAAA,IACb,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,IACpC,GAAI,yBAAyB,EAAE,aAAa,uBAAuB,KAAK,QAAQ,MAAM,CAAA;AAAA,EAAC,CACxF;AACH;AAgBO,SAAS,mBAAmB,UAA2C;AAC5E,QAAM,QAAQ,SAAS,OAAO,CAAC,SAAmC,KAAK,SAAS,MAAM;AACtF,QAAM,UAAU,gBAAgB,KAAK;AACrC,QAAM,cAAc,yBAAyB,QAAQ;AACrD,MAAI,cAAc,GAAG;AACnB,UAAM,OAAO,gBAAgB,WAAW,IAAI,gBAAgB,IAAI,UAAU,QAAQ;AAClF,UAAM,aAAa,MAAM,OAAO,CAAC,SAAS,KAAK,aAAaH,UAAAA,cAAc,EAAE;AAC5E,UAAM,OAAO,UACT,GAAG,QAAQ,OAAO,CAAC,EAAE,YAAA,CAAa,GAAG,QAAQ,MAAM,CAAC,CAAC,KACrD,aAAa,IACX,QAAQ,UAAU,IAAI,eAAe,IAAI,SAAS,OAAO,KACzD;AACN,WAAO,OAAO,GAAG,IAAI,MAAM,IAAI,KAAK;AAAA,EACtC;AACA,MAAI,QAAS,QAAO;AACpB,MAAI,MAAM,SAAS,EAAG,QAAO,QAAQ,MAAM,MAAM,IAAI,MAAM,WAAW,IAAI,SAAS,OAAO;AAC1F,SAAO;AACT;AAKA,SAAS,gBAAgB,OAAmD;AAC1E,QAAM,cAAc,MAAM,cAAc,CAAC,SAAS,KAAK,UAAU,OAAO;AACxE,QAAM,iBACJ,eAAe,KAAK,CAAC,MAAM,MAAM,cAAc,CAAC,EAAE,KAAK,CAAC,SAAS,KAAK,UAAU,UAAU;AAC5F,MAAI,kBAAkB,MAAM,KAAK,CAAC,SAAS,KAAK,UAAU,UAAU,EAAG,QAAO;AAC9E,MAAI,MAAM,KAAK,CAAC,SAAS,KAAK,UAAU,WAAW,EAAG,QAAO;AAC7D,MAAI,MAAM,KAAK,CAAC,SAAS,KAAK,UAAU,QAAQ,EAAG,QAAO;AAC1D,SAAO;AACT;AAWA,SAAS,iBACP,MACA,OACA,eACS;AACT,UAAO,6BAAM,UAAS,WAAW,QAAQ,iBAAiBI,kBAAAA,qBAAqB,IAAI;AACrF;AAQO,SAAS,aAAa,SAA8D;AACzF,QAAM,QAAQ,kBAAkB,OAAO;AACvC,SAAO,MAAM,SAAS,IAAI,MAAM,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,KAAK,MAAM,IAAI;AAC1E;AAeO,SAAS,kBAAkB,SAAmE;AACnG,MAAI,EAAC,mCAAS,QAAQ,QAAO,CAAA;AAE7B,QAAM,gBAAgB,QAAQ,cAAc,CAAC,UAAS,6BAAM,UAAS,WAAW;AAChF,QAAM,QAA4B,CAAA;AAClC,UAAQ,QAAQ,CAAC,MAAM,UAAU;AAC/B,QAAI,KAAK,QAAQ,iBAAiB,MAAM,OAAO,aAAa,EAAG,OAAM,KAAK,EAAE,OAAO,MAAM,KAAK,MAAM;AAAA,EACtG,CAAC;AACD,SAAO;AACT;AAOO,SAAS,2BAA2B,UAA8C;AACvF,SAAO,CAAC,UAAU;AAChB,UAAM,gBAAgB,MAAM,cAAc,CAAC,UAAS,6BAAM,UAAS,WAAW;AAC9E,WAAO,SAAS,KAAK,EAClB,IAAI,CAAC,WAAW;AAAA,MACf,GAAG;AAAA,MACH,SAAS,MAAM,QAAQ,OAAO,CAAC,UAAU,CAAC,iBAAiB,MAAM,KAAK,GAAG,OAAO,aAAa,CAAC;AAAA,IAAA,EAC9F,EACD,OAAO,CAAC,UAAU,MAAM,QAAQ,SAAS,CAAC;AAAA,EAC/C;AACF;AAOO,SAAS,uBACd,UACA,SACkB;AAClB,SAAO,CAAC,UACN,SAAS,KAAK,EACX,IAAI,CAAC,WAAW;AAAA,IACf,GAAG;AAAA,IACH,SAAS,MAAM,QAAQ,OAAO,CAAC,UAAU;AACvC,YAAM,OAAO,MAAM,KAAK;AACxB,aAAO,SAAS,UAAa,CAAC,QAAQ,IAAI;AAAA,IAC5C,CAAC;AAAA,EAAA,EACD,EACD,OAAO,CAAC,UAAU,MAAM,QAAQ,SAAS,CAAC;AACjD;;;;;;;;;;;;;;;"}

package/dist/chat/super-grouping/activity-timeline.d.ts

@@ -34,6 +34,13 @@ export type ActivityItem = {
     /** The tool's real result; absent while it runs or holds only the streaming placeholder. */
     result?: unknown;
     state: ActivityToolState;
+    /**
+     * Subagents the call delegated to: for a `task` call one, or none when it
+     * was refused, withdrawn or expired at its approval and never ran; for an
+     * `eval` call its in-interpreter `task()` dispatches
+     * (`countInEvalDispatches`), absent when it made none.
+     */
+    delegations?: number;
 };
 /** The turn as a whole: still working, parked on the person, ended in error, or done. */
 export type ActivityPhase = 'running' | 'waiting' | 'complete' | 'error';
@@ -84,6 +91,13 @@ export declare function getActivityToolState(part: ToolCallPart, messageStatus:
 export declare function buildActivityTimeline(content: readonly ThreadAssistantMessagePart[] | undefined, messageStatus: MessageStatus | undefined, options?: ActivityTimelineOptions): ActivityItem[];
 /** Number of tool calls in the timeline. */
 export declare function countActivityTools(timeline: readonly ActivityItem[]): number;
+/**
+ * Subagents the turn delegated to: its `task` calls that ran, plus the
+ * `task()` dispatches its `eval` calls made from inside the interpreter. A
+ * `task` step built without its count (a host's own timeline) counts unless it
+ * reads refused or cancelled.
+ */
+export declare function countActivityDelegations(timeline: readonly ActivityItem[]): number;
 /**
  * The turn's phase. Waiting on the person wins over everything — a
  * `requires-action` status, a waiting tool, or a host's own `waitingForInput`
@@ -119,6 +133,13 @@ export declare function summarizeActivityTool(item: Extract<ActivityItem, {
  * that no later call completed after. A failed command the agent then got past
  * (a search that found nothing, a retry that worked) is ordinary work, so a
  * long turn that recovered from it reads as the tools it used.
+ *
+ * A turn that delegated work leads with it — "Delegated to 10 agents · used 6
+ * tools" — counting its `task` calls and the `task()` dispatches its `eval`
+ * calls made from inside the interpreter (`countActivityDelegations`). A
+ * `task` call is the delegation itself, so the tools it is followed by are the
+ * turn's other calls; an outcome above replaces them ("Delegated to 3 agents ·
+ * completed with issues").
  */
 export declare function getActivitySummary(timeline: readonly ActivityItem[]): string;
 /** The part shape the final-text read needs; any message role's parts satisfy it. */

package/dist/chat/super-grouping/activity-timeline.js

@@ -1,6 +1,8 @@
 import { summarizeToolCall } from "../../tools/tool-summary.js";
+import { TASK_TOOL_NAME, EVAL_TOOL_NAME } from "../../agent-runtime/src/tool-names.js";
 import { readRejectedToolResult, classifyToolResult } from "../../agent-runtime/src/tool-result.js";
 import { isRunningToolPlaceholderArtifact } from "../../agent-runtime/src/running-tool-placeholder.js";
+import { countInEvalDispatches } from "../../agent-runtime/src/subagents.js";
 import { isSpokenTurnTextPart } from "../../agent-runtime/src/voice-presentation.js";
 const NO_TOOLS = /* @__PURE__ */ new Set();
 const NO_TOOL_CALLS = /* @__PURE__ */ new Set();
@@ -63,6 +65,8 @@ function buildActivityTimeline(content, messageStatus, options = {}) {
     const part = content[index];
     if (part.type === "tool-call") {
       const result = finalResult(part);
+      const state = getActivityToolState(part, messageStatus, options);
+      const delegations = toolCallDelegations({ part, state });
       timeline.push({
         kind: "tool",
         id: part.toolCallId,
@@ -70,7 +74,8 @@ function buildActivityTimeline(content, messageStatus, options = {}) {
         args: part.args,
         ...result !== void 0 ? { result } : {},
         toolName: part.toolName,
-        state: getActivityToolState(part, messageStatus, options)
+        state,
+        ...delegations !== null ? { delegations } : {}
       });
       continue;
     }
@@ -88,9 +93,32 @@ function buildActivityTimeline(content, messageStatus, options = {}) {
   }
   return timeline;
 }
+function toolCallDelegations({
+  part,
+  state
+}) {
+  var _a, _b;
+  if (part.toolName === TASK_TOOL_NAME) {
+    const withdrawn = ((_a = part.approval) == null ? void 0 : _a.resolution) === "cancelled" || ((_b = part.approval) == null ? void 0 : _b.resolution) === "expired";
+    return state === "rejected" || withdrawn ? 0 : 1;
+  }
+  if (part.toolName === EVAL_TOOL_NAME) {
+    const dispatches = countInEvalDispatches(part.artifact);
+    return dispatches > 0 ? dispatches : null;
+  }
+  return null;
+}
 function countActivityTools(timeline) {
   return timeline.reduce((count, item) => item.kind === "tool" ? count + 1 : count, 0);
 }
+function countActivityDelegations(timeline) {
+  return timeline.reduce((count, item) => {
+    if (item.kind !== "tool") return count;
+    if (item.delegations !== void 0) return count + item.delegations;
+    const ranTask = item.toolName === TASK_TOOL_NAME && item.state !== "rejected" && item.state !== "cancelled";
+    return ranTask ? count + 1 : count;
+  }, 0);
+}
 function resolveActivityPhase(status, timeline, { waitingForInput = false } = {}) {
   if (waitingForInput || (status == null ? void 0 : status.type) === "requires-action" || timeline.some((item) => item.kind === "tool" && item.state === "waiting")) {
     return "waiting";
@@ -123,21 +151,27 @@ function summarizeActivityTool(item, resolveToolDisplayName, assetTitles) {
   });
 }
 function getActivitySummary(timeline) {
-  const toolCount = countActivityTools(timeline);
   const tools = timeline.filter((item) => item.kind === "tool");
-  const lastFailure = tools.findLastIndex((item) => item.state === "error");
-  const endedOnFailure = lastFailure >= 0 && !tools.slice(lastFailure + 1).some((item) => item.state === "complete");
-  const hasIssue = endedOnFailure || tools.some((item) => item.state === "rejected");
-  if (hasIssue) return "Completed with issues";
-  if (timeline.some((item) => item.kind === "tool" && item.state === "cancelled")) {
-    return "Action cancelled";
-  }
-  if (timeline.some((item) => item.kind === "tool" && item.state === "paused")) {
-    return "Paused during tool use";
+  const outcome = activityOutcome(tools);
+  const delegations = countActivityDelegations(timeline);
+  if (delegations > 0) {
+    const lead = `Delegated to ${delegations} ${delegations === 1 ? "agent" : "agents"}`;
+    const otherTools = tools.filter((item) => item.toolName !== TASK_TOOL_NAME).length;
+    const rest = outcome ? `${outcome.charAt(0).toLowerCase()}${outcome.slice(1)}` : otherTools > 0 ? `used ${otherTools} ${otherTools === 1 ? "tool" : "tools"}` : null;
+    return rest ? `${lead} · ${rest}` : lead;
   }
-  if (toolCount > 0) return `Used ${toolCount} ${toolCount === 1 ? "tool" : "tools"}`;
+  if (outcome) return outcome;
+  if (tools.length > 0) return `Used ${tools.length} ${tools.length === 1 ? "tool" : "tools"}`;
   return "Reasoning complete";
 }
+function activityOutcome(tools) {
+  const lastFailure = tools.findLastIndex((item) => item.state === "error");
+  const endedOnFailure = lastFailure >= 0 && !tools.slice(lastFailure + 1).some((item) => item.state === "complete");
+  if (endedOnFailure || tools.some((item) => item.state === "rejected")) return "Completed with issues";
+  if (tools.some((item) => item.state === "cancelled")) return "Action cancelled";
+  if (tools.some((item) => item.state === "paused")) return "Paused during tool use";
+  return null;
+}
 function isAnswerTextPart(part, index, lastToolIndex) {
   return (part == null ? void 0 : part.type) === "text" && (index > lastToolIndex || isSpokenTurnTextPart(part));
 }
@@ -174,6 +208,7 @@ function excludePartsFromGroups(grouping, exclude) {
 }
 export {
   buildActivityTimeline,
+  countActivityDelegations,
   countActivityTools,
   excludeFinalTextFromGroups,
   excludePartsFromGroups,

package/dist/chat/super-grouping/activity-timeline.js.map

@@ -1 +1 @@
-{"version":3,"file":"activity-timeline.js","sources":["../../../src/chat/super-grouping/activity-timeline.ts"],"sourcesContent":["/**\n * The assistant turn's activity timeline — the one derivation of \"what did\n * this turn do, and how did each step end\" behind the collapsed view\n * (previously called the conversational view) on every surface: the SDK's\n * `AthenaChat`, Olympus's Spaces chat, and the Chrome extension. Pure\n * functions over assistant-ui message parts; `SuperGroupingCard` renders them.\n *\n * Step states come from the shared classifier (`classifyToolResult`) plus the\n * approval outcomes a part carries (`approval`, `interrupt`, a rejection\n * result), so a call that reads as failed, paused, or rejected on one surface\n * cannot read as a green check on another. Copy comes from the shared tool\n * summary registry (`summarizeToolCall`), itself built on the display\n * registry.\n */\nimport type {\n  MessageStatus,\n  ThreadAssistantMessagePart,\n  ToolCallMessagePartStatus,\n} from '@assistant-ui/react';\nimport {\n  classifyToolResult,\n  isRunningToolPlaceholderArtifact,\n  isSpokenTurnTextPart,\n  readRejectedToolResult,\n  type ToolStatusLabelState,\n} from '@athenaintel/agent-runtime';\nimport { summarizeToolCall, type ToolCallSummary } from '../../tools/tool-summary';\nimport type { GroupablePart, GroupingFunction } from './grouping-function';\n\nexport type ActivityToolState = ToolStatusLabelState;\n\nexport type ActivityItem =\n  | {\n      kind: 'reasoning';\n      id?: string;\n      /** Position of the part in the message's content. */\n      partIndex?: number;\n      text: string;\n      state: 'running' | 'complete';\n    }\n  | {\n      kind: 'tool';\n      id?: string;\n      /** Position of the part in the message's content. */\n      partIndex?: number;\n      toolName: string;\n      args?: ToolCallPart['args'];\n      /** The tool's real result; absent while it runs or holds only the streaming placeholder. */\n      result?: unknown;\n      state: ActivityToolState;\n    };\n\n/** The turn as a whole: still working, parked on the person, ended in error, or done. */\nexport type ActivityPhase = 'running' | 'waiting' | 'complete' | 'error';\n\ntype ToolCallPart = Extract<ThreadAssistantMessagePart, { type: 'tool-call' }>;\n\nexport interface ActivityTimelineOptions {\n  /**\n   * Tools whose unresolved call means the turn is waiting on the person even\n   * without an interrupt or approval on the part (the Chrome extension's\n   * device plan approval, which the tool UI itself collects).\n   */\n  waitingTools?: ReadonlySet<string>;\n  /**\n   * Calls the run is parked on, by tool-call id, as the host reads them off\n   * its pending approval: a gated call, or (in Olympus) a `task` call whose\n   * subagent waits on an approval. Any of them still without its real result\n   * reads as waiting.\n   */\n  waitingToolCallIds?: ReadonlySet<string>;\n  /**\n   * Tools whose result is an application payload relayed verbatim (the Chrome\n   * extension's page JavaScript), so a `success: false` flag counts only with\n   * an error detail — see `classifyToolResult`'s `passThroughPayload`.\n   */\n  passThroughTools?: ReadonlySet<string>;\n}\n\nconst NO_TOOLS: ReadonlySet<string> = new Set();\nconst NO_TOOL_CALLS: ReadonlySet<string> = new Set();\n\n/**\n * Whether a tool-call part still holds the backend's running-tool placeholder\n * result rather than the tool's real output. Long-running tools (task\n * subagents, studio and Python execution, deep research) append a ToolMessage\n * the moment they start so their card can fill in live; its marker reaches the\n * part's artifact (`isRunningToolPlaceholderArtifact`). The real ToolMessage\n * that replaces it has no such marker, so a defined `result` alone does not\n * mean the tool is done.\n */\nexport function isStreamingToolPlaceholder(part: Pick<ToolCallPart, 'artifact'>): boolean {\n  return isRunningToolPlaceholderArtifact(part.artifact);\n}\n\n/** The tool's real result: undefined while it has none or only the streaming placeholder. */\nfunction finalResult(part: ToolCallPart): unknown {\n  return isStreamingToolPlaceholder(part) ? undefined : part.result;\n}\n\nfunction toolCallStatus(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n): ToolCallMessagePartStatus | undefined {\n  if (finalResult(part) !== undefined) return { type: 'complete' };\n  if (messageStatus?.type === 'incomplete') {\n    return {\n      type: 'incomplete',\n      reason: messageStatus.reason === 'tool-calls' ? 'other' : messageStatus.reason,\n      error: messageStatus.error,\n    };\n  }\n  if (messageStatus?.type === 'complete') {\n    // The placeholder is the backend's word that the call is still in flight.\n    // A turn reads `complete` whenever nothing streams (a run parked on an\n    // approval inside a subagent, the gap before a drained run resumes), and\n    // assistant-ui counts the placeholder as the call's result when it settles\n    // that status, so the turn's status cannot finish the call.\n    return isStreamingToolPlaceholder(part) ? { type: 'running' } : { type: 'complete' };\n  }\n  if (messageStatus?.type === 'requires-action') {\n    return { type: 'requires-action', reason: messageStatus.reason };\n  }\n  if (messageStatus?.type === 'running') return { type: 'running' };\n  return undefined;\n}\n\n/** How one tool call ended (or is going), reading the approval fields before the result. */\nexport function getActivityToolState(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n  {\n    waitingTools = NO_TOOLS,\n    waitingToolCallIds = NO_TOOL_CALLS,\n    passThroughTools = NO_TOOLS,\n  }: ActivityTimelineOptions = {},\n): ActivityToolState {\n  if (part.approval?.approved === false || readRejectedToolResult(part.result) !== null) {\n    return 'rejected';\n  }\n  if (part.approval?.resolution === 'cancelled' || part.approval?.resolution === 'expired') {\n    return 'cancelled';\n  }\n  const result = finalResult(part);\n  const unresolved = result === undefined;\n  const messageIsActive =\n    messageStatus === undefined ||\n    messageStatus.type === 'running' ||\n    messageStatus.type === 'requires-action';\n  if (\n    unresolved &&\n    (part.interrupt?.type === 'human' ||\n      (part.approval !== undefined &&\n        part.approval.approved === undefined &&\n        part.approval.resolution === undefined) ||\n      waitingToolCallIds.has(part.toolCallId) ||\n      (waitingTools.has(part.toolName) && messageIsActive))\n  ) {\n    return 'waiting';\n  }\n\n  const classification = classifyToolResult({\n    status: toolCallStatus(part, messageStatus),\n    result,\n    isError: part.isError,\n    passThroughPayload: passThroughTools.has(part.toolName),\n  });\n  if (classification.state === 'requires-action') return 'waiting';\n  return classification.state;\n}\n\n/**\n * The compact reasoning/tool timeline in the order the parts streamed.\n *\n * A reasoning part is still streaming only while it is the final part of a\n * running message — once any later part appears, the thought has settled.\n * Settled reasoning parts with no text are dropped so the list never shows an\n * empty thinking row.\n */\nexport function buildActivityTimeline(\n  content: readonly ThreadAssistantMessagePart[] | undefined,\n  messageStatus: MessageStatus | undefined,\n  options: ActivityTimelineOptions = {},\n): ActivityItem[] {\n  if (!content?.length) return [];\n\n  const lastPartIndex = content.length - 1;\n  const timeline: ActivityItem[] = [];\n  for (let index = 0; index < content.length; index += 1) {\n    const part = content[index];\n    if (part.type === 'tool-call') {\n      const result = finalResult(part);\n      timeline.push({\n        kind: 'tool',\n        id: part.toolCallId,\n        partIndex: index,\n        args: part.args,\n        ...(result !== undefined ? { result } : {}),\n        toolName: part.toolName,\n        state: getActivityToolState(part, messageStatus, options),\n      });\n      continue;\n    }\n    if (part.type !== 'reasoning') continue;\n\n    const text = typeof part.text === 'string' ? part.text : '';\n    const stillStreaming = messageStatus?.type === 'running' && index === lastPartIndex;\n    if (!stillStreaming && text.trim() === '') continue;\n    timeline.push({\n      kind: 'reasoning',\n      id: `reasoning-${index}`,\n      partIndex: index,\n      text,\n      state: stillStreaming ? 'running' : 'complete',\n    });\n  }\n  return timeline;\n}\n\n/** Number of tool calls in the timeline. */\nexport function countActivityTools(timeline: readonly ActivityItem[]): number {\n  return timeline.reduce((count, item) => (item.kind === 'tool' ? count + 1 : count), 0);\n}\n\n/**\n * The turn's phase. Waiting on the person wins over everything — a\n * `requires-action` status, a waiting tool, or a host's own `waitingForInput`\n * assertion (no in-repo host passes one) — then the message's own status. A\n * complete turn with a step still running is running: only a step holding the\n * backend's running placeholder reads so once nothing streams (a run parked on\n * an approval inside a subagent, the gap before a drained run resumes).\n */\nexport function resolveActivityPhase(\n  status: MessageStatus | undefined,\n  timeline: readonly ActivityItem[],\n  { waitingForInput = false }: { waitingForInput?: boolean } = {},\n): ActivityPhase {\n  if (\n    waitingForInput ||\n    status?.type === 'requires-action' ||\n    timeline.some((item) => item.kind === 'tool' && item.state === 'waiting')\n  ) {\n    return 'waiting';\n  }\n  if (status?.type === 'running') return 'running';\n  if (status?.type === 'incomplete') return 'error';\n  if (\n    status?.type === 'complete' &&\n    timeline.some((item) => item.kind === 'tool' && item.state === 'running')\n  ) {\n    return 'running';\n  }\n  return 'complete';\n}\n\n/**\n * A settled thought's row: the heading a reasoning summary opens with\n * (\"**Checking the workstation**\" → \"Checking the workstation\"), else the\n * generic wording. The thought itself stays in the run's details.\n */\nexport function getReasoningLabel(text: string, state: 'running' | 'complete'): string {\n  if (state === 'running') return 'Thinking';\n  const heading = /^\\s*\\*\\*([^*\\n]{3,80}?)\\*\\*/.exec(text)?.[1]?.trim();\n  return heading ? heading.replace(/[.:]+$/, '') : 'Thought through the next step';\n}\n\n/**\n * The status-row copy for one step: the call's own summary from the shared\n * summary registry (`summarizeToolCall`: \"Ran git status\", \"Read config.ts\").\n * `resolveToolDisplayName` lets a host with a richer tool catalog name tools\n * neither registry has an entry for; `assetTitles` names the machine or\n * document a call targeted by id when an earlier result in the turn did.\n */\nexport function getActivityItemLabel(\n  item: ActivityItem,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n  assetTitles?: ReadonlyMap<string, string>,\n): string {\n  if (item.kind === 'reasoning') return getReasoningLabel(item.text, item.state);\n  return summarizeActivityTool(item, resolveToolDisplayName, assetTitles).label;\n}\n\n/** The summary of one tool step (see {@link getActivityItemLabel}). */\nexport function summarizeActivityTool(\n  item: Extract<ActivityItem, { kind: 'tool' }>,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n  assetTitles?: ReadonlyMap<string, string>,\n): ToolCallSummary {\n  return summarizeToolCall({\n    toolName: item.toolName,\n    args: item.args,\n    result: item.result,\n    status: item.state,\n    ...(assetTitles ? { assetTitles } : {}),\n    ...(resolveToolDisplayName ? { displayName: resolveToolDisplayName(item.toolName) } : {}),\n  });\n}\n\n/**\n * The collapsed-card summary of a finished turn. \"Completed with issues\" means\n * the turn ended on a problem: a call the person refused, or a failed call\n * that no later call completed after. A failed command the agent then got past\n * (a search that found nothing, a retry that worked) is ordinary work, so a\n * long turn that recovered from it reads as the tools it used.\n */\nexport function getActivitySummary(timeline: readonly ActivityItem[]): string {\n  const toolCount = countActivityTools(timeline);\n  const tools = timeline.filter((item) => item.kind === 'tool');\n  const lastFailure = tools.findLastIndex((item) => item.state === 'error');\n  const endedOnFailure =\n    lastFailure >= 0 && !tools.slice(lastFailure + 1).some((item) => item.state === 'complete');\n  const hasIssue = endedOnFailure || tools.some((item) => item.state === 'rejected');\n  if (hasIssue) return 'Completed with issues';\n  if (timeline.some((item) => item.kind === 'tool' && item.state === 'cancelled')) {\n    return 'Action cancelled';\n  }\n  if (timeline.some((item) => item.kind === 'tool' && item.state === 'paused')) {\n    return 'Paused during tool use';\n  }\n  if (toolCount > 0) return `Used ${toolCount} ${toolCount === 1 ? 'tool' : 'tools'}`;\n  return 'Reasoning complete';\n}\n\n/** The part shape the final-text read needs; any message role's parts satisfy it. */\nexport type FinalTextPart = { readonly type: string; readonly text?: string };\n\n/**\n * Whether a text part shows below the card instead of in the details panel:\n * it comes after the final tool call, or it holds a spoken voice turn's words\n * (a live turn heard during a delegated run lands between the run's tool\n * calls, see `isSpokenTurnTextPart`; it is the conversation, not narration).\n */\nfunction isAnswerTextPart(\n  part: { readonly type: string } | undefined,\n  index: number,\n  lastToolIndex: number,\n): boolean {\n  return part?.type === 'text' && (index > lastToolIndex || isSpokenTurnTextPart(part));\n}\n\n/**\n * The visible answer of a grouped turn: the text after the final tool call\n * (all of it when the turn never called a tool), plus the words of every\n * spoken voice turn in the message, in order. Other intermediate text (before\n * or between tool calls) stays available in the details panel.\n */\nexport function getFinalText(content: readonly FinalTextPart[] | undefined): string | null {\n  const parts = getFinalTextParts(content);\n  return parts.length > 0 ? parts.map((part) => part.text).join('\\n\\n') : null;\n}\n\n/** One text part of the visible answer, with its index in the message content. */\nexport interface FinalTextSegment {\n  index: number;\n  text: string;\n}\n\n/**\n * The parts `getFinalText` joins, each kept separate with its content index.\n * A spoken turn and the run's own reply can stream at the same time, so the\n * earlier part may grow while a later one exists: rendered as one joined\n * string, that text changes in the middle rather than at its end, and the\n * streaming reveal restarts from an empty bubble on every word.\n */\nexport function getFinalTextParts(content: readonly FinalTextPart[] | undefined): FinalTextSegment[] {\n  if (!content?.length) return [];\n\n  const lastToolIndex = content.findLastIndex((part) => part?.type === 'tool-call');\n  const parts: FinalTextSegment[] = [];\n  content.forEach((part, index) => {\n    if (part.text && isAnswerTextPart(part, index, lastToolIndex)) parts.push({ index, text: part.text });\n  });\n  return parts;\n}\n\n/**\n * Keep the answer out of the details panel: it renders below the card\n * (`SuperGroupingFinalText`), so the details grouping drops every text part\n * `getFinalText` shows and any group that becomes empty.\n */\nexport function excludeFinalTextFromGroups(grouping: GroupingFunction): GroupingFunction {\n  return (parts) => {\n    const lastToolIndex = parts.findLastIndex((part) => part?.type === 'tool-call');\n    return grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => !isAnswerTextPart(parts[index], index, lastToolIndex)),\n      }))\n      .filter((group) => group.indices.length > 0);\n  };\n}\n\n/**\n * Drop the parts `exclude` matches from every group, and any group left\n * empty: `SuperGroupingCard` renders inline tool calls outside the details,\n * so they must not render a second time inside it.\n */\nexport function excludePartsFromGroups(\n  grouping: GroupingFunction,\n  exclude: (part: GroupablePart) => boolean,\n): GroupingFunction {\n  return (parts) =>\n    grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => {\n          const part = parts[index];\n          return part === undefined || !exclude(part);\n        }),\n      }))\n      .filter((group) => group.indices.length > 0);\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"activity-timeline.js","sources":["../../../src/chat/super-grouping/activity-timeline.ts"],"sourcesContent":["/**\n * The assistant turn's activity timeline — the one derivation of \"what did\n * this turn do, and how did each step end\" behind the collapsed view\n * (previously called the conversational view) on every surface: the SDK's\n * `AthenaChat`, Olympus's Spaces chat, and the Chrome extension. Pure\n * functions over assistant-ui message parts; `SuperGroupingCard` renders them.\n *\n * Step states come from the shared classifier (`classifyToolResult`) plus the\n * approval outcomes a part carries (`approval`, `interrupt`, a rejection\n * result), so a call that reads as failed, paused, or rejected on one surface\n * cannot read as a green check on another. Copy comes from the shared tool\n * summary registry (`summarizeToolCall`), itself built on the display\n * registry.\n */\nimport type {\n  MessageStatus,\n  ThreadAssistantMessagePart,\n  ToolCallMessagePartStatus,\n} from '@assistant-ui/react';\nimport {\n  classifyToolResult,\n  countInEvalDispatches,\n  EVAL_TOOL_NAME,\n  isRunningToolPlaceholderArtifact,\n  isSpokenTurnTextPart,\n  readRejectedToolResult,\n  TASK_TOOL_NAME,\n  type ToolStatusLabelState,\n} from '@athenaintel/agent-runtime';\nimport { summarizeToolCall, type ToolCallSummary } from '../../tools/tool-summary';\nimport type { GroupablePart, GroupingFunction } from './grouping-function';\n\nexport type ActivityToolState = ToolStatusLabelState;\n\nexport type ActivityItem =\n  | {\n      kind: 'reasoning';\n      id?: string;\n      /** Position of the part in the message's content. */\n      partIndex?: number;\n      text: string;\n      state: 'running' | 'complete';\n    }\n  | {\n      kind: 'tool';\n      id?: string;\n      /** Position of the part in the message's content. */\n      partIndex?: number;\n      toolName: string;\n      args?: ToolCallPart['args'];\n      /** The tool's real result; absent while it runs or holds only the streaming placeholder. */\n      result?: unknown;\n      state: ActivityToolState;\n      /**\n       * Subagents the call delegated to: for a `task` call one, or none when it\n       * was refused, withdrawn or expired at its approval and never ran; for an\n       * `eval` call its in-interpreter `task()` dispatches\n       * (`countInEvalDispatches`), absent when it made none.\n       */\n      delegations?: number;\n    };\n\n/** The turn as a whole: still working, parked on the person, ended in error, or done. */\nexport type ActivityPhase = 'running' | 'waiting' | 'complete' | 'error';\n\ntype ToolCallPart = Extract<ThreadAssistantMessagePart, { type: 'tool-call' }>;\n\nexport interface ActivityTimelineOptions {\n  /**\n   * Tools whose unresolved call means the turn is waiting on the person even\n   * without an interrupt or approval on the part (the Chrome extension's\n   * device plan approval, which the tool UI itself collects).\n   */\n  waitingTools?: ReadonlySet<string>;\n  /**\n   * Calls the run is parked on, by tool-call id, as the host reads them off\n   * its pending approval: a gated call, or (in Olympus) a `task` call whose\n   * subagent waits on an approval. Any of them still without its real result\n   * reads as waiting.\n   */\n  waitingToolCallIds?: ReadonlySet<string>;\n  /**\n   * Tools whose result is an application payload relayed verbatim (the Chrome\n   * extension's page JavaScript), so a `success: false` flag counts only with\n   * an error detail — see `classifyToolResult`'s `passThroughPayload`.\n   */\n  passThroughTools?: ReadonlySet<string>;\n}\n\nconst NO_TOOLS: ReadonlySet<string> = new Set();\nconst NO_TOOL_CALLS: ReadonlySet<string> = new Set();\n\n/**\n * Whether a tool-call part still holds the backend's running-tool placeholder\n * result rather than the tool's real output. Long-running tools (task\n * subagents, studio and Python execution, deep research) append a ToolMessage\n * the moment they start so their card can fill in live; its marker reaches the\n * part's artifact (`isRunningToolPlaceholderArtifact`). The real ToolMessage\n * that replaces it has no such marker, so a defined `result` alone does not\n * mean the tool is done.\n */\nexport function isStreamingToolPlaceholder(part: Pick<ToolCallPart, 'artifact'>): boolean {\n  return isRunningToolPlaceholderArtifact(part.artifact);\n}\n\n/** The tool's real result: undefined while it has none or only the streaming placeholder. */\nfunction finalResult(part: ToolCallPart): unknown {\n  return isStreamingToolPlaceholder(part) ? undefined : part.result;\n}\n\nfunction toolCallStatus(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n): ToolCallMessagePartStatus | undefined {\n  if (finalResult(part) !== undefined) return { type: 'complete' };\n  if (messageStatus?.type === 'incomplete') {\n    return {\n      type: 'incomplete',\n      reason: messageStatus.reason === 'tool-calls' ? 'other' : messageStatus.reason,\n      error: messageStatus.error,\n    };\n  }\n  if (messageStatus?.type === 'complete') {\n    // The placeholder is the backend's word that the call is still in flight.\n    // A turn reads `complete` whenever nothing streams (a run parked on an\n    // approval inside a subagent, the gap before a drained run resumes), and\n    // assistant-ui counts the placeholder as the call's result when it settles\n    // that status, so the turn's status cannot finish the call.\n    return isStreamingToolPlaceholder(part) ? { type: 'running' } : { type: 'complete' };\n  }\n  if (messageStatus?.type === 'requires-action') {\n    return { type: 'requires-action', reason: messageStatus.reason };\n  }\n  if (messageStatus?.type === 'running') return { type: 'running' };\n  return undefined;\n}\n\n/** How one tool call ended (or is going), reading the approval fields before the result. */\nexport function getActivityToolState(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n  {\n    waitingTools = NO_TOOLS,\n    waitingToolCallIds = NO_TOOL_CALLS,\n    passThroughTools = NO_TOOLS,\n  }: ActivityTimelineOptions = {},\n): ActivityToolState {\n  if (part.approval?.approved === false || readRejectedToolResult(part.result) !== null) {\n    return 'rejected';\n  }\n  if (part.approval?.resolution === 'cancelled' || part.approval?.resolution === 'expired') {\n    return 'cancelled';\n  }\n  const result = finalResult(part);\n  const unresolved = result === undefined;\n  const messageIsActive =\n    messageStatus === undefined ||\n    messageStatus.type === 'running' ||\n    messageStatus.type === 'requires-action';\n  if (\n    unresolved &&\n    (part.interrupt?.type === 'human' ||\n      (part.approval !== undefined &&\n        part.approval.approved === undefined &&\n        part.approval.resolution === undefined) ||\n      waitingToolCallIds.has(part.toolCallId) ||\n      (waitingTools.has(part.toolName) && messageIsActive))\n  ) {\n    return 'waiting';\n  }\n\n  const classification = classifyToolResult({\n    status: toolCallStatus(part, messageStatus),\n    result,\n    isError: part.isError,\n    passThroughPayload: passThroughTools.has(part.toolName),\n  });\n  if (classification.state === 'requires-action') return 'waiting';\n  return classification.state;\n}\n\n/**\n * The compact reasoning/tool timeline in the order the parts streamed.\n *\n * A reasoning part is still streaming only while it is the final part of a\n * running message — once any later part appears, the thought has settled.\n * Settled reasoning parts with no text are dropped so the list never shows an\n * empty thinking row.\n */\nexport function buildActivityTimeline(\n  content: readonly ThreadAssistantMessagePart[] | undefined,\n  messageStatus: MessageStatus | undefined,\n  options: ActivityTimelineOptions = {},\n): ActivityItem[] {\n  if (!content?.length) return [];\n\n  const lastPartIndex = content.length - 1;\n  const timeline: ActivityItem[] = [];\n  for (let index = 0; index < content.length; index += 1) {\n    const part = content[index];\n    if (part.type === 'tool-call') {\n      const result = finalResult(part);\n      const state = getActivityToolState(part, messageStatus, options);\n      const delegations = toolCallDelegations({ part, state });\n      timeline.push({\n        kind: 'tool',\n        id: part.toolCallId,\n        partIndex: index,\n        args: part.args,\n        ...(result !== undefined ? { result } : {}),\n        toolName: part.toolName,\n        state,\n        ...(delegations !== null ? { delegations } : {}),\n      });\n      continue;\n    }\n    if (part.type !== 'reasoning') continue;\n\n    const text = typeof part.text === 'string' ? part.text : '';\n    const stillStreaming = messageStatus?.type === 'running' && index === lastPartIndex;\n    if (!stillStreaming && text.trim() === '') continue;\n    timeline.push({\n      kind: 'reasoning',\n      id: `reasoning-${index}`,\n      partIndex: index,\n      text,\n      state: stillStreaming ? 'running' : 'complete',\n    });\n  }\n  return timeline;\n}\n\n/**\n * Subagents one tool call delegated to (see `ActivityItem.delegations`), or\n * `null` for a call that delegates by nature of neither: a `task` call one,\n * unless the person refused it or its approval was withdrawn or expired (it\n * never ran); an `eval` call its in-interpreter dispatches, when it made any.\n */\nfunction toolCallDelegations({\n  part,\n  state,\n}: {\n  part: ToolCallPart;\n  state: ActivityToolState;\n}): number | null {\n  if (part.toolName === TASK_TOOL_NAME) {\n    const withdrawn =\n      part.approval?.resolution === 'cancelled' || part.approval?.resolution === 'expired';\n    return state === 'rejected' || withdrawn ? 0 : 1;\n  }\n  if (part.toolName === EVAL_TOOL_NAME) {\n    const dispatches = countInEvalDispatches(part.artifact);\n    return dispatches > 0 ? dispatches : null;\n  }\n  return null;\n}\n\n/** Number of tool calls in the timeline. */\nexport function countActivityTools(timeline: readonly ActivityItem[]): number {\n  return timeline.reduce((count, item) => (item.kind === 'tool' ? count + 1 : count), 0);\n}\n\n/**\n * Subagents the turn delegated to: its `task` calls that ran, plus the\n * `task()` dispatches its `eval` calls made from inside the interpreter. A\n * `task` step built without its count (a host's own timeline) counts unless it\n * reads refused or cancelled.\n */\nexport function countActivityDelegations(timeline: readonly ActivityItem[]): number {\n  return timeline.reduce((count, item) => {\n    if (item.kind !== 'tool') return count;\n    if (item.delegations !== undefined) return count + item.delegations;\n    const ranTask =\n      item.toolName === TASK_TOOL_NAME && item.state !== 'rejected' && item.state !== 'cancelled';\n    return ranTask ? count + 1 : count;\n  }, 0);\n}\n\n/**\n * The turn's phase. Waiting on the person wins over everything — a\n * `requires-action` status, a waiting tool, or a host's own `waitingForInput`\n * assertion (no in-repo host passes one) — then the message's own status. A\n * complete turn with a step still running is running: only a step holding the\n * backend's running placeholder reads so once nothing streams (a run parked on\n * an approval inside a subagent, the gap before a drained run resumes).\n */\nexport function resolveActivityPhase(\n  status: MessageStatus | undefined,\n  timeline: readonly ActivityItem[],\n  { waitingForInput = false }: { waitingForInput?: boolean } = {},\n): ActivityPhase {\n  if (\n    waitingForInput ||\n    status?.type === 'requires-action' ||\n    timeline.some((item) => item.kind === 'tool' && item.state === 'waiting')\n  ) {\n    return 'waiting';\n  }\n  if (status?.type === 'running') return 'running';\n  if (status?.type === 'incomplete') return 'error';\n  if (\n    status?.type === 'complete' &&\n    timeline.some((item) => item.kind === 'tool' && item.state === 'running')\n  ) {\n    return 'running';\n  }\n  return 'complete';\n}\n\n/**\n * A settled thought's row: the heading a reasoning summary opens with\n * (\"**Checking the workstation**\" → \"Checking the workstation\"), else the\n * generic wording. The thought itself stays in the run's details.\n */\nexport function getReasoningLabel(text: string, state: 'running' | 'complete'): string {\n  if (state === 'running') return 'Thinking';\n  const heading = /^\\s*\\*\\*([^*\\n]{3,80}?)\\*\\*/.exec(text)?.[1]?.trim();\n  return heading ? heading.replace(/[.:]+$/, '') : 'Thought through the next step';\n}\n\n/**\n * The status-row copy for one step: the call's own summary from the shared\n * summary registry (`summarizeToolCall`: \"Ran git status\", \"Read config.ts\").\n * `resolveToolDisplayName` lets a host with a richer tool catalog name tools\n * neither registry has an entry for; `assetTitles` names the machine or\n * document a call targeted by id when an earlier result in the turn did.\n */\nexport function getActivityItemLabel(\n  item: ActivityItem,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n  assetTitles?: ReadonlyMap<string, string>,\n): string {\n  if (item.kind === 'reasoning') return getReasoningLabel(item.text, item.state);\n  return summarizeActivityTool(item, resolveToolDisplayName, assetTitles).label;\n}\n\n/** The summary of one tool step (see {@link getActivityItemLabel}). */\nexport function summarizeActivityTool(\n  item: Extract<ActivityItem, { kind: 'tool' }>,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n  assetTitles?: ReadonlyMap<string, string>,\n): ToolCallSummary {\n  return summarizeToolCall({\n    toolName: item.toolName,\n    args: item.args,\n    result: item.result,\n    status: item.state,\n    ...(assetTitles ? { assetTitles } : {}),\n    ...(resolveToolDisplayName ? { displayName: resolveToolDisplayName(item.toolName) } : {}),\n  });\n}\n\n/**\n * The collapsed-card summary of a finished turn. \"Completed with issues\" means\n * the turn ended on a problem: a call the person refused, or a failed call\n * that no later call completed after. A failed command the agent then got past\n * (a search that found nothing, a retry that worked) is ordinary work, so a\n * long turn that recovered from it reads as the tools it used.\n *\n * A turn that delegated work leads with it — \"Delegated to 10 agents · used 6\n * tools\" — counting its `task` calls and the `task()` dispatches its `eval`\n * calls made from inside the interpreter (`countActivityDelegations`). A\n * `task` call is the delegation itself, so the tools it is followed by are the\n * turn's other calls; an outcome above replaces them (\"Delegated to 3 agents ·\n * completed with issues\").\n */\nexport function getActivitySummary(timeline: readonly ActivityItem[]): string {\n  const tools = timeline.filter((item): item is ToolActivityItem => item.kind === 'tool');\n  const outcome = activityOutcome(tools);\n  const delegations = countActivityDelegations(timeline);\n  if (delegations > 0) {\n    const lead = `Delegated to ${delegations} ${delegations === 1 ? 'agent' : 'agents'}`;\n    const otherTools = tools.filter((item) => item.toolName !== TASK_TOOL_NAME).length;\n    const rest = outcome\n      ? `${outcome.charAt(0).toLowerCase()}${outcome.slice(1)}`\n      : otherTools > 0\n        ? `used ${otherTools} ${otherTools === 1 ? 'tool' : 'tools'}`\n        : null;\n    return rest ? `${lead} · ${rest}` : lead;\n  }\n  if (outcome) return outcome;\n  if (tools.length > 0) return `Used ${tools.length} ${tools.length === 1 ? 'tool' : 'tools'}`;\n  return 'Reasoning complete';\n}\n\ntype ToolActivityItem = Extract<ActivityItem, { kind: 'tool' }>;\n\n/** How a finished turn's tool calls ended, when that is not simply the tools it used. */\nfunction activityOutcome(tools: readonly ToolActivityItem[]): string | null {\n  const lastFailure = tools.findLastIndex((item) => item.state === 'error');\n  const endedOnFailure =\n    lastFailure >= 0 && !tools.slice(lastFailure + 1).some((item) => item.state === 'complete');\n  if (endedOnFailure || tools.some((item) => item.state === 'rejected')) return 'Completed with issues';\n  if (tools.some((item) => item.state === 'cancelled')) return 'Action cancelled';\n  if (tools.some((item) => item.state === 'paused')) return 'Paused during tool use';\n  return null;\n}\n\n/** The part shape the final-text read needs; any message role's parts satisfy it. */\nexport type FinalTextPart = { readonly type: string; readonly text?: string };\n\n/**\n * Whether a text part shows below the card instead of in the details panel:\n * it comes after the final tool call, or it holds a spoken voice turn's words\n * (a live turn heard during a delegated run lands between the run's tool\n * calls, see `isSpokenTurnTextPart`; it is the conversation, not narration).\n */\nfunction isAnswerTextPart(\n  part: { readonly type: string } | undefined,\n  index: number,\n  lastToolIndex: number,\n): boolean {\n  return part?.type === 'text' && (index > lastToolIndex || isSpokenTurnTextPart(part));\n}\n\n/**\n * The visible answer of a grouped turn: the text after the final tool call\n * (all of it when the turn never called a tool), plus the words of every\n * spoken voice turn in the message, in order. Other intermediate text (before\n * or between tool calls) stays available in the details panel.\n */\nexport function getFinalText(content: readonly FinalTextPart[] | undefined): string | null {\n  const parts = getFinalTextParts(content);\n  return parts.length > 0 ? parts.map((part) => part.text).join('\\n\\n') : null;\n}\n\n/** One text part of the visible answer, with its index in the message content. */\nexport interface FinalTextSegment {\n  index: number;\n  text: string;\n}\n\n/**\n * The parts `getFinalText` joins, each kept separate with its content index.\n * A spoken turn and the run's own reply can stream at the same time, so the\n * earlier part may grow while a later one exists: rendered as one joined\n * string, that text changes in the middle rather than at its end, and the\n * streaming reveal restarts from an empty bubble on every word.\n */\nexport function getFinalTextParts(content: readonly FinalTextPart[] | undefined): FinalTextSegment[] {\n  if (!content?.length) return [];\n\n  const lastToolIndex = content.findLastIndex((part) => part?.type === 'tool-call');\n  const parts: FinalTextSegment[] = [];\n  content.forEach((part, index) => {\n    if (part.text && isAnswerTextPart(part, index, lastToolIndex)) parts.push({ index, text: part.text });\n  });\n  return parts;\n}\n\n/**\n * Keep the answer out of the details panel: it renders below the card\n * (`SuperGroupingFinalText`), so the details grouping drops every text part\n * `getFinalText` shows and any group that becomes empty.\n */\nexport function excludeFinalTextFromGroups(grouping: GroupingFunction): GroupingFunction {\n  return (parts) => {\n    const lastToolIndex = parts.findLastIndex((part) => part?.type === 'tool-call');\n    return grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => !isAnswerTextPart(parts[index], index, lastToolIndex)),\n      }))\n      .filter((group) => group.indices.length > 0);\n  };\n}\n\n/**\n * Drop the parts `exclude` matches from every group, and any group left\n * empty: `SuperGroupingCard` renders inline tool calls outside the details,\n * so they must not render a second time inside it.\n */\nexport function excludePartsFromGroups(\n  grouping: GroupingFunction,\n  exclude: (part: GroupablePart) => boolean,\n): GroupingFunction {\n  return (parts) =>\n    grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => {\n          const part = parts[index];\n          return part === undefined || !exclude(part);\n        }),\n      }))\n      .filter((group) => group.indices.length > 0);\n}\n"],"names":[],"mappings":";;;;;;AAyFA,MAAM,+BAAoC,IAAA;AAC1C,MAAM,oCAAyC,IAAA;AAWxC,SAAS,2BAA2B,MAA+C;AACxF,SAAO,iCAAiC,KAAK,QAAQ;AACvD;AAGA,SAAS,YAAY,MAA6B;AAChD,SAAO,2BAA2B,IAAI,IAAI,SAAY,KAAK;AAC7D;AAEA,SAAS,eACP,MACA,eACuC;AACvC,MAAI,YAAY,IAAI,MAAM,OAAW,QAAO,EAAE,MAAM,WAAA;AACpD,OAAI,+CAAe,UAAS,cAAc;AACxC,WAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,cAAc,WAAW,eAAe,UAAU,cAAc;AAAA,MACxE,OAAO,cAAc;AAAA,IAAA;AAAA,EAEzB;AACA,OAAI,+CAAe,UAAS,YAAY;AAMtC,WAAO,2BAA2B,IAAI,IAAI,EAAE,MAAM,cAAc,EAAE,MAAM,WAAA;AAAA,EAC1E;AACA,OAAI,+CAAe,UAAS,mBAAmB;AAC7C,WAAO,EAAE,MAAM,mBAAmB,QAAQ,cAAc,OAAA;AAAA,EAC1D;AACA,OAAI,+CAAe,UAAS,UAAW,QAAO,EAAE,MAAM,UAAA;AACtD,SAAO;AACT;AAGO,SAAS,qBACd,MACA,eACA;AAAA,EACE,eAAe;AAAA,EACf,qBAAqB;AAAA,EACrB,mBAAmB;AACrB,IAA6B,IACV;;AACnB,QAAI,UAAK,aAAL,mBAAe,cAAa,SAAS,uBAAuB,KAAK,MAAM,MAAM,MAAM;AACrF,WAAO;AAAA,EACT;AACA,QAAI,UAAK,aAAL,mBAAe,gBAAe,iBAAe,UAAK,aAAL,mBAAe,gBAAe,WAAW;AACxF,WAAO;AAAA,EACT;AACA,QAAM,SAAS,YAAY,IAAI;AAC/B,QAAM,aAAa,WAAW;AAC9B,QAAM,kBACJ,kBAAkB,UAClB,cAAc,SAAS,aACvB,cAAc,SAAS;AACzB,MACE,iBACC,UAAK,cAAL,mBAAgB,UAAS,WACvB,KAAK,aAAa,UACjB,KAAK,SAAS,aAAa,UAC3B,KAAK,SAAS,eAAe,UAC/B,mBAAmB,IAAI,KAAK,UAAU,KACrC,aAAa,IAAI,KAAK,QAAQ,KAAK,kBACtC;AACA,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,mBAAmB;AAAA,IACxC,QAAQ,eAAe,MAAM,aAAa;AAAA,IAC1C;AAAA,IACA,SAAS,KAAK;AAAA,IACd,oBAAoB,iBAAiB,IAAI,KAAK,QAAQ;AAAA,EAAA,CACvD;AACD,MAAI,eAAe,UAAU,kBAAmB,QAAO;AACvD,SAAO,eAAe;AACxB;AAUO,SAAS,sBACd,SACA,eACA,UAAmC,CAAA,GACnB;AAChB,MAAI,EAAC,mCAAS,QAAQ,QAAO,CAAA;AAE7B,QAAM,gBAAgB,QAAQ,SAAS;AACvC,QAAM,WAA2B,CAAA;AACjC,WAAS,QAAQ,GAAG,QAAQ,QAAQ,QAAQ,SAAS,GAAG;AACtD,UAAM,OAAO,QAAQ,KAAK;AAC1B,QAAI,KAAK,SAAS,aAAa;AAC7B,YAAM,SAAS,YAAY,IAAI;AAC/B,YAAM,QAAQ,qBAAqB,MAAM,eAAe,OAAO;AAC/D,YAAM,cAAc,oBAAoB,EAAE,MAAM,OAAO;AACvD,eAAS,KAAK;AAAA,QACZ,MAAM;AAAA,QACN,IAAI,KAAK;AAAA,QACT,WAAW;AAAA,QACX,MAAM,KAAK;AAAA,QACX,GAAI,WAAW,SAAY,EAAE,OAAA,IAAW,CAAA;AAAA,QACxC,UAAU,KAAK;AAAA,QACf;AAAA,QACA,GAAI,gBAAgB,OAAO,EAAE,gBAAgB,CAAA;AAAA,MAAC,CAC/C;AACD;AAAA,IACF;AACA,QAAI,KAAK,SAAS,YAAa;AAE/B,UAAM,OAAO,OAAO,KAAK,SAAS,WAAW,KAAK,OAAO;AACzD,UAAM,kBAAiB,+CAAe,UAAS,aAAa,UAAU;AACtE,QAAI,CAAC,kBAAkB,KAAK,KAAA,MAAW,GAAI;AAC3C,aAAS,KAAK;AAAA,MACZ,MAAM;AAAA,MACN,IAAI,aAAa,KAAK;AAAA,MACtB,WAAW;AAAA,MACX;AAAA,MACA,OAAO,iBAAiB,YAAY;AAAA,IAAA,CACrC;AAAA,EACH;AACA,SAAO;AACT;AAQA,SAAS,oBAAoB;AAAA,EAC3B;AAAA,EACA;AACF,GAGkB;;AAChB,MAAI,KAAK,aAAa,gBAAgB;AACpC,UAAM,cACJ,UAAK,aAAL,mBAAe,gBAAe,iBAAe,UAAK,aAAL,mBAAe,gBAAe;AAC7E,WAAO,UAAU,cAAc,YAAY,IAAI;AAAA,EACjD;AACA,MAAI,KAAK,aAAa,gBAAgB;AACpC,UAAM,aAAa,sBAAsB,KAAK,QAAQ;AACtD,WAAO,aAAa,IAAI,aAAa;AAAA,EACvC;AACA,SAAO;AACT;AAGO,SAAS,mBAAmB,UAA2C;AAC5E,SAAO,SAAS,OAAO,CAAC,OAAO,SAAU,KAAK,SAAS,SAAS,QAAQ,IAAI,OAAQ,CAAC;AACvF;AAQO,SAAS,yBAAyB,UAA2C;AAClF,SAAO,SAAS,OAAO,CAAC,OAAO,SAAS;AACtC,QAAI,KAAK,SAAS,OAAQ,QAAO;AACjC,QAAI,KAAK,gBAAgB,OAAW,QAAO,QAAQ,KAAK;AACxD,UAAM,UACJ,KAAK,aAAa,kBAAkB,KAAK,UAAU,cAAc,KAAK,UAAU;AAClF,WAAO,UAAU,QAAQ,IAAI;AAAA,EAC/B,GAAG,CAAC;AACN;AAUO,SAAS,qBACd,QACA,UACA,EAAE,kBAAkB,MAAA,IAAyC,IAC9C;AACf,MACE,oBACA,iCAAQ,UAAS,qBACjB,SAAS,KAAK,CAAC,SAAS,KAAK,SAAS,UAAU,KAAK,UAAU,SAAS,GACxE;AACA,WAAO;AAAA,EACT;AACA,OAAI,iCAAQ,UAAS,UAAW,QAAO;AACvC,OAAI,iCAAQ,UAAS,aAAc,QAAO;AAC1C,OACE,iCAAQ,UAAS,cACjB,SAAS,KAAK,CAAC,SAAS,KAAK,SAAS,UAAU,KAAK,UAAU,SAAS,GACxE;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAOO,SAAS,kBAAkB,MAAc,OAAuC;;AACrF,MAAI,UAAU,UAAW,QAAO;AAChC,QAAM,WAAU,yCAA8B,KAAK,IAAI,MAAvC,mBAA2C,OAA3C,mBAA+C;AAC/D,SAAO,UAAU,QAAQ,QAAQ,UAAU,EAAE,IAAI;AACnD;AASO,SAAS,qBACd,MACA,wBACA,aACQ;AACR,MAAI,KAAK,SAAS,YAAa,QAAO,kBAAkB,KAAK,MAAM,KAAK,KAAK;AAC7E,SAAO,sBAAsB,MAAM,wBAAwB,WAAW,EAAE;AAC1E;AAGO,SAAS,sBACd,MACA,wBACA,aACiB;AACjB,SAAO,kBAAkB;AAAA,IACvB,UAAU,KAAK;AAAA,IACf,MAAM,KAAK;AAAA,IACX,QAAQ,KAAK;AAAA,IACb,QAAQ,KAAK;AAAA,IACb,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,IACpC,GAAI,yBAAyB,EAAE,aAAa,uBAAuB,KAAK,QAAQ,MAAM,CAAA;AAAA,EAAC,CACxF;AACH;AAgBO,SAAS,mBAAmB,UAA2C;AAC5E,QAAM,QAAQ,SAAS,OAAO,CAAC,SAAmC,KAAK,SAAS,MAAM;AACtF,QAAM,UAAU,gBAAgB,KAAK;AACrC,QAAM,cAAc,yBAAyB,QAAQ;AACrD,MAAI,cAAc,GAAG;AACnB,UAAM,OAAO,gBAAgB,WAAW,IAAI,gBAAgB,IAAI,UAAU,QAAQ;AAClF,UAAM,aAAa,MAAM,OAAO,CAAC,SAAS,KAAK,aAAa,cAAc,EAAE;AAC5E,UAAM,OAAO,UACT,GAAG,QAAQ,OAAO,CAAC,EAAE,YAAA,CAAa,GAAG,QAAQ,MAAM,CAAC,CAAC,KACrD,aAAa,IACX,QAAQ,UAAU,IAAI,eAAe,IAAI,SAAS,OAAO,KACzD;AACN,WAAO,OAAO,GAAG,IAAI,MAAM,IAAI,KAAK;AAAA,EACtC;AACA,MAAI,QAAS,QAAO;AACpB,MAAI,MAAM,SAAS,EAAG,QAAO,QAAQ,MAAM,MAAM,IAAI,MAAM,WAAW,IAAI,SAAS,OAAO;AAC1F,SAAO;AACT;AAKA,SAAS,gBAAgB,OAAmD;AAC1E,QAAM,cAAc,MAAM,cAAc,CAAC,SAAS,KAAK,UAAU,OAAO;AACxE,QAAM,iBACJ,eAAe,KAAK,CAAC,MAAM,MAAM,cAAc,CAAC,EAAE,KAAK,CAAC,SAAS,KAAK,UAAU,UAAU;AAC5F,MAAI,kBAAkB,MAAM,KAAK,CAAC,SAAS,KAAK,UAAU,UAAU,EAAG,QAAO;AAC9E,MAAI,MAAM,KAAK,CAAC,SAAS,KAAK,UAAU,WAAW,EAAG,QAAO;AAC7D,MAAI,MAAM,KAAK,CAAC,SAAS,KAAK,UAAU,QAAQ,EAAG,QAAO;AAC1D,SAAO;AACT;AAWA,SAAS,iBACP,MACA,OACA,eACS;AACT,UAAO,6BAAM,UAAS,WAAW,QAAQ,iBAAiB,qBAAqB,IAAI;AACrF;AAQO,SAAS,aAAa,SAA8D;AACzF,QAAM,QAAQ,kBAAkB,OAAO;AACvC,SAAO,MAAM,SAAS,IAAI,MAAM,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,KAAK,MAAM,IAAI;AAC1E;AAeO,SAAS,kBAAkB,SAAmE;AACnG,MAAI,EAAC,mCAAS,QAAQ,QAAO,CAAA;AAE7B,QAAM,gBAAgB,QAAQ,cAAc,CAAC,UAAS,6BAAM,UAAS,WAAW;AAChF,QAAM,QAA4B,CAAA;AAClC,UAAQ,QAAQ,CAAC,MAAM,UAAU;AAC/B,QAAI,KAAK,QAAQ,iBAAiB,MAAM,OAAO,aAAa,EAAG,OAAM,KAAK,EAAE,OAAO,MAAM,KAAK,MAAM;AAAA,EACtG,CAAC;AACD,SAAO;AACT;AAOO,SAAS,2BAA2B,UAA8C;AACvF,SAAO,CAAC,UAAU;AAChB,UAAM,gBAAgB,MAAM,cAAc,CAAC,UAAS,6BAAM,UAAS,WAAW;AAC9E,WAAO,SAAS,KAAK,EAClB,IAAI,CAAC,WAAW;AAAA,MACf,GAAG;AAAA,MACH,SAAS,MAAM,QAAQ,OAAO,CAAC,UAAU,CAAC,iBAAiB,MAAM,KAAK,GAAG,OAAO,aAAa,CAAC;AAAA,IAAA,EAC9F,EACD,OAAO,CAAC,UAAU,MAAM,QAAQ,SAAS,CAAC;AAAA,EAC/C;AACF;AAOO,SAAS,uBACd,UACA,SACkB;AAClB,SAAO,CAAC,UACN,SAAS,KAAK,EACX,IAAI,CAAC,WAAW;AAAA,IACf,GAAG;AAAA,IACH,SAAS,MAAM,QAAQ,OAAO,CAAC,UAAU;AACvC,YAAM,OAAO,MAAM,KAAK;AACxB,aAAO,SAAS,UAAa,CAAC,QAAQ,IAAI;AAAA,IAC5C,CAAC;AAAA,EAAA,EACD,EACD,OAAO,CAAC,UAAU,MAAM,QAAQ,SAAS,CAAC;AACjD;"}

package/dist/chat/super-grouping/grouping-function.cjs

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isGroupedToolCallPart(part) {
+  return part.type === "tool-call" && typeof part.toolName === "string" && "toolCallId" in part && typeof part.toolCallId === "string";
+}
 const createToolBasedGroupingFunction = (getToolGroupKey) => (parts) => {
   const calledToolNames = /* @__PURE__ */ new Set();
   for (const part of parts) {
@@ -52,4 +55,5 @@ const createToolBasedGroupingFunction = (getToolGroupKey) => (parts) => {
   return groups;
 };
 exports.createToolBasedGroupingFunction = createToolBasedGroupingFunction;
+exports.isGroupedToolCallPart = isGroupedToolCallPart;
 //# sourceMappingURL=grouping-function.cjs.map

package/dist/chat/super-grouping/grouping-function.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"grouping-function.cjs","sources":["../../../src/chat/super-grouping/grouping-function.ts"],"sourcesContent":["import type { GetToolGroupKey } from './toolkit-map';\n\n/** The part shape grouping needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */\nexport type GroupablePart = {\n  type: string;\n  toolName?: string;\n};\n\n/** One group `MessagePrimitive.Unstable_PartsGrouped` renders through its `Group` component. */\nexport type MessagePartGroup = {\n  groupKey: string | undefined;\n  indices: number[];\n};\n\n/** The grouping contract `MessagePrimitive.Unstable_PartsGrouped` consumes. */\nexport type GroupingFunction = (parts: readonly GroupablePart[]) => MessagePartGroup[];\n\n/**\n * Groups adjacent parts by their toolkit group key: reasoning parts join the\n * open group, and a text part joins when the tool calls on both sides of it\n * share a key. Every `getToolGroupKey` call sees the open group's key and the\n * set of tools the message called, so a tool shared by several toolkits can\n * resolve to the one actually in play (Olympus attributes shared citation\n * tools to the enabled toolkit that way).\n */\nexport const createToolBasedGroupingFunction =\n  (getToolGroupKey: GetToolGroupKey): GroupingFunction =>\n  (parts) => {\n    const calledToolNames = new Set<string>();\n    for (const part of parts) {\n      if (part.type === 'tool-call' && part.toolName) calledToolNames.add(part.toolName);\n    }\n\n    const groups: MessagePartGroup[] = [];\n    let currentGroup: MessagePartGroup | null = null;\n\n    for (let idx = 0; idx < parts.length; idx++) {\n      const part = parts[idx];\n\n      // Reasoning parts join the current group (if any).\n      if (part?.type === 'reasoning') {\n        if (currentGroup) {\n          currentGroup.indices.push(idx);\n        } else {\n          groups.push({ groupKey: undefined, indices: [idx] });\n        }\n        continue;\n      }\n\n      let key: string | undefined;\n\n      if (part?.type === 'tool-call' && part.toolName) {\n        key = getToolGroupKey(part.toolName, {\n          preferredGroupKey: currentGroup?.groupKey,\n          calledToolNames,\n        });\n      } else if (part?.type === 'text') {\n        const prevKey = currentGroup?.groupKey;\n\n        let nextKey: string | undefined;\n        for (let lookIdx = idx + 1; lookIdx < parts.length; lookIdx++) {\n          const lookPart = parts[lookIdx];\n          if (lookPart?.type === 'reasoning' || lookPart?.type === 'text') continue;\n          if (lookPart?.type === 'tool-call' && lookPart.toolName) {\n            nextKey = getToolGroupKey(lookPart.toolName, {\n              preferredGroupKey: currentGroup?.groupKey,\n              calledToolNames,\n            });\n          }\n          break;\n        }\n\n        if (prevKey && nextKey && prevKey === nextKey) {\n          key = prevKey;\n        }\n      }\n\n      if (currentGroup && currentGroup.groupKey === key) {\n        currentGroup.indices.push(idx);\n      } else {\n        if (currentGroup) groups.push(currentGroup);\n        currentGroup = { groupKey: key, indices: [idx] };\n      }\n    }\n    if (currentGroup) groups.push(currentGroup);\n    return groups;\n  };\n"],"names":[],"mappings":";;AAyBO,MAAM,kCACX,CAAC,oBACD,CAAC,UAAU;AACT,QAAM,sCAAsB,IAAA;AAC5B,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,SAAS,eAAe,KAAK,SAAU,iBAAgB,IAAI,KAAK,QAAQ;AAAA,EACnF;AAEA,QAAM,SAA6B,CAAA;AACnC,MAAI,eAAwC;AAE5C,WAAS,MAAM,GAAG,MAAM,MAAM,QAAQ,OAAO;AAC3C,UAAM,OAAO,MAAM,GAAG;AAGtB,SAAI,6BAAM,UAAS,aAAa;AAC9B,UAAI,cAAc;AAChB,qBAAa,QAAQ,KAAK,GAAG;AAAA,MAC/B,OAAO;AACL,eAAO,KAAK,EAAE,UAAU,QAAW,SAAS,CAAC,GAAG,GAAG;AAAA,MACrD;AACA;AAAA,IACF;AAEA,QAAI;AAEJ,SAAI,6BAAM,UAAS,eAAe,KAAK,UAAU;AAC/C,YAAM,gBAAgB,KAAK,UAAU;AAAA,QACnC,mBAAmB,6CAAc;AAAA,QACjC;AAAA,MAAA,CACD;AAAA,IACH,YAAW,6BAAM,UAAS,QAAQ;AAChC,YAAM,UAAU,6CAAc;AAE9B,UAAI;AACJ,eAAS,UAAU,MAAM,GAAG,UAAU,MAAM,QAAQ,WAAW;AAC7D,cAAM,WAAW,MAAM,OAAO;AAC9B,aAAI,qCAAU,UAAS,gBAAe,qCAAU,UAAS,OAAQ;AACjE,aAAI,qCAAU,UAAS,eAAe,SAAS,UAAU;AACvD,oBAAU,gBAAgB,SAAS,UAAU;AAAA,YAC3C,mBAAmB,6CAAc;AAAA,YACjC;AAAA,UAAA,CACD;AAAA,QACH;AACA;AAAA,MACF;AAEA,UAAI,WAAW,WAAW,YAAY,SAAS;AAC7C,cAAM;AAAA,MACR;AAAA,IACF;AAEA,QAAI,gBAAgB,aAAa,aAAa,KAAK;AACjD,mBAAa,QAAQ,KAAK,GAAG;AAAA,IAC/B,OAAO;AACL,UAAI,aAAc,QAAO,KAAK,YAAY;AAC1C,qBAAe,EAAE,UAAU,KAAK,SAAS,CAAC,GAAG,EAAA;AAAA,IAC/C;AAAA,EACF;AACA,MAAI,aAAc,QAAO,KAAK,YAAY;AAC1C,SAAO;AACT;;"}
+{"version":3,"file":"grouping-function.cjs","sources":["../../../src/chat/super-grouping/grouping-function.ts"],"sourcesContent":["import type { ToolCallMessagePart } from '@assistant-ui/react';\nimport type { GetToolGroupKey } from './toolkit-map';\n\n/** The part shape grouping needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */\nexport type GroupablePart = {\n  type: string;\n  toolName?: string;\n};\n\n/**\n * Whether a part a grouping function was handed is a tool call. The parts it\n * groups are the message's own, so a tool call carries the whole call (its id,\n * its artifact), which a host's per-call predicate reads (`isInlineTool`).\n */\nexport function isGroupedToolCallPart(part: GroupablePart): part is ToolCallMessagePart {\n  return (\n    part.type === 'tool-call' &&\n    typeof part.toolName === 'string' &&\n    'toolCallId' in part &&\n    typeof part.toolCallId === 'string'\n  );\n}\n\n/** One group `MessagePrimitive.Unstable_PartsGrouped` renders through its `Group` component. */\nexport type MessagePartGroup = {\n  groupKey: string | undefined;\n  indices: number[];\n};\n\n/** The grouping contract `MessagePrimitive.Unstable_PartsGrouped` consumes. */\nexport type GroupingFunction = (parts: readonly GroupablePart[]) => MessagePartGroup[];\n\n/**\n * Groups adjacent parts by their toolkit group key: reasoning parts join the\n * open group, and a text part joins when the tool calls on both sides of it\n * share a key. Every `getToolGroupKey` call sees the open group's key and the\n * set of tools the message called, so a tool shared by several toolkits can\n * resolve to the one actually in play (Olympus attributes shared citation\n * tools to the enabled toolkit that way).\n */\nexport const createToolBasedGroupingFunction =\n  (getToolGroupKey: GetToolGroupKey): GroupingFunction =>\n  (parts) => {\n    const calledToolNames = new Set<string>();\n    for (const part of parts) {\n      if (part.type === 'tool-call' && part.toolName) calledToolNames.add(part.toolName);\n    }\n\n    const groups: MessagePartGroup[] = [];\n    let currentGroup: MessagePartGroup | null = null;\n\n    for (let idx = 0; idx < parts.length; idx++) {\n      const part = parts[idx];\n\n      // Reasoning parts join the current group (if any).\n      if (part?.type === 'reasoning') {\n        if (currentGroup) {\n          currentGroup.indices.push(idx);\n        } else {\n          groups.push({ groupKey: undefined, indices: [idx] });\n        }\n        continue;\n      }\n\n      let key: string | undefined;\n\n      if (part?.type === 'tool-call' && part.toolName) {\n        key = getToolGroupKey(part.toolName, {\n          preferredGroupKey: currentGroup?.groupKey,\n          calledToolNames,\n        });\n      } else if (part?.type === 'text') {\n        const prevKey = currentGroup?.groupKey;\n\n        let nextKey: string | undefined;\n        for (let lookIdx = idx + 1; lookIdx < parts.length; lookIdx++) {\n          const lookPart = parts[lookIdx];\n          if (lookPart?.type === 'reasoning' || lookPart?.type === 'text') continue;\n          if (lookPart?.type === 'tool-call' && lookPart.toolName) {\n            nextKey = getToolGroupKey(lookPart.toolName, {\n              preferredGroupKey: currentGroup?.groupKey,\n              calledToolNames,\n            });\n          }\n          break;\n        }\n\n        if (prevKey && nextKey && prevKey === nextKey) {\n          key = prevKey;\n        }\n      }\n\n      if (currentGroup && currentGroup.groupKey === key) {\n        currentGroup.indices.push(idx);\n      } else {\n        if (currentGroup) groups.push(currentGroup);\n        currentGroup = { groupKey: key, indices: [idx] };\n      }\n    }\n    if (currentGroup) groups.push(currentGroup);\n    return groups;\n  };\n"],"names":[],"mappings":";;AAcO,SAAS,sBAAsB,MAAkD;AACtF,SACE,KAAK,SAAS,eACd,OAAO,KAAK,aAAa,YACzB,gBAAgB,QAChB,OAAO,KAAK,eAAe;AAE/B;AAmBO,MAAM,kCACX,CAAC,oBACD,CAAC,UAAU;AACT,QAAM,sCAAsB,IAAA;AAC5B,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,SAAS,eAAe,KAAK,SAAU,iBAAgB,IAAI,KAAK,QAAQ;AAAA,EACnF;AAEA,QAAM,SAA6B,CAAA;AACnC,MAAI,eAAwC;AAE5C,WAAS,MAAM,GAAG,MAAM,MAAM,QAAQ,OAAO;AAC3C,UAAM,OAAO,MAAM,GAAG;AAGtB,SAAI,6BAAM,UAAS,aAAa;AAC9B,UAAI,cAAc;AAChB,qBAAa,QAAQ,KAAK,GAAG;AAAA,MAC/B,OAAO;AACL,eAAO,KAAK,EAAE,UAAU,QAAW,SAAS,CAAC,GAAG,GAAG;AAAA,MACrD;AACA;AAAA,IACF;AAEA,QAAI;AAEJ,SAAI,6BAAM,UAAS,eAAe,KAAK,UAAU;AAC/C,YAAM,gBAAgB,KAAK,UAAU;AAAA,QACnC,mBAAmB,6CAAc;AAAA,QACjC;AAAA,MAAA,CACD;AAAA,IACH,YAAW,6BAAM,UAAS,QAAQ;AAChC,YAAM,UAAU,6CAAc;AAE9B,UAAI;AACJ,eAAS,UAAU,MAAM,GAAG,UAAU,MAAM,QAAQ,WAAW;AAC7D,cAAM,WAAW,MAAM,OAAO;AAC9B,aAAI,qCAAU,UAAS,gBAAe,qCAAU,UAAS,OAAQ;AACjE,aAAI,qCAAU,UAAS,eAAe,SAAS,UAAU;AACvD,oBAAU,gBAAgB,SAAS,UAAU;AAAA,YAC3C,mBAAmB,6CAAc;AAAA,YACjC;AAAA,UAAA,CACD;AAAA,QACH;AACA;AAAA,MACF;AAEA,UAAI,WAAW,WAAW,YAAY,SAAS;AAC7C,cAAM;AAAA,MACR;AAAA,IACF;AAEA,QAAI,gBAAgB,aAAa,aAAa,KAAK;AACjD,mBAAa,QAAQ,KAAK,GAAG;AAAA,IAC/B,OAAO;AACL,UAAI,aAAc,QAAO,KAAK,YAAY;AAC1C,qBAAe,EAAE,UAAU,KAAK,SAAS,CAAC,GAAG,EAAA;AAAA,IAC/C;AAAA,EACF;AACA,MAAI,aAAc,QAAO,KAAK,YAAY;AAC1C,SAAO;AACT;;;"}

package/dist/chat/super-grouping/grouping-function.d.ts

@@ -1,9 +1,16 @@
+import type { ToolCallMessagePart } from '@assistant-ui/react';
 import type { GetToolGroupKey } from './toolkit-map';
 /** The part shape grouping needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */
 export type GroupablePart = {
     type: string;
     toolName?: string;
 };
+/**
+ * Whether a part a grouping function was handed is a tool call. The parts it
+ * groups are the message's own, so a tool call carries the whole call (its id,
+ * its artifact), which a host's per-call predicate reads (`isInlineTool`).
+ */
+export declare function isGroupedToolCallPart(part: GroupablePart): part is ToolCallMessagePart;
 /** One group `MessagePrimitive.Unstable_PartsGrouped` renders through its `Group` component. */
 export type MessagePartGroup = {
     groupKey: string | undefined;

package/dist/chat/super-grouping/grouping-function.js

@@ -1,3 +1,6 @@
+function isGroupedToolCallPart(part) {
+  return part.type === "tool-call" && typeof part.toolName === "string" && "toolCallId" in part && typeof part.toolCallId === "string";
+}
 const createToolBasedGroupingFunction = (getToolGroupKey) => (parts) => {
   const calledToolNames = /* @__PURE__ */ new Set();
   for (const part of parts) {
@@ -50,6 +53,7 @@ const createToolBasedGroupingFunction = (getToolGroupKey) => (parts) => {
   return groups;
 };
 export {
-  createToolBasedGroupingFunction
+  createToolBasedGroupingFunction,
+  isGroupedToolCallPart
 };
 //# sourceMappingURL=grouping-function.js.map

package/dist/chat/super-grouping/grouping-function.js.map

@@ -1 +1 @@
-{"version":3,"file":"grouping-function.js","sources":["../../../src/chat/super-grouping/grouping-function.ts"],"sourcesContent":["import type { GetToolGroupKey } from './toolkit-map';\n\n/** The part shape grouping needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */\nexport type GroupablePart = {\n  type: string;\n  toolName?: string;\n};\n\n/** One group `MessagePrimitive.Unstable_PartsGrouped` renders through its `Group` component. */\nexport type MessagePartGroup = {\n  groupKey: string | undefined;\n  indices: number[];\n};\n\n/** The grouping contract `MessagePrimitive.Unstable_PartsGrouped` consumes. */\nexport type GroupingFunction = (parts: readonly GroupablePart[]) => MessagePartGroup[];\n\n/**\n * Groups adjacent parts by their toolkit group key: reasoning parts join the\n * open group, and a text part joins when the tool calls on both sides of it\n * share a key. Every `getToolGroupKey` call sees the open group's key and the\n * set of tools the message called, so a tool shared by several toolkits can\n * resolve to the one actually in play (Olympus attributes shared citation\n * tools to the enabled toolkit that way).\n */\nexport const createToolBasedGroupingFunction =\n  (getToolGroupKey: GetToolGroupKey): GroupingFunction =>\n  (parts) => {\n    const calledToolNames = new Set<string>();\n    for (const part of parts) {\n      if (part.type === 'tool-call' && part.toolName) calledToolNames.add(part.toolName);\n    }\n\n    const groups: MessagePartGroup[] = [];\n    let currentGroup: MessagePartGroup | null = null;\n\n    for (let idx = 0; idx < parts.length; idx++) {\n      const part = parts[idx];\n\n      // Reasoning parts join the current group (if any).\n      if (part?.type === 'reasoning') {\n        if (currentGroup) {\n          currentGroup.indices.push(idx);\n        } else {\n          groups.push({ groupKey: undefined, indices: [idx] });\n        }\n        continue;\n      }\n\n      let key: string | undefined;\n\n      if (part?.type === 'tool-call' && part.toolName) {\n        key = getToolGroupKey(part.toolName, {\n          preferredGroupKey: currentGroup?.groupKey,\n          calledToolNames,\n        });\n      } else if (part?.type === 'text') {\n        const prevKey = currentGroup?.groupKey;\n\n        let nextKey: string | undefined;\n        for (let lookIdx = idx + 1; lookIdx < parts.length; lookIdx++) {\n          const lookPart = parts[lookIdx];\n          if (lookPart?.type === 'reasoning' || lookPart?.type === 'text') continue;\n          if (lookPart?.type === 'tool-call' && lookPart.toolName) {\n            nextKey = getToolGroupKey(lookPart.toolName, {\n              preferredGroupKey: currentGroup?.groupKey,\n              calledToolNames,\n            });\n          }\n          break;\n        }\n\n        if (prevKey && nextKey && prevKey === nextKey) {\n          key = prevKey;\n        }\n      }\n\n      if (currentGroup && currentGroup.groupKey === key) {\n        currentGroup.indices.push(idx);\n      } else {\n        if (currentGroup) groups.push(currentGroup);\n        currentGroup = { groupKey: key, indices: [idx] };\n      }\n    }\n    if (currentGroup) groups.push(currentGroup);\n    return groups;\n  };\n"],"names":[],"mappings":"AAyBO,MAAM,kCACX,CAAC,oBACD,CAAC,UAAU;AACT,QAAM,sCAAsB,IAAA;AAC5B,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,SAAS,eAAe,KAAK,SAAU,iBAAgB,IAAI,KAAK,QAAQ;AAAA,EACnF;AAEA,QAAM,SAA6B,CAAA;AACnC,MAAI,eAAwC;AAE5C,WAAS,MAAM,GAAG,MAAM,MAAM,QAAQ,OAAO;AAC3C,UAAM,OAAO,MAAM,GAAG;AAGtB,SAAI,6BAAM,UAAS,aAAa;AAC9B,UAAI,cAAc;AAChB,qBAAa,QAAQ,KAAK,GAAG;AAAA,MAC/B,OAAO;AACL,eAAO,KAAK,EAAE,UAAU,QAAW,SAAS,CAAC,GAAG,GAAG;AAAA,MACrD;AACA;AAAA,IACF;AAEA,QAAI;AAEJ,SAAI,6BAAM,UAAS,eAAe,KAAK,UAAU;AAC/C,YAAM,gBAAgB,KAAK,UAAU;AAAA,QACnC,mBAAmB,6CAAc;AAAA,QACjC;AAAA,MAAA,CACD;AAAA,IACH,YAAW,6BAAM,UAAS,QAAQ;AAChC,YAAM,UAAU,6CAAc;AAE9B,UAAI;AACJ,eAAS,UAAU,MAAM,GAAG,UAAU,MAAM,QAAQ,WAAW;AAC7D,cAAM,WAAW,MAAM,OAAO;AAC9B,aAAI,qCAAU,UAAS,gBAAe,qCAAU,UAAS,OAAQ;AACjE,aAAI,qCAAU,UAAS,eAAe,SAAS,UAAU;AACvD,oBAAU,gBAAgB,SAAS,UAAU;AAAA,YAC3C,mBAAmB,6CAAc;AAAA,YACjC;AAAA,UAAA,CACD;AAAA,QACH;AACA;AAAA,MACF;AAEA,UAAI,WAAW,WAAW,YAAY,SAAS;AAC7C,cAAM;AAAA,MACR;AAAA,IACF;AAEA,QAAI,gBAAgB,aAAa,aAAa,KAAK;AACjD,mBAAa,QAAQ,KAAK,GAAG;AAAA,IAC/B,OAAO;AACL,UAAI,aAAc,QAAO,KAAK,YAAY;AAC1C,qBAAe,EAAE,UAAU,KAAK,SAAS,CAAC,GAAG,EAAA;AAAA,IAC/C;AAAA,EACF;AACA,MAAI,aAAc,QAAO,KAAK,YAAY;AAC1C,SAAO;AACT;"}
+{"version":3,"file":"grouping-function.js","sources":["../../../src/chat/super-grouping/grouping-function.ts"],"sourcesContent":["import type { ToolCallMessagePart } from '@assistant-ui/react';\nimport type { GetToolGroupKey } from './toolkit-map';\n\n/** The part shape grouping needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */\nexport type GroupablePart = {\n  type: string;\n  toolName?: string;\n};\n\n/**\n * Whether a part a grouping function was handed is a tool call. The parts it\n * groups are the message's own, so a tool call carries the whole call (its id,\n * its artifact), which a host's per-call predicate reads (`isInlineTool`).\n */\nexport function isGroupedToolCallPart(part: GroupablePart): part is ToolCallMessagePart {\n  return (\n    part.type === 'tool-call' &&\n    typeof part.toolName === 'string' &&\n    'toolCallId' in part &&\n    typeof part.toolCallId === 'string'\n  );\n}\n\n/** One group `MessagePrimitive.Unstable_PartsGrouped` renders through its `Group` component. */\nexport type MessagePartGroup = {\n  groupKey: string | undefined;\n  indices: number[];\n};\n\n/** The grouping contract `MessagePrimitive.Unstable_PartsGrouped` consumes. */\nexport type GroupingFunction = (parts: readonly GroupablePart[]) => MessagePartGroup[];\n\n/**\n * Groups adjacent parts by their toolkit group key: reasoning parts join the\n * open group, and a text part joins when the tool calls on both sides of it\n * share a key. Every `getToolGroupKey` call sees the open group's key and the\n * set of tools the message called, so a tool shared by several toolkits can\n * resolve to the one actually in play (Olympus attributes shared citation\n * tools to the enabled toolkit that way).\n */\nexport const createToolBasedGroupingFunction =\n  (getToolGroupKey: GetToolGroupKey): GroupingFunction =>\n  (parts) => {\n    const calledToolNames = new Set<string>();\n    for (const part of parts) {\n      if (part.type === 'tool-call' && part.toolName) calledToolNames.add(part.toolName);\n    }\n\n    const groups: MessagePartGroup[] = [];\n    let currentGroup: MessagePartGroup | null = null;\n\n    for (let idx = 0; idx < parts.length; idx++) {\n      const part = parts[idx];\n\n      // Reasoning parts join the current group (if any).\n      if (part?.type === 'reasoning') {\n        if (currentGroup) {\n          currentGroup.indices.push(idx);\n        } else {\n          groups.push({ groupKey: undefined, indices: [idx] });\n        }\n        continue;\n      }\n\n      let key: string | undefined;\n\n      if (part?.type === 'tool-call' && part.toolName) {\n        key = getToolGroupKey(part.toolName, {\n          preferredGroupKey: currentGroup?.groupKey,\n          calledToolNames,\n        });\n      } else if (part?.type === 'text') {\n        const prevKey = currentGroup?.groupKey;\n\n        let nextKey: string | undefined;\n        for (let lookIdx = idx + 1; lookIdx < parts.length; lookIdx++) {\n          const lookPart = parts[lookIdx];\n          if (lookPart?.type === 'reasoning' || lookPart?.type === 'text') continue;\n          if (lookPart?.type === 'tool-call' && lookPart.toolName) {\n            nextKey = getToolGroupKey(lookPart.toolName, {\n              preferredGroupKey: currentGroup?.groupKey,\n              calledToolNames,\n            });\n          }\n          break;\n        }\n\n        if (prevKey && nextKey && prevKey === nextKey) {\n          key = prevKey;\n        }\n      }\n\n      if (currentGroup && currentGroup.groupKey === key) {\n        currentGroup.indices.push(idx);\n      } else {\n        if (currentGroup) groups.push(currentGroup);\n        currentGroup = { groupKey: key, indices: [idx] };\n      }\n    }\n    if (currentGroup) groups.push(currentGroup);\n    return groups;\n  };\n"],"names":[],"mappings":"AAcO,SAAS,sBAAsB,MAAkD;AACtF,SACE,KAAK,SAAS,eACd,OAAO,KAAK,aAAa,YACzB,gBAAgB,QAChB,OAAO,KAAK,eAAe;AAE/B;AAmBO,MAAM,kCACX,CAAC,oBACD,CAAC,UAAU;AACT,QAAM,sCAAsB,IAAA;AAC5B,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,SAAS,eAAe,KAAK,SAAU,iBAAgB,IAAI,KAAK,QAAQ;AAAA,EACnF;AAEA,QAAM,SAA6B,CAAA;AACnC,MAAI,eAAwC;AAE5C,WAAS,MAAM,GAAG,MAAM,MAAM,QAAQ,OAAO;AAC3C,UAAM,OAAO,MAAM,GAAG;AAGtB,SAAI,6BAAM,UAAS,aAAa;AAC9B,UAAI,cAAc;AAChB,qBAAa,QAAQ,KAAK,GAAG;AAAA,MAC/B,OAAO;AACL,eAAO,KAAK,EAAE,UAAU,QAAW,SAAS,CAAC,GAAG,GAAG;AAAA,MACrD;AACA;AAAA,IACF;AAEA,QAAI;AAEJ,SAAI,6BAAM,UAAS,eAAe,KAAK,UAAU;AAC/C,YAAM,gBAAgB,KAAK,UAAU;AAAA,QACnC,mBAAmB,6CAAc;AAAA,QACjC;AAAA,MAAA,CACD;AAAA,IACH,YAAW,6BAAM,UAAS,QAAQ;AAChC,YAAM,UAAU,6CAAc;AAE9B,UAAI;AACJ,eAAS,UAAU,MAAM,GAAG,UAAU,MAAM,QAAQ,WAAW;AAC7D,cAAM,WAAW,MAAM,OAAO;AAC9B,aAAI,qCAAU,UAAS,gBAAe,qCAAU,UAAS,OAAQ;AACjE,aAAI,qCAAU,UAAS,eAAe,SAAS,UAAU;AACvD,oBAAU,gBAAgB,SAAS,UAAU;AAAA,YAC3C,mBAAmB,6CAAc;AAAA,YACjC;AAAA,UAAA,CACD;AAAA,QACH;AACA;AAAA,MACF;AAEA,UAAI,WAAW,WAAW,YAAY,SAAS;AAC7C,cAAM;AAAA,MACR;AAAA,IACF;AAEA,QAAI,gBAAgB,aAAa,aAAa,KAAK;AACjD,mBAAa,QAAQ,KAAK,GAAG;AAAA,IAC/B,OAAO;AACL,UAAI,aAAc,QAAO,KAAK,YAAY;AAC1C,qBAAe,EAAE,UAAU,KAAK,SAAS,CAAC,GAAG,EAAA;AAAA,IAC/C;AAAA,EACF;AACA,MAAI,aAAc,QAAO,KAAK,YAAY;AAC1C,SAAO;AACT;"}

package/dist/chat/super-grouping/index.cjs

@@ -6,10 +6,13 @@ const GroupedMessageParts = require("./GroupedMessageParts.cjs");
 const groupingFunction = require("./grouping-function.cjs");
 const SuperGroupingCard = require("./SuperGroupingCard.cjs");
 const SuperGroupingTranscript = require("./SuperGroupingTranscript.cjs");
+const toolPartPlacement = require("./tool-part-placement.cjs");
 const turnSegments = require("./turn-segments.cjs");
 const turnTiming = require("./turn-timing.cjs");
 const toolkitMap = require("./toolkit-map.cjs");
+const inlineTools = require("../../tools/inline-tools.cjs");
 exports.buildActivityTimeline = activityTimeline.buildActivityTimeline;
+exports.countActivityDelegations = activityTimeline.countActivityDelegations;
 exports.countActivityTools = activityTimeline.countActivityTools;
 exports.excludeFinalTextFromGroups = activityTimeline.excludeFinalTextFromGroups;
 exports.excludePartsFromGroups = activityTimeline.excludePartsFromGroups;
@@ -32,6 +35,8 @@ exports.SuperGroupingFinalText = SuperGroupingCard.SuperGroupingFinalText;
 exports.resetRememberedExpansionsForTests = SuperGroupingCard.resetRememberedExpansionsForTests;
 exports.useActivityExpansion = SuperGroupingCard.useActivityExpansion;
 exports.SuperGroupingTranscript = SuperGroupingTranscript.SuperGroupingTranscript;
+exports.ToolPartPlacementProvider = toolPartPlacement.ToolPartPlacementProvider;
+exports.useToolPartPlacement = toolPartPlacement.useToolPartPlacement;
 exports.scopeGroupingToSegment = turnSegments.scopeGroupingToSegment;
 exports.splitTurnSegments = turnSegments.splitTurnSegments;
 exports.summarizeSegment = turnSegments.summarizeSegment;
@@ -39,4 +44,5 @@ exports.formatWorkDuration = turnTiming.formatWorkDuration;
 exports.readTurnTiming = turnTiming.readTurnTiming;
 exports.workedDurationMs = turnTiming.workedDurationMs;
 exports.defaultGetToolGroupKey = toolkitMap.defaultGetToolGroupKey;
+exports.isSdkInlineTool = inlineTools.isSdkInlineTool;
 //# sourceMappingURL=index.cjs.map

package/dist/chat/super-grouping/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/chat/super-grouping/index.d.ts

@@ -5,17 +5,20 @@
  * them mounted as the turn grows, the timeline derivation behind them, the
  * tool-based grouping function, and the transcript layout (the agent's
  * sentences in order with the work between them folded, under a "Working
- * for …" header).
+ * for …" header), and where the card renders a call's tool UI outside its
+ * details (`useToolPartPlacement`).
  * A lean entry so hosts with their own thread (Olympus, the Chrome extension)
  * mount it from source without the SDK's composer stack.
  */
-export { type ActivityItem, type ActivityPhase, type ActivityTimelineOptions, type ActivityToolState, buildActivityTimeline, countActivityTools, excludeFinalTextFromGroups, excludePartsFromGroups, type FinalTextPart, type FinalTextSegment, getActivityItemLabel, getActivitySummary, getReasoningLabel, getActivityToolState, isStreamingToolPlaceholder, getFinalText, getFinalTextParts, resolveActivityPhase, } from './activity-timeline';
+export { type ActivityItem, type ActivityPhase, type ActivityTimelineOptions, type ActivityToolState, buildActivityTimeline, countActivityDelegations, countActivityTools, excludeFinalTextFromGroups, excludePartsFromGroups, type FinalTextPart, type FinalTextSegment, getActivityItemLabel, getActivitySummary, getReasoningLabel, getActivityToolState, isStreamingToolPlaceholder, getFinalText, getFinalTextParts, resolveActivityPhase, } from './activity-timeline';
 export { CollapsibleGroup, type CollapsibleGroupProps, DEFAULT_TOOLKIT_THEME, SuperGroupingProvider, TOOLKIT_THEMES, type ToolkitTheme, } from './CollapsibleGroup';
 export { GroupedMessageParts, type GroupedMessagePartsProps } from './GroupedMessageParts';
 export { createToolBasedGroupingFunction, type GroupablePart, type GroupingFunction, type MessagePartGroup, } from './grouping-function';
 export { resetRememberedExpansionsForTests, SuperGroupingCard, type SuperGroupingCardProps, SuperGroupingFinalText, useActivityExpansion, } from './SuperGroupingCard';
 export { SuperGroupingTranscript, type SuperGroupingTranscriptProps } from './SuperGroupingTranscript';
 export type { TimelineStep } from './timeline-step';
+export { type ToolPartPlacement, ToolPartPlacementProvider, useToolPartPlacement } from './tool-part-placement';
 export { scopeGroupingToSegment, type SegmentablePart, type SegmentSummary, splitTurnSegments, summarizeSegment, type TurnSegment, } from './turn-segments';
 export { formatWorkDuration, readTurnTiming, type TurnTiming, type TurnTimingSources, workedDurationMs, } from './turn-timing';
 export { defaultGetToolGroupKey, type GetToolGroupKey, type ToolGroupKeyOptions } from './toolkit-map';
+export { isSdkInlineTool } from '../../tools/inline-tools';

package/dist/chat/super-grouping/index.js

@@ -1,12 +1,14 @@
-import { buildActivityTimeline, countActivityTools, excludeFinalTextFromGroups, excludePartsFromGroups, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, getFinalTextParts, getReasoningLabel, isStreamingToolPlaceholder, resolveActivityPhase } from "./activity-timeline.js";
+import { buildActivityTimeline, countActivityDelegations, countActivityTools, excludeFinalTextFromGroups, excludePartsFromGroups, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, getFinalTextParts, getReasoningLabel, isStreamingToolPlaceholder, resolveActivityPhase } from "./activity-timeline.js";
 import { CollapsibleGroup, DEFAULT_TOOLKIT_THEME, SuperGroupingProvider, TOOLKIT_THEMES } from "./CollapsibleGroup.js";
 import { GroupedMessageParts } from "./GroupedMessageParts.js";
 import { createToolBasedGroupingFunction } from "./grouping-function.js";
 import { SuperGroupingCard, SuperGroupingFinalText, resetRememberedExpansionsForTests, useActivityExpansion } from "./SuperGroupingCard.js";
 import { SuperGroupingTranscript } from "./SuperGroupingTranscript.js";
+import { ToolPartPlacementProvider, useToolPartPlacement } from "./tool-part-placement.js";
 import { scopeGroupingToSegment, splitTurnSegments, summarizeSegment } from "./turn-segments.js";
 import { formatWorkDuration, readTurnTiming, workedDurationMs } from "./turn-timing.js";
 import { defaultGetToolGroupKey } from "./toolkit-map.js";
+import { isSdkInlineTool } from "../../tools/inline-tools.js";
 export {
   CollapsibleGroup,
   DEFAULT_TOOLKIT_THEME,
@@ -16,7 +18,9 @@ export {
   SuperGroupingProvider,
   SuperGroupingTranscript,
   TOOLKIT_THEMES,
+  ToolPartPlacementProvider,
   buildActivityTimeline,
+  countActivityDelegations,
   countActivityTools,
   createToolBasedGroupingFunction,
   defaultGetToolGroupKey,
@@ -29,6 +33,7 @@ export {
   getFinalText,
   getFinalTextParts,
   getReasoningLabel,
+  isSdkInlineTool,
   isStreamingToolPlaceholder,
   readTurnTiming,
   resetRememberedExpansionsForTests,
@@ -37,6 +42,7 @@ export {
   splitTurnSegments,
   summarizeSegment,
   useActivityExpansion,
+  useToolPartPlacement,
   workedDurationMs
 };
 //# sourceMappingURL=index.js.map

package/dist/chat/super-grouping/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}