@skydiveai/pi-extensions 0.1.0-beta.2894 → 0.1.0-beta.2899

package/dist/index.mjs

@@ -2359,6 +2359,30 @@ async function postSubagentSpawn({ messageId, tasks }) {
 		tasks: body.tasks ?? []
 	};
 }
+async function postSubagentRearm({ messageId, taskId, timeoutMinutes }) {
+	const client = sandboxClient();
+	if (!client) throw new Error("no api url for subagent re-arm");
+	const res = await client.a2a.tasks[":id"].rearm.$post({
+		param: { id: taskId },
+		json: {
+			messageId,
+			timeoutMinutes
+		}
+	});
+	if (!res.ok) {
+		let detail = "";
+		try {
+			const body = await res.json();
+			if (typeof body.error === "string") detail = `: ${body.error}`;
+		} catch {}
+		throw new Error(`subagent re-arm POST failed (${res.status})${detail}`);
+	}
+	const body = await res.json();
+	return {
+		taskId: body.id,
+		deadlineAt: body.deadlineAt
+	};
+}
 function createHeartbeatThrottle({ messageId }) {
 	let lastAt = 0;
 	let pending = null;
@@ -4230,7 +4254,7 @@ const soulExtension = (pi) => {
 //#region src/extensions/subagent/index.ts
 const log$1 = logger.child({ module: "subagent-ext" });
 const MAX_TASKS = 8;
-const TaskItem = Type.Object({
+const SpawnTaskItem = Type.Object({
 	task: Type.String({ description: "The task to delegate to a subagent run." }),
 	title: Type.String({
 		description: "A SHORT name for this task — 3-6 words, sentence case, no trailing period. This is what the person in the chat sees as the row for this subagent, so name the work, do not restate the prompt. Good: \"Audit the billing gate\", \"Compare competitor pricing\", \"Draft the migration\". Bad: \"You are looking at apps/anyone/web and should check every component…\".",
@@ -4244,9 +4268,18 @@ const TaskItem = Type.Object({
 		maximum: 360
 	}))
 });
+const RearmTaskItem = Type.Object({
+	taskId: Type.String({ description: "The running subagent task to keep waiting for. Use the taskId returned by an earlier subagent call." }),
+	timeoutMinutes: Type.Integer({
+		description: "Wake again after this many minutes if the subagent is still running. This replaces no work and can be repeated after every timeout. Range 1-360.",
+		minimum: 1,
+		maximum: 360
+	})
+});
+const TaskItem = Type.Union([SpawnTaskItem, RearmTaskItem]);
 const DEFAULT_SUBAGENT_TIMEOUT_MS = 30 * 6e4;
 const SubagentParams = Type.Object({ tasks: Type.Array(TaskItem, {
-	description: "One or more tasks to delegate. Each spawns an isolated subagent run linked to this conversation; they run in parallel and each rewakes you with its result when it finishes.",
+	description: "Spawn subagent runs with { task, title, ... }, or keep waiting for a running task with { taskId, timeoutMinutes }. Re-arming schedules another parent wake without restarting or stopping the child.",
 	minItems: 1,
 	maxItems: MAX_TASKS
 }) });
@@ -4256,10 +4289,10 @@ function buildTool(messageId) {
 		name: SUBAGENT_TOOL_NAME,
 		label: "Subagent",
 		description: [
-			"Delegate one or more tasks to subagent runs — fresh isolated copies of yourself, each with its own context window, linked to this conversation.",
+			"Delegate tasks to isolated subagent runs, or re-arm a running task so it wakes you again later without stopping the child.",
 			"Use it to parallelize independent work, to keep a large or noisy subtask out of your own context, or to run a task under a specialized persona.",
 			"Fire-and-forget: this returns immediately after queueing. It does NOT wait for results. Each subagent runs on its own and, when it finishes, sends you its result on this thread — so queue the work, then keep going or end your turn. To chain, re-delegate after a result lands.",
-			"Pass tasks: [{ task, title, persona?, model? }]. title is a short 3-6 word name for the task — it is shown to the person in the chat as that subagent's row, so name the work rather than restating the prompt. persona is an optional extra system prompt layered ON TOP of your default persona for that task (it adds to, it does not replace, your identity); omit it to run with just your default persona. model is an optional model id for that task — prefer a lower-cost, faster model for well-scoped subtasks that don't need deep reasoning, and reserve a top-tier model for the ones that do; omit it to inherit your own model.",
+			"To spawn, pass { task, title, persona?, model?, timeoutMinutes? }. To keep waiting after a timeout, pass { taskId, timeoutMinutes }; this schedules another wake and leaves the same child running. title is the short human-visible name for new work. persona and model apply only when spawning.",
 			"Peering: each queued task comes back with its own conversation id. A subagent is a real linked conversation, so to see what one is doing RIGHT NOW while it runs — its reasoning, the tools it has called and their results, its progress — read that conversation with `platform conversations show <conversationId>` (you are already authorized; it is your own delegated run). Check in that way instead of waiting blind for the final result. The read reflects the child's persisted state, which lags a few seconds behind live (tool results land as they complete; in-progress reasoning can be up to ~5s stale), so peek between checkpoints rather than polling in a tight loop.",
 			"Steering: to add context, correct course, or answer a question a subagent needs mid-run, post to its conversation with `platform conversations post <conversationId> --message \"...\"`. If the subagent is still running, your message lands as a live steer picked up in that same turn; if it has gone idle, it queues as its next turn. This is the same primitive as any conversation message — there is no separate steer channel."
 		].join(" "),
@@ -4275,38 +4308,90 @@ function buildTool(messageId) {
 				details: {},
 				isError: true
 			};
-			const spawnTasks = tasks.map((t) => ({
-				task: t.task,
-				title: t.title ?? null,
-				persona: t.persona ?? null,
-				model: t.model ?? null,
-				timeoutMs: t.timeoutMinutes != null ? t.timeoutMinutes * 6e4 : DEFAULT_SUBAGENT_TIMEOUT_MS
+			const spawnRequests = tasks.flatMap((task, index) => "task" in task ? [{
+				task,
+				index
+			}] : []);
+			const rearmRequests = tasks.flatMap((task, index) => "taskId" in task ? [{
+				task,
+				index
+			}] : []);
+			if (spawnRequests.length > 0 && rearmRequests.length > 0) return {
+				content: [{
+					type: "text",
+					text: "A subagent call must either spawn new tasks or re-arm running tasks, not both."
+				}],
+				details: { error: "mixed subagent operations" }
+			};
+			const spawnTasks = spawnRequests.map(({ task }) => ({
+				task: task.task,
+				title: task.title ?? null,
+				persona: task.persona ?? null,
+				model: task.model ?? null,
+				timeoutMs: task.timeoutMinutes != null ? task.timeoutMinutes * 6e4 : DEFAULT_SUBAGENT_TIMEOUT_MS
 			}));
 			try {
-				const spawned = await postSubagentSpawn({
+				const spawned = spawnTasks.length ? await postSubagentSpawn({
 					messageId,
 					tasks: spawnTasks
-				});
+				}) : {
+					taskIds: [],
+					tasks: []
+				};
+				const rearmed = await Promise.all(rearmRequests.map(async ({ task, index }) => {
+					try {
+						const result = await postSubagentRearm({
+							messageId,
+							taskId: task.taskId,
+							timeoutMinutes: task.timeoutMinutes
+						});
+						return {
+							index,
+							timeoutMinutes: task.timeoutMinutes,
+							...result
+						};
+					} catch (err) {
+						const message = err instanceof Error ? err.message : String(err);
+						log$1.warn({
+							err,
+							event: "subagent_rearm_failed",
+							taskId: task.taskId
+						}, "subagent re-arm failed");
+						return {
+							index,
+							taskId: task.taskId,
+							error: message
+						};
+					}
+				}));
 				const { taskIds } = spawned;
 				log$1.info({
 					event: "subagent_spawned",
 					count: taskIds.length
 				}, "subagent tasks queued");
 				const convByTask = new Map(spawned.tasks.map((t) => [t.taskId, t.conversationId]));
-				const lines = taskIds.map((id, i) => {
-					const label = spawnTasks[i]?.title ?? spawnTasks[i]?.task ?? "";
-					const conv = convByTask.get(id);
-					return conv ? `- conversation ${conv}: ${label} (taskId ${id})` : `- ${label} (taskId ${id}, conversation id unavailable — cannot peer this run)`;
+				const lines = tasks.map((_, index) => {
+					const spawnIndex = spawnRequests.findIndex((request) => request.index === index);
+					if (spawnIndex >= 0) {
+						const id = taskIds[spawnIndex];
+						const label = spawnTasks[spawnIndex]?.title ?? spawnTasks[spawnIndex]?.task ?? "";
+						const conv = id ? convByTask.get(id) : void 0;
+						return conv ? `- conversation ${conv}: ${label} (taskId ${id})` : `- ${label} (taskId ${id}, conversation id unavailable — cannot peer this run)`;
+					}
+					const rearm = rearmed.find((request) => request.index === index);
+					if (!rearm) return "- task update unavailable";
+					return "error" in rearm ? `- taskId ${rearm.taskId ?? "unknown"}: re-arm failed — ${rearm.error}` : `- taskId ${rearm.taskId}: wake again in ${rearm.timeoutMinutes} minutes`;
 				}).join("\n");
 				const peerHint = spawned.tasks.length ? "\nEach subagent runs on its own conversation (id shown per task above). To SEE what one is doing while it runs, read it with `platform conversations show <conversationId>`. To STEER one mid-run — add context, correct course, answer a question — post to its conversation with `platform conversations post <conversationId> --message \"...\"`; it lands as a live steer if the subagent is still running, or as its next turn if it has gone idle." : "";
 				return {
 					content: [{
 						type: "text",
-						text: `Queued ${taskIds.length} subagent ${taskIds.length === 1 ? "run" : "runs"}. Each runs on its own and will send you its result on this thread when it finishes — keep working or end your turn meanwhile.\n${lines}${peerHint}`
+						text: `${taskIds.length ? `Queued ${taskIds.length} subagent ${taskIds.length === 1 ? "run" : "runs"}.` : ""}${rearmed.length ? `${taskIds.length ? " " : ""}Re-armed ${rearmed.length} running ${rearmed.length === 1 ? "task" : "tasks"}.` : ""} Each will wake you on completion or at its next timeout.\n${lines}${peerHint}`
 					}],
 					details: {
 						taskIds,
-						tasks: spawned.tasks
+						tasks: spawned.tasks,
+						rearmed
 					}
 				};
 			} catch (err) {
@@ -4314,11 +4399,11 @@ function buildTool(messageId) {
 				log$1.warn({
 					err,
 					event: "subagent_spawn_failed"
-				}, "subagent spawn failed");
+				}, "subagent request failed");
 				return {
 					content: [{
 						type: "text",
-						text: `Failed to queue subagent runs: ${message}`
+						text: `Failed to update subagent tasks: ${message}`
 					}],
 					details: {},
 					isError: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skydiveai/pi-extensions",
-  "version": "0.1.0-beta.2894",
+  "version": "0.1.0-beta.2899",
   "homepage": "https://skydive.com",
   "license": "MIT",
   "author": "Create, Inc.",