@gotgenes/pi-subagents 6.14.1 → 6.16.0

package/src/tools/spawn-config.ts

@@ -0,0 +1,146 @@
+/**
+ * spawn-config.ts — Pure config resolution for the Agent tool.
+ *
+ * Extracts all config resolution logic from execute: type resolution,
+ * invocation config merge, model resolution, max-turns normalization,
+ * tag building, and detail-base construction.
+ */
+
+import type { Model } from "@earendil-works/pi-ai";
+import { normalizeMaxTurns } from "../agent-runner.js";
+import type { AgentTypeRegistry } from "../agent-types.js";
+import { resolveAgentInvocationConfig } from "../invocation-config.js";
+import { resolveInvocationModel } from "../model-resolver.js";
+import type { AgentInvocation, IsolationMode, SubagentType, ThinkingLevel } from "../types.js";
+import {
+  type AgentDetails,
+  buildInvocationTags,
+  getDisplayName,
+  getPromptModeLabel,
+} from "../ui/display.js";
+
+/** Model info extracted from the parent session context. */
+export interface ModelInfo {
+  parentModel: { id: string; name?: string } | undefined;
+  modelRegistry: unknown;
+}
+
+/** Fully resolved config for spawning an agent. */
+export interface ResolvedSpawnConfig {
+  subagentType: string;
+  rawType: SubagentType;
+  fellBack: boolean;
+  displayName: string;
+  prompt: string;
+  description: string;
+  model: Model<any> | undefined;
+  effectiveMaxTurns: number | undefined;
+  thinking: ThinkingLevel | undefined;
+  inheritContext: boolean;
+  runInBackground: boolean;
+  isolated: boolean;
+  isolation: IsolationMode | undefined;
+  modelName: string | undefined;
+  agentInvocation: AgentInvocation;
+  agentTags: string[];
+  detailBase: Pick<AgentDetails, "displayName" | "description" | "subagentType" | "modelName" | "tags">;
+}
+
+/** Error result when model resolution fails. */
+export interface SpawnConfigError {
+  error: string;
+}
+
+/**
+ * Resolve all config for an Agent tool invocation.
+ *
+ * Pure function — no SDK types, no side effects.
+ * Returns either a fully resolved config or an error.
+ */
+export function resolveSpawnConfig(
+  params: Record<string, unknown>,
+  registry: AgentTypeRegistry,
+  modelInfo: ModelInfo,
+  settings: { readonly defaultMaxTurns: number | undefined },
+): ResolvedSpawnConfig | SpawnConfigError {
+  const rawType = params.subagent_type as SubagentType;
+  const resolved = registry.resolveType(rawType);
+  const subagentType = resolved ?? "general-purpose";
+  const fellBack = resolved === undefined;
+
+  const displayName = getDisplayName(subagentType, registry);
+
+  // Merge agent config defaults with tool-call params
+  const customConfig = registry.resolveAgentConfig(subagentType);
+  const resolvedConfig = resolveAgentInvocationConfig(customConfig, params);
+
+  // Resolve model
+  const resolution = resolveInvocationModel(
+    modelInfo.parentModel,
+    resolvedConfig.modelInput,
+    resolvedConfig.modelFromParams,
+    modelInfo.modelRegistry as any,
+  );
+  if (resolution.error) return { error: resolution.error };
+  const model = resolution.model;
+
+  const thinking = resolvedConfig.thinking;
+  const inheritContext = resolvedConfig.inheritContext;
+  const runInBackground = resolvedConfig.runInBackground;
+  const isolated = resolvedConfig.isolated;
+  const isolation = resolvedConfig.isolation;
+
+  // Compute display model name (only shown when different from parent)
+  const parentModelId = modelInfo.parentModel?.id;
+  const effectiveModelId = model?.id;
+  const modelName =
+    effectiveModelId && effectiveModelId !== parentModelId
+      ? (model?.name ?? effectiveModelId).replace(/^Claude\s+/i, "").toLowerCase()
+      : undefined;
+
+  const effectiveMaxTurns = normalizeMaxTurns(
+    resolvedConfig.maxTurns ?? settings.defaultMaxTurns,
+  );
+
+  const agentInvocation: AgentInvocation = {
+    modelName,
+    thinking,
+    maxTurns: normalizeMaxTurns(resolvedConfig.maxTurns),
+    isolated,
+    inheritContext,
+    runInBackground,
+    isolation,
+  };
+
+  const modeLabel = getPromptModeLabel(subagentType, registry);
+  const { tags: invocationTags } = buildInvocationTags(agentInvocation);
+  const agentTags = modeLabel ? [modeLabel, ...invocationTags] : invocationTags;
+
+  const detailBase = {
+    displayName,
+    description: params.description as string,
+    subagentType,
+    modelName,
+    tags: agentTags.length > 0 ? agentTags : undefined,
+  };
+
+  return {
+    subagentType,
+    rawType,
+    fellBack,
+    displayName,
+    prompt: params.prompt as string,
+    description: params.description as string,
+    model,
+    effectiveMaxTurns,
+    thinking,
+    inheritContext,
+    runInBackground,
+    isolated,
+    isolation,
+    modelName,
+    agentInvocation,
+    agentTags,
+    detailBase,
+  };
+}

package/src/tools/steer-tool.ts

@@ -49,7 +49,7 @@ export function createSteerTool(deps: SteerToolDeps) {
           `Agent "${params.agent_id}" is not running (status: ${record.status}). Cannot steer a non-running agent.`,
         );
       }
-      const session = record.execution?.session;
+      const session = record.session;
       if (!session) {
         // Session not ready yet — queue via manager for delivery once initialized
         deps.queueSteer(record.id, params.message);

package/src/ui/agent-activity-tracker.ts

@@ -5,24 +5,15 @@
  * in `ui-observer.ts`. Callers use named transition methods; readers use read-only accessors.
  */
 
-import { addUsage, type LifetimeUsage, type SessionLike } from "../usage.js";
-
-/** Usage delta accepted by onUsageUpdate — matches the LifetimeUsage accumulator shape. */
-export interface UsageDelta {
-	input: number;
-	output: number;
-	cacheWrite: number;
-}
+import type { SessionLike } from "../usage.js";
 
 /** Per-agent live activity state with explicit transition methods and read-only accessors. */
 export class AgentActivityTracker {
 	private _activeTools = new Map<string, string>();
 	private _toolKeySeq = 0;
-	private _toolUses = 0;
 	private _responseText = "";
 	private _session: SessionLike | undefined = undefined;
 	private _turnCount = 1;
-	private _lifetimeUsage: LifetimeUsage = { input: 0, output: 0, cacheWrite: 0 };
 
 	constructor(private readonly _maxTurns?: number) {}
 
@@ -33,12 +24,11 @@ export class AgentActivityTracker {
 		this._activeTools.set(toolName + "_" + (++this._toolKeySeq), toolName);
 	}
 
-	/** Record that a tool has finished executing; increments toolUses. No-op when no matching tool is active. */
-	onToolEnd(toolName: string): void {
+	/** Remove a tool from active tools (called when tool execution ends). No-op when no matching tool is active. */
+	onToolDone(toolName: string): void {
 		for (const [key, name] of this._activeTools) {
 			if (name === toolName) {
 				this._activeTools.delete(key);
-				this._toolUses++;
 				break;
 			}
 		}
@@ -59,11 +49,6 @@ export class AgentActivityTracker {
 		this._turnCount++;
 	}
 
-	/** Accumulate a usage delta into the lifetime usage totals. */
-	onUsageUpdate(delta: UsageDelta): void {
-		addUsage(this._lifetimeUsage, delta);
-	}
-
 	/** Bind the session reference (called once when the agent session is created). */
 	setSession(session: SessionLike): void {
 		this._session = session;
@@ -76,11 +61,6 @@ export class AgentActivityTracker {
 		return this._activeTools;
 	}
 
-	/** Total completed tool invocations. */
-	get toolUses(): number {
-		return this._toolUses;
-	}
-
 	/** The agent's latest partial response text (reset at each message start). */
 	get responseText(): string {
 		return this._responseText;
@@ -101,8 +81,4 @@ export class AgentActivityTracker {
 		return this._maxTurns;
 	}
 
-	/** Accumulated lifetime token usage (survives compaction). */
-	get lifetimeUsage(): Readonly<LifetimeUsage> {
-		return this._lifetimeUsage;
-	}
 }

package/src/ui/agent-menu.ts

@@ -207,7 +207,7 @@ export function createAgentsMenuHandler(deps: AgentMenuDeps) {
   }
 
   async function viewAgentConversation(ctx: ExtensionContext, record: AgentRecord) {
-    const session = record.execution?.session;
+    const session = record.session;
     if (!session) {
       ctx.ui.notify(
         `Agent is ${record.status === "queued" ? "queued" : "expired"} — no session available.`,

package/src/ui/agent-widget.ts

@@ -191,14 +191,13 @@ export class AgentWidget {
       const elapsed = formatMs(Date.now() - a.startedAt);
 
       const bg = this.agentActivity.get(a.id);
-      const toolUses = bg?.toolUses ?? a.toolUses;
-      const tokens = getLifetimeTotal(bg?.lifetimeUsage);
-      const contextPercent = getSessionContextPercent(bg?.session);
+      const tokens = getLifetimeTotal(a.lifetimeUsage);
+      const contextPercent = getSessionContextPercent(a.session);
       const tokenText = tokens > 0 ? formatSessionTokens(tokens, contextPercent, theme, a.compactionCount) : "";
 
       const parts: string[] = [];
       if (bg) parts.push(formatTurns(bg.turnCount, bg.maxTurns));
-      if (toolUses > 0) parts.push(`${toolUses} tool use${toolUses === 1 ? "" : "s"}`);
+      if (a.toolUses > 0) parts.push(`${a.toolUses} tool use${a.toolUses === 1 ? "" : "s"}`);
       if (tokenText) parts.push(tokenText);
       parts.push(elapsed);
       const statsText = parts.join(" · ");

package/src/ui/conversation-viewer.ts

@@ -155,11 +155,11 @@ export class ConversationViewer implements Component {
     const duration = formatDuration(this.record.startedAt, this.record.completedAt);
 
     const headerParts: string[] = [duration];
-    const toolUses = this.activity?.toolUses ?? this.record.toolUses;
+    const toolUses = this.record.toolUses;
     if (toolUses > 0) headerParts.unshift(`${toolUses} tool${toolUses === 1 ? "" : "s"}`);
-    const tokens = getLifetimeTotal(this.activity?.lifetimeUsage);
+    const tokens = getLifetimeTotal(this.record.lifetimeUsage);
     if (tokens > 0) {
-      const percent = getSessionContextPercent(this.activity?.session);
+      const percent = getSessionContextPercent(this.record.session);
       headerParts.push(formatSessionTokens(tokens, percent, th, this.record.compactionCount));
     }
 

package/src/ui/ui-observer.ts

@@ -40,7 +40,7 @@ export function subscribeUIObserver(
 		}
 
 		if (event.type === "tool_execution_end") {
-			tracker.onToolEnd(event.toolName);
+			tracker.onToolDone(event.toolName);
 			onUpdate?.();
 		}
 
@@ -61,16 +61,5 @@ export function subscribeUIObserver(
 			onUpdate?.();
 		}
 
-		if (event.type === "message_end" && event.message?.role === "assistant") {
-			const u = event.message.usage;
-			if (u) {
-				tracker.onUsageUpdate({
-					input: u.input ?? 0,
-					output: u.output ?? 0,
-					cacheWrite: u.cacheWrite ?? 0,
-				});
-				onUpdate?.();
-			}
-		}
 	});
 }