@pi-kaush/pi-tool-call-markers 0.2.2 → 0.2.4

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.2",
+  "version": "0.2.4",
   "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,288 @@ 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",
+  // Terminal rejections: the operation never executed (validation failures,
+  // auth-flow failures, missing inputs), unlike continuing-guidance codes.
+  "missing_server",
+  "missing_input",
+  "oauth_not_supported",
+  "auth_start_failed",
+  "not_authenticated",
+  "auth_complete_failed",
+  "query_too_long",
+  "unsafe_pattern",
+  "invalid_pattern",
+  "empty_query",
+]);
+
+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[] {
+      // The Box already shrinks our width by its horizontal padding before
+      // calling render, so only the badge deducts from this headline;
+      // counting the padding again starves the label at narrow widths.
+      const budget = Math.max(1, width - BADGE_WIDTH);
+      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. A cap too
+// small for the ellipsis keeps that many literal tail characters instead;
+// a zero-column cap lets the tail disappear rather than spill an ellipsis
+// outside its quota.
+function capFailureTail(tail: string, cap: number, theme: ThemeLike): string {
+  const tailWidth = visibleWidth(tail);
+  if (tailWidth <= cap) return tail;
+  const ellipsis = theme.fg("muted", "…");
+  const ellipsisWidth = visibleWidth(ellipsis);
+  if (cap <= 0) return "";
+  if (ellipsisWidth >= cap) return sliceByColumn(tail, 0, cap, true);
+  return `${sliceByColumn(tail, 0, cap - ellipsisWidth, 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, " ");
+}
+
+// Actions the mcp proxy dispatches before any mode selector (pi-mcp-adapter
+// 2.26.0). Unknown action values fall through to other modes, so their shapes
+// are shown raw instead of as a guessed operation.
+const MCP_ACTIONS: ReadonlySet<string> = new Set([
+  "ui-messages",
+  "auth-start",
+  "auth-complete",
+]);
+const MCP_MODE_KEYS = [
+  "tool",
+  "connect",
+  "describe",
+  "instructions",
+  "action",
+] as const;
+
+// A concise one-line label for the adapter's "mcp" proxy from the call's
+// shape alone. The adapter's dispatch order is an implementation detail, so
+// only a single unambiguous selector gets a named operation; conflicting,
+// empty, or unrecognized selectors return undefined so the caller shows the
+// complete compact args instead of claiming which operation executed.
+function mcpProxyCallLabel(
+  record: Record<string, unknown>,
+): string | undefined {
+  const selectors: string[] = [];
+  // An empty search still runs a search; every other selector must be a
+  // non-empty string to name an operation at all.
+  if (record.search !== undefined) selectors.push("search");
+  for (const key of MCP_MODE_KEYS) {
+    const value = record[key];
+    if (value === undefined) continue;
+    // An empty selector cannot dispatch, and which fallback ran is adapter
+    // internals, so the raw args are kept instead.
+    if (typeof value !== "string" || value.length === 0) return undefined;
+    selectors.push(key);
+  }
+
+  const server =
+    typeof record.server === "string" && record.server.length > 0
+      ? record.server
+      : undefined;
+  const rest: Record<string, unknown> = { ...record };
+  if (server !== undefined) delete rest.server;
+  const serverSuffix = server === undefined ? "" : ` @ ${server}`;
+
+  if (selectors.length === 0) {
+    // No mode selector: the adapter lists a named server or reports status.
+    const label = server === undefined ? "mcp status" : `mcp list ${server}`;
+    const restJson = squashJsonish(rest);
+    return restJson ? `${label} ${restJson}` : label;
+  }
+  if (selectors.length !== 1) return undefined;
+
+  const key = selectors[0]!;
+  delete rest[key];
+
+  if (key === "tool") {
+    delete rest.args;
+    const inner = squashJsonish(record.args);
+    const target = `${String(record.tool)}${serverSuffix}`;
+    return inner ? `${target} ${inner}` : target;
+  }
+  if (key === "search") {
+    const label =
+      `mcp search ${String(record.search)}`.trimEnd() + serverSuffix;
+    const restJson = squashJsonish(rest);
+    return restJson ? `${label} ${restJson}` : label;
+  }
+  if (key === "action") {
+    const name = String(record.action);
+    if (!MCP_ACTIONS.has(name)) return undefined;
+    let label = `mcp ${name}${serverSuffix}`;
+    if (name === "auth-complete") {
+      delete rest.args;
+      const input = squashJsonish(record.args);
+      if (input) label += ` ${input}`;
+    }
+    const restJson = squashJsonish(rest);
+    return restJson ? `${label} ${restJson}` : label;
+  }
+  // connect / describe / instructions: the adapter dispatches these modes
+  // without params.server, so a server argument is shown raw rather than as
+  // a scope suffix that implies an operation that never ran.
+  const label = `mcp ${key} ${String(record[key])}`;
+  const restJson = squashJsonish(
+    server === undefined ? rest : { ...rest, server },
+  );
+  return restJson ? `${label} ${restJson}` : label;
+}
+
+// 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, so the
+  // label is derived from the args' shape alone; the adapter's own
+  // compactTitle drops parameters (limit/offset) and is not trusted here.
+  if (
+    token === "mcp" &&
+    args &&
+    typeof args === "object" &&
+    !Array.isArray(args)
+  ) {
+    const record = args as Record<string, unknown>;
+    const proxyLabel = mcpProxyCallLabel(record);
+    // Unambiguous shapes get a concise name; anything else keeps the complete
+    // compact args so the row never claims an operation that may not have run.
+    if (proxyLabel) return proxyLabel;
+    const json = squashJsonish(args);
+    return json ? `mcp ${json}` : "mcp status";
+  }
+  const title = selfRenderedCallTitle(row);
+  const json = squashJsonish(args);
+  // Direct tools put only the bare name in their own title, 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 +563,6 @@ function isLiveRow(row: ToolExecutionRow): boolean {
   return (
     row.expanded === false &&
     (row.isPartial !== false || !row.result) &&
-    row.getRenderShell?.() !== "self" &&
     !hasImageResult(row)
   );
 }
@@ -310,6 +602,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 +657,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 +690,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)
@@ -480,6 +776,10 @@ function diffCounts(diff: string): { added: number; removed: number } {
 }
 
 function outcomeSummary(row: ToolExecutionRow): string | undefined {
+  // Self-rendered tools own their result framing; the built-in heuristics
+  // (line counts, diff stats) describe default-shell rows only, so their
+  // settled rows always fall back to the generic outcome.
+  if (row.getRenderShell?.() === "self") return undefined;
   if (!isCollapsibleSuccess(row)) return undefined;
 
   const text = resultText(row);
@@ -532,18 +832,25 @@ 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;
 }
 
+// A budget too small for the suffix keeps literal text instead, so a
+// one-column label never collapses into a bare ellipsis.
 function truncatePlain(text: string, width: number, suffix = "…"): string {
   const max = Math.max(0, width);
   const plain = stripAnsi(text);
   if (visibleWidth(plain) <= max) return plain;
 
   const suffixWidth = visibleWidth(suffix);
-  if (suffixWidth >= max) return sliceByColumn(suffix, 0, max, true);
+  if (suffixWidth >= max) return sliceByColumn(plain, 0, max, true);
   return `${sliceByColumn(plain, 0, max - suffixWidth, true)}${suffix}`;
 }
 
@@ -552,14 +859,23 @@ function fitSummary(summary: string, width: number): string {
   return visibleWidth(summary) <= max ? summary : truncatePlain(summary, max);
 }
 
+// Fits "head tail" into width while always reserving at least one literal
+// head column plus the joining space; the tail takes what is left and
+// disappears entirely when no columns remain.
 function fitSummaryTail(head: string, tail: string, width: number): string {
   const max = Math.max(1, width);
-  const summary = `${head.trimEnd()} ${tail}`;
-  if (visibleWidth(summary) <= max) return summary;
-
+  const headWidth = visibleWidth(head);
   const tailWidth = visibleWidth(tail);
-  if (tailWidth >= max) return truncatePlain(tail, max);
-  return `${truncatePlain(head, max - tailWidth - 1)} ${tail}`;
+  if (headWidth + 1 + tailWidth <= max) return `${head.trimEnd()} ${tail}`;
+  if (tailWidth === 0) return truncatePlain(head, max);
+  if (headWidth === 0) return truncatePlain(tail, max);
+
+  const labelBudget = Math.min(headWidth, Math.max(1, max - tailWidth - 1));
+  const tailBudget = Math.min(tailWidth, Math.max(0, max - labelBudget - 1));
+  if (tailBudget === 0) return truncatePlain(head, max);
+  const fittedTail =
+    tailWidth <= tailBudget ? tail : truncatePlain(tail, tailBudget);
+  return `${truncatePlain(head, labelBudget)} ${fittedTail}`;
 }
 
 function decorateSuccessfulCall(
@@ -620,17 +936,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 +985,6 @@ function renderedCallSummary(
     }
   }
 
-  if (selfRendered) return theme.fg("muted", "(details omitted)");
-
   const fallback = compactArgs(row.args);
   return fallback
     ? theme.fg("accent", fallback)
@@ -820,7 +1137,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 +1337,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 +1370,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);