@mystilleef/pi-subagent 0.9.0 → 0.10.2

package/src/progress/progress.ts

@@ -21,17 +21,22 @@ import { Box, Text } from "@earendil-works/pi-tui";
 import { formatSubagentTitle, type SubagentTheme } from "../output/ui.js";
 import {
   formatHeaderStats,
-  getProgressState,
-  type ProgressStatus,
   renderToolActivityForDisplay,
+} from "./progress-format.js";
+import {
+  getProgressState,
   STATUS_BG,
   STATUS_COLOR,
   STATUS_ICON,
   type SubagentProgressState,
-  type ThemeBg,
 } from "./progress-state.js";
 
 export { makeToolPreview } from "../output/normalize.js";
+export {
+  formatElapsed,
+  formatHeaderStats,
+  renderToolActivity,
+} from "./progress-format.js";
 export {
   cancelProgressState,
   clearProgressState,
@@ -39,20 +44,11 @@ export {
   extractProgressFromDetails,
   failProgressState,
   finalizeProgressState,
-  formatContextPercent,
-  formatElapsed,
-  formatHeaderStats,
   getProgressState,
   makeTaskPreview,
-  type ProgressStatus,
   patchProgressState,
-  renderToolActivity,
-  renderToolActivityForDisplay,
   resetProgressStore,
-  STATUS_COLOR,
-  STATUS_ICON,
   type SubagentProgressState,
-  type ThemeBg,
 } from "./progress-state.js";
 
 /**
@@ -111,10 +107,6 @@ class DynamicSubagentProgressText implements Component {
   }
 }
 
-function getProgressBackground(status: ProgressStatus): ThemeBg {
-  return STATUS_BG[status];
-}
-
 function renderProgressBox(
   state: SubagentProgressState,
   options: { expanded: boolean },
@@ -124,12 +116,12 @@ function renderProgressBox(
   const status = state.status;
   const title = formatSubagentTitle(state.agent, state.instanceName, theme);
   const header = `${theme.fg(STATUS_COLOR[status], STATUS_ICON[status])} ${title} ${theme.fg("dim", `[${status}]`)} ${theme.fg("muted", formatHeaderStats(state))}`;
-  const box = new Box(1, 1, (line) =>
-    theme.bg(getProgressBackground(status), line),
-  );
+  const box = new Box(1, 1, (line) => theme.bg(STATUS_BG[status], line));
   box.addChild(new Text(header, 0, 0));
   const body = makeProgressBody(state, options, theme, width);
   for (const line of body) box.addChild(line);
+  if (state.modelDisplay)
+    box.addChild(new Text(theme.fg("dim", state.modelDisplay), 0, 0));
   return box;
 }
 
@@ -149,6 +141,10 @@ function makeProgressBody(
   return [];
 }
 
+function bodyMargin(hasFooter: boolean, expanded: boolean): number {
+  return expanded || !hasFooter ? 0 : 1;
+}
+
 function makeRunningProgressBody(
   state: SubagentProgressState,
   options: { expanded: boolean },
@@ -161,11 +157,14 @@ function makeRunningProgressBody(
     state.activeToolActivity,
     activityBudget,
   );
+  const margin = bodyMargin(!!state.modelDisplay, options.expanded);
   if (activityPreview) {
-    body.push(new Text(formatRunningToolPreview(activityPreview, theme), 2, 0));
+    body.push(
+      new Text(formatRunningToolPreview(activityPreview, theme), 2, margin),
+    );
   }
   if (options.expanded)
-    body.push(new Text(theme.fg("dim", state.taskPreview), 2, 0));
+    body.push(new Text(theme.fg("dim", state.taskPreview), 2, margin));
   return body;
 }
 
@@ -175,10 +174,12 @@ function makeStoppedProgressBody(
   theme: SubagentTheme,
 ): Text[] {
   const body: Text[] = [];
-  if (state.errorText)
-    body.push(new Text(theme.fg("error", state.errorText), 2, 0));
+  const margin = bodyMargin(!!state.modelDisplay, options.expanded);
+  if (state.errorText) {
+    body.push(new Text(theme.fg("error", state.errorText), 2, margin));
+  }
   if (options.expanded)
-    body.push(new Text(theme.fg("dim", state.taskPreview), 2, 0));
+    body.push(new Text(theme.fg("dim", state.taskPreview), 2, margin));
   return body;
 }
 
@@ -188,8 +189,9 @@ function makeSuccessProgressBody(
   theme: SubagentTheme,
 ): Text[] {
   const output = state.finalOutput?.trim().split("\n")[0] ?? "";
+  const margin = bodyMargin(!!state.modelDisplay, options.expanded);
   if (!options.expanded) {
-    return output ? [new Text(theme.fg("toolOutput", output), 2, 0)] : [];
+    return output ? [new Text(theme.fg("toolOutput", output), 2, margin)] : [];
   }
   const body = [new Text(theme.fg("dim", state.taskPreview), 2, 0)];
   body.push(
@@ -197,9 +199,9 @@ function makeSuccessProgressBody(
       ? new Text(
           `${theme.fg("muted", "─── Output ───")}\n${theme.fg("toolOutput", output)}`,
           0,
-          0,
+          margin,
         )
-      : new Text(theme.fg("muted", "(no output)"), 0, 0),
+      : new Text(theme.fg("muted", "(no output)"), 0, margin),
   );
   return body;
 }

package/src/progress/result-details.ts

@@ -1,32 +1,29 @@
-import { TOOL_RESULT_FAILED_MESSAGE } from "../child/process.js";
+import type { Message } from "@earendil-works/pi-ai";
+import type { TerminationMetadata } from "../child/termination.js";
 import {
   formatSubagentResultForParent,
   summarizeFeedbackUiFinalOutput,
 } from "../output/summary.js";
-import type {
-  SingleResult,
-  SubagentDetails,
-  SubagentToolResult,
-  ToolActivity,
+import {
+  type SingleResult,
+  type StreamingProgress,
+  type SubagentDetails,
+  type SubagentToolResult,
+  TOOL_RESULT_FAILED_MESSAGE,
+  type ToolActivity,
 } from "../shared/types.js";
-import { detectMessageError } from "../shared/utils.js";
 import {
   extractProgressFromDetails,
   getProgressState,
   patchProgressState,
-  renderToolActivity,
+  type SubagentProgressState,
 } from "./progress.js";
-import { SENSITIVE_PATTERN } from "./progress-state.js";
+import { renderToolActivity, SENSITIVE_PATTERN } from "./progress-format.js";
 
-export function hasSubagentFailed(result: SingleResult): boolean {
-  return (
-    result.exitCode !== 0 ||
-    result.stopReason === "error" ||
-    result.stopReason === "aborted" ||
-    Boolean(result.errorMessage?.trim()) ||
-    detectMessageError(result.messages ?? [])
-  );
-}
+export type DetailsOptions = {
+  includeMessages?: boolean;
+  recentMessages?: Message[];
+};
 
 export function createSubagentError(result: SingleResult): Error {
   const formatted = formatSubagentResultForParent(result);
@@ -82,19 +79,86 @@ function redactSensitiveDebugMessages(messages: unknown): unknown {
   return messages.map(redactSensitiveDebugValue);
 }
 
+export function sanitizeResultDetails(
+  result: SingleResult,
+  includeDebugMessages: boolean,
+  options: DetailsOptions | undefined,
+): SingleResult {
+  const includeMessages =
+    includeDebugMessages && (options?.includeMessages ?? true);
+  const { messages, termination, progress, stderr, usage, ...core } = result;
+  const { contextWindowTokens, ...usageBase } = usage;
+  let progressValue: StreamingProgress | undefined;
+  if (progress) {
+    const {
+      activityText,
+      activeToolActivity,
+      lastToolPreview,
+      toolResultCompleted,
+      ...progBase
+    } = progress;
+    progressValue = {
+      toolCalls: progBase.toolCalls.map((tc) => ({
+        id: tc.id,
+        preview: tc.preview,
+      })),
+      ...(activityText !== undefined && { activityText }),
+      ...(activeToolActivity !== undefined && { activeToolActivity }),
+      ...(lastToolPreview !== undefined && { lastToolPreview }),
+      ...(toolResultCompleted !== undefined && { toolResultCompleted }),
+    };
+  }
+  let terminationValue: TerminationMetadata | undefined;
+  if (includeMessages && includeDebugMessages && termination) {
+    const { cancelReason, terminationSignal, fallbackCause, ...termBase } =
+      termination;
+    terminationValue = {
+      ...termBase,
+      ...(cancelReason !== undefined && { cancelReason }),
+      ...(terminationSignal !== undefined && { terminationSignal }),
+      ...(fallbackCause !== undefined && { fallbackCause }),
+    };
+  }
+  const sanitized: SingleResult = {
+    ...core,
+    stderr: includeDebugMessages ? stderr : "",
+    usage: {
+      ...usageBase,
+      ...(contextWindowTokens !== undefined && { contextWindowTokens }),
+    },
+  };
+  if (progressValue !== undefined) sanitized.progress = progressValue;
+  if (includeMessages) {
+    sanitized.messages = options?.recentMessages
+      ? [...options.recentMessages]
+      : messages !== undefined
+        ? [...messages]
+        : undefined;
+  }
+  if (terminationValue !== undefined) sanitized.termination = terminationValue;
+  return sanitized;
+}
+
 export function sanitizeDetailsForDisplay(
   details: SubagentDetails,
   includeMessages = false,
 ): SubagentDetails {
   return {
     ...details,
-    results: details.results.map(({ messages, termination, ...result }) => ({
-      ...result,
-      stderr: includeMessages ? result.stderr : "",
-      ...(includeMessages
-        ? { messages: redactSensitiveDebugMessages(messages), termination }
-        : {}),
-    })),
+    results: details.results.map((result) => {
+      const sanitized = sanitizeResultDetails(
+        result,
+        includeMessages,
+        undefined,
+      );
+      if (includeMessages && sanitized.messages) {
+        return {
+          ...sanitized,
+          messages: redactSensitiveDebugMessages(sanitized.messages),
+        };
+      }
+      return sanitized;
+    }),
   } as SubagentDetails;
 }
 
@@ -119,7 +183,7 @@ export function patchProgressFromDetails(
   } = extractProgressFromDetails(details, seenToolCallIds);
   const current = getProgressState(requestId);
   if (!current) return;
-  const patch: Record<string, unknown> = {
+  const patch: Partial<SubagentProgressState> = {
     toolCount: current.toolCount + newToolCallIds.length,
   };
   let nextActivity: ToolActivity | undefined;
@@ -133,7 +197,7 @@ export function patchProgressFromDetails(
     nextActivity = current.activeToolActivity;
   }
   if (toolResultCompleted && nextActivity?.child) {
-    const { child: _child, ...rest } = nextActivity;
+    const { child, ...rest } = nextActivity;
     nextActivity = rest;
   } else if (toolResultCompleted) {
     nextActivity = undefined;
@@ -148,20 +212,19 @@ export function patchProgressFromDetails(
   if (toolResultCompleted) {
     patch["toolResultCompleted"] = true;
   }
-  // Token accounting always applies when usage data is available
   if (latestResult?.usage) {
     patch["inputTokens"] = latestResult.usage.input;
     patch["outputTokens"] = latestResult.usage.output;
     patch["contextTokens"] = latestResult.usage.contextTokens;
     patch["contextWindowTokens"] = latestResult.usage.contextWindowTokens;
   }
-  patchProgressState(
-    requestId,
-    patch as Parameters<typeof patchProgressState>[1],
-  );
+  if (latestResult?.model?.trim()) {
+    patch["modelDisplay"] = latestResult.model;
+  }
+  patchProgressState(requestId, patch);
 }
 
-export function getSubagentText(result: SubagentToolResult): string {
+function getSubagentText(result: SubagentToolResult): string {
   return (result.content[0] as { text?: string })?.text ?? "";
 }
 

package/src/shared/types.ts

@@ -2,6 +2,8 @@ import type { Message } from "@earendil-works/pi-ai";
 import type { AgentScope } from "../agent/agents.js";
 import type { TerminationMetadata } from "../child/termination.js";
 
+export const TOOL_RESULT_FAILED_MESSAGE = "Subagent tool result failed.";
+
 export interface UsageStats {
   input: number;
   output: number;

package/src/shared/utils.ts

@@ -6,13 +6,14 @@ import {
   DefaultResourceLoader,
   getAgentDir,
 } from "@earendil-works/pi-coding-agent";
+import type { SingleResult } from "./types.js";
 
 export const DEFAULT_MAX_OUTPUT_BYTES = 50_000;
 export const DEFAULT_MAX_OUTPUT_LINES = 500;
 export const DEFAULT_AGENT_END_GRACE_MS = 250;
 export const DEFAULT_MAX_STDERR_BYTES = 10_000;
 export const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-export const MAX_SUBAGENT_DEPTH_CEILING = 10;
+const MAX_SUBAGENT_DEPTH_CEILING = 10;
 
 export interface SubagentOutputLimits {
   maxBytes: number;
@@ -130,6 +131,7 @@ async function canonicalPath(filePath: string): Promise<string> {
   try {
     return await fs.promises.realpath(filePath);
   } catch {
+    /* symlinks or missing paths fall back to absolute path resolution */
     return path.resolve(filePath);
   }
 }
@@ -209,18 +211,27 @@ export function subagentDepthEnv(): Record<string, string> {
   return { PI_SUBAGENT_DEPTH: String(getSubagentDepth() + 1) };
 }
 
-export function detectMessageError(messages: Message[]): boolean {
-  let lastAssistantIdx = -1;
+export function findLastAssistantTextMessage(messages: Message[]): number {
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (
       msg?.role === "assistant" &&
-      msg.content.some((c) => c.type === "text" && c.text.trim().length > 0)
+      Array.isArray(msg.content) &&
+      msg.content.some(
+        (c) =>
+          c.type === "text" &&
+          typeof c.text === "string" &&
+          c.text.trim().length > 0,
+      )
     ) {
-      lastAssistantIdx = i;
-      break;
+      return i;
     }
   }
+  return -1;
+}
+
+export function detectMessageError(messages: Message[]): boolean {
+  const lastAssistantIdx = findLastAssistantTextMessage(messages);
   const from = lastAssistantIdx >= 0 ? lastAssistantIdx + 1 : 0;
   for (let i = messages.length - 1; i >= from; i--) {
     const msg = messages[i];
@@ -228,3 +239,13 @@ export function detectMessageError(messages: Message[]): boolean {
   }
   return false;
 }
+
+export function hasSubagentFailed(result: SingleResult): boolean {
+  return (
+    result.exitCode !== 0 ||
+    result.stopReason === "error" ||
+    result.stopReason === "aborted" ||
+    Boolean(result.errorMessage?.trim()) ||
+    detectMessageError(result.messages ?? [])
+  );
+}