pi-crew 0.2.3 → 0.2.5

package/src/runtime/crew-agent-runtime.ts

@@ -1,60 +1,60 @@
-import type { TeamTaskStatus } from "../state/contracts.ts";
-import type { CrewActivityState, ModelRoutingState, UsageState } from "../state/types.ts";
-
-export type CrewRuntimeKind = "scaffold" | "child-process" | "live-session";
-export type CrewAgentStatus = "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled" | "stopped";
-
-export interface CrewAgentRecentTool {
-	tool: string;
-	args?: string;
-	endedAt: string;
-}
-
-export interface CrewAgentProgress {
-	currentTool?: string;
-	currentToolArgs?: string;
-	currentToolStartedAt?: string;
-	recentTools: CrewAgentRecentTool[];
-	recentOutput: string[];
-	toolCount: number;
-	tokens?: number;
-	turns?: number;
-	durationMs?: number;
-	lastActivityAt?: string;
-	activityState?: CrewActivityState;
-	failedTool?: string;
-	consecutiveFailures?: number;
-}
-
-export interface CrewAgentRecord {
-	id: string;
-	runId: string;
-	taskId: string;
-	agent: string;
-	role: string;
-	runtime: CrewRuntimeKind;
-	status: CrewAgentStatus;
-	startedAt: string;
-	completedAt?: string;
-	resultArtifactPath?: string;
-	transcriptPath?: string;
-	statusPath?: string;
-	eventsPath?: string;
-	outputPath?: string;
-	toolUses?: number;
-	jsonEvents?: number;
-	model?: string;
-	routing?: ModelRoutingState;
-	usage?: UsageState;
-	progress?: CrewAgentProgress;
-	error?: string;
-}
-
-export function taskStatusToAgentStatus(status: TeamTaskStatus): CrewAgentStatus {
-	if (status === "completed") return "completed";
-	if (status === "failed") return "failed";
-	if (status === "cancelled" || status === "skipped") return "cancelled";
-	if (status === "running") return "running";
-	if (status === "waiting") return "waiting";
-	return "queued";
-}
+import type { TeamTaskStatus } from "../state/contracts.ts";
+import type { CrewActivityState, ModelRoutingState, UsageState } from "../state/types.ts";
+
+export type CrewRuntimeKind = "scaffold" | "child-process" | "live-session";
+export type CrewAgentStatus = "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled" | "stopped";
+
+export interface CrewAgentRecentTool {
+	tool: string;
+	args?: string;
+	endedAt: string;
+}
+
+export interface CrewAgentProgress {
+	currentTool?: string;
+	currentToolArgs?: string;
+	currentToolStartedAt?: string;
+	recentTools: CrewAgentRecentTool[];
+	recentOutput: string[];
+	toolCount: number;
+	tokens?: number;
+	turns?: number;
+	durationMs?: number;
+	lastActivityAt?: string;
+	activityState?: CrewActivityState;
+	failedTool?: string;
+	consecutiveFailures?: number;
+}
+
+export interface CrewAgentRecord {
+	id: string;
+	runId: string;
+	taskId: string;
+	agent: string;
+	role: string;
+	runtime: CrewRuntimeKind;
+	status: CrewAgentStatus;
+	startedAt: string;
+	completedAt?: string;
+	resultArtifactPath?: string;
+	transcriptPath?: string;
+	statusPath?: string;
+	eventsPath?: string;
+	outputPath?: string;
+	toolUses?: number;
+	jsonEvents?: number;
+	model?: string;
+	routing?: ModelRoutingState;
+	usage?: UsageState;
+	progress?: CrewAgentProgress;
+	error?: string;
+}
+
+export function taskStatusToAgentStatus(status: TeamTaskStatus): CrewAgentStatus {
+	if (status === "completed") return "completed";
+	if (status === "failed") return "failed";
+	if (status === "cancelled" || status === "skipped") return "cancelled";
+	if (status === "running") return "running";
+	if (status === "waiting") return "waiting";
+	return "queued";
+}

package/src/runtime/cross-extension-rpc.ts

@@ -0,0 +1,72 @@
+export interface EventBus {
+	on(event: string, handler: (data: unknown) => void): () => void;
+	emit(event: string, data: unknown): void;
+}
+
+export type RpcReply<T = void> =
+	| { success: true; data?: T }
+	| { success: false; error: string };
+
+export const PROTOCOL_VERSION = 1;
+
+export interface RpcDeps {
+	events: EventBus;
+	getCtx: () => unknown | undefined;
+	spawn: (type: string, prompt: string, options?: Record<string, unknown>) => string;
+	abort: (agentId: string) => boolean;
+}
+
+export interface RpcHandle {
+	unsubPing: () => void;
+	unsubSpawn: () => void;
+	unsubStop: () => void;
+}
+
+function handleRpc<P extends { requestId: string }>(
+	events: EventBus,
+	channel: string,
+	fn: (params: P) => unknown | Promise<unknown>,
+): () => void {
+	return events.on(channel, async (raw: unknown) => {
+		const params = raw as P;
+		try {
+			const data = await fn(params);
+			const reply: { success: true; data?: unknown } = { success: true };
+			if (data !== undefined) reply.data = data;
+			events.emit(`${channel}:reply:${params.requestId}`, reply);
+		} catch (err: any) {
+			events.emit(`${channel}:reply:${params.requestId}`, {
+				success: false,
+				error: err?.message ?? String(err),
+			});
+		}
+	});
+}
+
+export function registerCrewRpcHandlers(deps: RpcDeps): RpcHandle {
+	const { events, getCtx, spawn, abort } = deps;
+
+	const unsubPing = handleRpc(events, "crew:rpc:ping", () => {
+		return { version: PROTOCOL_VERSION };
+	});
+
+	const unsubSpawn = handleRpc<{ requestId: string; type: string; prompt: string; options?: Record<string, unknown> }>(
+		events,
+		"crew:rpc:spawn",
+		({ type, prompt, options }) => {
+			const ctx = getCtx();
+			if (!ctx) throw new Error("No active session");
+			return { id: spawn(type, prompt, options ?? {}) };
+		},
+	);
+
+	const unsubStop = handleRpc<{ requestId: string; agentId: string }>(
+		events,
+		"crew:rpc:stop",
+		({ agentId }) => {
+			if (!abort(agentId)) throw new Error("Agent not found");
+		},
+	);
+
+	return { unsubPing, unsubSpawn, unsubStop };
+}

package/src/runtime/custom-tools/irc-tool.ts

@@ -1,201 +1,201 @@
-/**
- * G1: Custom tool — irc.
- *
- * Registers a real `irc` tool in the Pi SDK session so that
- * live-session workers can send messages to other live agents.
- *
- * Operations:
- * - `list`: List currently visible peer agents
- * - `send`: Send a message to a specific agent or broadcast to all
- *
- * Adapted from oh-my-pi's `IrcTool` pattern. Uses the live-agent-manager
- * for routing messages between in-process workers.
- */
-
-import { defineTool, type ToolDefinition } from "@mariozechner/pi-coding-agent";
-import { Type, type Static } from "@sinclair/typebox";
-import { listLiveAgents, sendIrcMessage, broadcastIrcMessage } from "../live-agent-manager.ts";
-import type { IrcMessage } from "../live-irc.ts";
-
-const IrcParams = Type.Object({
-	op: Type.Union(
-		[
-			Type.Literal("send", { description: "Send a message to one peer or to all peers." }),
-			Type.Literal("list", { description: "List currently visible peers." }),
-		],
-		{ description: "IRC operation." },
-	),
-	to: Type.Optional(
-		Type.String({
-			description: 'Recipient agent ID or "all" to broadcast.',
-		}),
-	),
-	message: Type.Optional(
-		Type.String({
-			description: "Message body to deliver.",
-		}),
-	),
-	awaitReply: Type.Optional(
-		Type.Boolean({
-			description: "Wait for a reply (default: true for DM, false for broadcast). Not yet supported — messages are fire-and-forget.",
-		}),
-	),
-});
-
-type IrcParams = Static<typeof IrcParams>;
-
-interface IrcDetails {
-	op: "send" | "list";
-	from?: string;
-	to?: string;
-	delivered?: string[];
-	notFound?: string[];
-	peers?: Array<{ id: string; status: string }>;
-	error?: string;
-}
-
-/**
- * Create an `irc` tool definition for a specific agent.
- *
- * @param selfId — This agent's ID (runId:taskId format)
- */
-export function createIrcTool(
-	selfId: string,
-): ToolDefinition<typeof IrcParams, IrcDetails> {
-	return defineTool({
-		name: "irc",
-		label: "IRC",
-		description:
-			"Send messages to other live agents in same team. " +
-			'Use `op: "list"` to see peers, `op: "send"` with `to` (agent ID or "all") and `message` to communicate.',
-		parameters: IrcParams,
-		promptSnippet: "Send messages to other live agents via the irc tool",
-		promptGuidelines: [
-			"Use irc to coordinate with other agents when you need information or want to share findings.",
-			'Use `op: "list"` first to discover available peers.',
-		],
-		async execute(
-			_toolCallId: string,
-			params: IrcParams,
-			_signal: AbortSignal | undefined,
-			_onUpdate: unknown,
-			_ctx: unknown,
-		): Promise<{ content: Array<{ type: "text"; text: string }>; details: IrcDetails }> {
-			if (params.op === "list") {
-				return executeList(selfId);
-			}
-			if (params.op === "send") {
-				return executeSend(selfId, params);
-			}
-			return {
-				content: [{ type: "text", text: "Unknown irc op." }],
-				details: { op: params.op, from: selfId, error: "Unknown operation." },
-			};
-		},
-	});
-}
-
-function executeList(selfId: string): { content: Array<{ type: "text"; text: string }>; details: IrcDetails } {
-	const agents = listLiveAgents();
-	const peers = agents
-		.filter((a) => a.agentId !== selfId && (a.status === "running" || a.status === "queued"))
-		.map((a) => ({ id: a.agentId, status: a.status }));
-
-	const lines: string[] = [];
-	if (peers.length === 0) {
-		lines.push("No other live agents.");
-	} else {
-		lines.push(`${peers.length} peer(s):`);
-		for (const peer of peers) {
-			lines.push(`- ${peer.id} (${peer.status})`);
-		}
-	}
-
-	return {
-		content: [{ type: "text", text: lines.join("\n") }],
-		details: { op: "list", from: selfId, peers },
-	};
-}
-
-function executeSend(
-	selfId: string,
-	params: IrcParams,
-): { content: Array<{ type: "text"; text: string }>; details: IrcDetails } {
-	const to = params.to?.trim();
-	const message = params.message?.trim();
-
-	if (!to) {
-		return {
-			content: [{ type: "text", text: '`to` is required for op="send".' }],
-			details: { op: "send", from: selfId, error: "Missing 'to' field." },
-		};
-	}
-	if (!message) {
-		return {
-			content: [{ type: "text", text: '`message` is required for op="send".' }],
-			details: { op: "send", from: selfId, to, error: "Missing 'message' field." },
-		};
-	}
-	if (to === selfId) {
-		return {
-			content: [{ type: "text", text: "Cannot send a message to yourself." }],
-			details: { op: "send", from: selfId, to, error: "Self-message not allowed." },
-		};
-	}
-
-	const ircMessage: IrcMessage = {
-		from: selfId,
-		to,
-		content: message,
-		timestamp: new Date().toISOString(),
-		awaitReply: params.awaitReply,
-	};
-
-	const notFound: string[] = [];
-	const delivered: string[] = [];
-
-	try {
-		if (to === "all") {
-			const recipients = broadcastIrcMessage(selfId, ircMessage);
-			delivered.push(...recipients);
-		} else {
-			// DM to specific agent
-			const agents = listLiveAgents();
-			const target = agents.find((a) => a.agentId === to);
-			if (!target || (target.status !== "running" && target.status !== "queued")) {
-				notFound.push(to);
-			} else {
-				try {
-					sendIrcMessage(to, ircMessage);
-					delivered.push(to);
-				} catch {
-					notFound.push(to);
-				}
-			}
-		}
-	} catch {
-		// Agent deregistered during routing — treat as not found
-		notFound.push(to);
-	}
-
-	const lines: string[] = [];
-	if (delivered.length > 0) {
-		lines.push(`Delivered to ${delivered.length} peer(s): ${delivered.join(", ")}`);
-	} else {
-		lines.push("No recipients received the message.");
-	}
-	if (notFound.length > 0) {
-		lines.push(`Unknown / unavailable peers: ${notFound.join(", ")}`);
-	}
-
-	return {
-		content: [{ type: "text", text: lines.join("\n") }],
-		details: {
-			op: "send",
-			from: selfId,
-			to,
-			delivered: delivered.length > 0 ? delivered : undefined,
-			notFound: notFound.length > 0 ? notFound : undefined,
-		},
-	};
-}
+/**
+ * G1: Custom tool — irc.
+ *
+ * Registers a real `irc` tool in the Pi SDK session so that
+ * live-session workers can send messages to other live agents.
+ *
+ * Operations:
+ * - `list`: List currently visible peer agents
+ * - `send`: Send a message to a specific agent or broadcast to all
+ *
+ * Adapted from oh-my-pi's `IrcTool` pattern. Uses the live-agent-manager
+ * for routing messages between in-process workers.
+ */
+
+import { defineTool, type ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { Type, type Static } from "@sinclair/typebox";
+import { listLiveAgents, sendIrcMessage, broadcastIrcMessage } from "../live-agent-manager.ts";
+import type { IrcMessage } from "../live-irc.ts";
+
+const IrcParams = Type.Object({
+	op: Type.Union(
+		[
+			Type.Literal("send", { description: "Send a message to one peer or to all peers." }),
+			Type.Literal("list", { description: "List currently visible peers." }),
+		],
+		{ description: "IRC operation." },
+	),
+	to: Type.Optional(
+		Type.String({
+			description: 'Recipient agent ID or "all" to broadcast.',
+		}),
+	),
+	message: Type.Optional(
+		Type.String({
+			description: "Message body to deliver.",
+		}),
+	),
+	awaitReply: Type.Optional(
+		Type.Boolean({
+			description: "Wait for a reply (default: true for DM, false for broadcast). Not yet supported — messages are fire-and-forget.",
+		}),
+	),
+});
+
+type IrcParams = Static<typeof IrcParams>;
+
+interface IrcDetails {
+	op: "send" | "list";
+	from?: string;
+	to?: string;
+	delivered?: string[];
+	notFound?: string[];
+	peers?: Array<{ id: string; status: string }>;
+	error?: string;
+}
+
+/**
+ * Create an `irc` tool definition for a specific agent.
+ *
+ * @param selfId — This agent's ID (runId:taskId format)
+ */
+export function createIrcTool(
+	selfId: string,
+): ToolDefinition<typeof IrcParams, IrcDetails> {
+	return defineTool({
+		name: "irc",
+		label: "IRC",
+		description:
+			"Send messages to other live agents in same team. " +
+			'Use `op: "list"` to see peers, `op: "send"` with `to` (agent ID or "all") and `message` to communicate.',
+		parameters: IrcParams,
+		promptSnippet: "Send messages to other live agents via the irc tool",
+		promptGuidelines: [
+			"Use irc to coordinate with other agents when you need information or want to share findings.",
+			'Use `op: "list"` first to discover available peers.',
+		],
+		async execute(
+			_toolCallId: string,
+			params: IrcParams,
+			_signal: AbortSignal | undefined,
+			_onUpdate: unknown,
+			_ctx: unknown,
+		): Promise<{ content: Array<{ type: "text"; text: string }>; details: IrcDetails }> {
+			if (params.op === "list") {
+				return executeList(selfId);
+			}
+			if (params.op === "send") {
+				return executeSend(selfId, params);
+			}
+			return {
+				content: [{ type: "text", text: "Unknown irc op." }],
+				details: { op: params.op, from: selfId, error: "Unknown operation." },
+			};
+		},
+	});
+}
+
+function executeList(selfId: string): { content: Array<{ type: "text"; text: string }>; details: IrcDetails } {
+	const agents = listLiveAgents();
+	const peers = agents
+		.filter((a) => a.agentId !== selfId && (a.status === "running" || a.status === "queued"))
+		.map((a) => ({ id: a.agentId, status: a.status }));
+
+	const lines: string[] = [];
+	if (peers.length === 0) {
+		lines.push("No other live agents.");
+	} else {
+		lines.push(`${peers.length} peer(s):`);
+		for (const peer of peers) {
+			lines.push(`- ${peer.id} (${peer.status})`);
+		}
+	}
+
+	return {
+		content: [{ type: "text", text: lines.join("\n") }],
+		details: { op: "list", from: selfId, peers },
+	};
+}
+
+function executeSend(
+	selfId: string,
+	params: IrcParams,
+): { content: Array<{ type: "text"; text: string }>; details: IrcDetails } {
+	const to = params.to?.trim();
+	const message = params.message?.trim();
+
+	if (!to) {
+		return {
+			content: [{ type: "text", text: '`to` is required for op="send".' }],
+			details: { op: "send", from: selfId, error: "Missing 'to' field." },
+		};
+	}
+	if (!message) {
+		return {
+			content: [{ type: "text", text: '`message` is required for op="send".' }],
+			details: { op: "send", from: selfId, to, error: "Missing 'message' field." },
+		};
+	}
+	if (to === selfId) {
+		return {
+			content: [{ type: "text", text: "Cannot send a message to yourself." }],
+			details: { op: "send", from: selfId, to, error: "Self-message not allowed." },
+		};
+	}
+
+	const ircMessage: IrcMessage = {
+		from: selfId,
+		to,
+		content: message,
+		timestamp: new Date().toISOString(),
+		awaitReply: params.awaitReply,
+	};
+
+	const notFound: string[] = [];
+	const delivered: string[] = [];
+
+	try {
+		if (to === "all") {
+			const recipients = broadcastIrcMessage(selfId, ircMessage);
+			delivered.push(...recipients);
+		} else {
+			// DM to specific agent
+			const agents = listLiveAgents();
+			const target = agents.find((a) => a.agentId === to);
+			if (!target || (target.status !== "running" && target.status !== "queued")) {
+				notFound.push(to);
+			} else {
+				try {
+					sendIrcMessage(to, ircMessage);
+					delivered.push(to);
+				} catch {
+					notFound.push(to);
+				}
+			}
+		}
+	} catch {
+		// Agent deregistered during routing — treat as not found
+		notFound.push(to);
+	}
+
+	const lines: string[] = [];
+	if (delivered.length > 0) {
+		lines.push(`Delivered to ${delivered.length} peer(s): ${delivered.join(", ")}`);
+	} else {
+		lines.push("No recipients received the message.");
+	}
+	if (notFound.length > 0) {
+		lines.push(`Unknown / unavailable peers: ${notFound.join(", ")}`);
+	}
+
+	return {
+		content: [{ type: "text", text: lines.join("\n") }],
+		details: {
+			op: "send",
+			from: selfId,
+			to,
+			delivered: delivered.length > 0 ? delivered : undefined,
+			notFound: notFound.length > 0 ? notFound : undefined,
+		},
+	};
+}