@pi-kaush/pi-tool-call-markers 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.1.2
+
+- Keep grouping within one assistant tool batch, so a later pending batch does not reopen completed groups.
+- Wait for every tool in a batch to settle, including tools beyond failed or expanded siblings.
+- Preserve partial and image-bearing results instead of collapsing them.
+- Treat self-rendered tools as owning their full shell and use only their stable header line in grouped summaries.
+
+## 0.1.1
+
+- Wait for every call in a contiguous parallel run to settle before grouping successful calls, which prevents completed prefixes and suffixes from repeatedly collapsing around active calls.
+
 ## 0.1.0
 
 - Collapse adjacent successful tool calls into one compact block per tool type, each with a gear header and bulleted call summaries.

package/README.md

@@ -10,7 +10,9 @@ When several tool calls of the same type succeed in a row, Pi normally renders e
 - **Bulleted call summaries.** Each call in a group becomes one bullet with a short summary (the tool name is stripped from the bullet since the header already names the tool).
 - **Vertical spacing between tool types.** A blank line separates one tool group from the next.
 - **Hanging indent for wrapped bullets.** When a summary wraps, continuation lines align under the bullet text rather than under the gear.
-- **Boundaries stay separate.** Visible thinking or text, still-running (active) calls, and failed calls split groups, so they never get silently merged.
+- **Tool batches settle before grouping.** A tool batch stays ungrouped while any sibling call is active. Completed batches remain stable when a later assistant turn starts, and successful calls group around failed-call boundaries after the batch settles.
+- **Self-rendered tools keep their shell.** Tools that own their framing keep singleton previews intact. Grouped summaries use only their stable header instead of scraping preview or diff lines.
+- **Partial and image results stay visible.** Streaming progress and image-bearing results are not collapsed into text-only groups.
 - **Errors expand in place.** A failed call keeps its own block and shows its full detail.
 - **Ctrl+O restores full blocks.** Expanding tools (`setToolsExpanded(true)`) brings back Pi's individual full blocks, results and all.
 - **Adjacent thinking blocks combine.** Only directly adjacent `thinking` blocks merge into one; a non-thinking block between them keeps them separate. Malformed thinking content safely falls back to Pi's renderer exactly once, so the display never breaks.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-kaush/pi-tool-call-markers",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Collapse adjacent successful tool calls into one compact, gear-headed block per tool type in Pi's transcript.",
   "license": "MIT",
   "author": "Kaushik Gopal",

package/src/index.ts

@@ -47,7 +47,10 @@ type ToolExecutionRow = {
   args?: unknown;
   expanded?: boolean;
   isPartial?: boolean;
-  result?: { isError?: boolean };
+  result?: {
+    isError?: boolean;
+    content?: Array<{ type?: unknown }>;
+  };
   contentBox?: ComponentContainer;
   contentText?: TextComponent;
   selfRenderContainer?: ComponentContainer;
@@ -204,14 +207,18 @@ function hideResultImages(row: ToolExecutionRow): void {
 }
 
 function collapseSuccessfulResult(row: ToolExecutionRow): void {
-  if (row.expanded !== false || !row.result || row.result.isError) return;
+  if (
+    row.expanded !== false ||
+    row.isPartial !== false ||
+    !row.result ||
+    row.result.isError ||
+    hasImageResult(row) ||
+    row.getRenderShell?.() === "self"
+  )
+    return;
 
   const collapsed = row.hasRendererDefinition?.()
-    ? removeResultComponent(
-        row.getRenderShell?.() === "self"
-          ? row.selfRenderContainer
-          : row.contentBox,
-      )
+    ? removeResultComponent(row.contentBox)
     : collapseGenericResult(row);
   if (collapsed) hideResultImages(row);
 }
@@ -222,15 +229,55 @@ function isToolExecutionRow(
   return component instanceof ToolExecutionComponent;
 }
 
+function isAssistantMessageRow(component: unknown): boolean {
+  return component instanceof AssistantMessageComponent;
+}
+
+function hasImageResult(row: ToolExecutionRow): boolean {
+  return (
+    row.result?.content?.some((content) => content.type === "image") === true ||
+    (row.imageComponents?.length ?? 0) > 0 ||
+    (row.imageSpacers?.length ?? 0) > 0
+  );
+}
+
 function isCollapsibleSuccess(row: ToolExecutionRow): boolean {
   return (
     row.expanded === false &&
     row.isPartial === false &&
     !!row.result &&
-    !row.result.isError
+    !row.result.isError &&
+    !hasImageResult(row)
   );
 }
 
+function isSettledToolRow(row: ToolExecutionRow): boolean {
+  return row.isPartial === false && !!row.result;
+}
+
+function hasUnsettledToolInBatch(
+  children: unknown[],
+  index: number,
+  renderAt: (index: number) => string[],
+): boolean {
+  for (const direction of [-1, 1] as const) {
+    for (
+      let candidateIndex = index + direction;
+      candidateIndex >= 0 && candidateIndex < children.length;
+      candidateIndex += direction
+    ) {
+      const candidate = children[candidateIndex];
+      if (isAssistantMessageRow(candidate)) break;
+      if (isToolExecutionRow(candidate)) {
+        if (!isSettledToolRow(candidate)) return true;
+        continue;
+      }
+      if (renderAt(candidateIndex).some(hasVisibleContent)) break;
+    }
+  }
+  return false;
+}
+
 function renderComponent(component: unknown, width: number): string[] {
   if (!component || typeof (component as ComponentLike).render !== "function")
     return [];
@@ -313,11 +360,12 @@ function renderedCallSummary(
     component = row.contentBox.children[0] as ComponentLike | undefined;
   }
 
+  const selfRendered = row.getRenderShell?.() === "self";
   if (component && typeof component.render === "function") {
     const visibleLines = component
       .render(Math.max(1, width))
       .filter(hasVisibleContent);
-    const rendered = visibleLines.slice(0, 3);
+    const rendered = visibleLines.slice(0, selfRendered ? 1 : 3);
     const line = rendered[0];
     if (line) {
       const first = trimRenderedLine(line);
@@ -353,6 +401,8 @@ function renderedCallSummary(
     }
   }
 
+  if (selfRendered) return theme.fg("muted", "(details omitted)");
+
   const fallback = compactArgs(row.args);
   return fallback
     ? theme.fg("accent", fallback)
@@ -550,6 +600,10 @@ function renderContainerWithToolGroups(
       lines.push(...renderAt(index));
       continue;
     }
+    if (hasUnsettledToolInBatch(children, index, renderAt)) {
+      lines.push(...renderAt(index));
+      continue;
+    }
 
     const group: ToolExecutionRow[] = [child];
     let lastMemberIndex = index;
@@ -559,6 +613,7 @@ function renderContainerWithToolGroups(
       candidateIndex++
     ) {
       const candidate = children[candidateIndex];
+      if (isAssistantMessageRow(candidate)) break;
       if (isToolExecutionRow(candidate)) {
         if (!isCollapsibleSuccess(candidate)) break;
         group.push(candidate);