@pi-kaush/pi-tool-call-markers 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Compact multiline singleton calls into one width-safe summary after settlement, including timeout metadata, while preserving the full native call under Ctrl+O.
 - Compose capped in-progress rows before the Box paints its background, fixing elapsed tails leaking outside the tool background and restoring the block's bottom padding.
 
 - Render in-progress calls as a single header line (elapsed time inline for `bash`) that settles into the final summary at the same height, so the transcript flows downwards without jumping.

package/README.md

@@ -12,9 +12,9 @@ When several tool calls run in a row, Pi normally renders each one as its own ex
 - **One-line, width-safe summaries.** Long targets truncate before their useful outcome tail instead of wrapping into taller blocks.
 - **Running calls group immediately.** Adjacent calls become bullets as they appear, and each pending marker or elapsed `bash` time updates to the final outcome in place. Successful settlement does not shrink the block, so the transcript only grows downwards.
 - **Sequential calls merge across quiet turns.** A later call joins the existing group immediately when no visible prose or thinking separates it; visible assistant content remains a hard boundary.
-- **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.
+- **Self-rendered tools get the same treatment.** Tools that own their framing (e.g. MCP adapter rows) collapse to the same one-line summary — args label plus outcome — with pending, success, and error backgrounds; expanding restores their full custom render.
 - **Image results stay visible.** Image-bearing results are not collapsed into text-only groups. Partial text output is held back while a call runs and surfaces through the final summary.
-- **Errors stay compact and visibly failed.** A failed call keeps its own error-colored block and native collapsed detail until expanded.
+- **Errors stay compact and visibly failed.** A failed call keeps an error-colored block: native collapsed detail for built-in tools, or a one-line summary with the first error line for self-rendered tools.
 - **Ctrl+O restores full blocks.** Expanding tools (`setToolsExpanded(true)`) brings back Pi's individual full blocks, including complete error details and successful results.
 
 ## Bundled thinking-block extension

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-kaush/pi-tool-call-markers",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Compact and group Pi tool calls, with a bundled extension for adjacent thinking blocks.",
   "license": "MIT",
   "author": "Kaushik Gopal",

package/src/index.ts

@@ -51,7 +51,11 @@ type ToolExecutionRow = {
     content?: Array<{ type?: unknown; text?: unknown }>;
     details?: Record<string, unknown>;
   };
-  rendererState?: { startedAt?: unknown; endedAt?: unknown };
+  rendererState?: {
+    startedAt?: unknown;
+    endedAt?: unknown;
+    compactTitle?: unknown;
+  };
   contentBox?: ComponentContainer;
   contentText?: TextComponent;
   selfRenderContainer?: ComponentContainer;
@@ -68,7 +72,6 @@ type PresentationPatchState = {
   theme?: ThemeLike;
   collapseParallel: boolean;
   groupCache: WeakMap<ToolExecutionRow, GroupRenderCache>;
-  liveRenderedRows: WeakSet<ToolExecutionRow>;
   rowVersions: WeakMap<ToolExecutionRow, number>;
   rowGroups: WeakMap<ToolExecutionRow, ToolExecutionRow[]>;
   rowSignatures: WeakMap<ToolExecutionRow, string>;
@@ -208,12 +211,20 @@ function collapseSuccessfulResult(
     row.expanded !== false ||
     row.isPartial !== false ||
     !row.result ||
-    row.result.isError ||
-    hasImageResult(row) ||
-    row.getRenderShell?.() === "self"
+    hasImageResult(row)
   )
     return;
 
+  if (row.getRenderShell?.() === "self") {
+    collapseSelfRenderedRow(row, theme);
+    return;
+  }
+
+  // Default-shell failures keep Pi's native error render, which already
+  // applies the error background. rowHasFailed also catches MCP tools that
+  // use the default shell (e.g. mcpScript) and report via details.error.
+  if (rowHasFailed(row)) return;
+
   const collapsed = row.hasRendererDefinition?.()
     ? removeResultComponent(row.contentBox)
     : collapseGenericResult(row);
@@ -223,6 +234,193 @@ function collapseSuccessfulResult(
   }
 }
 
+// Self-rendered tools (e.g. MCP adapter rows) own their framing, so there is
+// no result component to trim. Swap the whole container for a single summary
+// line in the same style as collapsed default-shell rows. Pi rebuilds the
+// container on every updateDisplay, so this never corrupts expanded renders.
+// Failures collapse too, with the error background and the first error line,
+// since MCP error output tends to be a huge markdown blob.
+function collapseSelfRenderedRow(
+  row: ToolExecutionRow,
+  theme?: ThemeLike,
+): void {
+  const container = row.selfRenderContainer;
+  if (!theme || !container || !Array.isArray(container.children)) return;
+
+  const failed = rowHasFailed(row);
+  const tail = failed
+    ? renderedErrorOutcome(row, theme)
+    : (renderedOutcome(row, theme) ?? renderedGenericOutcome(theme));
+  const box = new Box(1, 1, (text) =>
+    theme.bg(failed ? "toolErrorBg" : "toolSuccessBg", text),
+  );
+  box.addChild(
+    selfRenderedSummaryComponent(row, theme, tail, failed ? 0.5 : 1),
+  );
+  container.children = [box];
+}
+
+// The MCP adapter reports outcomes in details.error but only promotes
+// tool_error/call_failed to result.isError (see its toolErrorOverride);
+// remaining codes are informational guidance (ambiguous, no_instructions,
+// auth flows, ...). Keep the failure code list here so every presentation
+// decision — singletons and groups — shares one classification.
+const MCP_FAILURE_ERROR_CODES: ReadonlySet<string> = new Set([
+  "tool_error",
+  "call_failed",
+  "tool_not_found",
+  "tool_not_found_after_reconnect",
+  "connect_failed",
+  "not_found",
+  "server_not_found",
+  "server_disabled",
+  "server_backoff",
+  "server_not_connected",
+  "init_failed",
+  "init_timeout",
+  "not_initialized",
+  "server_unavailable",
+  "not_connected",
+  "timeout",
+  "script_error",
+]);
+
+function rowHasFailed(row: ToolExecutionRow): boolean {
+  if (row.result?.isError) return true;
+  const code = row.result?.details?.error;
+  return typeof code === "string" && MCP_FAILURE_ERROR_CODES.has(code);
+}
+
+function renderedErrorOutcome(row: ToolExecutionRow, theme: ThemeLike): string {
+  const firstLine =
+    resultText(row)
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0) ?? "error";
+  return `${theme.fg("muted", "→")} ${theme.fg("error", firstLine)}`;
+}
+
+function selfRenderedSummaryComponent(
+  row: ToolExecutionRow,
+  theme: ThemeLike,
+  tail: string,
+  maxTailShare = 1,
+): ComponentLike {
+  return {
+    render(width: number): string[] {
+      const budget = Math.max(1, width - BADGE_WIDTH - 2);
+      const summary = selfRenderedSummary(row, budget);
+      // Long error lines would otherwise evict the call summary entirely;
+      // cap the tail's share so the label always survives.
+      const cappedTail =
+        maxTailShare >= 1
+          ? tail
+          : capFailureTail(tail, Math.floor(budget * maxTailShare), theme);
+      return [fitSummaryTail(summary, cappedTail, budget)];
+    },
+    invalidate() {},
+  };
+}
+
+// Trim a failure tail to its quota of the budget, counting the appended
+// ellipsis inside the cap, so the call label keeps the leftover columns
+// plus the joining space instead of being truncated to nothing.
+function capFailureTail(tail: string, cap: number, theme: ThemeLike): string {
+  const tailWidth = visibleWidth(tail);
+  if (tailWidth <= cap) return tail;
+  const ellipsis = theme.fg("muted", "…");
+  return `${sliceByColumn(tail, 0, Math.max(0, cap - visibleWidth(ellipsis)), true)}${ellipsis}`;
+}
+
+function renderedGenericOutcome(theme: ThemeLike): string {
+  return `${theme.fg("muted", "→")} ${theme.fg("success", "done")}`;
+}
+
+// The MCP adapter stashes its call's first line in renderer state before
+// collapsing to an empty component, so prefer it over re-rendering the call.
+function selfRenderedCallTitle(row: ToolExecutionRow): string | undefined {
+  const title = row.rendererState?.compactTitle;
+  return typeof title === "string" && title.trim().length > 0
+    ? title.trim()
+    : undefined;
+}
+
+// The MCP proxy passes tool arguments as a JSON-encoded string; parse and
+// re-stringify so the summary shows compact JSON instead of escaped quotes.
+function squashJsonish(value: unknown): string {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        const compact = JSON.stringify(JSON.parse(trimmed));
+        return compact === "{}" ? "" : compact;
+      } catch {
+        return flattenNewlines(trimmed);
+      }
+    }
+    return flattenNewlines(value);
+  }
+  return compactArgs(value);
+}
+
+// String fallbacks still feed the one-line "tool {args}" summary label;
+// normalize embedded line breaks so a multiline argument cannot split it.
+function flattenNewlines(text: string): string {
+  return text.replace(/[\r\n]+/g, " ");
+}
+
+// Builds a one-line "tool {args}" label from the call arguments. The
+// adapter's own title drops the arguments and its pretty-printed JSON spans
+// many lines, so squash the JSON ourselves to keep the row at one line.
+function selfRenderedCallLabel(row: ToolExecutionRow): string {
+  const token = row.toolName ?? "tool";
+  const args = row.args;
+  // Only the adapter's "mcp" proxy tool uses these action shapes. Build the
+  // label from the args: the adapter's own compactTitle drops parameters
+  // (limit/offset) and can misname the action, so it is not trusted here.
+  if (
+    token === "mcp" &&
+    args &&
+    typeof args === "object" &&
+    !Array.isArray(args)
+  ) {
+    const record = args as Record<string, unknown>;
+    if (typeof record.tool === "string") {
+      const inner = squashJsonish(record.args);
+      const target =
+        typeof record.server === "string"
+          ? `${record.tool} @ ${record.server}`
+          : record.tool;
+      return inner ? `${target} ${inner}` : target;
+    }
+    for (const key of ["search", "connect", "describe", "action"] as const) {
+      const value = record[key];
+      if (typeof value !== "string" || value.length === 0) continue;
+      const rest: Record<string, unknown> = { ...record };
+      delete rest[key];
+      let label = key === "action" ? `mcp ${value}` : `mcp ${key} ${value}`;
+      if (typeof rest.server === "string") {
+        label += ` @ ${rest.server}`;
+        delete rest.server;
+      }
+      const restJson = squashJsonish(rest);
+      return restJson ? `${label} ${restJson}` : label;
+    }
+    if (typeof record.server === "string") return `mcp list ${record.server}`;
+  }
+  const title = selfRenderedCallTitle(row);
+  const json = squashJsonish(args);
+  // Proxy actions format nicer in the adapter's own title ("mcp search …");
+  // direct tools put only the bare name there, so append the args ourselves.
+  if (title && title !== token) return title;
+  if (json) return `${token} ${json}`;
+  return title ?? token;
+}
+
+function selfRenderedSummary(row: ToolExecutionRow, width: number): string {
+  return fitSummary(selfRenderedCallLabel(row), width);
+}
+
 function isToolExecutionRow(
   component: unknown,
 ): component is ToolExecutionRow & ComponentLike {
@@ -270,7 +468,6 @@ function isLiveRow(row: ToolExecutionRow): boolean {
   return (
     row.expanded === false &&
     (row.isPartial !== false || !row.result) &&
-    row.getRenderShell?.() !== "self" &&
     !hasImageResult(row)
   );
 }
@@ -310,6 +507,18 @@ function fitLiveHeader(
 // cap is composed before the Box applies background and padding, so the live
 // line keeps the tool background edge to edge and the block's bottom padding.
 function capLiveRowDisplay(row: ToolExecutionRow, theme?: ThemeLike): void {
+  // Pin live self-rendered rows (e.g. MCP calls) to the same one-line summary
+  // they settle into, so the block never grows and hops on completion.
+  if (row.getRenderShell?.() === "self") {
+    const container = row.selfRenderContainer;
+    if (!theme || !container || !Array.isArray(container.children)) return;
+    const box = new Box(1, 1, (text) => theme.bg("toolPendingBg", text));
+    box.addChild(
+      selfRenderedSummaryComponent(row, theme, theme.fg("muted", "…")),
+    );
+    container.children = [box];
+    return;
+  }
   if (row.hasRendererDefinition?.()) {
     const container = row.contentBox;
     if (!container || !Array.isArray(container.children)) return;
@@ -353,15 +562,11 @@ function isCollapsibleSuccess(row: ToolExecutionRow): boolean {
     row.expanded === false &&
     row.isPartial === false &&
     !!row.result &&
-    !row.result.isError &&
+    !rowHasFailed(row) &&
     !hasImageResult(row)
   );
 }
 
-function isSettledToolRow(row: ToolExecutionRow): boolean {
-  return row.isPartial === false && !!row.result;
-}
-
 function hasToolSiblingInAssistantBatch(
   children: unknown[],
   index: number,
@@ -390,10 +595,6 @@ function isGroupableToolRow(
   state: PresentationPatchState,
 ): boolean {
   if (!isLiveRow(row) && !isCollapsibleSuccess(row)) return false;
-  // Self-rendered tools can change height while active. Keep live instances
-  // individual so settling never collapses an already-painted preview.
-  if (row.getRenderShell?.() === "self" && state.liveRenderedRows.has(row))
-    return false;
   return (
     state.collapseParallel ||
     !hasToolSiblingInAssistantBatch(children, index, renderAt)
@@ -532,9 +733,14 @@ function renderedGroupedOutcome(
 ): string | undefined {
   const outcome = renderedOutcome(row, theme);
   if (outcome) return outcome;
-  if (!isLiveRow(row)) return undefined;
-  const elapsed = liveElapsedText(row);
-  return theme.fg("muted", elapsed ? `· ${elapsed}` : "…");
+  if (isLiveRow(row)) {
+    const elapsed = liveElapsedText(row);
+    return theme.fg("muted", elapsed ? `· ${elapsed}` : "…");
+  }
+  // Self-rendered tools have no per-tool outcome summary; keep the group's
+  // settled tail consistent with collapsed singletons.
+  if (row.getRenderShell?.() === "self") return renderedGenericOutcome(theme);
+  return undefined;
 }
 
 function truncatePlain(text: string, width: number, suffix = "…"): string {
@@ -574,17 +780,17 @@ function decorateSuccessfulCall(
   row.contentBox.children[0] = {
     render(width: number): string[] {
       const lines = original.render(width);
-      const lineIndex = lines.findIndex(hasVisibleContent);
-      if (lineIndex === -1) return lines;
-      const line = lines[lineIndex];
+      const visibleLines = lines.filter(hasVisibleContent);
+      const line = visibleLines[0];
       if (line === undefined) return lines;
-      const next = [...lines];
-      next[lineIndex] = fitSummaryTail(
-        trimRenderedLine(line),
-        outcome,
-        Math.max(1, width - BADGE_WIDTH),
-      );
-      return next;
+
+      const rendered = visibleLines.slice(0, 3).map(trimRenderedLine);
+      if (visibleLines.length > rendered.length)
+        rendered.push(theme.fg("muted", "…"));
+      const summary = rendered.join(theme.fg("muted", " · "));
+      return [
+        fitSummaryTail(summary, outcome, Math.max(1, width - BADGE_WIDTH)),
+      ];
     },
     invalidate() {
       original.invalidate();
@@ -620,17 +826,20 @@ function renderedCallSummary(
   width: number,
   theme: ThemeLike,
 ): string {
+  // Self-rendered call components change shape across the live/settled
+  // boundary (the adapter's call disappears once settled), so always build
+  // the summary from the stable args label instead of scraping the preview.
+  if (row.getRenderShell?.() === "self") return selfRenderedSummary(row, width);
+
   let component = row.callRendererComponent;
   if (!component && Array.isArray(row.contentBox?.children)) {
     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, selfRendered ? 1 : 3);
+    const rendered = visibleLines.slice(0, 3);
     const line = rendered[0];
     if (line) {
       const first = trimRenderedLine(line);
@@ -666,8 +875,6 @@ function renderedCallSummary(
     }
   }
 
-  if (selfRendered) return theme.fg("muted", "(details omitted)");
-
   const fallback = compactArgs(row.args);
   return fallback
     ? theme.fg("accent", fallback)
@@ -820,7 +1027,9 @@ function renderGroupedToolRows(
         width,
         theme,
       );
-    const box = new Box(1, 1, (text) => theme.bg("toolSuccessBg", text));
+    const box = new Box(1, 1, (text) =>
+      theme.bg(hasLiveMembers ? "toolPendingBg" : "toolSuccessBg", text),
+    );
     box.addChild(summary);
     lines = renderWithTemporaryChild(container, box, () =>
       state.originalRender.call(row, width),
@@ -1018,7 +1227,6 @@ function installPresentationPatch(): PresentationPatchState | undefined {
     const state: PresentationPatchState = {
       collapseParallel: envEnabled(COLLAPSE_PARALLEL_ENV, true),
       groupCache: new WeakMap(),
-      liveRenderedRows: new WeakSet(),
       rowVersions: new WeakMap(),
       rowGroups: new WeakMap(),
       rowSignatures: new WeakMap(),
@@ -1052,7 +1260,6 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       this: ToolExecutionRow,
       width: number,
     ): string[] {
-      if (!isSettledToolRow(this)) state.liveRenderedRows.add(this);
       const lines = state.originalRender.call(this, width);
       try {
         return decorateHeader(this, lines, width, state.theme);