pi-design-deck 0.1.0 → 0.2.0

package/index.ts

@@ -9,6 +9,7 @@ import { loadSettings } from "./settings.js";
 import { startDeckServer, type DeckServerHandle, type ModelInfo } from "./deck-server.js";
 import { isDeckOption, validateDeckConfig, validateSavedDeck } from "./deck-schema.js";
 import { buildGenerateMoreResult, buildRegenerateResult } from "./generate-prompts.js";
+import { generateWithModel } from "./model-runner.js";
 
 async function openUrl(pi: ExtensionAPI, url: string, browser?: string): Promise<void> {
 	const platform = os.platform();
@@ -41,6 +42,8 @@ interface DeckDetails {
 	status: "completed" | "cancelled" | "generate-more" | "aborted" | "error";
 	url: string;
 	selections?: Record<string, string>;
+	notes?: Record<string, string>;
+	finalNotes?: string;
 	slideId?: string;
 	reason?: string;
 }
@@ -117,7 +120,7 @@ function clearDeckIdleTimer(): void {
 	}
 }
 
-function cleanupActiveDeck(): void {
+function cleanupActiveDeck(reason?: string): void {
 	clearDeckIdleTimer();
 	if (restoreDeckThinking) {
 		restoreDeckThinking();
@@ -125,20 +128,23 @@ function cleanupActiveDeck(): void {
 	}
 	if (!activeDeckServer) return;
 	try {
-		activeDeckServer.handle.close();
+		activeDeckServer.handle.close(reason);
 	} catch {}
 	activeDeckServer = null;
 }
 
 function cleanupActiveDeckAndStoreResult(result: DeckToolResult): void {
 	if (!activeDeckServer) return;
+	// Extract close reason from result details
+	const details = result.details as DeckDetails | undefined;
+	const closeReason = details?.status === "aborted" ? "aborted" : details?.reason;
 	if (activeDeckServer.currentResolve) {
 		const resolve = activeDeckServer.currentResolve;
-		cleanupActiveDeck();
+		cleanupActiveDeck(closeReason);
 		resolve(result);
 	} else {
 		pendingDeckResult = result;
-		cleanupActiveDeck();
+		cleanupActiveDeck(closeReason);
 	}
 }
 
@@ -180,10 +186,16 @@ function attachDeckAbortHandler(signal: AbortSignal | undefined): void {
 	signal.addEventListener("abort", abortHandler, { once: true });
 }
 
-function formatDeckSelections(selections: Record<string, string>): string {
+function formatDeckSelections(selections: Record<string, string>, notes?: Record<string, string>): string {
 	const entries = Object.entries(selections);
 	if (entries.length === 0) return "(none)";
-	return entries.map(([key, value]) => `- ${key}: ${value}`).join("\n");
+	return entries.map(([key, value]) => {
+		const note = notes?.[key];
+		if (note) {
+			return `- ${key}: ${value}\n  Notes: ${note}`;
+		}
+		return `- ${key}: ${value}`;
+	}).join("\n");
 }
 
 export default function (pi: ExtensionAPI) {
@@ -273,17 +285,8 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 
-				if (activeDeckServer.currentResolve !== null) {
-					return {
-						content: [
-							{
-								type: "text",
-								text: "Design deck is not waiting for a generated option right now.",
-							},
-						],
-						details: { status: "error", url: activeDeckServer.handle.url },
-					};
-				}
+				// Note: We don't check currentResolve here because multiple parallel
+				// add-option calls are valid (e.g., user requests 3 options at once)
 
 				const slideId = p.slideId as string;
 				const option = p.option as string;
@@ -319,14 +322,14 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 
-				if (onUpdate) {
-					onUpdate({
-						content: [{ type: "text", text: `Pushed new option to slide ${slideId}.` }],
-						details: { status: "generate-more", url: activeDeckServer.handle.url, slideId },
-					});
-				}
-				attachDeckAbortHandler(signal);
-				return blockOnDeck();
+				// For add-option, return immediately without blocking.
+				// This allows parallel add-option calls to all succeed.
+				// The deck stays open and will send a new prompt when the user
+				// clicks generate-more again or submits.
+				return {
+					content: [{ type: "text", text: `Pushed option "${parsedOption.label}" to slide ${slideId}.` }],
+					details: { status: "generate-more", url: activeDeckServer.handle.url, slideId },
+				};
 			}
 
 			if (p.action === "replace-options") {
@@ -471,17 +474,28 @@ export default function (pi: ExtensionAPI) {
 				};
 			}
 
-			const handleSubmit = (selections: Record<string, string>) => {
+			const handleSubmit = (selections: Record<string, string>, notes?: Record<string, string>, finalNotes?: string) => {
 				if (!activeDeckServer) return;
 				const url = activeDeckServer.handle.url;
+				const hasNotes = notes && Object.keys(notes).length > 0;
+				const textParts = [`Design deck completed.\n\nSelections:\n${formatDeckSelections(selections, notes)}`];
+				if (finalNotes) {
+					textParts.push(`\nAdditional instructions:\n${finalNotes}`);
+				}
 				cleanupActiveDeckAndStoreResult({
 					content: [
 						{
 							type: "text",
-							text: `Design deck completed.\n\nSelections:\n${formatDeckSelections(selections)}`,
+							text: textParts.join(""),
 						},
 					],
-					details: { status: "completed", url, selections },
+					details: { 
+						status: "completed", 
+						url, 
+						selections, 
+						...(hasNotes ? { notes } : {}),
+						...(finalNotes ? { finalNotes } : {}),
+					},
 				});
 			};
 
@@ -502,8 +516,12 @@ export default function (pi: ExtensionAPI) {
 				});
 			};
 
-			const handleGenerateMore = (slideId: string, prompt?: string, model?: string, thinking?: string) => {
-				if (!activeDeckServer?.currentResolve) return;
+			const handleGenerateMore = (slideId: string, prompt?: string, model?: string, thinking?: string, count?: number) => {
+				if (!activeDeckServer?.currentResolve) {
+					// Agent is no longer listening - close the deck
+					cleanupActiveDeck("stale");
+					return;
+				}
 				const resolve = activeDeckServer.currentResolve;
 				activeDeckServer.currentResolve = null;
 				armDeckIdleTimer();
@@ -512,8 +530,9 @@ export default function (pi: ExtensionAPI) {
 				if (thinking && !effectiveModel) {
 					pi.setThinkingLevel(thinking as "off" | "minimal" | "low" | "medium" | "high" | "xhigh");
 				}
+				const effectiveCount = count && count >= 1 && count <= 5 ? count : 1;
 				resolve({
-					content: [{ type: "text", text: buildGenerateMoreResult(slideId, slide, prompt, effectiveModel, thinking) }],
+					content: [{ type: "text", text: buildGenerateMoreResult(slideId, slide, prompt, effectiveModel, thinking, effectiveCount) }],
 					details: {
 						status: "generate-more",
 						url: activeDeckServer.handle.url,
@@ -523,7 +542,11 @@ export default function (pi: ExtensionAPI) {
 			};
 
 			const handleRegenerateSlide = (slideId: string, prompt?: string, model?: string, thinking?: string) => {
-				if (!activeDeckServer?.currentResolve) return;
+				if (!activeDeckServer?.currentResolve) {
+					// Agent is no longer listening - close the deck
+					cleanupActiveDeck("stale");
+					return;
+				}
 				const resolve = activeDeckServer.currentResolve;
 				activeDeckServer.currentResolve = null;
 				armDeckIdleTimer();
@@ -664,6 +687,25 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerTool({
+		name: "deck_generate",
+		description: "Generate text using a specific model (for design deck option generation). Use this when the generate-more prompt specifies a model override.",
+		parameters: Type.Object({
+			model: Type.String({ description: "Full model ID in 'provider/model-id' format (e.g., 'anthropic/claude-haiku-4-5')" }),
+			task: Type.String({ description: "The generation task/prompt" }),
+		}),
+		async execute(_toolCallId, params) {
+			const { model, task } = params as { model: string; task: string };
+			try {
+				const result = await generateWithModel(model, task);
+				return { content: [{ type: "text", text: result }] };
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: `Generation failed: ${message}` }], isError: true };
+			}
+		},
+	});
+
 	pi.on("session_shutdown", () => {
 		pendingDeckResult = null;
 		cleanupActiveDeck();

package/model-runner.ts

@@ -0,0 +1,50 @@
+import { spawn } from "node:child_process";
+
+const TIMEOUT_MS = 120_000;
+
+export async function generateWithModel(fullModel: string, task: string): Promise<string> {
+	const parts = fullModel.split("/");
+	if (parts.length < 2) {
+		throw new Error(`Invalid model format: ${fullModel}. Expected "provider/model-id"`);
+	}
+	const provider = parts[0];
+	const modelId = parts.slice(1).join("/");
+
+	return new Promise((resolve, reject) => {
+		const args = ["--provider", provider, "--model", modelId, "--no-tools", "--no-session", "-p", task];
+
+		const proc = spawn("pi", args, {
+			stdio: ["ignore", "pipe", "pipe"],
+			env: process.env,
+		});
+
+		let stdout = "";
+		let stderr = "";
+
+		proc.stdout.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		proc.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+
+		const timer = setTimeout(() => {
+			proc.kill("SIGTERM");
+			reject(new Error("Generation timed out after 2 minutes"));
+		}, TIMEOUT_MS);
+
+		proc.on("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+
+		proc.on("close", (code) => {
+			clearTimeout(timer);
+			if (code === 0) {
+				resolve(stdout.trim());
+			} else {
+				reject(new Error(`pi exited with code ${code}: ${stderr.slice(0, 500)}`));
+			}
+		});
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-design-deck",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Visual design deck for presenting multi-slide options with high-fidelity previews",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -13,6 +13,7 @@
     "deck-schema.ts",
     "deck-server.ts",
     "generate-prompts.ts",
+    "model-runner.ts",
     "server-utils.ts",
     "settings.ts",
     "index.ts"

package/skills/design-deck/SKILL.md

@@ -234,13 +234,13 @@ The `add-option` call pushes the new option into the live deck and blocks again
 
 The deck shows a model dropdown below the header (when 2+ models are available). Users can pick which model generates new options and optionally save it as the default.
 
-When the generate-more result includes a model instruction (e.g. "Generate using model X via subagent"), delegate the option generation to a subagent with that model. Use a bare generator agent (no tools, no file output) rather than scout — this is pure text generation, not codebase investigation:
+When the generate-more result includes a model instruction (e.g. "Generate using model X via deck_generate"), use the built-in `deck_generate` tool to generate the option with that model:
 
 ```
-subagent({ agent: "generator", model: "google/gemini-3.1-pro", output: false, task: "Generate a JSON deck option..." })
+deck_generate({ model: "google/gemini-3.1-pro", task: "Generate a JSON deck option..." })
 ```
 
-Parse the subagent's text output as the option JSON and pass it to `add-option`.
+Parse the output as the option JSON and pass it to `add-option`.
 
 The default model can also be set in `~/.pi/agent/settings.json`: