@athenaintel/react 0.18.0 → 0.20.0

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

@@ -0,0 +1,91 @@
+/**
+ * The assistant turn's activity timeline — the one derivation of "what did
+ * this turn do, and how did each step end" behind the grouped
+ * ("conversational") view on every surface: the SDK's `AthenaChat`, Olympus's
+ * Spaces chat, and the Chrome extension. Pure functions over assistant-ui
+ * message parts; `SuperGroupingCard` renders them.
+ *
+ * Step states come from the shared classifier (`classifyToolResult`) plus the
+ * approval outcomes a part carries (`approval`, `interrupt`, a rejection
+ * result), so a call that reads as failed, paused, or rejected on one surface
+ * cannot read as a green check on another. Copy comes from the shared tool
+ * display registry (`toolStatusLabel`).
+ */
+import type { MessageStatus, ThreadAssistantMessagePart } from '@assistant-ui/react';
+import { type ToolStatusLabelState } from '@athenaintel/agent-runtime';
+import type { GroupingFunction } from './grouping-function';
+export type ActivityToolState = ToolStatusLabelState;
+export type ActivityItem = {
+    kind: 'reasoning';
+    text: string;
+    state: 'running' | 'complete';
+} | {
+    kind: 'tool';
+    toolName: string;
+    state: ActivityToolState;
+};
+/** The turn as a whole: still working, parked on the person, ended in error, or done. */
+export type ActivityPhase = 'running' | 'waiting' | 'complete' | 'error';
+type ToolCallPart = Extract<ThreadAssistantMessagePart, {
+    type: 'tool-call';
+}>;
+export interface ActivityTimelineOptions {
+    /**
+     * Tools whose unresolved call means the turn is waiting on the person even
+     * without an interrupt or approval on the part (the Chrome extension's
+     * device plan approval, which the tool UI itself collects).
+     */
+    waitingTools?: ReadonlySet<string>;
+    /**
+     * Tools whose result is an application payload relayed verbatim (the Chrome
+     * extension's page JavaScript), so a `success: false` flag counts only with
+     * an error detail — see `classifyToolResult`'s `passThroughPayload`.
+     */
+    passThroughTools?: ReadonlySet<string>;
+}
+/** How one tool call ended (or is going), reading the approval fields before the result. */
+export declare function getActivityToolState(part: ToolCallPart, messageStatus: MessageStatus | undefined, { waitingTools, passThroughTools }?: ActivityTimelineOptions): ActivityToolState;
+/**
+ * The compact reasoning/tool timeline in the order the parts streamed.
+ *
+ * A reasoning part is still streaming only while it is the final part of a
+ * running message — once any later part appears, the thought has settled.
+ * Settled reasoning parts with no text are dropped so the list never shows an
+ * empty thinking row.
+ */
+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;
+/**
+ * The turn's phase. Waiting on the person wins over everything — a
+ * `requires-action` status, a waiting tool, or a host's own `waitingForInput`
+ * assertion (no in-repo host passes one) — then the message's own status.
+ */
+export declare function resolveActivityPhase(status: MessageStatus | undefined, timeline: readonly ActivityItem[], { waitingForInput }?: {
+    waitingForInput?: boolean;
+}): ActivityPhase;
+/**
+ * The status-row copy for one step. `resolveToolDisplayName` lets a host with
+ * a richer tool catalog name tools the shared registry has no entry for.
+ */
+export declare function getActivityItemLabel(item: ActivityItem, resolveToolDisplayName?: (toolName: string) => string | undefined): string;
+/** The collapsed-card summary of a finished turn. */
+export declare function getActivitySummary(timeline: readonly ActivityItem[]): string;
+/** The part shape the final-text read needs; any message role's parts satisfy it. */
+export type FinalTextPart = {
+    readonly type: string;
+    readonly text?: string;
+};
+/**
+ * The visible answer of a grouped turn: the text after the final tool call,
+ * or all of it when the turn never called a tool. Intermediate text (before
+ * or between tool calls) stays available in the details panel.
+ */
+export declare function getFinalText(content: readonly FinalTextPart[] | undefined): string | null;
+/**
+ * Keep the final answer out of the details panel: it renders below the card
+ * (`SuperGroupingFinalText`), so the details grouping drops every text part
+ * after the last tool call and any group that becomes empty.
+ */
+export declare function excludeFinalTextFromGroups(grouping: GroupingFunction): GroupingFunction;
+export {};

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

@@ -0,0 +1,151 @@
+import "../../packages/agent-runtime/src/generated/runconfig-contract.js";
+import "react";
+import "@assistant-ui/tap";
+import "statewire";
+import "../../packages/agent-runtime/src/statewire-suspended.js";
+import { toolStatusLabel } from "../../packages/agent-runtime/src/tool-metadata.js";
+import { readRejectedToolResult, classifyToolResult } from "../../packages/agent-runtime/src/tool-result.js";
+import "@tanstack/react-query";
+import "../../packages/agent-runtime/src/statewire-state.js";
+import "../../packages/agent-runtime/src/messages.js";
+import "@assistant-ui/react-statewire";
+import "@assistant-ui/store";
+import "@assistant-ui/react-statewire/local-storage";
+import "../../packages/agent-runtime/src/statewire-attach-observer.js";
+import "../../packages/agent-runtime/src/thread-status.js";
+import "@assistant-ui/core";
+const NO_TOOLS = /* @__PURE__ */ new Set();
+function toolCallStatus(part, messageStatus) {
+  if (part.result !== void 0) return { type: "complete" };
+  if ((messageStatus == null ? void 0 : messageStatus.type) === "incomplete") {
+    return {
+      type: "incomplete",
+      reason: messageStatus.reason === "tool-calls" ? "other" : messageStatus.reason,
+      error: messageStatus.error
+    };
+  }
+  if ((messageStatus == null ? void 0 : messageStatus.type) === "complete") return { type: "complete" };
+  if ((messageStatus == null ? void 0 : messageStatus.type) === "requires-action") {
+    return { type: "requires-action", reason: messageStatus.reason };
+  }
+  if ((messageStatus == null ? void 0 : messageStatus.type) === "running") return { type: "running" };
+  return void 0;
+}
+function getActivityToolState(part, messageStatus, { waitingTools = NO_TOOLS, passThroughTools = NO_TOOLS } = {}) {
+  var _a, _b, _c, _d;
+  if (((_a = part.approval) == null ? void 0 : _a.approved) === false || readRejectedToolResult(part.result) !== null) {
+    return "rejected";
+  }
+  if (((_b = part.approval) == null ? void 0 : _b.resolution) === "cancelled" || ((_c = part.approval) == null ? void 0 : _c.resolution) === "expired") {
+    return "cancelled";
+  }
+  const unresolved = part.result === void 0;
+  const messageIsActive = messageStatus === void 0 || messageStatus.type === "running" || messageStatus.type === "requires-action";
+  if (unresolved && (((_d = part.interrupt) == null ? void 0 : _d.type) === "human" || part.approval !== void 0 && part.approval.approved === void 0 && part.approval.resolution === void 0 || waitingTools.has(part.toolName) && messageIsActive)) {
+    return "waiting";
+  }
+  const classification = classifyToolResult({
+    status: toolCallStatus(part, messageStatus),
+    result: part.result,
+    isError: part.isError,
+    passThroughPayload: passThroughTools.has(part.toolName)
+  });
+  if (classification.state === "requires-action") return "waiting";
+  return classification.state;
+}
+function buildActivityTimeline(content, messageStatus, options = {}) {
+  if (!(content == null ? void 0 : content.length)) return [];
+  const lastPartIndex = content.length - 1;
+  const timeline = [];
+  for (let index = 0; index < content.length; index += 1) {
+    const part = content[index];
+    if (part.type === "tool-call") {
+      timeline.push({
+        kind: "tool",
+        toolName: part.toolName,
+        state: getActivityToolState(part, messageStatus, options)
+      });
+      continue;
+    }
+    if (part.type !== "reasoning") continue;
+    const text = typeof part.text === "string" ? part.text : "";
+    const stillStreaming = (messageStatus == null ? void 0 : messageStatus.type) === "running" && index === lastPartIndex;
+    if (!stillStreaming && text.trim() === "") continue;
+    timeline.push({ kind: "reasoning", text, state: stillStreaming ? "running" : "complete" });
+  }
+  return timeline;
+}
+function countActivityTools(timeline) {
+  return timeline.reduce((count, item) => item.kind === "tool" ? 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";
+  }
+  if ((status == null ? void 0 : status.type) === "running") return "running";
+  if ((status == null ? void 0 : status.type) === "incomplete") return "error";
+  return "complete";
+}
+function getActivityItemLabel(item, resolveToolDisplayName) {
+  if (item.kind === "reasoning") {
+    return item.state === "running" ? "Thinking" : "Thought through the next step";
+  }
+  return toolStatusLabel(item.toolName, item.state, resolveToolDisplayName == null ? void 0 : resolveToolDisplayName(item.toolName));
+}
+function getActivitySummary(timeline) {
+  const toolCount = countActivityTools(timeline);
+  const hasIssue = timeline.some(
+    (item) => item.kind === "tool" && (item.state === "error" || 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";
+  }
+  if (toolCount > 0) return `Used ${toolCount} ${toolCount === 1 ? "tool" : "tools"}`;
+  return "Reasoning complete";
+}
+function getFinalText(content) {
+  var _a;
+  if (!(content == null ? void 0 : content.length)) return null;
+  let lastToolIndex = -1;
+  for (let index = content.length - 1; index >= 0; index -= 1) {
+    if (((_a = content[index]) == null ? void 0 : _a.type) === "tool-call") {
+      lastToolIndex = index;
+      break;
+    }
+  }
+  const texts = [];
+  for (let index = lastToolIndex + 1; index < content.length; index += 1) {
+    const part = content[index];
+    if ((part == null ? void 0 : part.type) === "text" && part.text) texts.push(part.text);
+  }
+  return texts.length > 0 ? texts.join("\n\n") : null;
+}
+function excludeFinalTextFromGroups(grouping) {
+  return (parts) => {
+    const lastToolIndex = parts.findLastIndex((part) => (part == null ? void 0 : part.type) === "tool-call");
+    return grouping(parts).map((group) => ({
+      ...group,
+      indices: group.indices.filter(
+        (index) => {
+          var _a;
+          return ((_a = parts[index]) == null ? void 0 : _a.type) !== "text" || index <= lastToolIndex;
+        }
+      )
+    })).filter((group) => group.indices.length > 0);
+  };
+}
+export {
+  buildActivityTimeline,
+  countActivityTools,
+  excludeFinalTextFromGroups,
+  getActivityItemLabel,
+  getActivitySummary,
+  getActivityToolState,
+  getFinalText,
+  resolveActivityPhase
+};
+//# sourceMappingURL=activity-timeline.js.map

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

@@ -0,0 +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 grouped\n * (\"conversational\") view on every surface: the SDK's `AthenaChat`, Olympus's\n * Spaces chat, and the Chrome extension. Pure functions over assistant-ui\n * 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 * display registry (`toolStatusLabel`).\n */\nimport type {\n  MessageStatus,\n  ThreadAssistantMessagePart,\n  ToolCallMessagePartStatus,\n} from '@assistant-ui/react';\nimport {\n  classifyToolResult,\n  readRejectedToolResult,\n  toolStatusLabel,\n  type ToolStatusLabelState,\n} from '@athenaintel/agent-runtime';\nimport type { GroupingFunction } from './grouping-function';\n\nexport type ActivityToolState = ToolStatusLabelState;\n\nexport type ActivityItem =\n  | { kind: 'reasoning'; text: string; state: 'running' | 'complete' }\n  | { kind: 'tool'; toolName: string; state: ActivityToolState };\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   * 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();\n\nfunction toolCallStatus(\n  part: ToolCallPart,\n  messageStatus: MessageStatus | undefined,\n): ToolCallMessagePartStatus | undefined {\n  if (part.result !== 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') return { type: 'complete' };\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  { waitingTools = NO_TOOLS, passThroughTools = NO_TOOLS }: 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 unresolved = part.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      (waitingTools.has(part.toolName) && messageIsActive))\n  ) {\n    return 'waiting';\n  }\n\n  const classification = classifyToolResult({\n    status: toolCallStatus(part, messageStatus),\n    result: part.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      timeline.push({\n        kind: 'tool',\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({ kind: 'reasoning', text, state: stillStreaming ? 'running' : 'complete' });\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.\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  return 'complete';\n}\n\n/**\n * The status-row copy for one step. `resolveToolDisplayName` lets a host with\n * a richer tool catalog name tools the shared registry has no entry for.\n */\nexport function getActivityItemLabel(\n  item: ActivityItem,\n  resolveToolDisplayName?: (toolName: string) => string | undefined,\n): string {\n  if (item.kind === 'reasoning') {\n    return item.state === 'running' ? 'Thinking' : 'Thought through the next step';\n  }\n  return toolStatusLabel(item.toolName, item.state, resolveToolDisplayName?.(item.toolName));\n}\n\n/** The collapsed-card summary of a finished turn. */\nexport function getActivitySummary(timeline: readonly ActivityItem[]): string {\n  const toolCount = countActivityTools(timeline);\n  const hasIssue = timeline.some(\n    (item) => item.kind === 'tool' && (item.state === 'error' || item.state === 'rejected'),\n  );\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 * The visible answer of a grouped turn: the text after the final tool call,\n * or all of it when the turn never called a tool. 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  if (!content?.length) return null;\n\n  let lastToolIndex = -1;\n  for (let index = content.length - 1; index >= 0; index -= 1) {\n    if (content[index]?.type === 'tool-call') {\n      lastToolIndex = index;\n      break;\n    }\n  }\n\n  const texts: string[] = [];\n  for (let index = lastToolIndex + 1; index < content.length; index += 1) {\n    const part = content[index];\n    if (part?.type === 'text' && part.text) texts.push(part.text);\n  }\n  return texts.length > 0 ? texts.join('\\n\\n') : null;\n}\n\n/**\n * Keep the final answer out of the details panel: it renders below the card\n * (`SuperGroupingFinalText`), so the details grouping drops every text part\n * after the last tool call 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(\n          (index) => parts[index]?.type !== 'text' || index <= lastToolIndex,\n        ),\n      }))\n      .filter((group) => group.indices.length > 0);\n  };\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createToolBasedGroupingFunction = (getToolGroupKey) => (parts) => {
+  const calledToolNames = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    if (part.type === "tool-call" && part.toolName) calledToolNames.add(part.toolName);
+  }
+  const groups = [];
+  let currentGroup = null;
+  for (let idx = 0; idx < parts.length; idx++) {
+    const part = parts[idx];
+    if ((part == null ? void 0 : part.type) === "reasoning") {
+      if (currentGroup) {
+        currentGroup.indices.push(idx);
+      } else {
+        groups.push({ groupKey: void 0, indices: [idx] });
+      }
+      continue;
+    }
+    let key;
+    if ((part == null ? void 0 : part.type) === "tool-call" && part.toolName) {
+      key = getToolGroupKey(part.toolName, {
+        preferredGroupKey: currentGroup == null ? void 0 : currentGroup.groupKey,
+        calledToolNames
+      });
+    } else if ((part == null ? void 0 : part.type) === "text") {
+      const prevKey = currentGroup == null ? void 0 : currentGroup.groupKey;
+      let nextKey;
+      for (let lookIdx = idx + 1; lookIdx < parts.length; lookIdx++) {
+        const lookPart = parts[lookIdx];
+        if ((lookPart == null ? void 0 : lookPart.type) === "reasoning" || (lookPart == null ? void 0 : lookPart.type) === "text") continue;
+        if ((lookPart == null ? void 0 : lookPart.type) === "tool-call" && lookPart.toolName) {
+          nextKey = getToolGroupKey(lookPart.toolName, {
+            preferredGroupKey: currentGroup == null ? void 0 : currentGroup.groupKey,
+            calledToolNames
+          });
+        }
+        break;
+      }
+      if (prevKey && nextKey && prevKey === nextKey) {
+        key = prevKey;
+      }
+    }
+    if (currentGroup && currentGroup.groupKey === key) {
+      currentGroup.indices.push(idx);
+    } else {
+      if (currentGroup) groups.push(currentGroup);
+      currentGroup = { groupKey: key, indices: [idx] };
+    }
+  }
+  if (currentGroup) groups.push(currentGroup);
+  return groups;
+};
+exports.createToolBasedGroupingFunction = createToolBasedGroupingFunction;
+//# sourceMappingURL=grouping-function.cjs.map

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

@@ -0,0 +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;;"}

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

@@ -1,19 +1,22 @@
 import type { GetToolGroupKey } from './toolkit-map';
-type AnyPart = {
+/** The part shape grouping needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */
+export type GroupablePart = {
     type: string;
     toolName?: string;
 };
-type MessagePartGroup = {
+/** One group `MessagePrimitive.Unstable_PartsGrouped` renders through its `Group` component. */
+export type MessagePartGroup = {
     groupKey: string | undefined;
     indices: number[];
 };
+/** The grouping contract `MessagePrimitive.Unstable_PartsGrouped` consumes. */
+export type GroupingFunction = (parts: readonly GroupablePart[]) => MessagePartGroup[];
 /**
- * Ported from Olympus `toolBasedGroupingFunction` in
- * `olympus/src/utils/assistantGrouping.ts`. Groups adjacent parts by their
- * toolkit group key, lets reasoning parts join the active group, and pulls
- * text parts into a group when both surrounding tool-call groups share the
- * same key. Returns the group descriptor that `MessagePrimitive.Unstable_PartsGrouped`
- * consumes.
+ * Groups adjacent parts by their toolkit group key: reasoning parts join the
+ * open group, and a text part joins when the tool calls on both sides of it
+ * share a key. Every `getToolGroupKey` call sees the open group's key and the
+ * set of tools the message called, so a tool shared by several toolkits can
+ * resolve to the one actually in play (Olympus attributes shared citation
+ * tools to the enabled toolkit that way).
  */
-export declare const createToolBasedGroupingFunction: (getToolGroupKey: GetToolGroupKey) => (parts: readonly AnyPart[]) => MessagePartGroup[];
-export {};
+export declare const createToolBasedGroupingFunction: (getToolGroupKey: GetToolGroupKey) => GroupingFunction;

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

@@ -0,0 +1,55 @@
+const createToolBasedGroupingFunction = (getToolGroupKey) => (parts) => {
+  const calledToolNames = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    if (part.type === "tool-call" && part.toolName) calledToolNames.add(part.toolName);
+  }
+  const groups = [];
+  let currentGroup = null;
+  for (let idx = 0; idx < parts.length; idx++) {
+    const part = parts[idx];
+    if ((part == null ? void 0 : part.type) === "reasoning") {
+      if (currentGroup) {
+        currentGroup.indices.push(idx);
+      } else {
+        groups.push({ groupKey: void 0, indices: [idx] });
+      }
+      continue;
+    }
+    let key;
+    if ((part == null ? void 0 : part.type) === "tool-call" && part.toolName) {
+      key = getToolGroupKey(part.toolName, {
+        preferredGroupKey: currentGroup == null ? void 0 : currentGroup.groupKey,
+        calledToolNames
+      });
+    } else if ((part == null ? void 0 : part.type) === "text") {
+      const prevKey = currentGroup == null ? void 0 : currentGroup.groupKey;
+      let nextKey;
+      for (let lookIdx = idx + 1; lookIdx < parts.length; lookIdx++) {
+        const lookPart = parts[lookIdx];
+        if ((lookPart == null ? void 0 : lookPart.type) === "reasoning" || (lookPart == null ? void 0 : lookPart.type) === "text") continue;
+        if ((lookPart == null ? void 0 : lookPart.type) === "tool-call" && lookPart.toolName) {
+          nextKey = getToolGroupKey(lookPart.toolName, {
+            preferredGroupKey: currentGroup == null ? void 0 : currentGroup.groupKey,
+            calledToolNames
+          });
+        }
+        break;
+      }
+      if (prevKey && nextKey && prevKey === nextKey) {
+        key = prevKey;
+      }
+    }
+    if (currentGroup && currentGroup.groupKey === key) {
+      currentGroup.indices.push(idx);
+    } else {
+      if (currentGroup) groups.push(currentGroup);
+      currentGroup = { groupKey: key, indices: [idx] };
+    }
+  }
+  if (currentGroup) groups.push(currentGroup);
+  return groups;
+};
+export {
+  createToolBasedGroupingFunction
+};
+//# sourceMappingURL=grouping-function.js.map

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

@@ -0,0 +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;"}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const activityTimeline = require("./activity-timeline.cjs");
+const CollapsibleGroup = require("./CollapsibleGroup.cjs");
+const groupingFunction = require("./grouping-function.cjs");
+const SuperGroupingCard = require("./SuperGroupingCard.cjs");
+const toolkitMap = require("./toolkit-map.cjs");
+exports.buildActivityTimeline = activityTimeline.buildActivityTimeline;
+exports.countActivityTools = activityTimeline.countActivityTools;
+exports.excludeFinalTextFromGroups = activityTimeline.excludeFinalTextFromGroups;
+exports.getActivityItemLabel = activityTimeline.getActivityItemLabel;
+exports.getActivitySummary = activityTimeline.getActivitySummary;
+exports.getActivityToolState = activityTimeline.getActivityToolState;
+exports.getFinalText = activityTimeline.getFinalText;
+exports.resolveActivityPhase = activityTimeline.resolveActivityPhase;
+exports.CollapsibleGroup = CollapsibleGroup.CollapsibleGroup;
+exports.DEFAULT_TOOLKIT_THEME = CollapsibleGroup.DEFAULT_TOOLKIT_THEME;
+exports.SuperGroupingProvider = CollapsibleGroup.SuperGroupingProvider;
+exports.TOOLKIT_THEMES = CollapsibleGroup.TOOLKIT_THEMES;
+exports.createToolBasedGroupingFunction = groupingFunction.createToolBasedGroupingFunction;
+exports.SuperGroupingCard = SuperGroupingCard.SuperGroupingCard;
+exports.SuperGroupingFinalText = SuperGroupingCard.SuperGroupingFinalText;
+exports.resetRememberedExpansionsForTests = SuperGroupingCard.resetRememberedExpansionsForTests;
+exports.useActivityExpansion = SuperGroupingCard.useActivityExpansion;
+exports.defaultGetToolGroupKey = toolkitMap.defaultGetToolGroupKey;
+//# sourceMappingURL=index.cjs.map

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * `@athenaintel/react/super-grouping` — the grouped ("conversational") view of
+ * an assistant turn: the activity card, its per-toolkit collapsible blocks,
+ * the timeline derivation behind them, and the tool-based grouping function.
+ * 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, type FinalTextPart, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, resolveActivityPhase, } from './activity-timeline';
+export { CollapsibleGroup, type CollapsibleGroupProps, DEFAULT_TOOLKIT_THEME, SuperGroupingProvider, TOOLKIT_THEMES, type ToolkitTheme, } from './CollapsibleGroup';
+export { createToolBasedGroupingFunction, type GroupablePart, type GroupingFunction, type MessagePartGroup, } from './grouping-function';
+export { resetRememberedExpansionsForTests, SuperGroupingCard, type SuperGroupingCardProps, SuperGroupingFinalText, useActivityExpansion, } from './SuperGroupingCard';
+export { defaultGetToolGroupKey, type GetToolGroupKey, type ToolGroupKeyOptions } from './toolkit-map';

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

@@ -0,0 +1,26 @@
+import { buildActivityTimeline, countActivityTools, excludeFinalTextFromGroups, getActivityItemLabel, getActivitySummary, getActivityToolState, getFinalText, resolveActivityPhase } from "./activity-timeline.js";
+import { CollapsibleGroup, DEFAULT_TOOLKIT_THEME, SuperGroupingProvider, TOOLKIT_THEMES } from "./CollapsibleGroup.js";
+import { createToolBasedGroupingFunction } from "./grouping-function.js";
+import { SuperGroupingCard, SuperGroupingFinalText, resetRememberedExpansionsForTests, useActivityExpansion } from "./SuperGroupingCard.js";
+import { defaultGetToolGroupKey } from "./toolkit-map.js";
+export {
+  CollapsibleGroup,
+  DEFAULT_TOOLKIT_THEME,
+  SuperGroupingCard,
+  SuperGroupingFinalText,
+  SuperGroupingProvider,
+  TOOLKIT_THEMES,
+  buildActivityTimeline,
+  countActivityTools,
+  createToolBasedGroupingFunction,
+  defaultGetToolGroupKey,
+  excludeFinalTextFromGroups,
+  getActivityItemLabel,
+  getActivitySummary,
+  getActivityToolState,
+  getFinalText,
+  resetRememberedExpansionsForTests,
+  resolveActivityPhase,
+  useActivityExpansion
+};
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_TOOL_TO_TOOLKIT = {
+  // Web
+  search: "Web",
+  browse: "Web",
+  web_search: "Web",
+  search_web: "Web",
+  web_scrape: "Web",
+  scrape_web: "Web",
+  // Document
+  create_new_document: "Document",
+  create_document_from_markdown: "Document",
+  append_markdown_to_athena_document: "Document",
+  replace_markdown_in_athena_document: "Document",
+  delete_blocks_from_athena_document: "Document",
+  convert_athena_doc_to_pdf: "Document",
+  convert_to_pdf: "Document",
+  // Word document (Studio)
+  CreateDocument: "Document (Word)",
+  CreateParagraph: "Document (Word)",
+  OpenDocument: "Document (Word)",
+  execute_word_commands: "Document (Word)",
+  create_new_word_document: "Document (Word)",
+  // Spreadsheet
+  create_new_sheet: "Spreadsheet",
+  update_sheet_range: "Spreadsheet",
+  format_sheet_range: "Spreadsheet",
+  bulk_format_sheet_range: "Spreadsheet",
+  create_table: "Spreadsheet",
+  update_table: "Spreadsheet",
+  create_chart: "Spreadsheet",
+  update_chart: "Spreadsheet",
+  // Studio sheet PTC
+  CreateWorkbook: "Spreadsheet",
+  AddSheet: "Spreadsheet",
+  OpenWorkbook: "Spreadsheet",
+  // Presentation
+  create_powerpoint_deck: "Presentation",
+  create_presentation_pptx_studio: "Presentation",
+  execute_presentation_code: "Presentation",
+  capture_slide_screenshot: "Presentation",
+  // Studio presentation PTC
+  CreatePresentation: "Presentation",
+  OpenPresentation: "Presentation",
+  AddSlide: "Presentation",
+  // Notebook
+  create_new_notebook: "Notebook",
+  run_notebook_cell: "Notebook",
+  // Python / code execution
+  run_python_code: "Python",
+  run_python: "Python",
+  // Database
+  run_sql: "Database",
+  run_database_sql: "Database",
+  run_sql_query_tool: "Database",
+  execute_sql: "Database",
+  describe_database: "Database",
+  list_database_tables: "Database",
+  get_database_table_schema: "Database",
+  // Email / calendar
+  search_email: "Email",
+  unified_email_search: "Email",
+  // Media
+  capture_moment: "Computer"
+};
+const UNGROUPED_TOOLS = [
+  "read_asset",
+  "read_full_asset",
+  "ask",
+  "open_asset_in_workspace",
+  "create_email_draft",
+  "unified_email_create_draft",
+  "unified_email_send",
+  "unified_email_edit_draft"
+];
+const CONTEXT_ONLY_TOOLS = [
+  "execute",
+  "ls",
+  "read_file",
+  "write_file",
+  "edit_file",
+  "glob",
+  "grep"
+];
+const SANDBOX_TOOLKIT_GROUPS = ["Notebook", "Computer", "Session Sandbox"];
+const defaultGetToolGroupKey = (toolName, options) => {
+  if (UNGROUPED_TOOLS.includes(toolName)) return void 0;
+  if (CONTEXT_ONLY_TOOLS.includes(toolName)) {
+    const preferred = options == null ? void 0 : options.preferredGroupKey;
+    return preferred && SANDBOX_TOOLKIT_GROUPS.includes(preferred) ? preferred : void 0;
+  }
+  return DEFAULT_TOOL_TO_TOOLKIT[toolName];
+};
+exports.defaultGetToolGroupKey = defaultGetToolGroupKey;
+//# sourceMappingURL=toolkit-map.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolkit-map.cjs","sources":["../../../src/chat/super-grouping/toolkit-map.ts"],"sourcesContent":["/**\n * Static map of tool names → toolkit group display key, mirroring Olympus's\n * runtime `toolDefinitionsStore` output. The SDK doesn't ship a backend-fetched\n * toolkit catalog, so this provides the same grouping behavior using the names\n * the agent typically calls. Consumers can override via the `getToolGroupKey`\n * prop on `<AthenaChat>`.\n *\n * Keys here are toolkit *display* names (what users see in the toolkit\n * selector), not toolkit IDs — they match Olympus's\n * `getToolkitToGroupKeyMap()` output.\n */\nconst DEFAULT_TOOL_TO_TOOLKIT: Record<string, string> = {\n  // Web\n  search: 'Web',\n  browse: 'Web',\n  web_search: 'Web',\n  search_web: 'Web',\n  web_scrape: 'Web',\n  scrape_web: 'Web',\n\n  // Document\n  create_new_document: 'Document',\n  create_document_from_markdown: 'Document',\n  append_markdown_to_athena_document: 'Document',\n  replace_markdown_in_athena_document: 'Document',\n  delete_blocks_from_athena_document: 'Document',\n  convert_athena_doc_to_pdf: 'Document',\n  convert_to_pdf: 'Document',\n\n  // Word document (Studio)\n  CreateDocument: 'Document (Word)',\n  CreateParagraph: 'Document (Word)',\n  OpenDocument: 'Document (Word)',\n  execute_word_commands: 'Document (Word)',\n  create_new_word_document: 'Document (Word)',\n\n  // Spreadsheet\n  create_new_sheet: 'Spreadsheet',\n  update_sheet_range: 'Spreadsheet',\n  format_sheet_range: 'Spreadsheet',\n  bulk_format_sheet_range: 'Spreadsheet',\n  create_table: 'Spreadsheet',\n  update_table: 'Spreadsheet',\n  create_chart: 'Spreadsheet',\n  update_chart: 'Spreadsheet',\n  // Studio sheet PTC\n  CreateWorkbook: 'Spreadsheet',\n  AddSheet: 'Spreadsheet',\n  OpenWorkbook: 'Spreadsheet',\n\n  // Presentation\n  create_powerpoint_deck: 'Presentation',\n  create_presentation_pptx_studio: 'Presentation',\n  execute_presentation_code: 'Presentation',\n  capture_slide_screenshot: 'Presentation',\n  // Studio presentation PTC\n  CreatePresentation: 'Presentation',\n  OpenPresentation: 'Presentation',\n  AddSlide: 'Presentation',\n\n  // Notebook\n  create_new_notebook: 'Notebook',\n  run_notebook_cell: 'Notebook',\n\n  // Python / code execution\n  run_python_code: 'Python',\n  run_python: 'Python',\n\n  // Database\n  run_sql: 'Database',\n  run_database_sql: 'Database',\n  run_sql_query_tool: 'Database',\n  execute_sql: 'Database',\n  describe_database: 'Database',\n  list_database_tables: 'Database',\n  get_database_table_schema: 'Database',\n\n  // Email / calendar\n  search_email: 'Email',\n  unified_email_search: 'Email',\n\n  // Media\n  capture_moment: 'Computer',\n};\n\n/**\n * Tools that should never participate in grouping — even when surrounded by\n * tools of the same toolkit. Mirrors Olympus's `UNGROUPED_TOOLS`.\n */\nconst UNGROUPED_TOOLS: readonly string[] = [\n  'read_asset',\n  'read_full_asset',\n  'ask',\n  'open_asset_in_workspace',\n  'create_email_draft',\n  'unified_email_create_draft',\n  'unified_email_send',\n  'unified_email_edit_draft',\n];\n\n/**\n * Generic sandbox runtime tools shared across many toolkits (notebook,\n * computer, session sandbox, …). Mirrors Olympus's `CONTEXT_ONLY_TOOLS`:\n * they never start a toolkit group on their own — they only inherit the\n * surrounding group.\n */\nconst CONTEXT_ONLY_TOOLS: readonly string[] = [\n  'execute',\n  'ls',\n  'read_file',\n  'write_file',\n  'edit_file',\n  'glob',\n  'grep',\n];\n\n/**\n * Group display keys for toolkits that target a sandbox and therefore contain\n * the shared runtime tools. Context-only tools may only inherit these groups —\n * an open Web or Email group must not absorb a sandbox call.\n */\nconst SANDBOX_TOOLKIT_GROUPS: readonly string[] = ['Notebook', 'Computer', 'Session Sandbox'];\n\nexport type ToolGroupKeyOptions = {\n  /** Display name of the surrounding group, when one is already open. */\n  preferredGroupKey?: string;\n  /**\n   * Distinct tool names the message called. Hosts with a toolkit catalog use\n   * it to attribute a tool shared by several toolkits to the one the message\n   * leans on; the default map ignores it.\n   */\n  calledToolNames?: ReadonlySet<string>;\n};\n\n/**\n * Default `getToolGroupKey` implementation used by the SDK's tool grouping.\n * Returns the toolkit display key for a tool name, or `undefined` if the tool\n * is ungrouped or unknown. Context-only tools inherit the surrounding group\n * and are otherwise ungrouped.\n *\n * Override per-app by passing `getToolGroupKey` (or a whole `groupingFunction`) to\n * `SuperGroupingCard`.\n */\nexport const defaultGetToolGroupKey = (\n  toolName: string,\n  options?: ToolGroupKeyOptions\n): string | undefined => {\n  if (UNGROUPED_TOOLS.includes(toolName)) return undefined;\n  if (CONTEXT_ONLY_TOOLS.includes(toolName)) {\n    const preferred = options?.preferredGroupKey;\n    return preferred && SANDBOX_TOOLKIT_GROUPS.includes(preferred) ? preferred : undefined;\n  }\n  return DEFAULT_TOOL_TO_TOOLKIT[toolName];\n};\n\nexport type GetToolGroupKey = (\n  toolName: string,\n  options?: ToolGroupKeyOptions\n) => string | undefined;\n"],"names":[],"mappings":";;AAWA,MAAM,0BAAkD;AAAA;AAAA,EAEtD,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,YAAY;AAAA;AAAA,EAGZ,qBAAqB;AAAA,EACrB,+BAA+B;AAAA,EAC/B,oCAAoC;AAAA,EACpC,qCAAqC;AAAA,EACrC,oCAAoC;AAAA,EACpC,2BAA2B;AAAA,EAC3B,gBAAgB;AAAA;AAAA,EAGhB,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,cAAc;AAAA,EACd,uBAAuB;AAAA,EACvB,0BAA0B;AAAA;AAAA,EAG1B,kBAAkB;AAAA,EAClB,oBAAoB;AAAA,EACpB,oBAAoB;AAAA,EACpB,yBAAyB;AAAA,EACzB,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA;AAAA,EAEd,gBAAgB;AAAA,EAChB,UAAU;AAAA,EACV,cAAc;AAAA;AAAA,EAGd,wBAAwB;AAAA,EACxB,iCAAiC;AAAA,EACjC,2BAA2B;AAAA,EAC3B,0BAA0B;AAAA;AAAA,EAE1B,oBAAoB;AAAA,EACpB,kBAAkB;AAAA,EAClB,UAAU;AAAA;AAAA,EAGV,qBAAqB;AAAA,EACrB,mBAAmB;AAAA;AAAA,EAGnB,iBAAiB;AAAA,EACjB,YAAY;AAAA;AAAA,EAGZ,SAAS;AAAA,EACT,kBAAkB;AAAA,EAClB,oBAAoB;AAAA,EACpB,aAAa;AAAA,EACb,mBAAmB;AAAA,EACnB,sBAAsB;AAAA,EACtB,2BAA2B;AAAA;AAAA,EAG3B,cAAc;AAAA,EACd,sBAAsB;AAAA;AAAA,EAGtB,gBAAgB;AAClB;AAMA,MAAM,kBAAqC;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAQA,MAAM,qBAAwC;AAAA,EAC5C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAOA,MAAM,yBAA4C,CAAC,YAAY,YAAY,iBAAiB;AAsBrF,MAAM,yBAAyB,CACpC,UACA,YACuB;AACvB,MAAI,gBAAgB,SAAS,QAAQ,EAAG,QAAO;AAC/C,MAAI,mBAAmB,SAAS,QAAQ,GAAG;AACzC,UAAM,YAAY,mCAAS;AAC3B,WAAO,aAAa,uBAAuB,SAAS,SAAS,IAAI,YAAY;AAAA,EAC/E;AACA,SAAO,wBAAwB,QAAQ;AACzC;;"}