@gotgenes/pi-subagents 6.9.0 → 6.9.2

package/src/tools/foreground-runner.ts

@@ -0,0 +1,175 @@
+import type { Model } from "@earendil-works/pi-ai";
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+import type { AgentSpawnConfig } from "../agent-manager.js";
+import type { AgentInvocation, AgentRecord, IsolationMode, ThinkingLevel } from "../types.js";
+import { AgentActivityTracker } from "../ui/agent-activity-tracker.js";
+import {
+  type AgentDetails,
+  describeActivity,
+  formatMs,
+  SPINNER,
+} from "../ui/agent-widget.js";
+import { subscribeUIObserver } from "../ui/ui-observer.js";
+import type { AgentActivityAccess } from "./agent-tool.js";
+import {
+  buildDetails,
+  formatLifetimeTokens,
+  getStatusNote,
+  textResult,
+} from "./helpers.js";
+
+/** Narrow manager interface for the foreground runner. */
+export interface ForegroundManagerDeps {
+  spawnAndWait(
+    ctx: any,
+    type: string,
+    prompt: string,
+    opts: Omit<AgentSpawnConfig, "isBackground">,
+  ): Promise<AgentRecord>;
+}
+
+/** Narrow widget interface for the foreground runner. */
+export interface ForegroundWidgetDeps {
+  ensureTimer(): void;
+  markFinished(id: string): void;
+}
+
+/** Injected collaborators for runForeground. */
+export interface ForegroundDeps {
+  manager: ForegroundManagerDeps;
+  widget: ForegroundWidgetDeps;
+  agentActivity: AgentActivityAccess;
+}
+
+/** All values the foreground runner needs, bundled from shared execute setup. */
+export interface ForegroundParams {
+  ctx: {
+    sessionManager: {
+      getSessionFile(): string;
+      getSessionId(): string;
+    };
+  };
+  subagentType: string;
+  prompt: string;
+  description: string;
+  detailBase: Pick<
+    AgentDetails,
+    "displayName" | "description" | "subagentType" | "modelName" | "tags"
+  >;
+  rawType: string;
+  fellBack: boolean;
+  model: Model<any> | undefined;
+  effectiveMaxTurns: number | undefined;
+  isolated: boolean | undefined;
+  inheritContext: boolean | undefined;
+  thinking: ThinkingLevel | undefined;
+  isolation: IsolationMode | undefined;
+  agentInvocation: AgentInvocation;
+}
+
+/**
+ * Run an agent synchronously in the foreground, streaming spinner updates.
+ * Owns: spinner interval, AgentActivityTracker creation, UI observer subscription,
+ * streaming onUpdate callbacks, cleanup, and result formatting.
+ */
+export async function runForeground(
+  deps: ForegroundDeps,
+  params: ForegroundParams,
+  signal: AbortSignal | undefined,
+  onUpdate: ((update: AgentToolResult<any>) => void) | undefined,
+) {
+  let spinnerFrame = 0;
+  const startedAt = Date.now();
+  let fgId: string | undefined;
+
+  const fgState = new AgentActivityTracker(params.effectiveMaxTurns);
+  let unsubUI: (() => void) | undefined;
+
+  const streamUpdate = () => {
+    const details: AgentDetails = {
+      ...params.detailBase,
+      toolUses: fgState.toolUses,
+      tokens: formatLifetimeTokens(fgState),
+      turnCount: fgState.turnCount,
+      maxTurns: fgState.maxTurns,
+      durationMs: Date.now() - startedAt,
+      status: "running",
+      activity: describeActivity(fgState.activeTools, fgState.responseText),
+      spinnerFrame: spinnerFrame % SPINNER.length,
+    };
+    onUpdate?.({
+      content: [{ type: "text", text: `${fgState.toolUses} tool uses...` }],
+      details: details as any,
+    });
+  };
+
+  // Animate spinner at ~80ms (smooth rotation through 10 braille frames)
+  const spinnerInterval = setInterval(() => {
+    spinnerFrame++;
+    streamUpdate();
+  }, 80);
+
+  streamUpdate();
+
+  let record: AgentRecord;
+  try {
+    record = await deps.manager.spawnAndWait(
+      params.ctx,
+      params.subagentType,
+      params.prompt,
+      {
+        description: params.description,
+        model: params.model,
+        maxTurns: params.effectiveMaxTurns,
+        isolated: params.isolated,
+        inheritContext: params.inheritContext,
+        thinkingLevel: params.thinking,
+        isolation: params.isolation,
+        invocation: params.agentInvocation,
+        signal,
+        parentSessionFile: params.ctx.sessionManager.getSessionFile(),
+        parentSessionId: params.ctx.sessionManager.getSessionId(),
+        onSessionCreated: (session, record) => {
+          fgState.setSession(session);
+          unsubUI = subscribeUIObserver(session, fgState, streamUpdate);
+          fgId = record.id;
+          deps.agentActivity.set(record.id, fgState);
+          deps.widget.ensureTimer();
+        },
+      },
+    );
+  } catch (err) {
+    clearInterval(spinnerInterval);
+    unsubUI?.();
+    return textResult(err instanceof Error ? err.message : String(err));
+  }
+
+  clearInterval(spinnerInterval);
+  unsubUI?.();
+
+  // Clean up foreground agent from widget
+  if (fgId) {
+    deps.agentActivity.delete(fgId);
+    deps.widget.markFinished(fgId);
+  }
+
+  const tokenText = formatLifetimeTokens(fgState);
+  const details = buildDetails(params.detailBase, record, fgState, { tokens: tokenText });
+
+  const fallbackNote = params.fellBack
+    ? `Note: Unknown agent type "${params.rawType}" \u2014 using general-purpose.\n\n`
+    : "";
+
+  if (record.status === "error") {
+    return textResult(`${fallbackNote}Agent failed: ${record.error}`, details);
+  }
+
+  const durationMs = (record.completedAt ?? Date.now()) - record.startedAt;
+  const statsParts = [`${record.toolUses} tool uses`];
+  if (tokenText) statsParts.push(tokenText);
+  return textResult(
+    `${fallbackNote}Agent completed in ${formatMs(durationMs)} (${statsParts.join(", ")})${getStatusNote(record.status)}.\n\n` +
+      (record.result?.trim() || "No output."),
+    details,
+  );
+}

package/src/tools/helpers.ts

@@ -1,7 +1,51 @@
 import type { AgentConfigLookup } from "../agent-types.js";
-import { formatTokens } from "../ui/agent-widget.js";
+import { AgentActivityTracker } from "../ui/agent-activity-tracker.js";
+import { type AgentDetails, formatTokens } from "../ui/agent-widget.js";
 import { getLifetimeTotal, type LifetimeUsage } from "../usage.js";
 
+/** Parenthetical status note for completed agent result text. */
+export function getStatusNote(status: string): string {
+  switch (status) {
+    case "aborted":
+      return " (aborted \u2014 max turns exceeded, output may be incomplete)";
+    case "steered":
+      return " (wrapped up \u2014 reached turn limit)";
+    case "stopped":
+      return " (stopped by user)";
+    default:
+      return "";
+  }
+}
+
+/** Build AgentDetails from a base + record-specific fields. */
+export function buildDetails(
+  base: Pick<AgentDetails, "displayName" | "description" | "subagentType" | "modelName" | "tags">,
+  record: {
+    toolUses: number;
+    startedAt: number;
+    completedAt?: number;
+    status: string;
+    error?: string;
+    id?: string;
+    lifetimeUsage: LifetimeUsage;
+  },
+  activity?: AgentActivityTracker,
+  overrides?: Partial<AgentDetails>,
+): AgentDetails {
+  return {
+    ...base,
+    toolUses: record.toolUses,
+    tokens: formatLifetimeTokens(record),
+    turnCount: activity?.turnCount,
+    maxTurns: activity?.maxTurns,
+    durationMs: (record.completedAt ?? Date.now()) - record.startedAt,
+    status: record.status as AgentDetails["status"],
+    agentId: record.id,
+    error: record.error,
+    ...overrides,
+  };
+}
+
 /** Tool execute return value for a text response. */
 export function textResult(msg: string, details?: unknown) {
   return { content: [{ type: "text" as const, text: msg }], details: details as any };

package/src/types.ts

@@ -18,11 +18,23 @@ export type MemoryScope = "user" | "project" | "local";
 /** Isolation mode for agent execution. */
 export type IsolationMode = "worktree";
 
-/** Unified agent configuration — used for both default and user-defined agents. */
-export interface AgentConfig {
+/** UI display and agent listing — name, display name, description, prompt mode. */
+export interface AgentIdentity {
   name: string;
   displayName?: string;
   description: string;
+  promptMode: "replace" | "append";
+}
+
+/** Prompt assembly — name, prompt mode, system prompt. */
+export interface AgentPromptConfig {
+  name: string;
+  promptMode: "replace" | "append";
+  systemPrompt: string;
+}
+
+/** Unified agent configuration — used for both default and user-defined agents. */
+export interface AgentConfig extends AgentIdentity, AgentPromptConfig {
   builtinToolNames?: string[];
   /** Tool denylist — these tools are removed even if `builtinToolNames` or extensions include them. */
   disallowedTools?: string[];
@@ -33,8 +45,6 @@ export interface AgentConfig {
   model?: string;
   thinking?: ThinkingLevel;
   maxTurns?: number;
-  systemPrompt: string;
-  promptMode: "replace" | "append";
   /** Default for spawn: fork parent conversation. undefined = caller decides. */
   inheritContext?: boolean;
   /** Default for spawn: run in background. undefined = caller decides. */
@@ -64,48 +74,6 @@ export interface AgentInvocation {
   isolation?: IsolationMode;
 }
 
-/** Details attached to custom notification messages for visual rendering. */
-export interface NotificationDetails {
-  id: string;
-  description: string;
-  status: string;
-  toolUses: number;
-  turnCount: number;
-  maxTurns?: number;
-  totalTokens: number;
-  durationMs: number;
-  outputFile?: string;
-  error?: string;
-  resultPreview: string;
-
-}
-
-/**
- * Plain data snapshot of the parent session state captured at spawn time.
- * Replaces live `ExtensionContext` references so queued agents don't read stale state.
- */
-export interface ParentSnapshot {
-  /** Parent working directory. */
-  cwd: string;
-  /** Parent's effective system prompt (for append-mode agents). */
-  systemPrompt: string;
-  /** Parent's current model instance (fallback when agent config has no model). */
-  model: unknown;
-  /** Model registry for resolving config.model strings and creating sessions. */
-  modelRegistry: {
-    find(provider: string, modelId: string): unknown;
-    getAvailable?(): Array<{ provider: string; id: string }>;
-  };
-  /** Pre-built parent conversation text (when inheritContext was requested). */
-  parentContext?: string;
-}
-
-export interface EnvInfo {
-  isGitRepo: boolean;
-  branch: string;
-  platform: string;
-}
-
 /**
  * Narrow shell-exec callback replacing `ExtensionAPI` in `detectEnv()`.
  * Matches the shape of `pi.exec()` without carrying an SDK dependency.

package/src/ui/agent-menu.ts

@@ -220,7 +220,7 @@ export function createAgentsMenuHandler(deps: AgentMenuDeps) {
 
     await ctx.ui.custom<undefined>(
       (tui: any, theme: any, _keybindings: any, done: any) => {
-        return new ConversationViewer(tui, session, record, activity, theme, done, deps.registry);
+        return new ConversationViewer({ tui, session, record, activity, theme, done, registry: deps.registry });
       },
       {
         overlay: true,

package/src/ui/conversation-viewer.ts

@@ -20,6 +20,16 @@ const MIN_VIEWPORT = 3;
 /** Height ceiling shared by the overlay's `maxHeight` and the viewer's internal viewport cap. */
 export const VIEWPORT_HEIGHT_PCT = 70;
 
+export interface ConversationViewerOptions {
+  tui: TUI;
+  session: AgentSession;
+  record: AgentRecord;
+  activity: AgentActivityTracker | undefined;
+  theme: Theme;
+  done: (result: undefined) => void;
+  registry: AgentConfigLookup;
+}
+
 export class ConversationViewer implements Component {
   private scrollOffset = 0;
   private autoScroll = true;
@@ -27,16 +37,23 @@ export class ConversationViewer implements Component {
   private lastInnerW = 0;
   private closed = false;
 
-  constructor(
-    private tui: TUI,
-    private session: AgentSession,
-    private record: AgentRecord,
-    private activity: AgentActivityTracker | undefined,
-    private theme: Theme,
-    private done: (result: undefined) => void,
-    private registry: AgentConfigLookup,
-  ) {
-    this.unsubscribe = session.subscribe(() => {
+  private tui: TUI;
+  private session: AgentSession;
+  private record: AgentRecord;
+  private activity: AgentActivityTracker | undefined;
+  private theme: Theme;
+  private done: (result: undefined) => void;
+  private registry: AgentConfigLookup;
+
+  constructor(options: ConversationViewerOptions) {
+    this.tui = options.tui;
+    this.session = options.session;
+    this.record = options.record;
+    this.activity = options.activity;
+    this.theme = options.theme;
+    this.done = options.done;
+    this.registry = options.registry;
+    this.unsubscribe = options.session.subscribe(() => {
       if (this.closed) return;
       this.tui.requestRender();
     });