@gotgenes/pi-subagents 7.2.1 → 7.2.3

package/src/tools/get-result-tool.ts

@@ -1,102 +1,127 @@
-import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import type { AgentConfigLookup } from "#src/config/agent-types";
+import { getAgentConversation } from "#src/lifecycle/agent-runner";
 import { getSessionContextPercent } from "#src/lifecycle/usage";
 import { formatLifetimeTokens, textResult } from "#src/tools/helpers";
 import type { AgentRecord } from "#src/types";
 import { formatDuration, getDisplayName } from "#src/ui/display";
 
-/** Create the get_subagent_result tool definition (without Pi SDK wrapper). */
-export function createGetResultTool(
-  getRecord: (id: string) => AgentRecord | undefined,
-  cancelNudge: (key: string) => void,
-  getConversation: (session: AgentSession) => string | undefined,
-  registry: AgentConfigLookup,
-) {
-  return {
-    name: "get_subagent_result" as const,
-    label: "Get Agent Result",
-    promptSnippet: "get_subagent_result: Check status and retrieve results from a background agent.",
-    description:
-      "Check status and retrieve results from a background agent. Use the agent ID returned by Agent with run_in_background.",
-    parameters: Type.Object({
-      agent_id: Type.String({
-        description: "The agent ID to check.",
-      }),
-      wait: Type.Optional(
-        Type.Boolean({
-          description: "If true, wait for the agent to complete before returning. Default: false.",
-        }),
-      ),
-      verbose: Type.Optional(
-        Type.Boolean({
-          description:
-            "If true, include the agent's full conversation (messages + tool calls). Default: false.",
-        }),
-      ),
-    }),
-    execute: async (
-      _toolCallId: string,
-      params: { agent_id: string; wait?: boolean; verbose?: boolean },
-      _signal: AbortSignal,
-      _onUpdate: unknown,
-      _ctx: unknown,
-    ) => {
-      const record = getRecord(params.agent_id);
-      if (!record) {
-        return textResult(`Agent not found: "${params.agent_id}". It may have been cleaned up.`);
-      }
+// ---- Deps interfaces ----
 
-      // Wait for completion if requested.
-      // Pre-mark resultConsumed BEFORE awaiting: onComplete fires inside .then()
-      // (attached earlier at spawn time) and always runs before this await resumes.
-      // Setting the flag here prevents a redundant follow-up notification.
-      if (params.wait && record.status === "running" && record.promise) {
-        // Pre-mark consumed BEFORE awaiting — onComplete fires inside .then() and
-        // always runs before this await resumes. Prevents a redundant notification.
-        record.notification?.markConsumed();
-        cancelNudge(params.agent_id);
-        await record.promise;
-      }
+export interface GetResultToolManager {
+	getRecord(id: string): AgentRecord | undefined;
+}
+
+export interface GetResultToolNotifications {
+	cancelNudge(key: string): void;
+}
+
+// ---- Class ----
+
+export class GetResultTool {
+	constructor(
+		private readonly manager: GetResultToolManager,
+		private readonly notifications: GetResultToolNotifications,
+		private readonly registry: AgentConfigLookup,
+	) {}
+
+	async execute(
+		_toolCallId: string,
+		params: { agent_id: string; wait?: boolean; verbose?: boolean },
+		_signal: AbortSignal,
+		_onUpdate: unknown,
+		_ctx: unknown,
+	) {
+		const record = this.manager.getRecord(params.agent_id);
+		if (!record) {
+			return textResult(`Agent not found: "${params.agent_id}". It may have been cleaned up.`);
+		}
+
+		// Wait for completion if requested.
+		// Pre-mark resultConsumed BEFORE awaiting: onComplete fires inside .then()
+		// (attached earlier at spawn time) and always runs before this await resumes.
+		// Setting the flag here prevents a redundant follow-up notification.
+		if (params.wait && record.status === "running" && record.promise) {
+			// Pre-mark consumed BEFORE awaiting — onComplete fires inside .then() and
+			// always runs before this await resumes. Prevents a redundant notification.
+			record.notification?.markConsumed();
+			this.notifications.cancelNudge(params.agent_id);
+			await record.promise;
+		}
+
+		const displayName = getDisplayName(record.type, this.registry);
+		const duration = formatDuration(record.startedAt, record.completedAt);
+		const tokens = formatLifetimeTokens(record);
+		const contextPercent = getSessionContextPercent(record.session);
+		const statsParts = [`Tool uses: ${record.toolUses}`];
+		if (tokens) statsParts.push(tokens);
+		if (contextPercent !== null) statsParts.push(`Context: ${Math.round(contextPercent)}%`);
+		if (record.compactionCount) statsParts.push(`Compactions: ${record.compactionCount}`);
+		statsParts.push(`Duration: ${duration}`);
 
-      const displayName = getDisplayName(record.type, registry);
-      const duration = formatDuration(record.startedAt, record.completedAt);
-      const tokens = formatLifetimeTokens(record);
-      const contextPercent = getSessionContextPercent(record.session);
-      const statsParts = [`Tool uses: ${record.toolUses}`];
-      if (tokens) statsParts.push(tokens);
-      if (contextPercent !== null) statsParts.push(`Context: ${Math.round(contextPercent)}%`);
-      if (record.compactionCount) statsParts.push(`Compactions: ${record.compactionCount}`);
-      statsParts.push(`Duration: ${duration}`);
+		let output =
+			`Agent: ${record.id}\n` +
+			`Type: ${displayName} | Status: ${record.status} | ${statsParts.join(" | ")}\n` +
+			`Description: ${record.description}\n\n`;
 
-      let output =
-        `Agent: ${record.id}\n` +
-        `Type: ${displayName} | Status: ${record.status} | ${statsParts.join(" | ")}\n` +
-        `Description: ${record.description}\n\n`;
+		if (record.status === "running") {
+			output += "Agent is still running. Use wait: true or check back later.";
+		} else if (record.status === "error") {
+			output += `Error: ${record.error}`;
+		} else {
+			output += record.result?.trim() ?? "No output.";
+		}
 
-      if (record.status === "running") {
-        output += "Agent is still running. Use wait: true or check back later.";
-      } else if (record.status === "error") {
-        output += `Error: ${record.error}`;
-      } else {
-        output += record.result?.trim() ?? "No output.";
-      }
+		// Mark result as consumed — suppresses the completion notification
+		if (record.status !== "running" && record.status !== "queued") {
+			record.notification?.markConsumed();
+			this.notifications.cancelNudge(params.agent_id);
+		}
 
-      // Mark result as consumed — suppresses the completion notification
-      if (record.status !== "running" && record.status !== "queued") {
-        record.notification?.markConsumed();
-        cancelNudge(params.agent_id);
-      }
+		// Verbose: include full conversation
+		if (params.verbose && record.session) {
+			const conversation = getAgentConversation(record.session);
+			if (conversation) {
+				output += `\n\n--- Agent Conversation ---\n${conversation}`;
+			}
+		}
 
-      // Verbose: include full conversation
-      if (params.verbose && record.session) {
-        const conversation = getConversation(record.session);
-        if (conversation) {
-          output += `\n\n--- Agent Conversation ---\n${conversation}`;
-        }
-      }
+		return textResult(output);
+	}
 
-      return textResult(output);
-    },
-  };
+	toToolDefinition() {
+		return defineTool({
+			name: "get_subagent_result" as const,
+			label: "Get Agent Result",
+			promptSnippet:
+				"get_subagent_result: Check status and retrieve results from a background agent.",
+			description:
+				"Check status and retrieve results from a background agent. Use the agent ID returned by Agent with run_in_background.",
+			parameters: Type.Object({
+				agent_id: Type.String({
+					description: "The agent ID to check.",
+				}),
+				wait: Type.Optional(
+					Type.Boolean({
+						description:
+							"If true, wait for the agent to complete before returning. Default: false.",
+					}),
+				),
+				verbose: Type.Optional(
+					Type.Boolean({
+						description:
+							"If true, include the agent's full conversation (messages + tool calls). Default: false.",
+					}),
+				),
+			}),
+			execute: (
+				toolCallId: string,
+				params: { agent_id: string; wait?: boolean; verbose?: boolean },
+				signal: AbortSignal,
+				onUpdate: unknown,
+				ctx: unknown,
+			) => this.execute(toolCallId, params, signal, onUpdate, ctx),
+		});
+	}
 }

package/src/tools/steer-tool.ts

@@ -1,84 +1,106 @@
-import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { getSessionContextPercent } from "#src/lifecycle/usage";
 import { formatLifetimeTokens, textResult } from "#src/tools/helpers";
 import type { AgentRecord } from "#src/types";
 
-/** Create the steer_subagent tool definition (without Pi SDK wrapper). */
-export function createSteerTool(
-  getRecord: (id: string) => AgentRecord | undefined,
-  emitEvent: (name: string, data: unknown) => void,
-  steerAgent: (session: AgentSession, message: string) => Promise<void>,
-  /** Buffer a steer for an agent whose session isn't ready yet. */
-  queueSteer: (id: string, message: string) => boolean,
-) {
-  return {
-    name: "steer_subagent" as const,
-    label: "Steer Agent",
-    promptSnippet: "steer_subagent: Send a mid-run message to redirect a running background agent.",
-    description:
-      "Send a steering message to a running agent. The message will interrupt the agent after its current tool execution " +
-      "and be injected into its conversation, allowing you to redirect its work mid-run. Only works on running agents.",
-    parameters: Type.Object({
-      agent_id: Type.String({
-        description: "The agent ID to steer (must be currently running).",
-      }),
-      message: Type.String({
-        description:
-          "The steering message to send. This will appear as a user message in the agent's conversation.",
-      }),
-    }),
-    execute: async (
-      _toolCallId: string,
-      params: { agent_id: string; message: string },
-      _signal: AbortSignal,
-      _onUpdate: unknown,
-      _ctx: unknown,
-    ) => {
-      const record = getRecord(params.agent_id);
-      if (!record) {
-        return textResult(
-          `Agent not found: "${params.agent_id}". It may have been cleaned up.`,
-        );
-      }
-      if (record.status !== "running") {
-        return textResult(
-          `Agent "${params.agent_id}" is not running (status: ${record.status}). Cannot steer a non-running agent.`,
-        );
-      }
-      const session = record.session;
-      if (!session) {
-        // Session not ready yet — queue via manager for delivery once initialized
-        queueSteer(record.id, params.message);
-        emitEvent("subagents:steered", { id: record.id, message: params.message });
-        return textResult(
-          `Steering message queued for agent ${record.id}. It will be delivered once the session initializes.`,
-        );
-      }
+// ---- Deps interfaces ----
 
-      try {
-        await steerAgent(session, params.message);
-        emitEvent("subagents:steered", { id: record.id, message: params.message });
-        const tokens = formatLifetimeTokens(record);
-        const contextPercent = getSessionContextPercent(session);
-        const stateParts: string[] = [];
-        if (tokens) stateParts.push(tokens);
-        stateParts.push(`${record.toolUses} tool ${record.toolUses === 1 ? "use" : "uses"}`);
-        if (contextPercent !== null)
-          stateParts.push(`context ${Math.round(contextPercent)}% full`);
-        if (record.compactionCount)
-          stateParts.push(
-            `${record.compactionCount} compaction${record.compactionCount === 1 ? "" : "s"}`,
-          );
-        return textResult(
-          `Steering message sent to agent ${record.id}. The agent will process it after its current tool execution.\n` +
-            `Current state: ${stateParts.join(" · ")}`,
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to steer agent: ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
-    },
-  };
+export interface SteerToolManager {
+	getRecord(id: string): AgentRecord | undefined;
+	queueSteer(id: string, message: string): boolean;
+}
+
+export interface SteerToolEvents {
+	emit(name: string, data: unknown): void;
+}
+
+// ---- Class ----
+
+export class SteerTool {
+	constructor(
+		private readonly manager: SteerToolManager,
+		private readonly events: SteerToolEvents,
+	) {}
+
+	async execute(
+		_toolCallId: string,
+		params: { agent_id: string; message: string },
+		_signal: AbortSignal,
+		_onUpdate: unknown,
+		_ctx: unknown,
+	) {
+		const record = this.manager.getRecord(params.agent_id);
+		if (!record) {
+			return textResult(
+				`Agent not found: "${params.agent_id}". It may have been cleaned up.`,
+			);
+		}
+		if (record.status !== "running") {
+			return textResult(
+				`Agent "${params.agent_id}" is not running (status: ${record.status}). Cannot steer a non-running agent.`,
+			);
+		}
+		const session = record.session;
+		if (!session) {
+			// Session not ready yet — queue via manager for delivery once initialized
+			this.manager.queueSteer(record.id, params.message);
+			this.events.emit("subagents:steered", { id: record.id, message: params.message });
+			return textResult(
+				`Steering message queued for agent ${record.id}. It will be delivered once the session initializes.`,
+			);
+		}
+
+		try {
+			await session.steer(params.message);
+			this.events.emit("subagents:steered", { id: record.id, message: params.message });
+			const tokens = formatLifetimeTokens(record);
+			const contextPercent = getSessionContextPercent(session);
+			const stateParts: string[] = [];
+			if (tokens) stateParts.push(tokens);
+			stateParts.push(`${record.toolUses} tool ${record.toolUses === 1 ? "use" : "uses"}`);
+			if (contextPercent !== null)
+				stateParts.push(`context ${Math.round(contextPercent)}% full`);
+			if (record.compactionCount)
+				stateParts.push(
+					`${record.compactionCount} compaction${record.compactionCount === 1 ? "" : "s"}`,
+				);
+			return textResult(
+				`Steering message sent to agent ${record.id}. The agent will process it after its current tool execution.\n` +
+					`Current state: ${stateParts.join(" · ")}`,
+			);
+		} catch (err) {
+			return textResult(
+				`Failed to steer agent: ${err instanceof Error ? err.message : String(err)}`,
+			);
+		}
+	}
+
+	toToolDefinition() {
+		return defineTool({
+			name: "steer_subagent" as const,
+			label: "Steer Agent",
+			promptSnippet:
+				"steer_subagent: Send a mid-run message to redirect a running background agent.",
+			description:
+				"Send a steering message to a running agent. The message will interrupt the agent after its current tool execution " +
+				"and be injected into its conversation, allowing you to redirect its work mid-run. Only works on running agents.",
+			parameters: Type.Object({
+				agent_id: Type.String({
+					description: "The agent ID to steer (must be currently running).",
+				}),
+				message: Type.String({
+					description:
+						"The steering message to send. This will appear as a user message in the agent's conversation.",
+				}),
+			}),
+			execute: (
+				toolCallId: string,
+				params: { agent_id: string; message: string },
+				signal: AbortSignal,
+				onUpdate: unknown,
+				ctx: unknown,
+			) => this.execute(toolCallId, params, signal, onUpdate, ctx),
+		});
+	}
 }